prompt
large_stringlengths 70
991k
| completion
large_stringlengths 0
1.02k
|
|---|---|
<|file_name|>test_public_api.py<|end_file_name|><｜fim▁begin｜>"""Test the IPython.kernel public API
Authors
-------
* MinRK<｜fim▁hole｜># Copyright (c) 2013, the IPython Development Team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------
import nose.tools as nt
from IPython.testing import decorators as dec
from IPython.kernel import launcher, connect
from IPython import kernel
#-----------------------------------------------------------------------------
# Classes and functions
#-----------------------------------------------------------------------------
@dec.parametric
def test_kms():
for base in ("", "Multi"):
KM = base + "KernelManager"
yield nt.assert_true(KM in dir(kernel), KM)
@dec.parametric
def test_kcs():
for base in ("", "Blocking"):
KM = base + "KernelClient"
yield nt.assert_true(KM in dir(kernel), KM)
@dec.parametric
def test_launcher():
for name in launcher.__all__:
yield nt.assert_true(name in dir(kernel), name)
@dec.parametric
def test_connect():
for name in connect.__all__:
yield nt.assert_true(name in dir(kernel), name)<｜fim▁end｜> | """
#----------------------------------------------------------------------------- |
<|file_name|>Module.cpp<|end_file_name|><｜fim▁begin｜>// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2011 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================
#include "Module.h"
#include "HostAPI.h"
namespace XMP_PLUGIN
{
static bool CheckAPICompatibility_V1 ( const PluginAPIRef pluginAPIs )
{
// these plugin APIs are mandatory to run an XMP file handler
if ( pluginAPIs->mTerminatePluginProc
&& pluginAPIs->mSetHostAPIProc
&& pluginAPIs->mInitializeSessionProc
&& pluginAPIs->mTerminateSessionProc
&& pluginAPIs->mCheckFileFormatProc
&& pluginAPIs->mCheckFolderFormatProc
&& pluginAPIs->mGetFileModDateProc
&& pluginAPIs->mCacheFileDataProc
&& pluginAPIs->mUpdateFileProc
&& pluginAPIs->mWriteTempFileProc )
{
return true;
}
return false;
}
static bool CheckAPICompatibility_V2 ( const PluginAPIRef pluginAPIs )
{
if ( CheckAPICompatibility_V1 ( pluginAPIs ) )
{
if ( pluginAPIs->mFillMetadataFilesProc
&& pluginAPIs->mFillAssociatedResourcesProc )
{
return true;
}
}
return false;
}
static bool CheckAPICompatibility_V3 ( const PluginAPIRef pluginAPIs )
{
if ( CheckAPICompatibility_V2 ( pluginAPIs ) )
{
if ( pluginAPIs->mIsMetadataWritableProc )
{
return true;
}
}
return false;
}
static bool CheckAPICompatibility ( const PluginAPIRef pluginAPIs )
{
// Note: This is the place where we can reject old plugins.
// For example if we consider all functionality of
// plugin API version 2 mandatory we can reject
// plugin version 1 by returning false in case 1.
switch ( pluginAPIs->mVersion )
{
case 1:
return CheckAPICompatibility_V1 ( pluginAPIs );
break;
case 2:
return CheckAPICompatibility_V2 ( pluginAPIs );
break;
case 3:
return CheckAPICompatibility_V3 ( pluginAPIs );
break;
default:
// The loaded plugin is newer than the host.
// Only basic functionality to run the plugin is required.
return CheckAPICompatibility_V1 ( pluginAPIs );
break;
}
}
PluginAPIRef Module::getPluginAPIs()
{
//
// return ref. to Plugin API, load module if not yet loaded
//
if ( !mPluginAPIs || mLoaded != kModuleLoaded )
{
if ( !load() )
{
XMP_Throw ( "Plugin API not available.", kXMPErr_Unavailable );
}
}
return mPluginAPIs;
}
bool Module::load()
{
XMP_AutoLock lock ( &mLoadingLock, kXMP_WriteLock );
return loadInternal();
}
void Module::unload()
{
XMP_AutoLock lock (&mLoadingLock, kXMP_WriteLock);
unloadInternal();
}
void Module::unloadInternal()
{
WXMP_Error error;
//
// terminate plugin
//
if( mPluginAPIs != NULL )
{
if( mPluginAPIs->mTerminatePluginProc )
{
mPluginAPIs->mTerminatePluginProc( &error );
}
delete mPluginAPIs;
mPluginAPIs = NULL;
}
//
// unload plugin module
//
if( mLoaded != kModuleNotLoaded )
{
UnloadModule(mHandle, false);
mHandle = NULL;
if( mLoaded == kModuleLoaded )
{
//
// Reset mLoaded to kModuleNotLoaded, if the module was loaded successfully.
// Otherwise let it remain kModuleErrorOnLoad so that we won't try to load
// it again if some other handler ask to do so.
//
mLoaded = kModuleNotLoaded;
}
}
CheckError( error );
}
bool Module::loadInternal()
{
if( mLoaded == kModuleNotLoaded )
{<｜fim▁hole｜> const char * errorMsg = NULL;
//
// load module
//
mLoaded = kModuleErrorOnLoad;
mHandle = LoadModule(mPath, false);
if( mHandle != NULL )
{
//
// get entry point function pointer
//
InitializePluginProc InitializePlugin = reinterpret_cast<InitializePluginProc>(
GetFunctionPointerFromModuleImpl(mHandle, "InitializePlugin") ); // legacy entry point
InitializePlugin2Proc InitializePlugin2 = reinterpret_cast<InitializePlugin2Proc>(
GetFunctionPointerFromModuleImpl(mHandle, "InitializePlugin2") );
if( InitializePlugin2 != NULL || InitializePlugin != NULL )
{
std::string moduleID;
GetResourceDataFromModule(mHandle, "MODULE_IDENTIFIER", "txt", moduleID);
mPluginAPIs = new PluginAPI();
memset( mPluginAPIs, 0, sizeof(PluginAPI) );
mPluginAPIs->mSize = sizeof(PluginAPI);
mPluginAPIs->mVersion = XMP_PLUGIN_VERSION; // informational: the latest version that the host knows about
WXMP_Error error;
//
// initialize plugin by calling entry point function
//
if( InitializePlugin2 != NULL )
{
HostAPIRef hostAPI = PluginManager::getHostAPI( XMP_HOST_API_VERSION );
InitializePlugin2( moduleID.c_str(), hostAPI, mPluginAPIs, &error );
if ( error.mErrorID == kXMPErr_NoError )
{
// check all function pointers are correct based on version numbers
if( CheckAPICompatibility( mPluginAPIs ) )
{
mLoaded = kModuleLoaded;
}
else
{
errorMsg = "Incompatible plugin API version.";
}
}
else
{
errorMsg = "Plugin initialization failed.";
}
}
else if( InitializePlugin != NULL )
{
// initialize through legacy plugin entry point
InitializePlugin( moduleID.c_str(), mPluginAPIs, &error );
if ( error.mErrorID == kXMPErr_NoError ) {
// check all function pointers are correct based on version numbers
bool compatibleAPIs = CheckAPICompatibility(mPluginAPIs);
if ( compatibleAPIs )
{
//
// set host API at plugin
//
HostAPIRef hostAPI = PluginManager::getHostAPI( mPluginAPIs->mVersion );
mPluginAPIs->mSetHostAPIProc( hostAPI, &error );
if( error.mErrorID == kXMPErr_NoError )
{
mLoaded = kModuleLoaded;
}
else
{
errorMsg = "Plugin API incomplete.";
}
}
else
{
errorMsg = "Incompatible plugin API version.";
}
}
else
{
errorMsg = "Plugin initialization failed.";
}
}
}
if( mLoaded != kModuleLoaded )
{
//
// plugin wasn't loaded and initialized successfully,
// so unload the module
//
this->unloadInternal();
}
}
else
{
errorMsg = "Can't load module";
}
if ( mLoaded != kModuleLoaded && errorMsg )
{
//
// error occurred
//
throw XMP_Error( kXMPErr_InternalFailure, errorMsg);
}
}
return ( mLoaded == kModuleLoaded );
}
} //namespace XMP_PLUGIN<｜fim▁end｜> | |
<|file_name|>Codec.java<|end_file_name|><｜fim▁begin｜>/*
* Copyright (c) 2014 Ian Bondoc
*
* This file is part of Jen8583
*
* Jen8583 is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of the License, or(at your option) any later version.
*
* Jen8583 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
package org.chiknrice.iso.codec;
import org.chiknrice.iso.config.ComponentDef.Encoding;
import java.nio.ByteBuffer;
/**
* The main contract for a codec used across encoding and decoding of message components. Each field/component of the
* ISO message would have its own instance of codec which contains the definition of how the value should be
* encoded/decoded. The codec should be designed to be thread safe as the instance would live throughout the life of the
* IsoMessageDef. Any issues encountered during encoding/decoding should be throwing a CodecException. Any issues
* encountered during codec configuration/construction the constructor should throw a ConfigException. A ConfigException
* should generally happen during startup while CodecException happens when the Codec is being used.
*
* @author <a href="mailto:[email protected]">Ian Bondoc</a>
*/
public interface Codec<T> {
/**
* The implementation should define how the value T should be decoded from the ByteBuffer provided. The
* implementation could either decode the value from a certain number of bytes or consume the whole ByteBuffer.
*
* @param buf
* @return the decoded value
*/
T decode(ByteBuffer buf);
/**
* The implementation should define how the value T should be encoded to the ByteBuffer provided. The ByteBuffer
* assumes the value would be encoded from the current position.
*
* @param buf
* @param value the value to be encoded
<｜fim▁hole｜> /**
* Defines how the value should be encoded/decoded.
*
* @return the encoding defined for the value.
*/
Encoding getEncoding();
}<｜fim▁end｜> | */
void encode(ByteBuffer buf, T value);
|
<|file_name|>SpringCacheManagerWrapper.java<|end_file_name|><｜fim▁begin｜>/**
* Copyright (c) 2005-2012 https://github.com/zhangkaitao Licensed under the Apache License, Version 2.0 (the
* "License");
*/
package com.yang.spinach.common.utils.spring;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.sf.ehcache.Ehcache;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.util.CollectionUtils;
import org.springframework.cache.support.SimpleValueWrapper;
/**
* 包装Spring cache抽象
*/
public class SpringCacheManagerWrapper implements CacheManager {
private org.springframework.cache.CacheManager cacheManager;
/**
* 设置spring cache manager
*
* @param cacheManager
*/
public void setCacheManager(
org.springframework.cache.CacheManager cacheManager) {
this.cacheManager = cacheManager;
}
@Override
public <K, V> Cache<K, V> getCache(String name) throws CacheException {
org.springframework.cache.Cache springCache = cacheManager
.getCache(name);
return new SpringCacheWrapper(springCache);
}
static class SpringCacheWrapper implements Cache {
private final org.springframework.cache.Cache springCache;
SpringCacheWrapper(org.springframework.cache.Cache springCache) {
this.springCache = springCache;
}
@Override
public Object get(Object key) throws CacheException {
Object value = springCache.get(key);
if (value instanceof SimpleValueWrapper) {
return ((SimpleValueWrapper) value).get();
}
return value;
}
@Override
public Object put(Object key, Object value) throws CacheException {
springCache.put(key, value);
return value;
}
@Override
public Object remove(Object key) throws CacheException {
springCache.evict(key);
return null;
}
@Override
public void clear() throws CacheException {
springCache.clear();
}
@Override
public int size() {
if (springCache.getNativeCache() instanceof Ehcache) {
Ehcache ehcache = (Ehcache) springCache.getNativeCache();
return ehcache.getSize();
}
throw new UnsupportedOperationException(
"invoke spring cache abstract size method not supported");
}
@Override
public Set keys() {
if (springCache.getNativeCache() instanceof Ehcache) {
Ehcache ehcache = (Ehcache) springCache.getNativeCache();
return new HashSet(ehcache.getKeys());
}
throw new UnsupportedOperationException(
"invoke spring cache abstract keys method not supported");
}
@Override<｜fim▁hole｜> if (springCache.getNativeCache() instanceof Ehcache) {
Ehcache ehcache = (Ehcache) springCache.getNativeCache();
System.out.println("cache savePath:"
+ ehcache.getCacheManager().getDiskStorePath()
+ "--------------");
List keys = ehcache.getKeys();
if (!CollectionUtils.isEmpty(keys)) {
List values = new ArrayList(keys.size());
for (Object key : keys) {
Object value = get(key);
if (value != null) {
values.add(value);
}
}
return Collections.unmodifiableList(values);
} else {
return Collections.emptyList();
}
}
throw new UnsupportedOperationException(
"invoke spring cache abstract values method not supported");
}
}
}<｜fim▁end｜> | public Collection values() { |
<|file_name|>mod.rs<|end_file_name|><｜fim▁begin｜>// Zinc, the bare metal stack for rust.
// Copyright 2014 Vladimir "farcaller" Pouzanov <[email protected]>
//
// 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.
use std::rc::Rc;
use std::ops::DerefMut;
use syntax::abi;
use syntax::ast::TokenTree;
use syntax::ast;
use syntax::ast_util::empty_generics;
use syntax::codemap::{Span, DUMMY_SP};
use syntax::ext::base::ExtCtxt;
use syntax::ext::build::AstBuilder;
use syntax::ext::quote::rt::{ToTokens, ExtParseUtils};
use syntax::parse::token::InternedString;
use syntax::ptr::P;
use node;
mod mcu;
mod os;
pub mod meta_args;
pub struct Builder {
main_stmts: Vec<P<ast::Stmt>>,
type_items: Vec<P<ast::Item>>,
pt: Rc<node::PlatformTree>,
}
impl Builder {
pub fn build(cx: &mut ExtCtxt, pt: Rc<node::PlatformTree>) -> Option<Builder> {
let mut builder = Builder::new(pt.clone());
if !pt.expect_subnodes(cx, &["mcu", "os", "drivers"]) {
return None;
}
match pt.get_by_path("mcu") {
Some(node) => mcu::attach(&mut builder, cx, node),
None => (), // TODO(farcaller): should it actaully fail?
}
match pt.get_by_path("os") {
Some(node) => os::attach(&mut builder, cx, node),
None => (), // TODO(farcaller): this should fail.
}
match pt.get_by_path("drivers") {
Some(node) => ::drivers_pt::attach(&mut builder, cx, node),
None => (),
}
for sub in pt.nodes().iter() {
Builder::walk_mutate(&mut builder, cx, sub);
}
let base_node = pt.get_by_path("mcu").and_then(|mcu|{mcu.get_by_path("clock")});
match base_node {
Some(node) => Builder::walk_materialize(&mut builder, cx, node),
None => {
cx.parse_sess().span_diagnostic.span_err(DUMMY_SP,
"root node `mcu::clock` must be present");
}
}<｜fim▁hole｜>
Some(builder)
}
fn walk_mutate(builder: &mut Builder, cx: &mut ExtCtxt, node: &Rc<node::Node>) {
let maybe_mut = node.mutator.get();
if maybe_mut.is_some() {
maybe_mut.unwrap()(builder, cx, node.clone());
}
for sub in node.subnodes().iter() {
Builder::walk_mutate(builder, cx, sub);
}
}
// FIXME(farcaller): verify that all nodes have been materialized
fn walk_materialize(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
let maybe_mat = node.materializer.get();
if maybe_mat.is_some() {
maybe_mat.unwrap()(builder, cx, node.clone());
}
let rev_depends = node.rev_depends_on.borrow();
for weak_sub in rev_depends.iter() {
let sub = weak_sub.upgrade().unwrap();
let mut sub_deps = sub.depends_on.borrow_mut();
let deps = sub_deps.deref_mut();
let mut index = None;
let mut i = 0u;
// FIXME: iter().position()
for dep in deps.iter() {
let strong_dep = dep.upgrade().unwrap();
if node == strong_dep {
index = Some(i);
break;
}
i = i + 1;
}
if index.is_none() {
panic!("no index found");
} else {
deps.remove(index.unwrap());
if deps.len() == 0 {
Builder::walk_materialize(builder, cx, sub.clone());
}
}
}
}
pub fn new(pt: Rc<node::PlatformTree>) -> Builder {
Builder {
main_stmts: Vec::new(),
type_items: Vec::new(),
pt: pt,
}
}
pub fn main_stmts(&self) -> Vec<P<ast::Stmt>> {
self.main_stmts.clone()
}
pub fn pt(&self) -> Rc<node::PlatformTree> {
self.pt.clone()
}
pub fn add_main_statement(&mut self, stmt: P<ast::Stmt>) {
self.main_stmts.push(stmt);
}
pub fn add_type_item(&mut self, item: P<ast::Item>) {
self.type_items.push(item);
}
fn emit_main(&self, cx: &ExtCtxt) -> P<ast::Item> {
// init stack
let init_stack_stmt = cx.stmt_expr(quote_expr!(&*cx,
zinc::hal::mem_init::init_stack();
));
// init data
let init_data_stmt = cx.stmt_expr(quote_expr!(&*cx,
zinc::hal::mem_init::init_data();
));
let mut stmts = vec!(init_stack_stmt, init_data_stmt);
stmts.push_all(self.main_stmts.as_slice());
let body = cx.block(DUMMY_SP, stmts, None);
let unused_variables = cx.meta_word(DUMMY_SP,
InternedString::new("unused_variables"));
let allow = cx.meta_list(
DUMMY_SP,
InternedString::new("allow"), vec!(unused_variables));
let allow_noncamel = cx.attribute(DUMMY_SP, allow);
self.item_fn(cx, DUMMY_SP, "main", &[allow_noncamel], body)
}
fn emit_morestack(&self, cx: &ExtCtxt) -> P<ast::Item> {
let stmt = cx.stmt_expr(quote_expr!(&*cx,
core::intrinsics::abort()
// or
// zinc::os::task::morestack();
));
let empty_span = DUMMY_SP;
let body = cx.block(empty_span, vec!(stmt), None);
self.item_fn(cx, empty_span, "__morestack", &[], body)
}
pub fn emit_items(&self, cx: &ExtCtxt) -> Vec<P<ast::Item>> {
let non_camel_case_types = cx.meta_word(DUMMY_SP,
InternedString::new("non_camel_case_types"));
let allow = cx.meta_list(
DUMMY_SP,
InternedString::new("allow"), vec!(non_camel_case_types));
let allow_noncamel = cx.attribute(DUMMY_SP, allow);
let use_zinc = cx.view_use_simple(DUMMY_SP, ast::Inherited, cx.path_ident(
DUMMY_SP, cx.ident_of("zinc")));
let pt_mod_item = cx.item_mod(DUMMY_SP, DUMMY_SP, cx.ident_of("pt"),
vec!(allow_noncamel), vec!(use_zinc), self.type_items.clone());
if self.type_items.len() > 0 {
vec!(pt_mod_item, self.emit_main(cx), self.emit_morestack(cx))
} else {
vec!(self.emit_main(cx), self.emit_morestack(cx))
}
}
fn item_fn(&self, cx: &ExtCtxt, span: Span, name: &str,
local_attrs: &[ast::Attribute], body: P<ast::Block>)
-> P<ast::Item> {
let attr_no_mangle = cx.attribute(span, cx.meta_word(
span, InternedString::new("no_mangle")));
let mut attrs = vec!(attr_no_mangle);
attrs.push_all(local_attrs);
P(ast::Item {
ident: cx.ident_of(name),
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: ast::ItemFn(
cx.fn_decl(Vec::new(), cx.ty(DUMMY_SP, ast::Ty_::TyTup(Vec::new()))),
ast::Unsafety::Unsafe,
abi::Rust, // TODO(farcaller): should this be abi::C?
empty_generics(),
body),
vis: ast::Public,
span: span,
})
}
}
pub struct TokenString(pub String);
impl ToTokens for TokenString {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
let &TokenString(ref s) = self;
(cx as &ExtParseUtils).parse_tts(s.clone())
}
}
pub fn add_node_dependency(node: &Rc<node::Node>, dep: &Rc<node::Node>) {
let mut depends_on = node.depends_on.borrow_mut();
depends_on.deref_mut().push(dep.downgrade());
let mut rev_depends_on = dep.rev_depends_on.borrow_mut();
rev_depends_on.push(node.downgrade());
}
#[cfg(test)]
mod test {
use test_helpers::fails_to_build;
#[test]
fn fails_to_parse_pt_with_unknown_root_node() {
fails_to_build("unknown@node {}");
}
#[test]
fn fails_to_parse_pt_with_unknown_mcu() {
fails_to_build("mcu@bad {}");
}
}<｜fim▁end｜> | |
<|file_name|>admin_usuario_dir_envio.js<|end_file_name|><｜fim▁begin｜>function listar_dir_envio(){
$.ajax({
cache: false,
url: administrador + "administrador_usuario.php?accion=listar_direccion_envio",
type: 'POST',
data: {"id_cliente": id_cliente_js},
dataType: "json",
beforeSend: function () {
//$("#result_informacion").html("Procesando, espere por favor..." );
},
success: function (data) {
$("#result_informacion").append("<div class='pleca-titulo space10'></div><div class='encabezado-descripcion'>Datos de envío</div>" +
"<table id='direcciones' cellspacing='0'><thead><tr><th>Dirección</th><th>Colonia</th><th>Codigo Postal</th><th>Ciudad</th><th>Estado</th><th> </th></tr></thead></table>");
$.each(data.direccion_envio, function(k,v){
var inter = '';
if(v.num_int){
inter = v.num_int;
}
var pe= ' ';
if(v.id_estatusSi == 3){
pe = "<div style='color: #D81830; height: 20px; font-size: 11px; font-family: italic; font-weight: bold'>pago express</div>";
}
$("#direcciones").append('<tr><td>'+ v.calle + ' ' +
v.num_ext + ' ' +
inter + pe +'</td><td>' +
v.colonia + '</td><td>' +
v.cp + '</td><td>' +
v.ciudad + '</td><td>' +
v.estado + '</td>'+
'<td valign="top"><div onclick=\"editar_dir_envio('+ v.id_consecutivoSi +')\"><a href="#">editar</a></div><div onclick=\"eliminar_dir_envio('+ v.id_consecutivoSi +')\"><a href="#">eliminar</a></div></td>'+
'</tr>');
});
$('#boton_datos').removeAttr('disabled');
}
});
}
function eliminar_dir_envio(id_env){
var conf = confirm("¿Estas seguro?");
if(conf){
$.ajax({
cache: false,
url: administrador + "administrador_usuario.php?accion=eliminar_direccion",
type: 'POST',
data: {"id_dir": id_env, "id_cliente": id_cliente_js},
beforeSend: function () {
$("#result_informacion").html("<div class='procesando'>Procesando, espere por favor...</div>" );
},
success: function (response) {
$("#result_informacion").html(response);
if($("#eliminar_direccion").text()== 1){
$("#result_informacion").html('<div class="encabezado-descripcion">Se elimino la información.</div>');
setTimeout('$("#boton_datos").click()', 2500);
}
}
});
}
}
function editar_dir_envio(id_dir){
$.ajax({
cache: false,
url: administrador + "administrador_usuario.php?accion=editar_dir_envio",
type: 'GET',
data: {"id_dir": id_dir, "id_cliente": id_cliente_js},
beforeSend: function () {
$("#result_informacion").html("<div class='procesando'>Procesando, espere por favor...</div>" );
},
success: function (response) {
$("#result_informacion").html(response);
/*
var forms = $("form[id*='registro']");
var reg_cp = /^([1-9]{2}|[0-9][1-9]|[1-9][0-9])[0-9]{3}$/;
var reg_email = /^[^0-9][a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)*[@][a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)*[.][a-zA-Z]{2,4}$/;
var reg_nombres = /^[A-ZáéíóúÁÉÍÓÚÑñ \'.-]{1,30}$/i;
var reg_numeros = /^[A-Z0-9 -.#\/]{1,50}$/i;
var reg_direccion = /^[A-Z0-9 \'.,-áéíóúÁÉÍÓÚÑñ]{1,50}$/i;
var reg_telefono = /^[0-9 ()+-]{10,20}$/
var calle = $("#txt_calle");
var num_ext = $("#txt_numero");
var cp = $("#txt_cp");
var pais = $("#sel_pais");
var estado_t = $("#txt_estado");
var ciudad_t = $("#txt_ciudad");
var colonia_t = $("#txt_colonia");
var estado_s = $("#sel_estados");
var ciudad_s = $("#sel_ciudades");
var colonia_s = $("#sel_colonias");
var telefono= $("#txt_telefono");
var estado, ciudad, colonia;
$('.div_otro_pais').hide();
//onChange:
$('#sel_pais').change(function() {
//hacer un toggle si es necesario
var es_mx = false;
$.getJSON(ecommerce + "direccion_envio/es_mexico/" + $(this).val(),
function(data) {
if (!data.result) { //no es México
$('.div_mexico').hide();
$('.div_otro_pais').show();
} else {
$('.div_mexico').show();
$('.div_otro_pais').hide();
}
}
);
}).change(); //se lanza al inicio de la carga para verificar al inicio
$('#sel_estados').change(function() {
//actualizar ciudad y colonia
var clave_estado = $("#sel_estados option:selected").val();
//alert('change estado ' + clave_estado);
actualizar_ciudades(clave_estado);
//limpiar las colonias
$("#sel_colonias").empty();
$("<option></option>").attr("value", '').html('Selecionar').appendTo("#sel_colonias");
});
$('#sel_ciudades').change(function() {
//actualizar ciudad y colonia
var clave_estado = $("#sel_estados option:selected").val();
var ciudad = $("#sel_ciudades option:selected").val();
//alert('change estado ' + clave_estado + '' + 'change ciudad ' + ciudad + '');
actualizar_colonias(clave_estado, ciudad);
});
$('#sel_colonias').change(function() {
//actualizar cp en base a la colonia seleccionada
var clave_estado = $("#sel_estados option:selected").val();
var ciudad = $("#sel_ciudades option:selected").val();
var colonia = $("#sel_colonias option:selected").val();<｜fim▁hole｜>
//con el botón de llenar sólo se recupera y selecciona edo. y ciudad
$("#btn_cp").click(function() {
var text_selected = $("#sel_pais option:selected").text();
var val_selected = $("#sel_pais option:selected").val();
var cp = $.trim($("#txt_cp").val()); //.val();
//validar cp
if (!cp || !reg_cp.test($.trim(cp))) {
alert('Por favor ingresa un código válido');
return false
}
//var sel_estados = $("#sel_estados");
$.ajax({
type: "POST",
data: {'codigo_postal' : cp},
url: ecommerce + "direccion_envio/get_info_sepomex",
dataType: "json",
async: false,
success: function(data) {
//alert("success: " + data.msg);
if (typeof data.sepomex != null && data.sepomex.length != 0) { //regresa un array con las colonias
//alert('data is ok, tipo: ' + typeof(data));
var sepomex = data.sepomex; //colonias
var codigo_postal = sepomex[0].codigo_postal;
var clave_estado = sepomex[0].clave_estado;
var estado = sepomex[0].estado;
var ciudad = sepomex[0].ciudad;
$("#sel_estados").val(clave_estado);
//alert("Estado: " + estado + ", ciudad: " + ciudad + ", cp: " + codigo_postal);
//$("#sel_estados").trigger('change');
//carga del catálogo ciudades y selección
$.post( ecommerce + 'direccion_envio/get_ciudades',
// when the Web server responds to the request
{ 'estado': clave_estado},
function(datos) {
var ciudades = datos.ciudades;
$("#sel_ciudades").empty();
$("<option></option>").attr("value", '').html('Selecionar').appendTo("#sel_ciudades");
if (ciudades.length == undefined) { //DF sólo devuelve un obj de ciudad.
$("<option></option>").attr("value", ciudades.clave_ciudad).html(ciudades.ciudad).appendTo("#sel_ciudades");
$("#sel_ciudades").trigger('change'); //trigger cities' change event
} else { //ciudades.length == 'undefined'
$.each(ciudades, function(indice, ciudad) {
if (ciudad.clave_ciudad != '') {
$("<option></option>").attr("value", ciudad.clave_ciudad).html(ciudad.ciudad).appendTo("#sel_ciudades");
}
});
}
//select choosen city
$("#sel_ciudades").val(ciudad);
//trigger ciudades change
//$("#sel_ciudades").trigger('change');
//Cargar las colonias
$("#sel_colonias").empty();
if (sepomex.length > 1)
$("<option></option>").attr("value", '').html('Selecionar').appendTo("#sel_colonias");
$.each(sepomex, function(indice, colonia) {
if (colonia.colonia != '') {
$("<option></option>").attr("value", colonia.colonia).html(colonia.colonia).appendTo("#sel_colonias");
}
});
},
"json"
);
} else if (data.sepomex.length == 0) {
$("#sel_estados").val('');
$('#sel_estados').trigger('change');
alert("El código no devolvió resultados");
//Remover información del formulario
}
},
error: function(data) {
alert("error: " + data.error);
},
complete: function(data) {
},
//async: false,
cache: false
});
});
*/
}
});
}
function enviar_dir_envio(id_dir){
var txt_calle = $('#txt_calle').val();
var txt_numero = $('#txt_numero').val();
var txt_num_int = $('#txt_num_int').val();
var txt_cp = $('#txt_cp').val();
var sel_pais = $('#sel_pais').val();
var txt_estado = $('#txt_estado').val();
var txt_ciudad = $('#txt_ciudad').val();
var txt_colonia = $('#txt_colonia').val();
var sel_estados = $('#sel_estados').val();
var sel_ciudades = $('#sel_ciudades').val();
var sel_colonias = $('#sel_colonias').val();
var txt_telefono = $('#txt_telefono').val();
var txt_referencia = $('#txt_referencia').val();
if($("#chk_default").is(':checked')){
var chk_default = 1;
}
else{
var chk_default = 0;
}
var parametros = {
"txt_calle" : txt_calle,
"txt_numero" : txt_numero,
"txt_num_int" : txt_num_int,
"txt_cp" : txt_cp,
"sel_pais" : sel_pais,
"txt_estado" : txt_estado,
"txt_ciudad" : txt_ciudad,
"txt_colonia" : txt_colonia,
"sel_estados" : sel_estados,
"sel_ciudades" : sel_ciudades,
"sel_colonias" : sel_colonias,
"txt_telefono" : txt_telefono,
"txt_referencia" : txt_referencia,
"chk_default" : chk_default
}
$.ajax({
cache: false,
data: parametros,
url: administrador + "administrador_usuario.php?accion=editar_dir_envio&id_dir=" + id_dir + "&id_cliente=" + id_cliente_js,
type: 'POST',
beforeSend: function () {
$("#result_informacion").html("<div class='procesando'>Procesando, espere por favor...</div>");
},
success: function (response) {
$("#result_informacion").html(response);
if($("#update_correcto").text()== 1){
alert('llega');
$("#result_informacion").html('<div class="encabezado-descripcion">Tus datos se han actualizado correctamente.</div>');
setTimeout('$("#boton_datos").click()', 2500);
}
}
});
}
function actualizar_ciudades(clave_estado) {
// var ecommerce = "http://localhost/ecommerce/";
$.post( ecommerce + 'direccion_envio/get_ciudades',
// when the Web server responds to the request
{ 'estado': clave_estado},
function(datos) {
var ciudades = datos.ciudades;
$("#sel_ciudades").empty();
$("<option></option>").attr("value", '').html('Selecionar').appendTo("#sel_ciudades");
if (ciudades != null) {
if (ciudades.length == undefined) { //DF sólo devuelve un obj de ciudad.
$("<option></option>").attr("value", ciudades.clave_ciudad).html(ciudades.ciudad).appendTo("#sel_ciudades");
$("#sel_ciudades").trigger('change'); //trigger cities' change event
} else { //ciudades.length == 'undefined'
$.each(ciudades, function(indice, ciudad) {
if (ciudad.clave_ciudad != '') {
$("<option></option>").attr("value", ciudad.clave_ciudad).html(ciudad.ciudad).appendTo("#sel_ciudades");
}
});
}
}
},
"json"
);
}
function actualizar_colonias(clave_estado, ciudad) {
//var ecommerce = "http://localhost/ecommerce/";
$.post( ecommerce + 'direccion_envio/get_colonias',
// when the Web server responds to the request
{ 'estado': clave_estado, 'ciudad': ciudad },
function(datos) {
var colonias = datos.colonias;
$("#sel_colonias").empty();
$("<option></option>").attr("value", '').html('Selecionar').appendTo("#sel_colonias");
if (colonias != null) {
$.each(colonias, function(indice, colonia) {
$("<option></option>").attr("value", colonia.colonia).html(colonia.colonia).appendTo("#sel_colonias");
});
}
},
"json"
);
}
function actualizar_cp(clave_estado, ciudad, colonia) {
//var ecommerce = "http://localhost/ecommerce/";
$.post( ecommerce + 'direccion_envio/get_colonias',
// when the Web server responds to the request
{ 'estado': clave_estado, 'ciudad': ciudad},
function(datos) {
var colonias = datos.colonias;
$.each(colonias, function(indice, col) {
if (colonia == col.colonia)
$("#txt_cp").val(col.codigo_postal);
//$("<option></option>").attr("value", colonia.colonia).html(colonia.colonia).appendTo("#sel_colonias");
});
},
"json"
);
}<｜fim▁end｜> |
actualizar_cp(clave_estado, ciudad, colonia);
}); |
<|file_name|>waker_ref.rs<|end_file_name|><｜fim▁begin｜>use super::arc_wake::{ArcWake};
use super::waker::waker_vtable;
use alloc::sync::Arc;
use core::mem::ManuallyDrop;
use core::marker::PhantomData;
use core::ops::Deref;
use core::task::{Waker, RawWaker};
/// A [`Waker`] that is only valid for a given lifetime.
///
/// Note: this type implements [`Deref<Target = Waker>`](std::ops::Deref),
/// so it can be used to get a `&Waker`.
#[derive(Debug)]
pub struct WakerRef<'a> {
waker: ManuallyDrop<Waker>,
_marker: PhantomData<&'a ()>,
}
impl<'a> WakerRef<'a> {
/// Create a new [`WakerRef`] from a [`Waker`] reference.
pub fn new(waker: &'a Waker) -> Self {
// copy the underlying (raw) waker without calling a clone,
// as we won't call Waker::drop either.
let waker = ManuallyDrop::new(unsafe { core::ptr::read(waker) });
WakerRef {
waker,
_marker: PhantomData,
}
}
/// Create a new [`WakerRef`] from a [`Waker`] that must not be dropped.
///
/// Note: this if for rare cases where the caller created a [`Waker`] in
/// an unsafe way (that will be valid only for a lifetime to be determined
/// by the caller), and the [`Waker`] doesn't need to or must not be
/// destroyed.
pub fn new_unowned(waker: ManuallyDrop<Waker>) -> Self {
WakerRef {
waker,
_marker: PhantomData,
}
}
}
impl Deref for WakerRef<'_> {
type Target = Waker;
fn deref(&self) -> &Waker {
&self.waker
}
}
/// Creates a reference to a [`Waker`] from a reference to `Arc<impl ArcWake>`.
///<｜fim▁hole｜>where
W: ArcWake
{
// simply copy the pointer instead of using Arc::into_raw,
// as we don't actually keep a refcount by using ManuallyDrop.<
let ptr = (&**wake as *const W) as *const ();
let waker = ManuallyDrop::new(unsafe {
Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>()))
});
WakerRef::new_unowned(waker)
}<｜fim▁end｜> | /// The resulting [`Waker`] will call
/// [`ArcWake.wake()`](ArcWake::wake) if awoken.
#[inline]
pub fn waker_ref<W>(wake: &Arc<W>) -> WakerRef<'_> |
<|file_name|>playlist-metadata-widget.service.ts<|end_file_name|><｜fim▁begin｜>import { Injectable, OnDestroy } from '@angular/core';
import { KalturaMultiRequest } from 'kaltura-ngx-client';
import { PlaylistWidget } from '../playlist-widget';
import { KalturaPlaylist } from 'kaltura-ngx-client';
import { Observable } from 'rxjs';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';
import { TagSearchAction } from 'kaltura-ngx-client';
import { KalturaTagFilter } from 'kaltura-ngx-client';
import { KalturaTaggedObjectType } from 'kaltura-ngx-client';
import { KalturaFilterPager } from 'kaltura-ngx-client';
import { KalturaClient } from 'kaltura-ngx-client';
import { asyncScheduler } from 'rxjs';
import { KMCPermissions, KMCPermissionsService } from 'app-shared/kmc-shared/kmc-permissions';
import { ContentPlaylistViewSections } from 'app-shared/kmc-shared/kmc-views/details-views';
import {KalturaLogger} from '@kaltura-ng/kaltura-logger';
import { cancelOnDestroy, tag } from '@kaltura-ng/kaltura-common';
import { observeOn } from 'rxjs/operators';
import { merge } from 'rxjs';
import { of } from 'rxjs';
@Injectable()
export class PlaylistMetadataWidget extends PlaylistWidget implements OnDestroy {
public metadataForm: FormGroup;
constructor(private _formBuilder: FormBuilder,
private _permissionsService: KMCPermissionsService,
private _kalturaServerClient: KalturaClient,
logger: KalturaLogger) {
super(ContentPlaylistViewSections.Metadata, logger);
this._buildForm();
}
ngOnDestroy() {
}
private _buildForm(): void {
this.metadataForm = this._formBuilder.group({
name: ['', Validators.required],
description: '',
tags: null
});
}
private _monitorFormChanges(): void {
merge(this.metadataForm.valueChanges, this.metadataForm.statusChanges)
.pipe(cancelOnDestroy(this))
.pipe(observeOn(asyncScheduler)) // using async scheduler so the form group status/dirty mode will be synchornized
.subscribe(() => {
super.updateState({
isValid: this.metadataForm.status !== 'INVALID',
isDirty: this.metadataForm.dirty
});
}
);
}
protected onValidate(wasActivated: boolean): Observable<{ isValid: boolean }> {
const name = wasActivated ? this.metadataForm.value.name : this.data.name;
const hasValue = (name || '').trim() !== '';
return of({
isValid: hasValue
});
}
protected onDataSaving(newData: KalturaPlaylist, request: KalturaMultiRequest): void {
if (this.wasActivated) {
const metadataFormValue = this.metadataForm.value;
newData.name = metadataFormValue.name;
newData.description = metadataFormValue.description;
newData.tags = (metadataFormValue.tags || []).join(',');
} else {
newData.name = this.data.name;<｜fim▁hole｜>
/**
* Do some cleanups if needed once the section is removed
*/
protected onReset(): void {
this.metadataForm.reset();
}
protected onActivate(firstTimeActivating: boolean): void {
this.metadataForm.reset({
name: this.data.name,
description: this.data.description,
tags: this.data.tags ? this.data.tags.split(', ') : null
});
if (firstTimeActivating) {
this._monitorFormChanges();
}
if (!this.isNewData && !this._permissionsService.hasPermission(KMCPermissions.PLAYLIST_UPDATE)) {
this.metadataForm.disable({ emitEvent: false, onlySelf: true });
}
}
public searchTags(text: string): Observable<string[]> {
return Observable.create(
observer => {
const requestSubscription = this._kalturaServerClient.request(
new TagSearchAction(
{
tagFilter: new KalturaTagFilter(
{
tagStartsWith: text,
objectTypeEqual: KalturaTaggedObjectType.entry
}
),
pager: new KalturaFilterPager({
pageIndex: 0,
pageSize: 30
})
}
)
)
.pipe(cancelOnDestroy(this))
.subscribe(
result => {
const tags = result.objects.map(item => item.tag);
observer.next(tags);
observer.complete();
},
err => {
observer.error(err);
}
);
return () => {
console.log('entryMetadataHandler.searchTags(): cancelled');
requestSubscription.unsubscribe();
}
});
}
}<｜fim▁end｜> | newData.description = this.data.description;
newData.tags = this.data.tags;
}
} |
<|file_name|>UriEnabledResource.java<|end_file_name|><｜fim▁begin｜>/*****************************************************************************************
* *** BEGIN LICENSE BLOCK *****
*
* Version: MPL 2.0
*
* echocat Jomon, Copyright (c) 2012-2013 echocat
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* *** END LICENSE BLOCK *****
****************************************************************************************/
package org.echocat.jomon.resources;
import javax.annotation.Nonnull;
public interface UriEnabledResource extends Resource {
@Nonnull
public String getUri();
<｜fim▁hole｜><｜fim▁end｜> | } |
<|file_name|>concept.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
"""Provides concept object."""
from __future__ import absolute_import
from .. import t1types
from ..entity import Entity
class Concept(Entity):
"""Concept entity."""
collection = 'concepts'
resource = 'concept'
_relations = {
'advertiser',
}
_pull = {
'advertiser_id': int,
'created_on': t1types.strpt,
'id': int,<｜fim▁hole｜> }
_push = _pull.copy()
_push.update({
'status': int,
})
def __init__(self, session, properties=None, **kwargs):
super(Concept, self).__init__(session, properties, **kwargs)<｜fim▁end｜> | 'name': None,
'status': t1types.int_to_bool,
'updated_on': t1types.strpt,
'version': int, |
<|file_name|>messages_et.js<|end_file_name|><｜fim▁begin｜><｜fim▁hole｜>(function( factory ) {
if ( typeof define === "function" && define.amd ) {
define( ["jquery", "../jquery.validate"], factory );
} else if (typeof exports === "object") {
factory(require("jquery"));
} else {
factory( jQuery );
}
}(function( $ ) {
/*
* Translated default messages for the jQuery validation plugin.
* Locale: ET (Estonian; eesti, eesti keel)
*/
$.extend($.validator.messages, {
required: "See väli peab olema täidetud.",
maxlength: $.validator.format("Palun sisestage vähem kui {0} tähemärki."),
minlength: $.validator.format("Palun sisestage vähemalt {0} tähemärki."),
rangelength: $.validator.format("Palun sisestage väärtus vahemikus {0} kuni {1} tähemärki."),
email: "Palun sisestage korrektne e-maili aadress.",
url: "Palun sisestage korrektne URL.",
date: "Palun sisestage korrektne kuupäev.",
dateISO: "Palun sisestage korrektne kuupäev (YYYY-MM-DD).",
number: "Palun sisestage korrektne number.",
digits: "Palun sisestage ainult numbreid.",
equalTo: "Palun sisestage sama väärtus uuesti.",
range: $.validator.format("Palun sisestage väärtus vahemikus {0} kuni {1}."),
max: $.validator.format("Palun sisestage väärtus, mis on väiksem või võrdne arvuga {0}."),
min: $.validator.format("Palun sisestage väärtus, mis on suurem või võrdne arvuga {0}."),
creditcard: "Palun sisestage korrektne krediitkaardi number."
});
}));<｜fim▁end｜> | |
<|file_name|>lib.rs<|end_file_name|><｜fim▁begin｜>use cookie::Cookie as Cookie_M;
use sapper::header::{Cookie, SetCookie};
use sapper::{Key, Request, Response, Result};
pub struct SessionVal;
impl Key for SessionVal {
type Value = String;
}
pub fn session_val(req: &mut Request, ckey: Option<&'static str>) -> Result<()> {
if ckey.is_none() {
return Ok(());
}
let mut session_value: Option<String> = None;
match req.headers().get::<Cookie>() {
Some(cookie_headers) => {
//let mut cookie_jar = CookieJar::new();
for header in cookie_headers.iter() {
let raw_str = match ::std::str::from_utf8(&header.as_bytes()) {
Ok(string) => string,
Err(_) => continue,
};
for cookie_str in raw_str.split(";").map(|s| s.trim()) {
if let Ok(cookie) = Cookie_M::parse(cookie_str) {
if cookie.name() == ckey.unwrap() {
session_value = Some(cookie.value().to_owned());
break;
}
}
}
}
}
None => {
println!("no cookie in headers");
}
}
session_value.and_then(|val| {
req.ext_mut().insert::<SessionVal>(val);<｜fim▁hole｜>}
// library function
pub fn set_cookie(
res: &mut Response,
ckey: String,
val: String,
domain: Option<String>,
path: Option<String>,
secure: Option<bool>,
max_age: Option<i64>,
) -> Result<()> {
let mut cookie = Cookie_M::new(ckey, val);
if domain.is_some() {
cookie.set_domain(domain.unwrap());
}
if path.is_some() {
cookie.set_path(path.unwrap());
}
if secure.is_some() {
cookie.set_secure(secure.unwrap());
}
if max_age.is_some() {
cookie.set_max_age(time::Duration::seconds(max_age.unwrap()))
}
res.headers_mut().set(SetCookie(vec![cookie.to_string()]));
Ok(())
}
#[cfg(test)]
mod tests {
#[test]
fn it_works() {}
}<｜fim▁end｜> | Some(())
});
Ok(()) |
<|file_name|>0009_auto_20201201_1412.py<|end_file_name|><｜fim▁begin｜># Generated by Django 2.2.15 on 2020-12-01 13:12
from django.db import migrations
import djmoney.models.fields
class Migration(migrations.Migration):
dependencies = [
("projects", "0008_auto_20190220_1133"),
]
operations = [
migrations.AddField(
model_name="project",
name="amount_invoiced",
field=djmoney.models.fields.MoneyField(
blank=True,
decimal_places=2,
default_currency="CHF",
max_digits=10,
null=True,
),
),
migrations.AddField(
model_name="project",
name="amount_invoiced_currency",
field=djmoney.models.fields.CurrencyField(
choices=[
("XUA", "ADB Unit of Account"),
("AFN", "Afghani"),
("DZD", "Algerian Dinar"),
("ARS", "Argentine Peso"),
("AMD", "Armenian Dram"),
("AWG", "Aruban Guilder"),
("AUD", "Australian Dollar"),
("AZN", "Azerbaijanian Manat"),
("BSD", "Bahamian Dollar"),
("BHD", "Bahraini Dinar"),
("THB", "Baht"),
("PAB", "Balboa"),
("BBD", "Barbados Dollar"),
("BYN", "Belarussian Ruble"),
("BYR", "Belarussian Ruble"),
("BZD", "Belize Dollar"),
("BMD", "Bermudian Dollar (customarily known as Bermuda Dollar)"),
("BTN", "Bhutanese ngultrum"),
("VEF", "Bolivar Fuerte"),
("BOB", "Boliviano"),
("XBA", "Bond Markets Units European Composite Unit (EURCO)"),
("BRL", "Brazilian Real"),
("BND", "Brunei Dollar"),
("BGN", "Bulgarian Lev"),
("BIF", "Burundi Franc"),
("XOF", "CFA Franc BCEAO"),
("XAF", "CFA franc BEAC"),
("XPF", "CFP Franc"),
("CAD", "Canadian Dollar"),
("CVE", "Cape Verde Escudo"),
("KYD", "Cayman Islands Dollar"),
("CLP", "Chilean peso"),
("XTS", "Codes specifically reserved for testing purposes"),
("COP", "Colombian peso"),
("KMF", "Comoro Franc"),
("CDF", "Congolese franc"),
("BAM", "Convertible Marks"),
("NIO", "Cordoba Oro"),
("CRC", "Costa Rican Colon"),
("HRK", "Croatian Kuna"),
("CUP", "Cuban Peso"),
("CUC", "Cuban convertible peso"),
("CZK", "Czech Koruna"),
("GMD", "Dalasi"),
("DKK", "Danish Krone"),
("MKD", "Denar"),
("DJF", "Djibouti Franc"),
("STD", "Dobra"),
("DOP", "Dominican Peso"),
("VND", "Dong"),
("XCD", "East Caribbean Dollar"),
("EGP", "Egyptian Pound"),
("SVC", "El Salvador Colon"),
("ETB", "Ethiopian Birr"),
("EUR", "Euro"),
("XBB", "European Monetary Unit (E.M.U.-6)"),
("XBD", "European Unit of Account 17(E.U.A.-17)"),
("XBC", "European Unit of Account 9(E.U.A.-9)"),
("FKP", "Falkland Islands Pound"),
("FJD", "Fiji Dollar"),
("HUF", "Forint"),
("GHS", "Ghana Cedi"),
("GIP", "Gibraltar Pound"),
("XAU", "Gold"),
("XFO", "Gold-Franc"),
("PYG", "Guarani"),
("GNF", "Guinea Franc"),
("GYD", "Guyana Dollar"),
("HTG", "Haitian gourde"),
("HKD", "Hong Kong Dollar"),
("UAH", "Hryvnia"),
("ISK", "Iceland Krona"),
("INR", "Indian Rupee"),
("IRR", "Iranian Rial"),
("IQD", "Iraqi Dinar"),
("IMP", "Isle of Man Pound"),
("JMD", "Jamaican Dollar"),
("JOD", "Jordanian Dinar"),
("KES", "Kenyan Shilling"),
("PGK", "Kina"),
("LAK", "Kip"),
("KWD", "Kuwaiti Dinar"),
("AOA", "Kwanza"),
("MMK", "Kyat"),
("GEL", "Lari"),
("LVL", "Latvian Lats"),
("LBP", "Lebanese Pound"),
("ALL", "Lek"),
("HNL", "Lempira"),
("SLL", "Leone"),
("LSL", "Lesotho loti"),
("LRD", "Liberian Dollar"),
("LYD", "Libyan Dinar"),
("SZL", "Lilangeni"),
("LTL", "Lithuanian Litas"),
("MGA", "Malagasy Ariary"),
("MWK", "Malawian Kwacha"),
("MYR", "Malaysian Ringgit"),
("TMM", "Manat"),
("MUR", "Mauritius Rupee"),
("MZN", "Metical"),
("MXV", "Mexican Unidad de Inversion (UDI)"),
("MXN", "Mexican peso"),
("MDL", "Moldovan Leu"),
("MAD", "Moroccan Dirham"),
("BOV", "Mvdol"),
("NGN", "Naira"),
("ERN", "Nakfa"),
("NAD", "Namibian Dollar"),
("NPR", "Nepalese Rupee"),
("ANG", "Netherlands Antillian Guilder"),
("ILS", "New Israeli Sheqel"),
("RON", "New Leu"),
("TWD", "New Taiwan Dollar"),
("NZD", "New Zealand Dollar"),
("KPW", "North Korean Won"),
("NOK", "Norwegian Krone"),
("PEN", "Nuevo Sol"),
("MRO", "Ouguiya"),
("TOP", "Paanga"),
("PKR", "Pakistan Rupee"),
("XPD", "Palladium"),
("MOP", "Pataca"),
("PHP", "Philippine Peso"),
("XPT", "Platinum"),
("GBP", "Pound Sterling"),
("BWP", "Pula"),
("QAR", "Qatari Rial"),
("GTQ", "Quetzal"),
("ZAR", "Rand"),
("OMR", "Rial Omani"),
("KHR", "Riel"),
("MVR", "Rufiyaa"),
("IDR", "Rupiah"),
("RUB", "Russian Ruble"),
("RWF", "Rwanda Franc"),
("XDR", "SDR"),
("SHP", "Saint Helena Pound"),
("SAR", "Saudi Riyal"),
("RSD", "Serbian Dinar"),
("SCR", "Seychelles Rupee"),
("XAG", "Silver"),
("SGD", "Singapore Dollar"),
("SBD", "Solomon Islands Dollar"),
("KGS", "Som"),
("SOS", "Somali Shilling"),
("TJS", "Somoni"),
("SSP", "South Sudanese Pound"),
("LKR", "Sri Lanka Rupee"),
("XSU", "Sucre"),
("SDG", "Sudanese Pound"),
("SRD", "Surinam Dollar"),
("SEK", "Swedish Krona"),
("CHF", "Swiss Franc"),
("SYP", "Syrian Pound"),
("BDT", "Taka"),
("WST", "Tala"),
("TZS", "Tanzanian Shilling"),
("KZT", "Tenge"),
(
"XXX",
"The codes assigned for transactions where no currency is involved",
),
("TTD", "Trinidad and Tobago Dollar"),
("MNT", "Tugrik"),
("TND", "Tunisian Dinar"),
("TRY", "Turkish Lira"),
("TMT", "Turkmenistan New Manat"),
("TVD", "Tuvalu dollar"),
("AED", "UAE Dirham"),
("XFU", "UIC-Franc"),
("USD", "US Dollar"),
("USN", "US Dollar (Next day)"),
("UGX", "Uganda Shilling"),
("CLF", "Unidad de Fomento"),
("COU", "Unidad de Valor Real"),
("UYI", "Uruguay Peso en Unidades Indexadas (URUIURUI)"),
("UYU", "Uruguayan peso"),
("UZS", "Uzbekistan Sum"),
("VUV", "Vatu"),
("CHE", "WIR Euro"),
("CHW", "WIR Franc"),
("KRW", "Won"),
("YER", "Yemeni Rial"),
("JPY", "Yen"),
("CNY", "Yuan Renminbi"),
("ZMK", "Zambian Kwacha"),
("ZMW", "Zambian Kwacha"),
("ZWD", "Zimbabwe Dollar A/06"),
("ZWN", "Zimbabwe dollar A/08"),
("ZWL", "Zimbabwe dollar A/09"),
("PLN", "Zloty"),
],
default="CHF",
editable=False,
max_length=3,
),
),
migrations.AddField(
model_name="project",
name="amount_offered",
field=djmoney.models.fields.MoneyField(
blank=True,
decimal_places=2,
default_currency="CHF",
max_digits=10,
null=True,
),
),
migrations.AddField(
model_name="project",
name="amount_offered_currency",
field=djmoney.models.fields.CurrencyField(
choices=[
("XUA", "ADB Unit of Account"),
("AFN", "Afghani"),
("DZD", "Algerian Dinar"),
("ARS", "Argentine Peso"),
("AMD", "Armenian Dram"),
("AWG", "Aruban Guilder"),
("AUD", "Australian Dollar"),
("AZN", "Azerbaijanian Manat"),
("BSD", "Bahamian Dollar"),
("BHD", "Bahraini Dinar"),
("THB", "Baht"),
("PAB", "Balboa"),
("BBD", "Barbados Dollar"),
("BYN", "Belarussian Ruble"),
("BYR", "Belarussian Ruble"),
("BZD", "Belize Dollar"),
("BMD", "Bermudian Dollar (customarily known as Bermuda Dollar)"),
("BTN", "Bhutanese ngultrum"),
("VEF", "Bolivar Fuerte"),
("BOB", "Boliviano"),
("XBA", "Bond Markets Units European Composite Unit (EURCO)"),
("BRL", "Brazilian Real"),
("BND", "Brunei Dollar"),
("BGN", "Bulgarian Lev"),
("BIF", "Burundi Franc"),
("XOF", "CFA Franc BCEAO"),
("XAF", "CFA franc BEAC"),
("XPF", "CFP Franc"),
("CAD", "Canadian Dollar"),
("CVE", "Cape Verde Escudo"),
("KYD", "Cayman Islands Dollar"),
("CLP", "Chilean peso"),
("XTS", "Codes specifically reserved for testing purposes"),
("COP", "Colombian peso"),
("KMF", "Comoro Franc"),
("CDF", "Congolese franc"),
("BAM", "Convertible Marks"),
("NIO", "Cordoba Oro"),
("CRC", "Costa Rican Colon"),
("HRK", "Croatian Kuna"),
("CUP", "Cuban Peso"),
("CUC", "Cuban convertible peso"),
("CZK", "Czech Koruna"),
("GMD", "Dalasi"),
("DKK", "Danish Krone"),
("MKD", "Denar"),
("DJF", "Djibouti Franc"),
("STD", "Dobra"),
("DOP", "Dominican Peso"),
("VND", "Dong"),
("XCD", "East Caribbean Dollar"),
("EGP", "Egyptian Pound"),
("SVC", "El Salvador Colon"),
("ETB", "Ethiopian Birr"),
("EUR", "Euro"),
("XBB", "European Monetary Unit (E.M.U.-6)"),
("XBD", "European Unit of Account 17(E.U.A.-17)"),
("XBC", "European Unit of Account 9(E.U.A.-9)"),
("FKP", "Falkland Islands Pound"),
("FJD", "Fiji Dollar"),<｜fim▁hole｜> ("GHS", "Ghana Cedi"),
("GIP", "Gibraltar Pound"),
("XAU", "Gold"),
("XFO", "Gold-Franc"),
("PYG", "Guarani"),
("GNF", "Guinea Franc"),
("GYD", "Guyana Dollar"),
("HTG", "Haitian gourde"),
("HKD", "Hong Kong Dollar"),
("UAH", "Hryvnia"),
("ISK", "Iceland Krona"),
("INR", "Indian Rupee"),
("IRR", "Iranian Rial"),
("IQD", "Iraqi Dinar"),
("IMP", "Isle of Man Pound"),
("JMD", "Jamaican Dollar"),
("JOD", "Jordanian Dinar"),
("KES", "Kenyan Shilling"),
("PGK", "Kina"),
("LAK", "Kip"),
("KWD", "Kuwaiti Dinar"),
("AOA", "Kwanza"),
("MMK", "Kyat"),
("GEL", "Lari"),
("LVL", "Latvian Lats"),
("LBP", "Lebanese Pound"),
("ALL", "Lek"),
("HNL", "Lempira"),
("SLL", "Leone"),
("LSL", "Lesotho loti"),
("LRD", "Liberian Dollar"),
("LYD", "Libyan Dinar"),
("SZL", "Lilangeni"),
("LTL", "Lithuanian Litas"),
("MGA", "Malagasy Ariary"),
("MWK", "Malawian Kwacha"),
("MYR", "Malaysian Ringgit"),
("TMM", "Manat"),
("MUR", "Mauritius Rupee"),
("MZN", "Metical"),
("MXV", "Mexican Unidad de Inversion (UDI)"),
("MXN", "Mexican peso"),
("MDL", "Moldovan Leu"),
("MAD", "Moroccan Dirham"),
("BOV", "Mvdol"),
("NGN", "Naira"),
("ERN", "Nakfa"),
("NAD", "Namibian Dollar"),
("NPR", "Nepalese Rupee"),
("ANG", "Netherlands Antillian Guilder"),
("ILS", "New Israeli Sheqel"),
("RON", "New Leu"),
("TWD", "New Taiwan Dollar"),
("NZD", "New Zealand Dollar"),
("KPW", "North Korean Won"),
("NOK", "Norwegian Krone"),
("PEN", "Nuevo Sol"),
("MRO", "Ouguiya"),
("TOP", "Paanga"),
("PKR", "Pakistan Rupee"),
("XPD", "Palladium"),
("MOP", "Pataca"),
("PHP", "Philippine Peso"),
("XPT", "Platinum"),
("GBP", "Pound Sterling"),
("BWP", "Pula"),
("QAR", "Qatari Rial"),
("GTQ", "Quetzal"),
("ZAR", "Rand"),
("OMR", "Rial Omani"),
("KHR", "Riel"),
("MVR", "Rufiyaa"),
("IDR", "Rupiah"),
("RUB", "Russian Ruble"),
("RWF", "Rwanda Franc"),
("XDR", "SDR"),
("SHP", "Saint Helena Pound"),
("SAR", "Saudi Riyal"),
("RSD", "Serbian Dinar"),
("SCR", "Seychelles Rupee"),
("XAG", "Silver"),
("SGD", "Singapore Dollar"),
("SBD", "Solomon Islands Dollar"),
("KGS", "Som"),
("SOS", "Somali Shilling"),
("TJS", "Somoni"),
("SSP", "South Sudanese Pound"),
("LKR", "Sri Lanka Rupee"),
("XSU", "Sucre"),
("SDG", "Sudanese Pound"),
("SRD", "Surinam Dollar"),
("SEK", "Swedish Krona"),
("CHF", "Swiss Franc"),
("SYP", "Syrian Pound"),
("BDT", "Taka"),
("WST", "Tala"),
("TZS", "Tanzanian Shilling"),
("KZT", "Tenge"),
(
"XXX",
"The codes assigned for transactions where no currency is involved",
),
("TTD", "Trinidad and Tobago Dollar"),
("MNT", "Tugrik"),
("TND", "Tunisian Dinar"),
("TRY", "Turkish Lira"),
("TMT", "Turkmenistan New Manat"),
("TVD", "Tuvalu dollar"),
("AED", "UAE Dirham"),
("XFU", "UIC-Franc"),
("USD", "US Dollar"),
("USN", "US Dollar (Next day)"),
("UGX", "Uganda Shilling"),
("CLF", "Unidad de Fomento"),
("COU", "Unidad de Valor Real"),
("UYI", "Uruguay Peso en Unidades Indexadas (URUIURUI)"),
("UYU", "Uruguayan peso"),
("UZS", "Uzbekistan Sum"),
("VUV", "Vatu"),
("CHE", "WIR Euro"),
("CHW", "WIR Franc"),
("KRW", "Won"),
("YER", "Yemeni Rial"),
("JPY", "Yen"),
("CNY", "Yuan Renminbi"),
("ZMK", "Zambian Kwacha"),
("ZMW", "Zambian Kwacha"),
("ZWD", "Zimbabwe Dollar A/06"),
("ZWN", "Zimbabwe dollar A/08"),
("ZWL", "Zimbabwe dollar A/09"),
("PLN", "Zloty"),
],
default="CHF",
editable=False,
max_length=3,
),
),
migrations.AddField(
model_name="task",
name="amount_invoiced",
field=djmoney.models.fields.MoneyField(
blank=True,
decimal_places=2,
default_currency="CHF",
max_digits=10,
null=True,
),
),
migrations.AddField(
model_name="task",
name="amount_invoiced_currency",
field=djmoney.models.fields.CurrencyField(
choices=[
("XUA", "ADB Unit of Account"),
("AFN", "Afghani"),
("DZD", "Algerian Dinar"),
("ARS", "Argentine Peso"),
("AMD", "Armenian Dram"),
("AWG", "Aruban Guilder"),
("AUD", "Australian Dollar"),
("AZN", "Azerbaijanian Manat"),
("BSD", "Bahamian Dollar"),
("BHD", "Bahraini Dinar"),
("THB", "Baht"),
("PAB", "Balboa"),
("BBD", "Barbados Dollar"),
("BYN", "Belarussian Ruble"),
("BYR", "Belarussian Ruble"),
("BZD", "Belize Dollar"),
("BMD", "Bermudian Dollar (customarily known as Bermuda Dollar)"),
("BTN", "Bhutanese ngultrum"),
("VEF", "Bolivar Fuerte"),
("BOB", "Boliviano"),
("XBA", "Bond Markets Units European Composite Unit (EURCO)"),
("BRL", "Brazilian Real"),
("BND", "Brunei Dollar"),
("BGN", "Bulgarian Lev"),
("BIF", "Burundi Franc"),
("XOF", "CFA Franc BCEAO"),
("XAF", "CFA franc BEAC"),
("XPF", "CFP Franc"),
("CAD", "Canadian Dollar"),
("CVE", "Cape Verde Escudo"),
("KYD", "Cayman Islands Dollar"),
("CLP", "Chilean peso"),
("XTS", "Codes specifically reserved for testing purposes"),
("COP", "Colombian peso"),
("KMF", "Comoro Franc"),
("CDF", "Congolese franc"),
("BAM", "Convertible Marks"),
("NIO", "Cordoba Oro"),
("CRC", "Costa Rican Colon"),
("HRK", "Croatian Kuna"),
("CUP", "Cuban Peso"),
("CUC", "Cuban convertible peso"),
("CZK", "Czech Koruna"),
("GMD", "Dalasi"),
("DKK", "Danish Krone"),
("MKD", "Denar"),
("DJF", "Djibouti Franc"),
("STD", "Dobra"),
("DOP", "Dominican Peso"),
("VND", "Dong"),
("XCD", "East Caribbean Dollar"),
("EGP", "Egyptian Pound"),
("SVC", "El Salvador Colon"),
("ETB", "Ethiopian Birr"),
("EUR", "Euro"),
("XBB", "European Monetary Unit (E.M.U.-6)"),
("XBD", "European Unit of Account 17(E.U.A.-17)"),
("XBC", "European Unit of Account 9(E.U.A.-9)"),
("FKP", "Falkland Islands Pound"),
("FJD", "Fiji Dollar"),
("HUF", "Forint"),
("GHS", "Ghana Cedi"),
("GIP", "Gibraltar Pound"),
("XAU", "Gold"),
("XFO", "Gold-Franc"),
("PYG", "Guarani"),
("GNF", "Guinea Franc"),
("GYD", "Guyana Dollar"),
("HTG", "Haitian gourde"),
("HKD", "Hong Kong Dollar"),
("UAH", "Hryvnia"),
("ISK", "Iceland Krona"),
("INR", "Indian Rupee"),
("IRR", "Iranian Rial"),
("IQD", "Iraqi Dinar"),
("IMP", "Isle of Man Pound"),
("JMD", "Jamaican Dollar"),
("JOD", "Jordanian Dinar"),
("KES", "Kenyan Shilling"),
("PGK", "Kina"),
("LAK", "Kip"),
("KWD", "Kuwaiti Dinar"),
("AOA", "Kwanza"),
("MMK", "Kyat"),
("GEL", "Lari"),
("LVL", "Latvian Lats"),
("LBP", "Lebanese Pound"),
("ALL", "Lek"),
("HNL", "Lempira"),
("SLL", "Leone"),
("LSL", "Lesotho loti"),
("LRD", "Liberian Dollar"),
("LYD", "Libyan Dinar"),
("SZL", "Lilangeni"),
("LTL", "Lithuanian Litas"),
("MGA", "Malagasy Ariary"),
("MWK", "Malawian Kwacha"),
("MYR", "Malaysian Ringgit"),
("TMM", "Manat"),
("MUR", "Mauritius Rupee"),
("MZN", "Metical"),
("MXV", "Mexican Unidad de Inversion (UDI)"),
("MXN", "Mexican peso"),
("MDL", "Moldovan Leu"),
("MAD", "Moroccan Dirham"),
("BOV", "Mvdol"),
("NGN", "Naira"),
("ERN", "Nakfa"),
("NAD", "Namibian Dollar"),
("NPR", "Nepalese Rupee"),
("ANG", "Netherlands Antillian Guilder"),
("ILS", "New Israeli Sheqel"),
("RON", "New Leu"),
("TWD", "New Taiwan Dollar"),
("NZD", "New Zealand Dollar"),
("KPW", "North Korean Won"),
("NOK", "Norwegian Krone"),
("PEN", "Nuevo Sol"),
("MRO", "Ouguiya"),
("TOP", "Paanga"),
("PKR", "Pakistan Rupee"),
("XPD", "Palladium"),
("MOP", "Pataca"),
("PHP", "Philippine Peso"),
("XPT", "Platinum"),
("GBP", "Pound Sterling"),
("BWP", "Pula"),
("QAR", "Qatari Rial"),
("GTQ", "Quetzal"),
("ZAR", "Rand"),
("OMR", "Rial Omani"),
("KHR", "Riel"),
("MVR", "Rufiyaa"),
("IDR", "Rupiah"),
("RUB", "Russian Ruble"),
("RWF", "Rwanda Franc"),
("XDR", "SDR"),
("SHP", "Saint Helena Pound"),
("SAR", "Saudi Riyal"),
("RSD", "Serbian Dinar"),
("SCR", "Seychelles Rupee"),
("XAG", "Silver"),
("SGD", "Singapore Dollar"),
("SBD", "Solomon Islands Dollar"),
("KGS", "Som"),
("SOS", "Somali Shilling"),
("TJS", "Somoni"),
("SSP", "South Sudanese Pound"),
("LKR", "Sri Lanka Rupee"),
("XSU", "Sucre"),
("SDG", "Sudanese Pound"),
("SRD", "Surinam Dollar"),
("SEK", "Swedish Krona"),
("CHF", "Swiss Franc"),
("SYP", "Syrian Pound"),
("BDT", "Taka"),
("WST", "Tala"),
("TZS", "Tanzanian Shilling"),
("KZT", "Tenge"),
(
"XXX",
"The codes assigned for transactions where no currency is involved",
),
("TTD", "Trinidad and Tobago Dollar"),
("MNT", "Tugrik"),
("TND", "Tunisian Dinar"),
("TRY", "Turkish Lira"),
("TMT", "Turkmenistan New Manat"),
("TVD", "Tuvalu dollar"),
("AED", "UAE Dirham"),
("XFU", "UIC-Franc"),
("USD", "US Dollar"),
("USN", "US Dollar (Next day)"),
("UGX", "Uganda Shilling"),
("CLF", "Unidad de Fomento"),
("COU", "Unidad de Valor Real"),
("UYI", "Uruguay Peso en Unidades Indexadas (URUIURUI)"),
("UYU", "Uruguayan peso"),
("UZS", "Uzbekistan Sum"),
("VUV", "Vatu"),
("CHE", "WIR Euro"),
("CHW", "WIR Franc"),
("KRW", "Won"),
("YER", "Yemeni Rial"),
("JPY", "Yen"),
("CNY", "Yuan Renminbi"),
("ZMK", "Zambian Kwacha"),
("ZMW", "Zambian Kwacha"),
("ZWD", "Zimbabwe Dollar A/06"),
("ZWN", "Zimbabwe dollar A/08"),
("ZWL", "Zimbabwe dollar A/09"),
("PLN", "Zloty"),
],
default="CHF",
editable=False,
max_length=3,
),
),
migrations.AddField(
model_name="task",
name="amount_offered",
field=djmoney.models.fields.MoneyField(
blank=True,
decimal_places=2,
default_currency="CHF",
max_digits=10,
null=True,
),
),
migrations.AddField(
model_name="task",
name="amount_offered_currency",
field=djmoney.models.fields.CurrencyField(
choices=[
("XUA", "ADB Unit of Account"),
("AFN", "Afghani"),
("DZD", "Algerian Dinar"),
("ARS", "Argentine Peso"),
("AMD", "Armenian Dram"),
("AWG", "Aruban Guilder"),
("AUD", "Australian Dollar"),
("AZN", "Azerbaijanian Manat"),
("BSD", "Bahamian Dollar"),
("BHD", "Bahraini Dinar"),
("THB", "Baht"),
("PAB", "Balboa"),
("BBD", "Barbados Dollar"),
("BYN", "Belarussian Ruble"),
("BYR", "Belarussian Ruble"),
("BZD", "Belize Dollar"),
("BMD", "Bermudian Dollar (customarily known as Bermuda Dollar)"),
("BTN", "Bhutanese ngultrum"),
("VEF", "Bolivar Fuerte"),
("BOB", "Boliviano"),
("XBA", "Bond Markets Units European Composite Unit (EURCO)"),
("BRL", "Brazilian Real"),
("BND", "Brunei Dollar"),
("BGN", "Bulgarian Lev"),
("BIF", "Burundi Franc"),
("XOF", "CFA Franc BCEAO"),
("XAF", "CFA franc BEAC"),
("XPF", "CFP Franc"),
("CAD", "Canadian Dollar"),
("CVE", "Cape Verde Escudo"),
("KYD", "Cayman Islands Dollar"),
("CLP", "Chilean peso"),
("XTS", "Codes specifically reserved for testing purposes"),
("COP", "Colombian peso"),
("KMF", "Comoro Franc"),
("CDF", "Congolese franc"),
("BAM", "Convertible Marks"),
("NIO", "Cordoba Oro"),
("CRC", "Costa Rican Colon"),
("HRK", "Croatian Kuna"),
("CUP", "Cuban Peso"),
("CUC", "Cuban convertible peso"),
("CZK", "Czech Koruna"),
("GMD", "Dalasi"),
("DKK", "Danish Krone"),
("MKD", "Denar"),
("DJF", "Djibouti Franc"),
("STD", "Dobra"),
("DOP", "Dominican Peso"),
("VND", "Dong"),
("XCD", "East Caribbean Dollar"),
("EGP", "Egyptian Pound"),
("SVC", "El Salvador Colon"),
("ETB", "Ethiopian Birr"),
("EUR", "Euro"),
("XBB", "European Monetary Unit (E.M.U.-6)"),
("XBD", "European Unit of Account 17(E.U.A.-17)"),
("XBC", "European Unit of Account 9(E.U.A.-9)"),
("FKP", "Falkland Islands Pound"),
("FJD", "Fiji Dollar"),
("HUF", "Forint"),
("GHS", "Ghana Cedi"),
("GIP", "Gibraltar Pound"),
("XAU", "Gold"),
("XFO", "Gold-Franc"),
("PYG", "Guarani"),
("GNF", "Guinea Franc"),
("GYD", "Guyana Dollar"),
("HTG", "Haitian gourde"),
("HKD", "Hong Kong Dollar"),
("UAH", "Hryvnia"),
("ISK", "Iceland Krona"),
("INR", "Indian Rupee"),
("IRR", "Iranian Rial"),
("IQD", "Iraqi Dinar"),
("IMP", "Isle of Man Pound"),
("JMD", "Jamaican Dollar"),
("JOD", "Jordanian Dinar"),
("KES", "Kenyan Shilling"),
("PGK", "Kina"),
("LAK", "Kip"),
("KWD", "Kuwaiti Dinar"),
("AOA", "Kwanza"),
("MMK", "Kyat"),
("GEL", "Lari"),
("LVL", "Latvian Lats"),
("LBP", "Lebanese Pound"),
("ALL", "Lek"),
("HNL", "Lempira"),
("SLL", "Leone"),
("LSL", "Lesotho loti"),
("LRD", "Liberian Dollar"),
("LYD", "Libyan Dinar"),
("SZL", "Lilangeni"),
("LTL", "Lithuanian Litas"),
("MGA", "Malagasy Ariary"),
("MWK", "Malawian Kwacha"),
("MYR", "Malaysian Ringgit"),
("TMM", "Manat"),
("MUR", "Mauritius Rupee"),
("MZN", "Metical"),
("MXV", "Mexican Unidad de Inversion (UDI)"),
("MXN", "Mexican peso"),
("MDL", "Moldovan Leu"),
("MAD", "Moroccan Dirham"),
("BOV", "Mvdol"),
("NGN", "Naira"),
("ERN", "Nakfa"),
("NAD", "Namibian Dollar"),
("NPR", "Nepalese Rupee"),
("ANG", "Netherlands Antillian Guilder"),
("ILS", "New Israeli Sheqel"),
("RON", "New Leu"),
("TWD", "New Taiwan Dollar"),
("NZD", "New Zealand Dollar"),
("KPW", "North Korean Won"),
("NOK", "Norwegian Krone"),
("PEN", "Nuevo Sol"),
("MRO", "Ouguiya"),
("TOP", "Paanga"),
("PKR", "Pakistan Rupee"),
("XPD", "Palladium"),
("MOP", "Pataca"),
("PHP", "Philippine Peso"),
("XPT", "Platinum"),
("GBP", "Pound Sterling"),
("BWP", "Pula"),
("QAR", "Qatari Rial"),
("GTQ", "Quetzal"),
("ZAR", "Rand"),
("OMR", "Rial Omani"),
("KHR", "Riel"),
("MVR", "Rufiyaa"),
("IDR", "Rupiah"),
("RUB", "Russian Ruble"),
("RWF", "Rwanda Franc"),
("XDR", "SDR"),
("SHP", "Saint Helena Pound"),
("SAR", "Saudi Riyal"),
("RSD", "Serbian Dinar"),
("SCR", "Seychelles Rupee"),
("XAG", "Silver"),
("SGD", "Singapore Dollar"),
("SBD", "Solomon Islands Dollar"),
("KGS", "Som"),
("SOS", "Somali Shilling"),
("TJS", "Somoni"),
("SSP", "South Sudanese Pound"),
("LKR", "Sri Lanka Rupee"),
("XSU", "Sucre"),
("SDG", "Sudanese Pound"),
("SRD", "Surinam Dollar"),
("SEK", "Swedish Krona"),
("CHF", "Swiss Franc"),
("SYP", "Syrian Pound"),
("BDT", "Taka"),
("WST", "Tala"),
("TZS", "Tanzanian Shilling"),
("KZT", "Tenge"),
(
"XXX",
"The codes assigned for transactions where no currency is involved",
),
("TTD", "Trinidad and Tobago Dollar"),
("MNT", "Tugrik"),
("TND", "Tunisian Dinar"),
("TRY", "Turkish Lira"),
("TMT", "Turkmenistan New Manat"),
("TVD", "Tuvalu dollar"),
("AED", "UAE Dirham"),
("XFU", "UIC-Franc"),
("USD", "US Dollar"),
("USN", "US Dollar (Next day)"),
("UGX", "Uganda Shilling"),
("CLF", "Unidad de Fomento"),
("COU", "Unidad de Valor Real"),
("UYI", "Uruguay Peso en Unidades Indexadas (URUIURUI)"),
("UYU", "Uruguayan peso"),
("UZS", "Uzbekistan Sum"),
("VUV", "Vatu"),
("CHE", "WIR Euro"),
("CHW", "WIR Franc"),
("KRW", "Won"),
("YER", "Yemeni Rial"),
("JPY", "Yen"),
("CNY", "Yuan Renminbi"),
("ZMK", "Zambian Kwacha"),
("ZMW", "Zambian Kwacha"),
("ZWD", "Zimbabwe Dollar A/06"),
("ZWN", "Zimbabwe dollar A/08"),
("ZWL", "Zimbabwe dollar A/09"),
("PLN", "Zloty"),
],
default="CHF",
editable=False,
max_length=3,
),
),
]<｜fim▁end｜> | ("HUF", "Forint"), |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜># Copyright 2015 Google Inc. 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<｜fim▁hole｜># limitations under the License.
"""A setuptools based setup module.
See:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
# This file conforms to the external style guide.
# pylint: disable=bad-indentation
import codecs
import os
import setuptools
here = os.path.abspath(os.path.dirname(__file__))
with codecs.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
long_description = f.read()
setuptools.setup(
name='appstart',
version='0.8',
description='A utility to start GAE Managed VMs in containers.',
long_description=long_description,
url='https://github.com/GoogleCloudPlatform/appstart',
author='Mitchell Gouzenko',
author_email='[email protected]',
license='APACHE',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Development Tools',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords='GAE Google App Engine appengine development docker',
packages=setuptools.find_packages(exclude='tests'),
package_data={'appstart.devappserver_init': ['Dockerfile', 'das.sh'],
'appstart.pinger': ['Dockerfile'],
'appstart.sandbox': ['app.yaml']},
install_requires=['docker-py'],
entry_points={
'console_scripts': [
'appstart=appstart.cli.start_script:main',
],
},
)<｜fim▁end｜> | |
<|file_name|>gpa.py<|end_file_name|><｜fim▁begin｜><｜fim▁hole｜># Class list file should be a csv with COURSE_ID,NUM_UNITS,GRADE
# GRADE should be LETTER with potential modifiers after that
# registrar.mit.edu/classes-grades-evaluations/grades/calculating-gpa
import argparse
import pandas as pd
def get_parser():
# Get the argument parser for this script
parser = argparse.ArgumentParser()
parser.add_argument('-F', '--filename', help='Filename for grades')
return parser
class GPACalculator:
def __init__(self, fname):
# Load file via pandas
self.__data = pd.read_csv(
fname,
header=None,
names=['course', 'units', 'grade']
)
def calc_gpa(self):
# Map grades to grade points
grade_points = self.__data.grade.apply(self.__grade_point_mapper)
# Multiply pointwise by units
grade_points_weighted = grade_points * self.__data.units
# Sum weighted units
weighted_units_sum = grade_points_weighted.sum()
# Divide by total units
gpa_raw = weighted_units_sum / self.__data.units.sum()
# Round to nearest tenth
return round(gpa_raw, 1)
def __grade_point_mapper(self, grade):
# Maps a string letter grade to a numerical value
# MIT 5.0 scale
grade_map = {
'A': 5,
'B': 4,
'C': 3,
'D': 2,
'F': 0,
}
first_char = grade[0].upper()
try:
return grade_map[first_char]
except:
raise ValueError('Invalid grade {grade}'.format(grade=grade))
if __name__ == '__main__':
# Set up argument parsing
parser = get_parser()
args = parser.parse_args()
# Make sure filename is present
if not args.filename:
raise ValueError('Must provide filename via -F, --filename')
# Create calculator
calc = GPACalculator(args.filename)
# Execute and print
gpa = calc.calc_gpa()
print(gpa)<｜fim▁end｜> | # Quick script to calculate GPA given a class list file. |
<|file_name|>test_metaplugin.py<|end_file_name|><｜fim▁begin｜># vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2012, Nachi Ueno, NTT MCL, Inc.
# 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.
import os
import mock
import mox
from oslo.config import cfg
import stubout
import testtools
from quantum import context
from quantum.db import api as db
from quantum.extensions.flavor import (FLAVOR_NETWORK, FLAVOR_ROUTER)
from quantum.openstack.common import uuidutils
from quantum.plugins.metaplugin.meta_quantum_plugin import FlavorNotFound
from quantum.plugins.metaplugin.meta_quantum_plugin import MetaPluginV2
from quantum.tests import base
CONF_FILE = ""
ROOTDIR = os.path.dirname(os.path.dirname(__file__))
ETCDIR = os.path.join(ROOTDIR, 'etc')
META_PATH = "quantum.plugins.metaplugin"
FAKE_PATH = "quantum.tests.unit.metaplugin"
PROXY_PATH = "%s.proxy_quantum_plugin.ProxyPluginV2" % META_PATH
PLUGIN_LIST = """
fake1:%s.fake_plugin.Fake1,fake2:%s.fake_plugin.Fake2,proxy:%s
""".strip() % (FAKE_PATH, FAKE_PATH, PROXY_PATH)
L3_PLUGIN_LIST = """
fake1:%s.fake_plugin.Fake1,fake2:%s.fake_plugin.Fake2
""".strip() % (FAKE_PATH, FAKE_PATH)
def etcdir(*p):
return os.path.join(ETCDIR, *p)
def setup_metaplugin_conf():
cfg.CONF.set_override('auth_url', 'http://localhost:35357/v2.0',
'PROXY')
cfg.CONF.set_override('auth_region', 'RegionOne', 'PROXY')
cfg.CONF.set_override('admin_user', 'quantum', 'PROXY')
cfg.CONF.set_override('admin_password', 'password', 'PROXY')
cfg.CONF.set_override('admin_tenant_name', 'service', 'PROXY')
cfg.CONF.set_override('plugin_list', PLUGIN_LIST, 'META')
cfg.CONF.set_override('l3_plugin_list', L3_PLUGIN_LIST, 'META')
cfg.CONF.set_override('default_flavor', 'fake2', 'META')
cfg.CONF.set_override('default_l3_flavor', 'fake1', 'META')
cfg.CONF.set_override('base_mac', "12:34:56:78:90:ab")
#TODO(nati) remove this after subnet quota change is merged
cfg.CONF.set_override('max_dns_nameservers', 10)
cfg.CONF.set_override('rpc_backend',
'quantum.openstack.common.rpc.impl_fake')
class MetaQuantumPluginV2Test(base.BaseTestCase):
"""Class conisting of MetaQuantumPluginV2 unit tests."""
def setUp(self):
super(MetaQuantumPluginV2Test, self).setUp()
db._ENGINE = None
db._MAKER = None
self.fake_tenant_id = uuidutils.generate_uuid()
self.context = context.get_admin_context()
db.configure_db()
setup_metaplugin_conf()
self.mox = mox.Mox()
self.stubs = stubout.StubOutForTesting()
self.client_cls_p = mock.patch('quantumclient.v2_0.client.Client')
client_cls = self.client_cls_p.start()
self.client_inst = mock.Mock()
client_cls.return_value = self.client_inst
self.client_inst.create_network.return_value = \
{'id': 'fake_id'}
self.client_inst.create_port.return_value = \
{'id': 'fake_id'}
self.client_inst.create_subnet.return_value = \
{'id': 'fake_id'}
self.client_inst.update_network.return_value = \
{'id': 'fake_id'}
self.client_inst.update_port.return_value = \
{'id': 'fake_id'}<｜fim▁hole｜> self.client_inst.update_subnet.return_value = \
{'id': 'fake_id'}
self.client_inst.delete_network.return_value = True
self.client_inst.delete_port.return_value = True
self.client_inst.delete_subnet.return_value = True
self.plugin = MetaPluginV2(configfile=None)
def _fake_network(self, flavor):
data = {'network': {'name': flavor,
'admin_state_up': True,
'shared': False,
'router:external': [],
'tenant_id': self.fake_tenant_id,
FLAVOR_NETWORK: flavor}}
return data
def _fake_port(self, net_id):
return {'port': {'name': net_id,
'network_id': net_id,
'admin_state_up': True,
'device_id': 'bad_device_id',
'device_owner': 'bad_device_owner',
'admin_state_up': True,
'host_routes': [],
'fixed_ips': [],
'mac_address':
self.plugin._generate_mac(self.context, net_id),
'tenant_id': self.fake_tenant_id}}
def _fake_subnet(self, net_id):
allocation_pools = [{'start': '10.0.0.2',
'end': '10.0.0.254'}]
return {'subnet': {'name': net_id,
'network_id': net_id,
'gateway_ip': '10.0.0.1',
'dns_nameservers': ['10.0.0.2'],
'host_routes': [],
'cidr': '10.0.0.0/24',
'allocation_pools': allocation_pools,
'enable_dhcp': True,
'ip_version': 4}}
def _fake_router(self, flavor):
data = {'router': {'name': flavor, 'admin_state_up': True,
'tenant_id': self.fake_tenant_id,
FLAVOR_ROUTER: flavor,
'external_gateway_info': None}}
return data
def test_create_delete_network(self):
network1 = self._fake_network('fake1')
ret1 = self.plugin.create_network(self.context, network1)
self.assertEqual('fake1', ret1[FLAVOR_NETWORK])
network2 = self._fake_network('fake2')
ret2 = self.plugin.create_network(self.context, network2)
self.assertEqual('fake2', ret2[FLAVOR_NETWORK])
network3 = self._fake_network('proxy')
ret3 = self.plugin.create_network(self.context, network3)
self.assertEqual('proxy', ret3[FLAVOR_NETWORK])
db_ret1 = self.plugin.get_network(self.context, ret1['id'])
self.assertEqual('fake1', db_ret1['name'])
db_ret2 = self.plugin.get_network(self.context, ret2['id'])
self.assertEqual('fake2', db_ret2['name'])
db_ret3 = self.plugin.get_network(self.context, ret3['id'])
self.assertEqual('proxy', db_ret3['name'])
db_ret4 = self.plugin.get_networks(self.context)
self.assertEqual(3, len(db_ret4))
db_ret5 = self.plugin.get_networks(self.context,
{FLAVOR_NETWORK: ['fake1']})
self.assertEqual(1, len(db_ret5))
self.assertEqual('fake1', db_ret5[0]['name'])
self.plugin.delete_network(self.context, ret1['id'])
self.plugin.delete_network(self.context, ret2['id'])
self.plugin.delete_network(self.context, ret3['id'])
def test_create_delete_port(self):
network1 = self._fake_network('fake1')
network_ret1 = self.plugin.create_network(self.context, network1)
network2 = self._fake_network('fake2')
network_ret2 = self.plugin.create_network(self.context, network2)
network3 = self._fake_network('proxy')
network_ret3 = self.plugin.create_network(self.context, network3)
port1 = self._fake_port(network_ret1['id'])
port2 = self._fake_port(network_ret2['id'])
port3 = self._fake_port(network_ret3['id'])
port1_ret = self.plugin.create_port(self.context, port1)
port2_ret = self.plugin.create_port(self.context, port2)
port3_ret = self.plugin.create_port(self.context, port3)
self.assertEqual(network_ret1['id'], port1_ret['network_id'])
self.assertEqual(network_ret2['id'], port2_ret['network_id'])
self.assertEqual(network_ret3['id'], port3_ret['network_id'])
port1['port']['admin_state_up'] = False
port2['port']['admin_state_up'] = False
port3['port']['admin_state_up'] = False
self.plugin.update_port(self.context, port1_ret['id'], port1)
self.plugin.update_port(self.context, port2_ret['id'], port2)
self.plugin.update_port(self.context, port3_ret['id'], port3)
port_in_db1 = self.plugin.get_port(self.context, port1_ret['id'])
port_in_db2 = self.plugin.get_port(self.context, port2_ret['id'])
port_in_db3 = self.plugin.get_port(self.context, port3_ret['id'])
self.assertEqual(False, port_in_db1['admin_state_up'])
self.assertEqual(False, port_in_db2['admin_state_up'])
self.assertEqual(False, port_in_db3['admin_state_up'])
self.plugin.delete_port(self.context, port1_ret['id'])
self.plugin.delete_port(self.context, port2_ret['id'])
self.plugin.delete_port(self.context, port3_ret['id'])
self.plugin.delete_network(self.context, network_ret1['id'])
self.plugin.delete_network(self.context, network_ret2['id'])
self.plugin.delete_network(self.context, network_ret3['id'])
def test_create_delete_subnet(self):
# for this test we need to enable overlapping ips
cfg.CONF.set_default('allow_overlapping_ips', True)
network1 = self._fake_network('fake1')
network_ret1 = self.plugin.create_network(self.context, network1)
network2 = self._fake_network('fake2')
network_ret2 = self.plugin.create_network(self.context, network2)
network3 = self._fake_network('proxy')
network_ret3 = self.plugin.create_network(self.context, network3)
subnet1 = self._fake_subnet(network_ret1['id'])
subnet2 = self._fake_subnet(network_ret2['id'])
subnet3 = self._fake_subnet(network_ret3['id'])
subnet1_ret = self.plugin.create_subnet(self.context, subnet1)
subnet2_ret = self.plugin.create_subnet(self.context, subnet2)
subnet3_ret = self.plugin.create_subnet(self.context, subnet3)
self.assertEqual(network_ret1['id'], subnet1_ret['network_id'])
self.assertEqual(network_ret2['id'], subnet2_ret['network_id'])
self.assertEqual(network_ret3['id'], subnet3_ret['network_id'])
subnet_in_db1 = self.plugin.get_subnet(self.context, subnet1_ret['id'])
subnet_in_db2 = self.plugin.get_subnet(self.context, subnet2_ret['id'])
subnet_in_db3 = self.plugin.get_subnet(self.context, subnet3_ret['id'])
subnet1['subnet']['allocation_pools'].pop()
subnet2['subnet']['allocation_pools'].pop()
subnet3['subnet']['allocation_pools'].pop()
self.plugin.update_subnet(self.context,
subnet1_ret['id'], subnet1)
self.plugin.update_subnet(self.context,
subnet2_ret['id'], subnet2)
self.plugin.update_subnet(self.context,
subnet3_ret['id'], subnet3)
subnet_in_db1 = self.plugin.get_subnet(self.context, subnet1_ret['id'])
subnet_in_db2 = self.plugin.get_subnet(self.context, subnet2_ret['id'])
subnet_in_db3 = self.plugin.get_subnet(self.context, subnet3_ret['id'])
self.assertEqual(4, subnet_in_db1['ip_version'])
self.assertEqual(4, subnet_in_db2['ip_version'])
self.assertEqual(4, subnet_in_db3['ip_version'])
self.plugin.delete_subnet(self.context, subnet1_ret['id'])
self.plugin.delete_subnet(self.context, subnet2_ret['id'])
self.plugin.delete_subnet(self.context, subnet3_ret['id'])
self.plugin.delete_network(self.context, network_ret1['id'])
self.plugin.delete_network(self.context, network_ret2['id'])
self.plugin.delete_network(self.context, network_ret3['id'])
def test_create_delete_router(self):
router1 = self._fake_router('fake1')
router_ret1 = self.plugin.create_router(self.context, router1)
router2 = self._fake_router('fake2')
router_ret2 = self.plugin.create_router(self.context, router2)
self.assertEqual('fake1', router_ret1[FLAVOR_ROUTER])
self.assertEqual('fake2', router_ret2[FLAVOR_ROUTER])
router_in_db1 = self.plugin.get_router(self.context, router_ret1['id'])
router_in_db2 = self.plugin.get_router(self.context, router_ret2['id'])
self.assertEqual('fake1', router_in_db1[FLAVOR_ROUTER])
self.assertEqual('fake2', router_in_db2[FLAVOR_ROUTER])
self.plugin.delete_router(self.context, router_ret1['id'])
self.plugin.delete_router(self.context, router_ret2['id'])
with testtools.ExpectedException(FlavorNotFound):
self.plugin.get_router(self.context, router_ret1['id'])
def test_extension_method(self):
self.assertEqual('fake1', self.plugin.fake_func())
self.assertEqual('fake2', self.plugin.fake_func2())
def test_extension_not_implemented_method(self):
try:
self.plugin.not_implemented()
except AttributeError:
return
except Exception:
self.fail("AttributeError Error is not raised")
self.fail("No Error is not raised")
def tearDown(self):
self.mox.UnsetStubs()
self.stubs.UnsetAll()
self.stubs.SmartUnsetAll()
self.mox.VerifyAll()
db.clear_db()
super(MetaQuantumPluginV2Test, self).tearDown()<｜fim▁end｜> | |
<|file_name|>ValidatedTextBox.js<|end_file_name|><｜fim▁begin｜>import React from 'react';
import FormGroup from 'react-bootstrap/lib/FormGroup';
import FormControl from 'react-bootstrap/lib/FormControl';
import ControlLabel from 'react-bootstrap/lib/ControlLabel';
import HelpBlock from 'react-bootstrap/lib/HelpBlock';
class ValidatedTextBox extends React.Component {
constructor(props){
super(props);
this.props = props;
this.state = {value: ''}
}
handleChange(e){
this.setState({value: e.target.value});
this.props.onChange(e.target.value);
}
render () {
const { controlId, validationState, label, value, onChange, helpText } = this.props;
return (
<form>
<FormGroup <｜fim▁hole｜> <FormControl
type="text"
value={this.state.value}
placeholder="Enter Quizlet set number"
onChange={this.handleChange.bind(this)}
/>
<FormControl.Feedback />
<HelpBlock>{helpText}</HelpBlock>
</FormGroup>
</form>
);
}
}
module.exports = ValidatedTextBox<｜fim▁end｜> | controlId={controlId}
validationState={validationState}>
<ControlLabel> {label} </ControlLabel> |
<|file_name|>string_utils.rs<|end_file_name|><｜fim▁begin｜>//! Various utilities for string operations.
/// Join items of a collection with separator.
pub trait JoinWithSeparator<S> {
/// Result type of the operation
type Output;
/// Join items of `self` with `separator`.
fn join(self, separator: S) -> Self::Output;
}
impl<S, S2, X> JoinWithSeparator<S2> for X
where S: AsRef<str>,
S2: AsRef<str>,
X: Iterator<Item = S>
{
type Output = String;
fn join(self, separator: S2) -> String {
self.fold("".to_string(), |a, b| {
let m = if a.is_empty() {
a
} else {
a + separator.as_ref()
};
m + b.as_ref()
})
}
}
/// Iterator over words in a camel-case
/// or snake-case string.
pub struct WordIterator<'a> {
string: &'a str,
index: usize,
}
impl<'a> WordIterator<'a> {
/// Create iterator over `string`.
pub fn new(string: &str) -> WordIterator {
WordIterator {
string: string,
index: 0,
}
}
}
fn char_at(str: &str, index: usize) -> char {
if index >= str.len() {
panic!("char_at: index out of bounds");
}
str[index..index + 1].chars().next().unwrap()
}
impl<'a> Iterator for WordIterator<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<&'a str> {
while self.index < self.string.len() && &self.string[self.index..self.index + 1] == "_" {
self.index += 1;
}
if self.index >= self.string.len() {
return None;
}
let mut i = self.index + 1;
let current_word_is_number = i < self.string.len() && char_at(self.string, i).is_digit(10);
while i < self.string.len() {
let current = char_at(self.string, i);
if current == '_' || current.is_uppercase() {
break;
}
if !current_word_is_number && current.is_digit(10) {
break;
}
i += 1;
}
let result = &self.string[self.index..i];
self.index = i;
Some(result)
}
}
/// Convert to string with different cases
pub trait CaseOperations {
/// Convert to class-case string ("WordWordWord")
fn to_class_case(self) -> String;
/// Convert to snake-case string ("word_word_word")
fn to_snake_case(self) -> String;
/// Convert to upper-case string ("WORD_WORD_WORD")
fn to_upper_case_words(self) -> String;
}
fn iterator_to_class_case<S: AsRef<str>, T: Iterator<Item = S>>(it: T) -> String {
it.map(|x| if char_at(x.as_ref(), 0).is_digit(10) {
x.as_ref().to_uppercase()
} else {
format!("{}{}",
x.as_ref()[0..1].to_uppercase(),
x.as_ref()[1..].to_lowercase())
})
.join("")
}
fn ends_with_digit<S: AsRef<str>>(s: S) -> bool {
let str = s.as_ref();
if str.len() > 0 {
str[str.len() - 1..str.len()]
.chars()
.next()
.unwrap()
.is_digit(10)
} else {
false
}
}
fn iterator_to_snake_case<S: AsRef<str>, T: Iterator<Item = S>>(it: T) -> String {
let mut parts: Vec<_> = it.map(|x| x.as_ref().to_lowercase()).collect();
replace_all_sub_vecs(&mut parts, vec!["na", "n"]);
replace_all_sub_vecs(&mut parts, vec!["open", "g", "l"]);
replace_all_sub_vecs(&mut parts, vec!["i", "o"]);
replace_all_sub_vecs(&mut parts, vec!["2", "d"]);
replace_all_sub_vecs(&mut parts, vec!["3", "d"]);
replace_all_sub_vecs(&mut parts, vec!["4", "d"]);
let mut str = String::new();
for (i, part) in parts.into_iter().enumerate() {
if part.is_empty() {
continue;
}
if i > 0 && !(part.chars().all(|c| c.is_digit(10)) && !ends_with_digit(&str)) {
str.push('_');
}
str.push_str(&part);
}
str
}
fn iterator_to_upper_case_words<S: AsRef<str>, T: Iterator<Item = S>>(it: T) -> String {
it.map(|x| x.as_ref().to_uppercase()).join("_")
}
#[cfg_attr(feature="clippy", allow(needless_range_loop))]
fn replace_all_sub_vecs(parts: &mut Vec<String>, needle: Vec<&str>) {
let mut any_found = true;
while any_found {
any_found = false;
if parts.len() + 1 >= needle.len() {
// TODO: maybe rewrite this
for i in 0..parts.len() + 1 - needle.len() {
if &parts[i..i + needle.len()] == &needle[..] {
for _ in 0..needle.len() - 1 {<｜fim▁hole｜> parts.remove(i + 1);
}
parts[i] = needle.join("");
any_found = true;
break;
}
}
}
}
}
impl<'a> CaseOperations for &'a str {
fn to_class_case(self) -> String {
iterator_to_class_case(WordIterator::new(self))
}
fn to_snake_case(self) -> String {
iterator_to_snake_case(WordIterator::new(self))
}
fn to_upper_case_words(self) -> String {
iterator_to_upper_case_words(WordIterator::new(self))
}
}
impl<'a> CaseOperations for Vec<&'a str> {
fn to_class_case(self) -> String {
iterator_to_class_case(self.into_iter())
}
fn to_snake_case(self) -> String {
iterator_to_snake_case(self.into_iter())
}
fn to_upper_case_words(self) -> String {
iterator_to_upper_case_words(self.into_iter())
}
}<｜fim▁end｜> | |
<|file_name|>gecko.mako.rs<|end_file_name|><｜fim▁begin｜>/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// `data` comes from components/style/properties.mako.rs; see build.rs for more details.
<%!
from data import to_camel_case, to_camel_case_lower
from data import Keyword
%>
<%namespace name="helpers" file="/helpers.mako.rs" />
use app_units::Au;
use custom_properties::CustomPropertiesMap;
use gecko_bindings::bindings;
% for style_struct in data.style_structs:
use gecko_bindings::structs::${style_struct.gecko_ffi_name};
use gecko_bindings::bindings::Gecko_Construct_Default_${style_struct.gecko_ffi_name};
use gecko_bindings::bindings::Gecko_CopyConstruct_${style_struct.gecko_ffi_name};
use gecko_bindings::bindings::Gecko_Destroy_${style_struct.gecko_ffi_name};
% endfor
use gecko_bindings::bindings::Gecko_CopyCounterStyle;
use gecko_bindings::bindings::Gecko_CopyCursorArrayFrom;
use gecko_bindings::bindings::Gecko_CopyFontFamilyFrom;
use gecko_bindings::bindings::Gecko_CopyImageValueFrom;
use gecko_bindings::bindings::Gecko_CopyListStyleImageFrom;
use gecko_bindings::bindings::Gecko_EnsureImageLayersLength;
use gecko_bindings::bindings::Gecko_SetCursorArrayLength;
use gecko_bindings::bindings::Gecko_SetCursorImageValue;
use gecko_bindings::bindings::Gecko_StyleTransition_SetUnsupportedProperty;
use gecko_bindings::bindings::Gecko_NewCSSShadowArray;
use gecko_bindings::bindings::Gecko_nsStyleFont_SetLang;
use gecko_bindings::bindings::Gecko_nsStyleFont_CopyLangFrom;
use gecko_bindings::bindings::Gecko_SetListStyleImageNone;
use gecko_bindings::bindings::Gecko_SetListStyleImageImageValue;
use gecko_bindings::bindings::Gecko_SetNullImageValue;
use gecko_bindings::bindings::{Gecko_ResetFilters, Gecko_CopyFiltersFrom};
use gecko_bindings::bindings::RawGeckoPresContextBorrowed;
use gecko_bindings::structs;
use gecko_bindings::structs::nsCSSPropertyID;
use gecko_bindings::structs::mozilla::CSSPseudoElementType;
use gecko_bindings::structs::mozilla::CSSPseudoElementType_InheritingAnonBox;
use gecko_bindings::structs::root::NS_STYLE_CONTEXT_TYPE_SHIFT;
use gecko_bindings::sugar::ns_style_coord::{CoordDataValue, CoordData, CoordDataMut};
use gecko::values::convert_nscolor_to_rgba;
use gecko::values::convert_rgba_to_nscolor;
use gecko::values::GeckoStyleCoordConvertible;
use gecko::values::round_border_to_device_pixels;
use logical_geometry::WritingMode;
use media_queries::Device;
use properties::animated_properties::TransitionProperty;
use properties::computed_value_flags::*;
use properties::{longhands, Importance, LonghandId};
use properties::{PropertyDeclaration, PropertyDeclarationBlock, PropertyDeclarationId};
use rule_tree::StrongRuleNode;
use selector_parser::PseudoElement;
use servo_arc::{Arc, RawOffsetArc};
use std::mem::{forget, uninitialized, transmute, zeroed};
use std::{cmp, ops, ptr};
use values::{self, Auto, CustomIdent, Either, KeyframesName, None_};
use values::computed::{NonNegativeLength, ToComputedValue, Percentage};
use values::computed::font::{FontSize, SingleFontFamily};
use values::computed::effects::{BoxShadow, Filter, SimpleShadow};
use values::computed::outline::OutlineStyle;
use values::generics::transform::TransformStyle;
use computed_values::border_style;
pub mod style_structs {
% for style_struct in data.style_structs:
pub use super::${style_struct.gecko_struct_name} as ${style_struct.name};
% endfor
}
/// FIXME(emilio): This is completely duplicated with the other properties code.
pub type ComputedValuesInner = ::gecko_bindings::structs::ServoComputedData;
#[repr(C)]
pub struct ComputedValues(::gecko_bindings::structs::mozilla::ServoStyleContext);
impl ComputedValues {
pub fn new(
device: &Device,
parent: Option<<&ComputedValues>,
pseudo: Option<<&PseudoElement>,
custom_properties: Option<Arc<CustomPropertiesMap>>,
writing_mode: WritingMode,
flags: ComputedValueFlags,
rules: Option<StrongRuleNode>,
visited_style: Option<Arc<ComputedValues>>,
% for style_struct in data.style_structs:
${style_struct.ident}: Arc<style_structs::${style_struct.name}>,
% endfor
) -> Arc<Self> {
ComputedValuesInner::new(
custom_properties,
writing_mode,
flags,
rules,
visited_style,
% for style_struct in data.style_structs:
${style_struct.ident},
% endfor
).to_outer(
device.pres_context(),
parent,
pseudo.map(|p| p.pseudo_info())
)
}
pub fn default_values(pres_context: RawGeckoPresContextBorrowed) -> Arc<Self> {
ComputedValuesInner::new(
/* custom_properties = */ None,
/* writing_mode = */ WritingMode::empty(), // FIXME(bz): This seems dubious
ComputedValueFlags::empty(),
/* rules = */ None,
/* visited_style = */ None,
% for style_struct in data.style_structs:
style_structs::${style_struct.name}::default(pres_context),
% endfor
).to_outer(pres_context, None, None)
}
pub fn pseudo(&self) -> Option<PseudoElement> {
use string_cache::Atom;
let atom = (self.0)._base.mPseudoTag.mRawPtr;
if atom.is_null() {
return None;
}
let atom = Atom::from(atom);
PseudoElement::from_atom(&atom)
}
fn get_pseudo_type(&self) -> CSSPseudoElementType {
let bits = (self.0)._base.mBits;
let our_type = bits >> NS_STYLE_CONTEXT_TYPE_SHIFT;
unsafe { transmute(our_type as u8) }
}
pub fn is_anon_box(&self) -> bool {
let our_type = self.get_pseudo_type();
return our_type == CSSPseudoElementType_InheritingAnonBox ||
our_type == CSSPseudoElementType::NonInheritingAnonBox;
}
}
impl Drop for ComputedValues {
fn drop(&mut self) {
unsafe {
bindings::Gecko_ServoStyleContext_Destroy(&mut self.0);
}
}
}
unsafe impl Sync for ComputedValues {}
unsafe impl Send for ComputedValues {}
impl Clone for ComputedValues {
fn clone(&self) -> Self {
unreachable!()
}
}
impl Clone for ComputedValuesInner {
fn clone(&self) -> Self {
ComputedValuesInner {
% for style_struct in data.style_structs:
${style_struct.gecko_name}: self.${style_struct.gecko_name}.clone(),
% endfor
custom_properties: self.custom_properties.clone(),
writing_mode: self.writing_mode.clone(),
flags: self.flags.clone(),
rules: self.rules.clone(),
visited_style: self.visited_style.clone(),
}
}
}
type PseudoInfo = (*mut structs::nsAtom, structs::CSSPseudoElementType);
type ParentStyleContextInfo<'a> = Option< &'a ComputedValues>;
impl ComputedValuesInner {
pub fn new(custom_properties: Option<Arc<CustomPropertiesMap>>,
writing_mode: WritingMode,
flags: ComputedValueFlags,
rules: Option<StrongRuleNode>,
visited_style: Option<Arc<ComputedValues>>,
% for style_struct in data.style_structs:
${style_struct.ident}: Arc<style_structs::${style_struct.name}>,
% endfor
) -> Self {
ComputedValuesInner {
custom_properties: custom_properties,
writing_mode: writing_mode,
rules: rules,
visited_style: visited_style.map(|x| Arc::into_raw_offset(x)),
flags: flags,
% for style_struct in data.style_structs:
${style_struct.gecko_name}: Arc::into_raw_offset(${style_struct.ident}),
% endfor
}
}
fn to_outer(
self,
pres_context: RawGeckoPresContextBorrowed,
parent: ParentStyleContextInfo,
info: Option<PseudoInfo>
) -> Arc<ComputedValues> {
let (tag, ty) = if let Some(info) = info {
info
} else {
(ptr::null_mut(), structs::CSSPseudoElementType::NotPseudo)
};
unsafe { self.to_outer_helper(pres_context, parent, ty, tag) }
}
unsafe fn to_outer_helper(
self,
pres_context: bindings::RawGeckoPresContextBorrowed,
parent: ParentStyleContextInfo,
pseudo_ty: structs::CSSPseudoElementType,
pseudo_tag: *mut structs::nsAtom
) -> Arc<ComputedValues> {
let arc = {
let arc: Arc<ComputedValues> = Arc::new(uninitialized());
bindings::Gecko_ServoStyleContext_Init(&arc.0 as *const _ as *mut _,
parent, pres_context,
&self, pseudo_ty, pseudo_tag);
// We're simulating a move by having C++ do a memcpy and then forgetting
// it on this end.
forget(self);
arc
};
arc
}
}
impl ops::Deref for ComputedValues {
type Target = ComputedValuesInner;
fn deref(&self) -> &ComputedValuesInner {
&self.0.mSource
}
}
impl ops::DerefMut for ComputedValues {
fn deref_mut(&mut self) -> &mut ComputedValuesInner {
&mut self.0.mSource
}
}
impl ComputedValuesInner {
/// Returns true if the value of the `content` property would make a
/// pseudo-element not rendered.
#[inline]
pub fn ineffective_content_property(&self) -> bool {
self.get_counters().ineffective_content_property()
}
% for style_struct in data.style_structs:
#[inline]
pub fn clone_${style_struct.name_lower}(&self) -> Arc<style_structs::${style_struct.name}> {
Arc::from_raw_offset(self.${style_struct.gecko_name}.clone())
}
#[inline]
pub fn get_${style_struct.name_lower}(&self) -> &style_structs::${style_struct.name} {
&self.${style_struct.gecko_name}
}
pub fn ${style_struct.name_lower}_arc(&self) -> &RawOffsetArc<style_structs::${style_struct.name}> {
&self.${style_struct.gecko_name}
}
#[inline]
pub fn mutate_${style_struct.name_lower}(&mut self) -> &mut style_structs::${style_struct.name} {
RawOffsetArc::make_mut(&mut self.${style_struct.gecko_name})
}
% endfor
/// Gets the raw visited style. Useful for memory reporting.
pub fn get_raw_visited_style(&self) -> &Option<RawOffsetArc<ComputedValues>> {
&self.visited_style
}
#[allow(non_snake_case)]
pub fn has_moz_binding(&self) -> bool {
!self.get_box().gecko.mBinding.mRawPtr.is_null()
}
pub fn to_declaration_block(&self, property: PropertyDeclarationId) -> PropertyDeclarationBlock {
let value = match property {
% for prop in data.longhands:
% if prop.animatable:
PropertyDeclarationId::Longhand(LonghandId::${prop.camel_case}) => {
PropertyDeclaration::${prop.camel_case}(
% if prop.boxed:
Box::new(
% endif
longhands::${prop.ident}::SpecifiedValue::from_computed_value(
&self.get_${prop.style_struct.ident.strip("_")}().clone_${prop.ident}())
% if prop.boxed:
)
% endif
)
},
% endif
% endfor
PropertyDeclarationId::Custom(_name) => unimplemented!(),
_ => unimplemented!()
};
PropertyDeclarationBlock::with_one(value, Importance::Normal)
}
}
<%def name="declare_style_struct(style_struct)">
pub use ::gecko_bindings::structs::mozilla::Gecko${style_struct.gecko_name} as ${style_struct.gecko_struct_name};
impl ${style_struct.gecko_struct_name} {
pub fn gecko(&self) -> &${style_struct.gecko_ffi_name} {
&self.gecko
}
pub fn gecko_mut(&mut self) -> &mut ${style_struct.gecko_ffi_name} {
&mut self.gecko
}
}
</%def>
<%def name="impl_simple_setter(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
${set_gecko_property(gecko_ffi_name, "From::from(v)")}
}
</%def>
<%def name="impl_simple_clone(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
From::from(self.gecko.${gecko_ffi_name})
}
</%def>
<%def name="impl_simple_copy(ident, gecko_ffi_name, on_set=None, *kwargs)">
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name} = other.gecko.${gecko_ffi_name};
% if on_set:
self.${on_set}();
% endif
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
</%def>
<%def name="impl_coord_copy(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name}.copy_from(&other.gecko.${gecko_ffi_name});
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
</%def>
<%!
def get_gecko_property(ffi_name, self_param = "self"):
if "mBorderColor" in ffi_name:
return ffi_name.replace("mBorderColor",
"unsafe { *%s.gecko.__bindgen_anon_1.mBorderColor.as_ref() }"
% self_param)
return "%s.gecko.%s" % (self_param, ffi_name)
def set_gecko_property(ffi_name, expr):
if "mBorderColor" in ffi_name:
ffi_name = ffi_name.replace("mBorderColor",
"*self.gecko.__bindgen_anon_1.mBorderColor.as_mut()")
return "unsafe { %s = %s };" % (ffi_name, expr)
return "self.gecko.%s = %s;" % (ffi_name, expr)
%>
<%def name="impl_keyword_setter(ident, gecko_ffi_name, keyword, cast_type='u8', on_set=None)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use properties::longhands::${ident}::computed_value::T as Keyword;
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
let result = match v {
% for value in keyword.values_for('gecko'):
Keyword::${to_camel_case(value)} =>
structs::${keyword.gecko_constant(value)} ${keyword.maybe_cast(cast_type)},
% endfor
};
${set_gecko_property(gecko_ffi_name, "result")}
% if on_set:
self.${on_set}();
% endif
}
</%def>
<%def name="impl_keyword_clone(ident, gecko_ffi_name, keyword, cast_type='u8')">
// FIXME: We introduced non_upper_case_globals for -moz-appearance only
// since the prefix of Gecko value starts with ThemeWidgetType_NS_THEME.
// We should remove this after fix bug 1371809.
#[allow(non_snake_case, non_upper_case_globals)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use properties::longhands::${ident}::computed_value::T as Keyword;
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
// Some constant macros in the gecko are defined as negative integer(e.g. font-stretch).
// And they are convert to signed integer in Rust bindings. We need to cast then
// as signed type when we have both signed/unsigned integer in order to use them
// as match's arms.
// Also, to use same implementation here we use casted constant if we have only singed values.
% if keyword.gecko_enum_prefix is None:
% for value in keyword.values_for('gecko'):
const ${keyword.casted_constant_name(value, cast_type)} : ${cast_type} =
structs::${keyword.gecko_constant(value)} as ${cast_type};
% endfor
match ${get_gecko_property(gecko_ffi_name)} as ${cast_type} {
% for value in keyword.values_for('gecko'):
${keyword.casted_constant_name(value, cast_type)} => Keyword::${to_camel_case(value)},
% endfor
% if keyword.gecko_inexhaustive:
_ => panic!("Found unexpected value in style struct for ${ident} property"),
% endif
}
% else:
match ${get_gecko_property(gecko_ffi_name)} {
% for value in keyword.values_for('gecko'):
structs::${keyword.gecko_constant(value)} => Keyword::${to_camel_case(value)},
% endfor
% if keyword.gecko_inexhaustive:
_ => panic!("Found unexpected value in style struct for ${ident} property"),
% endif
}
% endif
}
</%def>
<%def name="impl_color_setter(ident, gecko_ffi_name)">
#[allow(unreachable_code)]
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
${set_gecko_property(gecko_ffi_name, "v.into()")}
}
</%def>
<%def name="impl_color_copy(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
let color = ${get_gecko_property(gecko_ffi_name, self_param = "other")};
${set_gecko_property(gecko_ffi_name, "color")};
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
</%def>
<%def name="impl_color_clone(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
${get_gecko_property(gecko_ffi_name)}.into()
}
</%def>
<%def name="impl_keyword(ident, gecko_ffi_name, keyword, cast_type='u8', **kwargs)">
<%call expr="impl_keyword_setter(ident, gecko_ffi_name, keyword, cast_type, **kwargs)"></%call>
<%call expr="impl_simple_copy(ident, gecko_ffi_name, **kwargs)"></%call>
<%call expr="impl_keyword_clone(ident, gecko_ffi_name, keyword, cast_type)"></%call>
</%def>
<%def name="impl_simple(ident, gecko_ffi_name)">
<%call expr="impl_simple_setter(ident, gecko_ffi_name)"></%call>
<%call expr="impl_simple_copy(ident, gecko_ffi_name)"></%call>
<%call expr="impl_simple_clone(ident, gecko_ffi_name)"></%call>
</%def>
<%def name="impl_absolute_length(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
${set_gecko_property(gecko_ffi_name, "v.to_i32_au()")}
}
<%call expr="impl_simple_copy(ident, gecko_ffi_name)"></%call>
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
Au(self.gecko.${gecko_ffi_name}).into()
}
</%def>
<%def name="impl_position(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
${set_gecko_property("%s.mXPosition" % gecko_ffi_name, "v.horizontal.into()")}
${set_gecko_property("%s.mYPosition" % gecko_ffi_name, "v.vertical.into()")}
}
<%call expr="impl_simple_copy(ident, gecko_ffi_name)"></%call>
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
longhands::${ident}::computed_value::T {
horizontal: self.gecko.${gecko_ffi_name}.mXPosition.into(),
vertical: self.gecko.${gecko_ffi_name}.mYPosition.into(),
}
}
</%def>
<%def name="impl_color(ident, gecko_ffi_name)">
<%call expr="impl_color_setter(ident, gecko_ffi_name)"></%call>
<%call expr="impl_color_copy(ident, gecko_ffi_name)"></%call>
<%call expr="impl_color_clone(ident, gecko_ffi_name)"></%call>
</%def>
<%def name="impl_rgba_color(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
${set_gecko_property(gecko_ffi_name, "convert_rgba_to_nscolor(&v)")}
}
<%call expr="impl_simple_copy(ident, gecko_ffi_name)"></%call>
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
convert_nscolor_to_rgba(${get_gecko_property(gecko_ffi_name)})
}
</%def>
<%def name="impl_svg_length(ident, gecko_ffi_name)">
// When context-value is used on an SVG length, the corresponding flag is
// set on mContextFlags, and the length field is set to the initial value.
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use values::generics::svg::{SVGLength, SvgLengthOrPercentageOrNumber};
use gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
let length = match v {
SVGLength::Length(length) => {
self.gecko.mContextFlags &= !CONTEXT_VALUE;
length
}
SVGLength::ContextValue => {
self.gecko.mContextFlags |= CONTEXT_VALUE;
match longhands::${ident}::get_initial_value() {
SVGLength::Length(length) => length,
_ => unreachable!("Initial value should not be context-value"),
}
}
};
match length {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop) =>
self.gecko.${gecko_ffi_name}.set(lop),
SvgLengthOrPercentageOrNumber::Number(num) =>
self.gecko.${gecko_ffi_name}.set_value(CoordDataValue::Factor(num.into())),
}
}
pub fn copy_${ident}_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
self.gecko.${gecko_ffi_name}.copy_from(&other.gecko.${gecko_ffi_name});
self.gecko.mContextFlags =
(self.gecko.mContextFlags & !CONTEXT_VALUE) |
(other.gecko.mContextFlags & CONTEXT_VALUE);
}
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use values::generics::svg::{SVGLength, SvgLengthOrPercentageOrNumber};
use values::computed::LengthOrPercentage;
use gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
if (self.gecko.mContextFlags & CONTEXT_VALUE) != 0 {
return SVGLength::ContextValue;
}
let length = match self.gecko.${gecko_ffi_name}.as_value() {
CoordDataValue::Factor(number) =>
SvgLengthOrPercentageOrNumber::Number(number),
CoordDataValue::Coord(coord) =>
SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Length(Au(coord).into())),
CoordDataValue::Percent(p) =>
SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Percentage(Percentage(p))),
CoordDataValue::Calc(calc) =>
SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Calc(calc.into())),
_ => unreachable!("Unexpected coordinate in ${ident}"),
};
SVGLength::Length(length.into())
}
</%def>
<%def name="impl_svg_opacity(ident, gecko_ffi_name)">
<% source_prefix = ident.split("_")[0].upper() + "_OPACITY_SOURCE" %>
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use gecko_bindings::structs::nsStyleSVG_${source_prefix}_MASK as MASK;
use gecko_bindings::structs::nsStyleSVG_${source_prefix}_SHIFT as SHIFT;
use gecko_bindings::structs::nsStyleSVGOpacitySource::*;
use values::generics::svg::SVGOpacity;
self.gecko.mContextFlags &= !MASK;
match v {
SVGOpacity::Opacity(opacity) => {
self.gecko.mContextFlags |=
(eStyleSVGOpacitySource_Normal as u8) << SHIFT;
self.gecko.${gecko_ffi_name} = opacity;
}
SVGOpacity::ContextFillOpacity => {
self.gecko.mContextFlags |=
(eStyleSVGOpacitySource_ContextFillOpacity as u8) << SHIFT;
self.gecko.${gecko_ffi_name} = 1.;
}
SVGOpacity::ContextStrokeOpacity => {
self.gecko.mContextFlags |=
(eStyleSVGOpacitySource_ContextStrokeOpacity as u8) << SHIFT;
self.gecko.${gecko_ffi_name} = 1.;
}
}
}
pub fn copy_${ident}_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleSVG_${source_prefix}_MASK as MASK;
self.gecko.${gecko_ffi_name} = other.gecko.${gecko_ffi_name};
self.gecko.mContextFlags =
(self.gecko.mContextFlags & !MASK) |
(other.gecko.mContextFlags & MASK);
}
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use gecko_bindings::structs::nsStyleSVG_${source_prefix}_MASK as MASK;
use gecko_bindings::structs::nsStyleSVG_${source_prefix}_SHIFT as SHIFT;
use gecko_bindings::structs::nsStyleSVGOpacitySource::*;
use values::generics::svg::SVGOpacity;
let source = (self.gecko.mContextFlags & MASK) >> SHIFT;
if source == eStyleSVGOpacitySource_Normal as u8 {
return SVGOpacity::Opacity(self.gecko.${gecko_ffi_name});
} else {
debug_assert_eq!(self.gecko.${gecko_ffi_name}, 1.0);
if source == eStyleSVGOpacitySource_ContextFillOpacity as u8 {
SVGOpacity::ContextFillOpacity
} else {
debug_assert_eq!(source, eStyleSVGOpacitySource_ContextStrokeOpacity as u8);
SVGOpacity::ContextStrokeOpacity
}
}
}
</%def>
<%def name="impl_svg_paint(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, mut v: longhands::${ident}::computed_value::T) {
use values::generics::svg::SVGPaintKind;
use self::structs::nsStyleSVGPaintType;
use self::structs::nsStyleSVGFallbackType;
let ref mut paint = ${get_gecko_property(gecko_ffi_name)};
unsafe {
bindings::Gecko_nsStyleSVGPaint_Reset(paint);
}
let fallback = v.fallback.take();
match v.kind {
SVGPaintKind::None => return,
SVGPaintKind::ContextFill => {
paint.mType = nsStyleSVGPaintType::eStyleSVGPaintType_ContextFill;
}
SVGPaintKind::ContextStroke => {
paint.mType = nsStyleSVGPaintType::eStyleSVGPaintType_ContextStroke;
}
SVGPaintKind::PaintServer(url) => {
unsafe {
bindings::Gecko_nsStyleSVGPaint_SetURLValue(paint, url.for_ffi());
}
}
SVGPaintKind::Color(color) => {
paint.mType = nsStyleSVGPaintType::eStyleSVGPaintType_Color;
unsafe {
*paint.mPaint.mColor.as_mut() = convert_rgba_to_nscolor(&color);
}
}
}
paint.mFallbackType = match fallback {
Some(Either::First(color)) => {
paint.mFallbackColor = convert_rgba_to_nscolor(&color);
nsStyleSVGFallbackType::eStyleSVGFallbackType_Color
},
Some(Either::Second(_)) => {
nsStyleSVGFallbackType::eStyleSVGFallbackType_None
},
None => nsStyleSVGFallbackType::eStyleSVGFallbackType_NotSet
};
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
unsafe {
bindings::Gecko_nsStyleSVGPaint_CopyFrom(
&mut ${get_gecko_property(gecko_ffi_name)},
& ${get_gecko_property(gecko_ffi_name, "other")}
);
}
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use values::generics::svg::{SVGPaint, SVGPaintKind};
use values::specified::url::SpecifiedUrl;
use self::structs::nsStyleSVGPaintType;
use self::structs::nsStyleSVGFallbackType;
let ref paint = ${get_gecko_property(gecko_ffi_name)};
let fallback = match paint.mFallbackType {
nsStyleSVGFallbackType::eStyleSVGFallbackType_Color => {
Some(Either::First(convert_nscolor_to_rgba(paint.mFallbackColor)))
},
nsStyleSVGFallbackType::eStyleSVGFallbackType_None => {
Some(Either::Second(None_))
},
nsStyleSVGFallbackType::eStyleSVGFallbackType_NotSet => None,
};
let kind = match paint.mType {
nsStyleSVGPaintType::eStyleSVGPaintType_None => SVGPaintKind::None,
nsStyleSVGPaintType::eStyleSVGPaintType_ContextFill => SVGPaintKind::ContextFill,
nsStyleSVGPaintType::eStyleSVGPaintType_ContextStroke => SVGPaintKind::ContextStroke,
nsStyleSVGPaintType::eStyleSVGPaintType_Server => {
unsafe {
SVGPaintKind::PaintServer(
SpecifiedUrl::from_url_value_data(
&(**paint.mPaint.mPaintServer.as_ref())._base
).unwrap()
)
}
}
nsStyleSVGPaintType::eStyleSVGPaintType_Color => {
unsafe { SVGPaintKind::Color(convert_nscolor_to_rgba(*paint.mPaint.mColor.as_ref())) }
}
};
SVGPaint {
kind: kind,
fallback: fallback,
}
}
</%def>
<%def name="impl_non_negative_length(ident, gecko_ffi_name, inherit_from=None,
round_to_pixels=False)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
let value = {
% if round_to_pixels:
let au_per_device_px = Au(self.gecko.mTwipsPerPixel);
round_border_to_device_pixels(Au::from(v), au_per_device_px).0
% else:
v.0.to_i32_au()
% endif
};
% if inherit_from:
self.gecko.${inherit_from} = value;
% endif
self.gecko.${gecko_ffi_name} = value;
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
% if inherit_from:
self.gecko.${inherit_from} = other.gecko.${inherit_from};
// NOTE: This is needed to easily handle the `unset` and `initial`
// keywords, which are implemented calling this function.
//
// In practice, this means that we may have an incorrect value here, but
// we'll adjust that properly in the style fixup phase.
//
// FIXME(emilio): We could clean this up a bit special-casing the reset_
// function below.
self.gecko.${gecko_ffi_name} = other.gecko.${inherit_from};
% else:
self.gecko.${gecko_ffi_name} = other.gecko.${gecko_ffi_name};
% endif
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
Au(self.gecko.${gecko_ffi_name}).into()
}
</%def>
<%def name="impl_split_style_coord(ident, gecko_ffi_name, index)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
v.to_gecko_style_coord(&mut self.gecko.${gecko_ffi_name}.data_at_mut(${index}));
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name}.data_at_mut(${index}).copy_from(&other.gecko.${gecko_ffi_name}.data_at(${index}));
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use properties::longhands::${ident}::computed_value::T;
T::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}.data_at(${index}))
.expect("clone for ${ident} failed")
}
</%def>
<%def name="impl_style_coord(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
v.to_gecko_style_coord(&mut self.gecko.${gecko_ffi_name});
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name}.copy_from(&other.gecko.${gecko_ffi_name});
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use properties::longhands::${ident}::computed_value::T;
T::from_gecko_style_coord(&self.gecko.${gecko_ffi_name})
.expect("clone for ${ident} failed")
}
</%def>
<%def name="impl_style_sides(ident)">
<% gecko_ffi_name = "m" + to_camel_case(ident) %>
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
v.to_gecko_rect(&mut self.gecko.${gecko_ffi_name});
}
<%self:copy_sides_style_coord ident="${ident}"></%self:copy_sides_style_coord>
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
longhands::${ident}::computed_value::T::from_gecko_rect(&self.gecko.${gecko_ffi_name})
.expect("clone for ${ident} failed")
}
</%def>
<%def name="copy_sides_style_coord(ident)">
<% gecko_ffi_name = "m" + to_camel_case(ident) %>
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
% for side in SIDES:
self.gecko.${gecko_ffi_name}.data_at_mut(${side.index})
.copy_from(&other.gecko.${gecko_ffi_name}.data_at(${side.index}));
% endfor
${ caller.body() }
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
</%def>
<%def name="impl_corner_style_coord(ident, gecko_ffi_name, x_index, y_index)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
v.0.width().to_gecko_style_coord(&mut self.gecko.${gecko_ffi_name}.data_at_mut(${x_index}));
v.0.height().to_gecko_style_coord(&mut self.gecko.${gecko_ffi_name}.data_at_mut(${y_index}));
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name}.data_at_mut(${x_index})
.copy_from(&other.gecko.${gecko_ffi_name}.data_at(${x_index}));
self.gecko.${gecko_ffi_name}.data_at_mut(${y_index})
.copy_from(&other.gecko.${gecko_ffi_name}.data_at(${y_index}));
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use values::computed::border::BorderCornerRadius;
let width = GeckoStyleCoordConvertible::from_gecko_style_coord(
&self.gecko.${gecko_ffi_name}.data_at(${x_index}))
.expect("Failed to clone ${ident}");
let height = GeckoStyleCoordConvertible::from_gecko_style_coord(
&self.gecko.${gecko_ffi_name}.data_at(${y_index}))
.expect("Failed to clone ${ident}");
BorderCornerRadius::new(width, height)
}
</%def>
<%def name="impl_css_url(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use gecko_bindings::sugar::refptr::RefPtr;
match v {
Either::First(url) => {
let refptr = unsafe {
let ptr = bindings::Gecko_NewURLValue(url.for_ffi());
if ptr.is_null() {
self.gecko.${gecko_ffi_name}.clear();
return;
}
RefPtr::from_addrefed(ptr)
};
self.gecko.${gecko_ffi_name}.set_move(refptr)
}
Either::Second(_none) => {
unsafe {
self.gecko.${gecko_ffi_name}.clear();
}
}
}
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
unsafe {
self.gecko.${gecko_ffi_name}.set(&other.gecko.${gecko_ffi_name});
}
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use values::specified::url::SpecifiedUrl;
use values::None_;
if self.gecko.${gecko_ffi_name}.mRawPtr.is_null() {
Either::Second(None_)
} else {
unsafe {
let ref gecko_url_value = *self.gecko.${gecko_ffi_name}.mRawPtr;
Either::First(SpecifiedUrl::from_url_value_data(&gecko_url_value._base)
.expect("${gecko_ffi_name} could not convert to SpecifiedUrl"))
}
}
}
</%def>
<%
transform_functions = [
("Matrix3D", "matrix3d", ["number"] * 16),
("PrefixedMatrix3D", "matrix3d", ["number"] * 12 + ["lopon"] * 2
+ ["lon"] + ["number"]),
("Matrix", "matrix", ["number"] * 6),
("PrefixedMatrix", "matrix", ["number"] * 4 + ["lopon"] * 2),
("Translate", "translate", ["lop", "optional_lop"]),
("Translate3D", "translate3d", ["lop", "lop", "length"]),
("TranslateX", "translatex", ["lop"]),
("TranslateY", "translatey", ["lop"]),
("TranslateZ", "translatez", ["length"]),
("Scale3D", "scale3d", ["number"] * 3),
("Scale", "scale", ["number", "optional_number"]),
("ScaleX", "scalex", ["number"]),
("ScaleY", "scaley", ["number"]),
("ScaleZ", "scalez", ["number"]),
("Rotate", "rotate", ["angle"]),
("Rotate3D", "rotate3d", ["number"] * 3 + ["angle"]),
("RotateX", "rotatex", ["angle"]),
("RotateY", "rotatey", ["angle"]),
("RotateZ", "rotatez", ["angle"]),
("Skew", "skew", ["angle", "optional_angle"]),
("SkewX", "skewx", ["angle"]),
("SkewY", "skewy", ["angle"]),
("Perspective", "perspective", ["length"]),
("InterpolateMatrix", "interpolatematrix", ["list"] * 2 + ["percentage"]),
("AccumulateMatrix", "accumulatematrix", ["list"] * 2 + ["integer_to_percentage"])
]
%>
<%def name="transform_function_arm(name, keyword, items)">
<%
has_optional = items[-1].startswith("optional_")
pattern = None
if keyword == "matrix3d":
# m11: number1, m12: number2, ..
single_patterns = ["m%s: %s" % (str(a / 4 + 1) + str(a % 4 + 1), b + str(a + 1)) for (a, b)
in enumerate(items)]
pattern = "(Matrix3D { %s })" % ", ".join(single_patterns)
elif keyword == "matrix":
# a: number1, b: number2, ..
single_patterns = ["%s: %s" % (chr(ord('a') + a), b + str(a + 1)) for (a, b)
in enumerate(items)]
pattern = "(Matrix { %s })" % ", ".join(single_patterns)
elif keyword == "interpolatematrix":
pattern = " { from_list: ref list1, to_list: ref list2, progress: percentage3 }"
elif keyword == "accumulatematrix":
pattern = " { from_list: ref list1, to_list: ref list2, count: integer_to_percentage3 }"
else:
# Generate contents of pattern from items
pattern = "(%s)" % ", ".join([b + str(a+1) for (a,b) in enumerate(items)])
# First %s substituted with the call to GetArrayItem, the second
# %s substituted with the corresponding variable
css_value_setters = {
"length" : "bindings::Gecko_CSSValue_SetPixelLength(%s, %s.px())",
"percentage" : "bindings::Gecko_CSSValue_SetPercentage(%s, %s.0)",
# Note: This is an integer type, but we use it as a percentage value in Gecko, so
# need to cast it to f32.
"integer_to_percentage" : "bindings::Gecko_CSSValue_SetPercentage(%s, %s as f32)",
"lop" : "%s.set_lop(%s)",
"lopon" : "set_lopon(%s, %s)",
"lon" : "set_lon(%s, %s)",
"angle" : "%s.set_angle(%s)",
"number" : "bindings::Gecko_CSSValue_SetNumber(%s, %s)",
# Note: We use nsCSSValueSharedList here, instead of nsCSSValueList_heap
# because this function is not called on the main thread and
# nsCSSValueList_heap is not thread safe.
"list" : "%s.set_shared_list(%s.0.iter().map(&convert_to_ns_css_value));",
}
%>
::values::generics::transform::TransformOperation::${name}${pattern} => {
% if has_optional:
let optional_present = ${items[-1] + str(len(items))}.is_some();
let len = if optional_present {
${len(items) + 1}
} else {
${len(items)}
};
% else:
let len = ${len(items) + 1};
% endif
bindings::Gecko_CSSValue_SetFunction(gecko_value, len);
bindings::Gecko_CSSValue_SetKeyword(
bindings::Gecko_CSSValue_GetArrayItem(gecko_value, 0),
structs::nsCSSKeyword::eCSSKeyword_${keyword}
);
% for index, item in enumerate(items):
<% replaced_item = item.replace("optional_", "") %>
% if item.startswith("optional"):
if let Some(${replaced_item + str(index + 1)}) = ${item + str(index + 1)} {
% endif
% if item == "list":
debug_assert!(!${item}${index + 1}.0.is_empty());
% endif
${css_value_setters[replaced_item] % (
"bindings::Gecko_CSSValue_GetArrayItem(gecko_value, %d)" % (index + 1),
replaced_item + str(index + 1)
)};
% if item.startswith("optional"):
}
% endif
% endfor
}
</%def>
<%def name="computed_operation_arm(name, keyword, items)">
<%
# %s is substituted with the call to GetArrayItem.
css_value_getters = {
"length" : "Length::new(bindings::Gecko_CSSValue_GetNumber(%s))",
"lop" : "%s.get_lop()",
"lopon" : "Either::Second(%s.get_lop())",
"lon" : "Either::First(%s.get_length())",
"angle" : "%s.get_angle()",
"number" : "bindings::Gecko_CSSValue_GetNumber(%s)",
"percentage" : "Percentage(bindings::Gecko_CSSValue_GetPercentage(%s))",
"integer_to_percentage" : "bindings::Gecko_CSSValue_GetPercentage(%s) as i32",
"list" : "Transform(convert_shared_list_to_operations(%s))",
}
pre_symbols = "("
post_symbols = ")"
if keyword == "interpolatematrix" or keyword == "accumulatematrix":
# We generate this like: "TransformOperation::InterpolateMatrix {", so the space is
# between "InterpolateMatrix"/"AccumulateMatrix" and '{'
pre_symbols = " {"
post_symbols = "}"
elif keyword == "matrix3d":
pre_symbols = "(Matrix3D {"
post_symbols = "})"
elif keyword == "matrix":
pre_symbols = "(Matrix {"
post_symbols = "})"
field_names = None
if keyword == "interpolatematrix":
field_names = ["from_list", "to_list", "progress"]
elif keyword == "accumulatematrix":
field_names = ["from_list", "to_list", "count"]
%>
<%
guard = ""
if name == "Matrix3D" or name == "Matrix":
guard = "if !needs_prefix "
elif name == "PrefixedMatrix3D" or name == "PrefixedMatrix":
guard = "if needs_prefix "
%>
structs::nsCSSKeyword::eCSSKeyword_${keyword} ${guard}=> {
::values::generics::transform::TransformOperation::${name}${pre_symbols}
% for index, item in enumerate(items):
% if keyword == "matrix3d":
m${index / 4 + 1}${index % 4 + 1}:
% elif keyword == "matrix":
${chr(ord('a') + index)}:
% elif keyword == "interpolatematrix" or keyword == "accumulatematrix":
${field_names[index]}:
% endif
<%
getter = css_value_getters[item.replace("optional_", "")] % (
"bindings::Gecko_CSSValue_GetArrayItemConst(gecko_value, %d)" % (index + 1)
)
%>
% if item.startswith("optional_"):
if (**gecko_value.mValue.mArray.as_ref()).mCount == ${index + 1} {
None
} else {
Some(${getter})
}
% else:
${getter}
% endif
,
% endfor
${post_symbols}
},
</%def>
fn set_single_transform_function(
servo_value: &values::computed::TransformOperation,
gecko_value: &mut structs::nsCSSValue /* output */
) {
use values::computed::{Length, LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrNumber};
use values::computed::TransformOperation;
use values::generics::transform::{Matrix, Matrix3D};
let convert_to_ns_css_value = |item: &TransformOperation| -> structs::nsCSSValue {
let mut value = structs::nsCSSValue::null();
set_single_transform_function(item, &mut value);
value
};
unsafe fn set_lopon(css: &mut structs::nsCSSValue, lopon: LengthOrPercentageOrNumber) {
let lop = match lopon {
Either::First(number) => LengthOrPercentage::Length(Length::new(number)),
Either::Second(lop) => lop,
};
css.set_lop(lop);
}
unsafe fn set_lon(css: &mut structs::nsCSSValue, lopon: LengthOrNumber) {
let length = match lopon {
Either::Second(number) => Length::new(number),
Either::First(l) => l,
};
bindings::Gecko_CSSValue_SetPixelLength(css, length.px())
}
unsafe {
match *servo_value {
% for servo, gecko, format in transform_functions:
${transform_function_arm(servo, gecko, format)}
% endfor
}
}
}
pub fn convert_transform(
input: &[values::computed::TransformOperation],
output: &mut structs::root::RefPtr<structs::root::nsCSSValueSharedList>
) {
use gecko_bindings::sugar::refptr::RefPtr;
unsafe { output.clear() };
let list = unsafe {
RefPtr::from_addrefed(bindings::Gecko_NewCSSValueSharedList(input.len() as u32))
};
let value_list = unsafe { list.mHead.as_mut() };
if let Some(value_list) = value_list {
for (gecko, servo) in value_list.into_iter().zip(input.into_iter()) {
set_single_transform_function(servo, gecko);
}
}
output.set_move(list);
}
fn clone_single_transform_function(
gecko_value: &structs::nsCSSValue
) -> values::computed::TransformOperation {
use values::computed::{Length, Percentage, TransformOperation};
use values::generics::transform::{Matrix, Matrix3D};
use values::generics::transform::Transform;
let convert_shared_list_to_operations = |value: &structs::nsCSSValue|
-> Vec<TransformOperation> {
debug_assert!(value.mUnit == structs::nsCSSUnit::eCSSUnit_SharedList);
let value_list = unsafe {
value.mValue.mSharedList.as_ref()
.as_mut().expect("List pointer should be non-null").mHead.as_ref()
};
debug_assert!(value_list.is_some(), "An empty shared list is not allowed");
value_list.unwrap().into_iter()
.map(|item| clone_single_transform_function(item))
.collect()
};
let transform_function = unsafe {
bindings::Gecko_CSSValue_GetKeyword(bindings::Gecko_CSSValue_GetArrayItemConst(gecko_value, 0))
};
let needs_prefix = if transform_function == structs::nsCSSKeyword::eCSSKeyword_matrix3d {
unsafe {
bindings::Gecko_CSSValue_GetArrayItemConst(gecko_value, 13).mUnit
!= structs::nsCSSUnit::eCSSUnit_Number ||
bindings::Gecko_CSSValue_GetArrayItemConst(gecko_value, 14).mUnit
!= structs::nsCSSUnit::eCSSUnit_Number ||
bindings::Gecko_CSSValue_GetArrayItemConst(gecko_value, 15).mUnit
!= structs::nsCSSUnit::eCSSUnit_Number
}
} else {
false
};
unsafe {
match transform_function {
% for servo, gecko, format in transform_functions:
${computed_operation_arm(servo, gecko, format)}
% endfor
_ => panic!("unacceptable transform function"),
}
}
}
pub fn clone_transform_from_list(
list: Option< &structs::root::nsCSSValueList>
) -> values::computed::Transform {
use values::generics::transform::Transform;
let result = match list {
Some(list) => {
list.into_iter()
.filter_map(|value| {
// Handle none transform.
if value.is_none() {
None
} else {
Some(clone_single_transform_function(value))
}
})
.collect::<Vec<_>>()
},
_ => vec![],
};
Transform(result)
}
<%def name="impl_transform(ident, gecko_ffi_name)">
#[allow(non_snake_case)]<｜fim▁hole｜> use gecko_properties::convert_transform;
if other.0.is_empty() {
unsafe {
self.gecko.${gecko_ffi_name}.clear();
}
return;
};
convert_transform(&other.0, &mut self.gecko.${gecko_ffi_name});
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
unsafe { self.gecko.${gecko_ffi_name}.set(&other.gecko.${gecko_ffi_name}); }
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> values::computed::Transform {
use gecko_properties::clone_transform_from_list;
use values::generics::transform::Transform;
if self.gecko.${gecko_ffi_name}.mRawPtr.is_null() {
return Transform(vec!());
}
let list = unsafe { (*self.gecko.${gecko_ffi_name}.to_safe().get()).mHead.as_ref() };
clone_transform_from_list(list)
}
</%def>
<%def name="impl_transform_origin(ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: values::computed::TransformOrigin) {
self.gecko.${gecko_ffi_name}[0].set(v.horizontal);
self.gecko.${gecko_ffi_name}[1].set(v.vertical);
// transform-origin supports the third value for depth, while
// -moz-window-transform-origin doesn't. The following code is
// for handling this difference. If we can have more knowledge
// about the type here, we may want to check that the length is
// exactly either 2 or 3 in compile time.
if let Some(third) = self.gecko.${gecko_ffi_name}.get_mut(2) {
third.set(v.depth);
}
}
#[allow(non_snake_case)]
pub fn copy_${ident}_from(&mut self, other: &Self) {
self.gecko.${gecko_ffi_name}[0].copy_from(&other.gecko.${gecko_ffi_name}[0]);
self.gecko.${gecko_ffi_name}[1].copy_from(&other.gecko.${gecko_ffi_name}[1]);
if let (Some(self_third), Some(other_third)) =
(self.gecko.${gecko_ffi_name}.get_mut(2), other.gecko.${gecko_ffi_name}.get(2))
{
self_third.copy_from(other_third)
}
}
#[allow(non_snake_case)]
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> values::computed::TransformOrigin {
use values::computed::{Length, LengthOrPercentage, TransformOrigin};
TransformOrigin {
horizontal: LengthOrPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[0])
.expect("clone for LengthOrPercentage failed"),
vertical: LengthOrPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[1])
.expect("clone for LengthOrPercentage failed"),
depth: if let Some(third) = self.gecko.${gecko_ffi_name}.get(2) {
Length::from_gecko_style_coord(third)
.expect("clone for Length failed")
} else {
Length::new(0.)
},
}
}
</%def>
<%def name="impl_logical(name, **kwargs)">
${helpers.logical_setter(name)}
</%def>
<%def name="impl_style_struct(style_struct)">
impl ${style_struct.gecko_struct_name} {
#[allow(dead_code, unused_variables)]
pub fn default(pres_context: RawGeckoPresContextBorrowed) -> Arc<Self> {
let mut result = Arc::new(${style_struct.gecko_struct_name} { gecko: unsafe { zeroed() } });
unsafe {
Gecko_Construct_Default_${style_struct.gecko_ffi_name}(&mut Arc::get_mut(&mut result).unwrap().gecko,
pres_context);
}
result
}
pub fn get_gecko(&self) -> &${style_struct.gecko_ffi_name} {
&self.gecko
}
}
impl Drop for ${style_struct.gecko_struct_name} {
fn drop(&mut self) {
unsafe {
Gecko_Destroy_${style_struct.gecko_ffi_name}(&mut self.gecko);
}
}
}
impl Clone for ${style_struct.gecko_struct_name} {
fn clone(&self) -> Self {
unsafe {
let mut result = ${style_struct.gecko_struct_name} { gecko: zeroed() };
Gecko_CopyConstruct_${style_struct.gecko_ffi_name}(&mut result.gecko, &self.gecko);
result
}
}
}
</%def>
<%def name="impl_simple_type_with_conversion(ident, gecko_ffi_name=None)">
<%
if gecko_ffi_name is None:
gecko_ffi_name = "m" + to_camel_case(ident)
%>
#[allow(non_snake_case)]
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
self.gecko.${gecko_ffi_name} = From::from(v)
}
<% impl_simple_copy(ident, gecko_ffi_name) %>
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
From::from(self.gecko.${gecko_ffi_name})
}
</%def>
<%def name="impl_font_settings(ident, tag_type, value_type, gecko_value_type)">
<%
gecko_ffi_name = to_camel_case_lower(ident)
%>
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
let current_settings = &mut self.gecko.mFont.${gecko_ffi_name};
current_settings.clear_pod();
unsafe { current_settings.set_len_pod(v.0.len() as u32) };
for (current, other) in current_settings.iter_mut().zip(v.0.iter()) {
current.mTag = other.tag.0;
current.mValue = other.value as ${gecko_value_type};
}
}
pub fn copy_${ident}_from(&mut self, other: &Self) {
let current_settings = &mut self.gecko.mFont.${gecko_ffi_name};
let other_settings = &other.gecko.mFont.${gecko_ffi_name};
let settings_length = other_settings.len() as u32;
current_settings.clear_pod();
unsafe { current_settings.set_len_pod(settings_length) };
for (current, other) in current_settings.iter_mut().zip(other_settings.iter()) {
current.mTag = other.mTag;
current.mValue = other.mValue;
}
}
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use values::generics::font::{FontSettings, ${tag_type}};
use values::specified::font::FontTag;
FontSettings(
self.gecko.mFont.${gecko_ffi_name}.iter().map(|gecko_font_setting| {
${tag_type} {
tag: FontTag(gecko_font_setting.mTag),
value: gecko_font_setting.mValue as ${value_type},
}
}).collect::<Vec<_>>().into_boxed_slice()
)
}
</%def>
<%def name="impl_trait(style_struct_name, skip_longhands='')">
<%
style_struct = next(x for x in data.style_structs if x.name == style_struct_name)
longhands = [x for x in style_struct.longhands
if not (skip_longhands == "*" or x.name in skip_longhands.split())]
# Types used with predefined_type()-defined properties that we can auto-generate.
predefined_types = {
"length::LengthOrAuto": impl_style_coord,
"length::LengthOrNormal": impl_style_coord,
"length::NonNegativeLengthOrAuto": impl_style_coord,
"length::NonNegativeLengthOrNormal": impl_style_coord,
"GreaterThanOrEqualToOneNumber": impl_simple,
"Length": impl_absolute_length,
"Position": impl_position,
"LengthOrPercentage": impl_style_coord,
"LengthOrPercentageOrAuto": impl_style_coord,
"LengthOrPercentageOrNone": impl_style_coord,
"LengthOrNone": impl_style_coord,
"LengthOrNormal": impl_style_coord,
"MaxLength": impl_style_coord,
"MozLength": impl_style_coord,
"MozScriptMinSize": impl_absolute_length,
"MozScriptSizeMultiplier": impl_simple,
"NonNegativeLengthOrPercentage": impl_style_coord,
"NonNegativeNumber": impl_simple,
"Number": impl_simple,
"Integer": impl_simple,
"Opacity": impl_simple,
"Color": impl_color,
"RGBAColor": impl_rgba_color,
"SVGLength": impl_svg_length,
"SVGOpacity": impl_svg_opacity,
"SVGPaint": impl_svg_paint,
"SVGWidth": impl_svg_length,
"Transform": impl_transform,
"TransformOrigin": impl_transform_origin,
"UrlOrNone": impl_css_url,
}
def longhand_method(longhand):
args = dict(ident=longhand.ident, gecko_ffi_name=longhand.gecko_ffi_name)
# get the method and pass additional keyword or type-specific arguments
if longhand.logical:
method = impl_logical
args.update(name=longhand.name)
elif longhand.keyword:
method = impl_keyword
args.update(keyword=longhand.keyword)
if "font" in longhand.ident:
args.update(cast_type=longhand.cast_type)
else:
method = predefined_types[longhand.predefined_type]
method(**args)
picked_longhands = []
for x in longhands:
if x.keyword or x.predefined_type in predefined_types or x.logical:
picked_longhands.append(x)
%>
impl ${style_struct.gecko_struct_name} {
/*
* Manually-Implemented Methods.
*/
${caller.body().strip()}
/*
* Auto-Generated Methods.
*/
<%
for longhand in picked_longhands:
longhand_method(longhand)
%>
}
</%def>
<%!
class Side(object):
def __init__(self, name, index):
self.name = name
self.ident = name.lower()
self.index = index
class Corner(object):
def __init__(self, vert, horiz, index):
self.x_name = "HalfCorner::eCorner" + vert + horiz + "X"
self.y_name = "HalfCorner::eCorner" + vert + horiz + "Y"
self.ident = (vert + "_" + horiz).lower()
self.x_index = 2 * index
self.y_index = 2 * index + 1
class GridLine(object):
def __init__(self, name):
self.ident = "grid-" + name.lower()
self.name = self.ident.replace('-', '_')
self.gecko = "m" + to_camel_case(self.ident)
SIDES = [Side("Top", 0), Side("Right", 1), Side("Bottom", 2), Side("Left", 3)]
CORNERS = [Corner("Top", "Left", 0), Corner("Top", "Right", 1),
Corner("Bottom", "Right", 2), Corner("Bottom", "Left", 3)]
GRID_LINES = map(GridLine, ["row-start", "row-end", "column-start", "column-end"])
%>
#[allow(dead_code)]
fn static_assert() {
unsafe {
% for corner in CORNERS:
transmute::<_, [u32; ${corner.x_index}]>([1; structs::${corner.x_name} as usize]);
transmute::<_, [u32; ${corner.y_index}]>([1; structs::${corner.y_name} as usize]);
% endfor
}
// Note: using the above technique with an enum hits a rust bug when |structs| is in a different crate.
% for side in SIDES:
{ const DETAIL: u32 = [0][(structs::Side::eSide${side.name} as usize != ${side.index}) as usize]; let _ = DETAIL; }
% endfor
}
<% border_style_keyword = Keyword("border-style",
"none solid double dotted dashed hidden groove ridge inset outset") %>
<% skip_border_longhands = " ".join(["border-{0}-{1}".format(x.ident, y)
for x in SIDES
for y in ["color", "style", "width"]] +
["border-{0}-radius".format(x.ident.replace("_", "-"))
for x in CORNERS]) %>
<%self:impl_trait style_struct_name="Border"
skip_longhands="${skip_border_longhands} border-image-source border-image-outset
border-image-repeat border-image-width border-image-slice">
% for side in SIDES:
<% impl_keyword("border_%s_style" % side.ident,
"mBorderStyle[%s]" % side.index,
border_style_keyword,
on_set="update_border_%s" % side.ident) %>
// This is needed because the initial mComputedBorder value is set to zero.
//
// In order to compute stuff, we start from the initial struct, and keep
// going down the tree applying properties.
//
// That means, effectively, that when we set border-style to something
// non-hidden, we should use the initial border instead.
//
// Servo stores the initial border-width in the initial struct, and then
// adjusts as needed in the fixup phase. This means that the initial struct
// is technically not valid without fixups, and that you lose pretty much
// any sharing of the initial struct, which is kind of unfortunate.
//
// Gecko has two fields for this, one that stores the "specified" border,
// and other that stores the actual computed one. That means that when we
// set border-style, border-width may change and we need to sync back to the
// specified one. This is what this function does.
//
// Note that this doesn't impose any dependency in the order of computation
// of the properties. This is only relevant if border-style is specified,
// but border-width isn't. If border-width is specified at some point, the
// two mBorder and mComputedBorder fields would be the same already.
//
// Once we're here, we know that we'll run style fixups, so it's fine to
// just copy the specified border here, we'll adjust it if it's incorrect
// later.
fn update_border_${side.ident}(&mut self) {
self.gecko.mComputedBorder.${side.ident} = self.gecko.mBorder.${side.ident};
}
<% impl_color("border_%s_color" % side.ident, "(mBorderColor)[%s]" % side.index) %>
<% impl_non_negative_length("border_%s_width" % side.ident,
"mComputedBorder.%s" % side.ident,
inherit_from="mBorder.%s" % side.ident,
round_to_pixels=True) %>
pub fn border_${side.ident}_has_nonzero_width(&self) -> bool {
self.gecko.mComputedBorder.${side.ident} != 0
}
% endfor
% for corner in CORNERS:
<% impl_corner_style_coord("border_%s_radius" % corner.ident,
"mBorderRadius",
corner.x_index,
corner.y_index) %>
% endfor
pub fn set_border_image_source(&mut self, image: longhands::border_image_source::computed_value::T) {
unsafe {
// Prevent leaking of the last elements we did set
Gecko_SetNullImageValue(&mut self.gecko.mBorderImageSource);
}
if let Either::Second(image) = image {
self.gecko.mBorderImageSource.set(image);
}
}
pub fn copy_border_image_source_from(&mut self, other: &Self) {
unsafe {
Gecko_CopyImageValueFrom(&mut self.gecko.mBorderImageSource,
&other.gecko.mBorderImageSource);
}
}
pub fn reset_border_image_source(&mut self, other: &Self) {
self.copy_border_image_source_from(other)
}
pub fn clone_border_image_source(&self) -> longhands::border_image_source::computed_value::T {
use values::None_;
match unsafe { self.gecko.mBorderImageSource.into_image() } {
Some(image) => Either::Second(image),
None => Either::First(None_),
}
}
<% impl_style_sides("border_image_outset") %>
<%
border_image_repeat_keywords = ["Stretch", "Repeat", "Round", "Space"]
%>
pub fn set_border_image_repeat(&mut self, v: longhands::border_image_repeat::computed_value::T) {
use values::specified::border::BorderImageRepeatKeyword;
use gecko_bindings::structs::StyleBorderImageRepeat;
% for i, side in enumerate(["H", "V"]):
self.gecko.mBorderImageRepeat${side} = match v.${i} {
% for keyword in border_image_repeat_keywords:
BorderImageRepeatKeyword::${keyword} => StyleBorderImageRepeat::${keyword},
% endfor
};
% endfor
}
pub fn copy_border_image_repeat_from(&mut self, other: &Self) {
self.gecko.mBorderImageRepeatH = other.gecko.mBorderImageRepeatH;
self.gecko.mBorderImageRepeatV = other.gecko.mBorderImageRepeatV;
}
pub fn reset_border_image_repeat(&mut self, other: &Self) {
self.copy_border_image_repeat_from(other)
}
pub fn clone_border_image_repeat(&self) -> longhands::border_image_repeat::computed_value::T {
use values::specified::border::BorderImageRepeatKeyword;
use gecko_bindings::structs::StyleBorderImageRepeat;
% for side in ["H", "V"]:
let servo_${side.lower()} = match self.gecko.mBorderImageRepeat${side} {
% for keyword in border_image_repeat_keywords:
StyleBorderImageRepeat::${keyword} => BorderImageRepeatKeyword::${keyword},
% endfor
};
% endfor
longhands::border_image_repeat::computed_value::T(servo_h, servo_v)
}
<% impl_style_sides("border_image_width") %>
pub fn set_border_image_slice(&mut self, v: longhands::border_image_slice::computed_value::T) {
use gecko_bindings::structs::{NS_STYLE_BORDER_IMAGE_SLICE_NOFILL, NS_STYLE_BORDER_IMAGE_SLICE_FILL};
v.offsets.to_gecko_rect(&mut self.gecko.mBorderImageSlice);
let fill = if v.fill {
NS_STYLE_BORDER_IMAGE_SLICE_FILL
} else {
NS_STYLE_BORDER_IMAGE_SLICE_NOFILL
};
self.gecko.mBorderImageFill = fill as u8;
}
<%self:copy_sides_style_coord ident="border_image_slice">
self.gecko.mBorderImageFill = other.gecko.mBorderImageFill;
</%self:copy_sides_style_coord>
pub fn clone_border_image_slice(&self) -> longhands::border_image_slice::computed_value::T {
use gecko_bindings::structs::NS_STYLE_BORDER_IMAGE_SLICE_FILL;
use values::computed::{BorderImageSlice, NumberOrPercentage};
type NumberOrPercentageRect = ::values::generics::rect::Rect<NumberOrPercentage>;
BorderImageSlice {
offsets:
NumberOrPercentageRect::from_gecko_rect(&self.gecko.mBorderImageSlice)
.expect("mBorderImageSlice[${side}] could not convert to NumberOrPercentageRect"),
fill: self.gecko.mBorderImageFill as u32 == NS_STYLE_BORDER_IMAGE_SLICE_FILL
}
}
</%self:impl_trait>
<% skip_margin_longhands = " ".join(["margin-%s" % x.ident for x in SIDES]) %>
<%self:impl_trait style_struct_name="Margin"
skip_longhands="${skip_margin_longhands}">
% for side in SIDES:
<% impl_split_style_coord("margin_%s" % side.ident,
"mMargin",
side.index) %>
% endfor
</%self:impl_trait>
<% skip_padding_longhands = " ".join(["padding-%s" % x.ident for x in SIDES]) %>
<%self:impl_trait style_struct_name="Padding"
skip_longhands="${skip_padding_longhands}">
% for side in SIDES:
<% impl_split_style_coord("padding_%s" % side.ident,
"mPadding",
side.index) %>
% endfor
</%self:impl_trait>
<% skip_position_longhands = " ".join(x.ident for x in SIDES + GRID_LINES) %>
<%self:impl_trait style_struct_name="Position"
skip_longhands="${skip_position_longhands} z-index order align-content
justify-content align-self justify-self align-items
justify-items grid-auto-rows grid-auto-columns grid-auto-flow
grid-template-areas grid-template-rows grid-template-columns">
% for side in SIDES:
<% impl_split_style_coord("%s" % side.ident,
"mOffset",
side.index) %>
% endfor
pub fn set_z_index(&mut self, v: longhands::z_index::computed_value::T) {
match v {
Either::First(n) => self.gecko.mZIndex.set_value(CoordDataValue::Integer(n)),
Either::Second(Auto) => self.gecko.mZIndex.set_value(CoordDataValue::Auto),
}
}
pub fn copy_z_index_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleUnit;
// z-index is never a calc(). If it were, we'd be leaking here, so
// assert that it isn't.
debug_assert!(self.gecko.mZIndex.unit() != nsStyleUnit::eStyleUnit_Calc);
unsafe {
self.gecko.mZIndex.copy_from_unchecked(&other.gecko.mZIndex);
}
}
pub fn reset_z_index(&mut self, other: &Self) {
self.copy_z_index_from(other)
}
pub fn clone_z_index(&self) -> longhands::z_index::computed_value::T {
return match self.gecko.mZIndex.as_value() {
CoordDataValue::Integer(n) => Either::First(n),
CoordDataValue::Auto => Either::Second(Auto),
_ => {
debug_assert!(false);
Either::First(0)
}
}
}
% for kind in ["align", "justify"]:
${impl_simple_type_with_conversion(kind + "_content")}
${impl_simple_type_with_conversion(kind + "_self")}
% endfor
${impl_simple_type_with_conversion("align_items")}
pub fn set_justify_items(&mut self, v: longhands::justify_items::computed_value::T) {
self.gecko.mSpecifiedJustifyItems = v.specified.into();
self.set_computed_justify_items(v.computed);
}
pub fn set_computed_justify_items(&mut self, v: values::specified::JustifyItems) {
debug_assert!(v.0 != ::values::specified::align::AlignFlags::AUTO);
self.gecko.mJustifyItems = v.into();
}
pub fn reset_justify_items(&mut self, reset_style: &Self) {
self.gecko.mJustifyItems = reset_style.gecko.mJustifyItems;
self.gecko.mSpecifiedJustifyItems = reset_style.gecko.mSpecifiedJustifyItems;
}
pub fn copy_justify_items_from(&mut self, other: &Self) {
self.gecko.mJustifyItems = other.gecko.mJustifyItems;
self.gecko.mSpecifiedJustifyItems = other.gecko.mJustifyItems;
}
pub fn clone_justify_items(&self) -> longhands::justify_items::computed_value::T {
longhands::justify_items::computed_value::T {
computed: self.gecko.mJustifyItems.into(),
specified: self.gecko.mSpecifiedJustifyItems.into(),
}
}
pub fn set_order(&mut self, v: longhands::order::computed_value::T) {
self.gecko.mOrder = v;
}
pub fn clone_order(&self) -> longhands::order::computed_value::T {
self.gecko.mOrder
}
${impl_simple_copy('order', 'mOrder')}
% for value in GRID_LINES:
pub fn set_${value.name}(&mut self, v: longhands::${value.name}::computed_value::T) {
use gecko_bindings::structs::{nsStyleGridLine_kMinLine, nsStyleGridLine_kMaxLine};
let ident = v.ident.as_ref().map_or(&[] as &[_], |ident| ident.0.as_slice());
self.gecko.${value.gecko}.mLineName.assign(ident);
self.gecko.${value.gecko}.mHasSpan = v.is_span;
if let Some(integer) = v.line_num {
// clamping the integer between a range
self.gecko.${value.gecko}.mInteger = cmp::max(nsStyleGridLine_kMinLine,
cmp::min(integer, nsStyleGridLine_kMaxLine));
}
}
pub fn copy_${value.name}_from(&mut self, other: &Self) {
self.gecko.${value.gecko}.mHasSpan = other.gecko.${value.gecko}.mHasSpan;
self.gecko.${value.gecko}.mInteger = other.gecko.${value.gecko}.mInteger;
self.gecko.${value.gecko}.mLineName.assign(&*other.gecko.${value.gecko}.mLineName);
}
pub fn reset_${value.name}(&mut self, other: &Self) {
self.copy_${value.name}_from(other)
}
pub fn clone_${value.name}(&self) -> longhands::${value.name}::computed_value::T {
use gecko_bindings::structs::{nsStyleGridLine_kMinLine, nsStyleGridLine_kMaxLine};
use string_cache::Atom;
longhands::${value.name}::computed_value::T {
is_span: self.gecko.${value.gecko}.mHasSpan,
ident: {
let name = self.gecko.${value.gecko}.mLineName.to_string();
if name.len() == 0 {
None
} else {
Some(CustomIdent(Atom::from(name)))
}
},
line_num:
if self.gecko.${value.gecko}.mInteger == 0 {
None
} else {
debug_assert!(nsStyleGridLine_kMinLine <= self.gecko.${value.gecko}.mInteger);
debug_assert!(self.gecko.${value.gecko}.mInteger <= nsStyleGridLine_kMaxLine);
Some(self.gecko.${value.gecko}.mInteger)
},
}
}
% endfor
% for kind in ["rows", "columns"]:
pub fn set_grid_auto_${kind}(&mut self, v: longhands::grid_auto_${kind}::computed_value::T) {
v.to_gecko_style_coords(&mut self.gecko.mGridAuto${kind.title()}Min,
&mut self.gecko.mGridAuto${kind.title()}Max)
}
pub fn copy_grid_auto_${kind}_from(&mut self, other: &Self) {
self.gecko.mGridAuto${kind.title()}Min.copy_from(&other.gecko.mGridAuto${kind.title()}Min);
self.gecko.mGridAuto${kind.title()}Max.copy_from(&other.gecko.mGridAuto${kind.title()}Max);
}
pub fn reset_grid_auto_${kind}(&mut self, other: &Self) {
self.copy_grid_auto_${kind}_from(other)
}
pub fn clone_grid_auto_${kind}(&self) -> longhands::grid_auto_${kind}::computed_value::T {
::values::generics::grid::TrackSize::from_gecko_style_coords(&self.gecko.mGridAuto${kind.title()}Min,
&self.gecko.mGridAuto${kind.title()}Max)
}
pub fn set_grid_template_${kind}(&mut self, v: longhands::grid_template_${kind}::computed_value::T) {
<% self_grid = "self.gecko.mGridTemplate%s" % kind.title() %>
use gecko_bindings::structs::{nsTArray, nsStyleGridLine_kMaxLine};
use nsstring::nsStringRepr;
use std::usize;
use values::CustomIdent;
use values::generics::grid::TrackListType::Auto;
use values::generics::grid::{GridTemplateComponent, RepeatCount};
#[inline]
fn set_line_names(servo_names: &[CustomIdent], gecko_names: &mut nsTArray<nsStringRepr>) {
unsafe {
bindings::Gecko_ResizeTArrayForStrings(gecko_names, servo_names.len() as u32);
}
for (servo_name, gecko_name) in servo_names.iter().zip(gecko_names.iter_mut()) {
gecko_name.assign(servo_name.0.as_slice());
}
}
let max_lines = nsStyleGridLine_kMaxLine as usize - 1; // for accounting the final <line-names>
let result = match v {
GridTemplateComponent::None => ptr::null_mut(),
GridTemplateComponent::TrackList(track) => {
let mut num_values = track.values.len();
if let Auto(_) = track.list_type {
num_values += 1;
}
num_values = cmp::min(num_values, max_lines);
let value = unsafe {
bindings::Gecko_CreateStyleGridTemplate(num_values as u32,
(num_values + 1) as u32).as_mut().unwrap()
};
let mut auto_idx = usize::MAX;
let mut auto_track_size = None;
if let Auto(idx) = track.list_type {
auto_idx = idx as usize;
let auto_repeat = track.auto_repeat.as_ref().expect("expected <auto-track-repeat> value");
if auto_repeat.count == RepeatCount::AutoFill {
value.set_mIsAutoFill(true);
}
value.mRepeatAutoIndex = idx as i16;
// NOTE: Gecko supports only one set of values in <auto-repeat>
// i.e., it can only take repeat(auto-fill, [a] 10px [b]), and no more.
set_line_names(&auto_repeat.line_names[0], &mut value.mRepeatAutoLineNameListBefore);
set_line_names(&auto_repeat.line_names[1], &mut value.mRepeatAutoLineNameListAfter);
auto_track_size = Some(auto_repeat.track_sizes.get(0).unwrap().clone());
} else {
unsafe {
bindings::Gecko_ResizeTArrayForStrings(
&mut value.mRepeatAutoLineNameListBefore, 0);
bindings::Gecko_ResizeTArrayForStrings(
&mut value.mRepeatAutoLineNameListAfter, 0);
}
}
let mut line_names = track.line_names.into_iter();
let mut values_iter = track.values.into_iter();
{
let min_max_iter = value.mMinTrackSizingFunctions.iter_mut()
.zip(value.mMaxTrackSizingFunctions.iter_mut());
for (i, (gecko_min, gecko_max)) in min_max_iter.enumerate().take(max_lines) {
let name_list = line_names.next().expect("expected line-names");
set_line_names(&name_list, &mut value.mLineNameLists[i]);
if i == auto_idx {
let track_size = auto_track_size.take()
.expect("expected <track-size> for <auto-track-repeat>");
track_size.to_gecko_style_coords(gecko_min, gecko_max);
continue
}
let track_size = values_iter.next().expect("expected <track-size> value");
track_size.to_gecko_style_coords(gecko_min, gecko_max);
}
}
let final_names = line_names.next().unwrap();
set_line_names(&final_names, value.mLineNameLists.last_mut().unwrap());
value
},
GridTemplateComponent::Subgrid(list) => {
let names_length = match list.fill_idx {
Some(_) => list.names.len() - 1,
None => list.names.len(),
};
let num_values = cmp::min(names_length, max_lines + 1);
let value = unsafe {
bindings::Gecko_CreateStyleGridTemplate(0, num_values as u32).as_mut().unwrap()
};
value.set_mIsSubgrid(true);
let mut names = list.names.into_vec();
if let Some(idx) = list.fill_idx {
value.set_mIsAutoFill(true);
value.mRepeatAutoIndex = idx as i16;
set_line_names(&names.swap_remove(idx as usize),
&mut value.mRepeatAutoLineNameListBefore);
}
for (servo_names, gecko_names) in names.iter().zip(value.mLineNameLists.iter_mut()) {
set_line_names(servo_names, gecko_names);
}
value
},
};
unsafe { bindings::Gecko_SetStyleGridTemplate(&mut ${self_grid}, result); }
}
pub fn copy_grid_template_${kind}_from(&mut self, other: &Self) {
unsafe {
bindings::Gecko_CopyStyleGridTemplateValues(&mut ${self_grid},
other.gecko.mGridTemplate${kind.title()}.mPtr);
}
}
pub fn reset_grid_template_${kind}(&mut self, other: &Self) {
self.copy_grid_template_${kind}_from(other)
}
pub fn clone_grid_template_${kind}(&self) -> longhands::grid_template_${kind}::computed_value::T {
<% self_grid = "self.gecko.mGridTemplate%s" % kind.title() %>
use Atom;
use gecko_bindings::structs::nsTArray;
use nsstring::nsStringRepr;
use values::CustomIdent;
use values::generics::grid::{GridTemplateComponent, LineNameList, RepeatCount};
use values::generics::grid::{TrackList, TrackListType, TrackListValue, TrackRepeat, TrackSize};
let value = match unsafe { ${self_grid}.mPtr.as_ref() } {
None => return GridTemplateComponent::None,
Some(value) => value,
};
#[inline]
fn to_boxed_customident_slice(gecko_names: &nsTArray<nsStringRepr>) -> Box<[CustomIdent]> {
let idents: Vec<CustomIdent> = gecko_names.iter().map(|gecko_name| {
CustomIdent(Atom::from(gecko_name.to_string()))
}).collect();
idents.into_boxed_slice()
}
#[inline]
fn to_line_names_vec(gecko_line_names: &nsTArray<nsTArray<nsStringRepr>>)
-> Vec<Box<[CustomIdent]>> {
gecko_line_names.iter().map(|gecko_names| {
to_boxed_customident_slice(gecko_names)
}).collect()
}
let repeat_auto_index = value.mRepeatAutoIndex as usize;
if value.mIsSubgrid() {
let mut names_vec = to_line_names_vec(&value.mLineNameLists);
let fill_idx = if value.mIsAutoFill() {
names_vec.insert(
repeat_auto_index,
to_boxed_customident_slice(&value.mRepeatAutoLineNameListBefore));
Some(repeat_auto_index as u32)
} else {
None
};
let names = names_vec.into_boxed_slice();
GridTemplateComponent::Subgrid(LineNameList{names, fill_idx})
} else {
let mut auto_repeat = None;
let mut list_type = TrackListType::Normal;
let line_names = to_line_names_vec(&value.mLineNameLists).into_boxed_slice();
let mut values = Vec::with_capacity(value.mMinTrackSizingFunctions.len());
let min_max_iter = value.mMinTrackSizingFunctions.iter()
.zip(value.mMaxTrackSizingFunctions.iter());
for (i, (gecko_min, gecko_max)) in min_max_iter.enumerate() {
let track_size = TrackSize::from_gecko_style_coords(gecko_min, gecko_max);
if i == repeat_auto_index {
list_type = TrackListType::Auto(repeat_auto_index as u16);
let count = if value.mIsAutoFill() {
RepeatCount::AutoFill
} else {
RepeatCount::AutoFit
};
let line_names = {
let mut vec: Vec<Box<[CustomIdent]>> = Vec::with_capacity(2);
vec.push(to_boxed_customident_slice(
&value.mRepeatAutoLineNameListBefore));
vec.push(to_boxed_customident_slice(
&value.mRepeatAutoLineNameListAfter));
vec.into_boxed_slice()
};
let track_sizes = vec!(track_size);
auto_repeat = Some(TrackRepeat{count, line_names, track_sizes});
} else {
values.push(TrackListValue::TrackSize(track_size));
}
}
GridTemplateComponent::TrackList(TrackList{list_type, values, line_names, auto_repeat})
}
}
% endfor
${impl_simple_type_with_conversion("grid_auto_flow")}
pub fn set_grid_template_areas(&mut self, v: values::computed::position::GridTemplateAreas) {
use gecko_bindings::bindings::Gecko_NewGridTemplateAreasValue;
use gecko_bindings::sugar::refptr::UniqueRefPtr;
let v = match v {
Either::First(areas) => areas,
Either::Second(_) => {
unsafe { self.gecko.mGridTemplateAreas.clear() }
return;
},
};
let mut refptr = unsafe {
UniqueRefPtr::from_addrefed(
Gecko_NewGridTemplateAreasValue(v.0.areas.len() as u32, v.0.strings.len() as u32, v.0.width))
};
for (servo, gecko) in v.0.areas.into_iter().zip(refptr.mNamedAreas.iter_mut()) {
gecko.mName.assign_utf8(&*servo.name);
gecko.mColumnStart = servo.columns.start;
gecko.mColumnEnd = servo.columns.end;
gecko.mRowStart = servo.rows.start;
gecko.mRowEnd = servo.rows.end;
}
for (servo, gecko) in v.0.strings.into_iter().zip(refptr.mTemplates.iter_mut()) {
gecko.assign_utf8(&*servo);
}
self.gecko.mGridTemplateAreas.set_move(refptr.get())
}
pub fn copy_grid_template_areas_from(&mut self, other: &Self) {
unsafe { self.gecko.mGridTemplateAreas.set(&other.gecko.mGridTemplateAreas) }
}
pub fn reset_grid_template_areas(&mut self, other: &Self) {
self.copy_grid_template_areas_from(other)
}
pub fn clone_grid_template_areas(&self) -> values::computed::position::GridTemplateAreas {
use std::ops::Range;
use values::None_;
use values::specified::position::{NamedArea, TemplateAreas, TemplateAreasArc};
if self.gecko.mGridTemplateAreas.mRawPtr.is_null() {
return Either::Second(None_);
}
let gecko_grid_template_areas = self.gecko.mGridTemplateAreas.mRawPtr;
let areas = unsafe {
let vec: Vec<NamedArea> =
(*gecko_grid_template_areas).mNamedAreas.iter().map(|gecko_name_area| {
let name = gecko_name_area.mName.to_string().into_boxed_str();
let rows = Range {
start: gecko_name_area.mRowStart,
end: gecko_name_area.mRowEnd
};
let columns = Range {
start: gecko_name_area.mColumnStart,
end: gecko_name_area.mColumnEnd
};
NamedArea{ name, rows, columns }
}).collect();
vec.into_boxed_slice()
};
let strings = unsafe {
let vec: Vec<Box<str>> =
(*gecko_grid_template_areas).mTemplates.iter().map(|gecko_template| {
gecko_template.to_string().into_boxed_str()
}).collect();
vec.into_boxed_slice()
};
let width = unsafe {
(*gecko_grid_template_areas).mNColumns
};
Either::First(TemplateAreasArc(Arc::new(TemplateAreas{ areas, strings, width })))
}
</%self:impl_trait>
<% skip_outline_longhands = " ".join("outline-style outline-width".split() +
["-moz-outline-radius-{0}".format(x.ident.replace("_", ""))
for x in CORNERS]) %>
<%self:impl_trait style_struct_name="Outline"
skip_longhands="${skip_outline_longhands}">
#[allow(non_snake_case)]
pub fn set_outline_style(&mut self, v: longhands::outline_style::computed_value::T) {
// FIXME(bholley): Align binary representations and ditch |match| for
// cast + static_asserts
let result = match v {
% for value in border_style_keyword.values_for('gecko'):
OutlineStyle::Other(border_style::T::${to_camel_case(value)}) =>
structs::${border_style_keyword.gecko_constant(value)} ${border_style_keyword.maybe_cast("u8")},
% endfor
OutlineStyle::Auto =>
structs::${border_style_keyword.gecko_constant('auto')} ${border_style_keyword.maybe_cast("u8")},
};
${set_gecko_property("mOutlineStyle", "result")}
// NB: This is needed to correctly handling the initial value of
// outline-width when outline-style changes, see the
// update_border_${side.ident} comment for more details.
self.gecko.mActualOutlineWidth = self.gecko.mOutlineWidth;
}
#[allow(non_snake_case)]
pub fn copy_outline_style_from(&mut self, other: &Self) {
self.gecko.mOutlineStyle = other.gecko.mOutlineStyle;
}
#[allow(non_snake_case)]
pub fn reset_outline_style(&mut self, other: &Self) {
self.copy_outline_style_from(other)
}
#[allow(non_snake_case)]
pub fn clone_outline_style(&self) -> longhands::outline_style::computed_value::T {
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
match ${get_gecko_property("mOutlineStyle")} ${border_style_keyword.maybe_cast("u32")} {
% for value in border_style_keyword.values_for('gecko'):
structs::${border_style_keyword.gecko_constant(value)} => {
OutlineStyle::Other(border_style::T::${to_camel_case(value)})
},
% endfor
structs::${border_style_keyword.gecko_constant('auto')} => OutlineStyle::Auto,
% if border_style_keyword.gecko_inexhaustive:
_ => panic!("Found unexpected value in style struct for outline_style property"),
% endif
}
}
<% impl_non_negative_length("outline_width", "mActualOutlineWidth",
inherit_from="mOutlineWidth",
round_to_pixels=True) %>
% for corner in CORNERS:
<% impl_corner_style_coord("_moz_outline_radius_%s" % corner.ident.replace("_", ""),
"mOutlineRadius",
corner.x_index,
corner.y_index) %>
% endfor
pub fn outline_has_nonzero_width(&self) -> bool {
self.gecko.mActualOutlineWidth != 0
}
</%self:impl_trait>
<%
skip_font_longhands = """font-family font-size font-size-adjust font-weight
font-synthesis -x-lang font-variant-alternates
font-variant-east-asian font-variant-ligatures
font-variant-numeric font-language-override
font-feature-settings font-variation-settings
-moz-min-font-size-ratio -x-text-zoom"""
%>
<%self:impl_trait style_struct_name="Font"
skip_longhands="${skip_font_longhands}">
// Negative numbers are invalid at parse time, but <integer> is still an
// i32.
<% impl_font_settings("font_feature_settings", "FeatureTagValue", "i32", "u32") %>
<% impl_font_settings("font_variation_settings", "VariationValue", "f32", "f32") %>
pub fn fixup_none_generic(&mut self, device: &Device) {
self.gecko.mFont.systemFont = false;
unsafe {
bindings::Gecko_nsStyleFont_FixupNoneGeneric(&mut self.gecko, device.pres_context())
}
}
pub fn fixup_system(&mut self, default_font_type: structs::FontFamilyType) {
self.gecko.mFont.systemFont = true;
self.gecko.mGenericID = structs::kGenericFont_NONE;
self.gecko.mFont.fontlist.mDefaultFontType = default_font_type;
}
pub fn set_font_family(&mut self, v: longhands::font_family::computed_value::T) {
self.gecko.mGenericID = structs::kGenericFont_NONE;
if let Some(generic) = v.0.single_generic() {
self.gecko.mGenericID = generic;
}
self.gecko.mFont.fontlist.mFontlist.mBasePtr.set_move((v.0).0.clone());
}
pub fn font_family_count(&self) -> usize {
0
}
pub fn font_family_at(&self, _: usize) -> SingleFontFamily {
unimplemented!()
}
pub fn copy_font_family_from(&mut self, other: &Self) {
unsafe { Gecko_CopyFontFamilyFrom(&mut self.gecko.mFont, &other.gecko.mFont); }
self.gecko.mGenericID = other.gecko.mGenericID;
self.gecko.mFont.systemFont = other.gecko.mFont.systemFont;
}
pub fn reset_font_family(&mut self, other: &Self) {
self.copy_font_family_from(other)
}
pub fn clone_font_family(&self) -> longhands::font_family::computed_value::T {
use gecko_bindings::structs::FontFamilyType;
use values::computed::font::{FontFamily, SingleFontFamily, FontFamilyList};
let fontlist = &self.gecko.mFont.fontlist;
let shared_fontlist = unsafe { fontlist.mFontlist.mBasePtr.to_safe() };
if shared_fontlist.mNames.is_empty() {
let default = match fontlist.mDefaultFontType {
FontFamilyType::eFamily_serif => {
SingleFontFamily::Generic(atom!("serif"))
}
FontFamilyType::eFamily_sans_serif => {
SingleFontFamily::Generic(atom!("sans-serif"))
}
_ => panic!("Default generic must be serif or sans-serif"),
};
FontFamily(FontFamilyList::new(Box::new([default])))
} else {
FontFamily(FontFamilyList(shared_fontlist))
}
}
pub fn unzoom_fonts(&mut self, device: &Device) {
self.gecko.mSize = device.unzoom_text(Au(self.gecko.mSize)).0;
self.gecko.mScriptUnconstrainedSize = device.unzoom_text(Au(self.gecko.mScriptUnconstrainedSize)).0;
self.gecko.mFont.size = device.unzoom_text(Au(self.gecko.mFont.size)).0;
}
pub fn set_font_size(&mut self, v: FontSize) {
use values::specified::font::KeywordSize;
self.gecko.mSize = v.size().0;
self.gecko.mScriptUnconstrainedSize = v.size().0;
if let Some(info) = v.keyword_info {
self.gecko.mFontSizeKeyword = match info.kw {
KeywordSize::XXSmall => structs::NS_STYLE_FONT_SIZE_XXSMALL,
KeywordSize::XSmall => structs::NS_STYLE_FONT_SIZE_XSMALL,
KeywordSize::Small => structs::NS_STYLE_FONT_SIZE_SMALL,
KeywordSize::Medium => structs::NS_STYLE_FONT_SIZE_MEDIUM,
KeywordSize::Large => structs::NS_STYLE_FONT_SIZE_LARGE,
KeywordSize::XLarge => structs::NS_STYLE_FONT_SIZE_XLARGE,
KeywordSize::XXLarge => structs::NS_STYLE_FONT_SIZE_XXLARGE,
KeywordSize::XXXLarge => structs::NS_STYLE_FONT_SIZE_XXXLARGE,
} as u8;
self.gecko.mFontSizeFactor = info.factor;
self.gecko.mFontSizeOffset = info.offset.0.to_i32_au();
} else {
self.gecko.mFontSizeKeyword = structs::NS_STYLE_FONT_SIZE_NO_KEYWORD as u8;
self.gecko.mFontSizeFactor = 1.;
self.gecko.mFontSizeOffset = 0;
}
}
/// Set font size, taking into account scriptminsize and scriptlevel
/// Returns Some(size) if we have to recompute the script unconstrained size
pub fn apply_font_size(
&mut self,
v: FontSize,
parent: &Self,
device: &Device,
) -> Option<NonNegativeLength> {
let (adjusted_size, adjusted_unconstrained_size) =
self.calculate_script_level_size(parent, device);
// In this case, we have been unaffected by scriptminsize, ignore it
if parent.gecko.mSize == parent.gecko.mScriptUnconstrainedSize &&
adjusted_size == adjusted_unconstrained_size {
self.set_font_size(v);
self.fixup_font_min_size(device);
None
} else {
self.gecko.mSize = v.size().0;
self.fixup_font_min_size(device);
Some(Au(parent.gecko.mScriptUnconstrainedSize).into())
}
}
pub fn fixup_font_min_size(&mut self, device: &Device) {
unsafe { bindings::Gecko_nsStyleFont_FixupMinFontSize(&mut self.gecko, device.pres_context()) }
}
pub fn apply_unconstrained_font_size(&mut self, v: NonNegativeLength) {
self.gecko.mScriptUnconstrainedSize = v.0.to_i32_au();
}
/// Calculates the constrained and unconstrained font sizes to be inherited
/// from the parent.
///
/// See ComputeScriptLevelSize in Gecko's nsRuleNode.cpp
///
/// scriptlevel is a property that affects how font-size is inherited. If scriptlevel is
/// +1, for example, it will inherit as the script size multiplier times
/// the parent font. This does not affect cases where the font-size is
/// explicitly set.
///
/// However, this transformation is not allowed to reduce the size below
/// scriptminsize. If this inheritance will reduce it to below
/// scriptminsize, it will be set to scriptminsize or the parent size,
/// whichever is smaller (the parent size could be smaller than the min size
/// because it was explicitly specified).
///
/// Now, within a node that has inherited a font-size which was
/// crossing scriptminsize once the scriptlevel was applied, a negative
/// scriptlevel may be used to increase the size again.
///
/// This should work, however if we have already been capped by the
/// scriptminsize multiple times, this can lead to a jump in the size.
///
/// For example, if we have text of the form:
///
/// huge large medium small tiny reallytiny tiny small medium huge
///
/// which is represented by progressive nesting and scriptlevel values of
/// +1 till the center after which the scriptlevel is -1, the "tiny"s should
/// be the same size, as should be the "small"s and "medium"s, etc.
///
/// However, if scriptminsize kicked it at around "medium", then
/// medium/tiny/reallytiny will all be the same size (the min size).
/// A -1 scriptlevel change after this will increase the min size by the
/// multiplier, making the second tiny larger than medium.
///
/// Instead, we wish for the second "tiny" to still be capped by the script
/// level, and when we reach the second "large", it should be the same size
/// as the original one.
///
/// We do this by cascading two separate font sizes. The font size (mSize)
/// is the actual displayed font size. The unconstrained font size
/// (mScriptUnconstrainedSize) is the font size in the situation where
/// scriptminsize never applied.
///
/// We calculate the proposed inherited font size based on scriptlevel and
/// the parent unconstrained size, instead of using the parent font size.
/// This is stored in the node's unconstrained size and will also be stored
/// in the font size provided that it is above the min size.
///
/// All of this only applies when inheriting. When the font size is
/// manually set, scriptminsize does not apply, and both the real and
/// unconstrained size are set to the explicit value. However, if the font
/// size is manually set to an em or percent unit, the unconstrained size
/// will be set to the value of that unit computed against the parent
/// unconstrained size, whereas the font size will be set computing against
/// the parent font size.
pub fn calculate_script_level_size(&self, parent: &Self, device: &Device) -> (Au, Au) {
use std::cmp;
let delta = self.gecko.mScriptLevel.saturating_sub(parent.gecko.mScriptLevel);
let parent_size = Au(parent.gecko.mSize);
let parent_unconstrained_size = Au(parent.gecko.mScriptUnconstrainedSize);
if delta == 0 {
return (parent_size, parent_unconstrained_size)
}
let mut min = Au(parent.gecko.mScriptMinSize);
if self.gecko.mAllowZoom {
min = device.zoom_text(min);
}
let scale = (parent.gecko.mScriptSizeMultiplier as f32).powi(delta as i32);
let new_size = parent_size.scale_by(scale);
let new_unconstrained_size = parent_unconstrained_size.scale_by(scale);
if scale < 1. {
// The parent size can be smaller than scriptminsize,
// e.g. if it was specified explicitly. Don't scale
// in this case, but we don't want to set it to scriptminsize
// either since that will make it larger.
if parent_size < min {
(parent_size, new_unconstrained_size)
} else {
(cmp::max(min, new_size), new_unconstrained_size)
}
} else {
// If the new unconstrained size is larger than the min size,
// this means we have escaped the grasp of scriptminsize
// and can revert to using the unconstrained size.
// However, if the new size is even larger (perhaps due to usage
// of em units), use that instead.
(cmp::min(new_size, cmp::max(new_unconstrained_size, min)),
new_unconstrained_size)
}
}
/// This function will also handle scriptminsize and scriptlevel
/// so should not be called when you just want the font sizes to be copied.
/// Hence the different name.
pub fn inherit_font_size_from(&mut self, parent: &Self,
kw_inherited_size: Option<NonNegativeLength>,
device: &Device) {
let (adjusted_size, adjusted_unconstrained_size)
= self.calculate_script_level_size(parent, device);
if adjusted_size.0 != parent.gecko.mSize ||
adjusted_unconstrained_size.0 != parent.gecko.mScriptUnconstrainedSize {
// This is incorrect. When there is both a keyword size being inherited
// and a scriptlevel change, we must handle the keyword size the same
// way we handle em units. This complicates things because we now have
// to keep track of the adjusted and unadjusted ratios in the kw font size.
// This only affects the use case of a generic font being used in MathML.
//
// If we were to fix this I would prefer doing it by removing the
// ruletree walk on the Gecko side in nsRuleNode::SetGenericFont
// and instead using extra bookkeeping in the mSize and mScriptUnconstrainedSize
// values, and reusing those instead of font_size_keyword.
// In the case that MathML has given us an adjusted size, apply it.
// Keep track of the unconstrained adjusted size.
self.gecko.mSize = adjusted_size.0;
// Technically the MathML constrained size may also be keyword-derived
// but we ignore this since it would be too complicated
// to correctly track and it's mostly unnecessary.
self.gecko.mFontSizeKeyword = structs::NS_STYLE_FONT_SIZE_NO_KEYWORD as u8;
self.gecko.mFontSizeFactor = 1.;
self.gecko.mFontSizeOffset = 0;
self.gecko.mScriptUnconstrainedSize = adjusted_unconstrained_size.0;
} else if let Some(size) = kw_inherited_size {
// Parent element was a keyword-derived size.
self.gecko.mSize = size.0.to_i32_au();
// Copy keyword info over.
self.gecko.mFontSizeFactor = parent.gecko.mFontSizeFactor;
self.gecko.mFontSizeOffset = parent.gecko.mFontSizeOffset;
self.gecko.mFontSizeKeyword = parent.gecko.mFontSizeKeyword;
// MathML constraints didn't apply here, so we can ignore this.
self.gecko.mScriptUnconstrainedSize = size.0.to_i32_au();
} else {
// MathML isn't affecting us, and our parent element does not
// have a keyword-derived size. Set things normally.
self.gecko.mSize = parent.gecko.mSize;
// copy keyword info over
self.gecko.mFontSizeKeyword = structs::NS_STYLE_FONT_SIZE_NO_KEYWORD as u8;
self.gecko.mFontSizeFactor = 1.;
self.gecko.mFontSizeOffset = 0;
self.gecko.mScriptUnconstrainedSize = parent.gecko.mScriptUnconstrainedSize;
}
self.fixup_font_min_size(device);
}
pub fn clone_font_size(&self) -> FontSize {
use values::computed::font::KeywordInfo;
use values::specified::font::KeywordSize;
let size = Au(self.gecko.mSize).into();
let kw = match self.gecko.mFontSizeKeyword as u32 {
structs::NS_STYLE_FONT_SIZE_XXSMALL => KeywordSize::XXSmall,
structs::NS_STYLE_FONT_SIZE_XSMALL => KeywordSize::XSmall,
structs::NS_STYLE_FONT_SIZE_SMALL => KeywordSize::Small,
structs::NS_STYLE_FONT_SIZE_MEDIUM => KeywordSize::Medium,
structs::NS_STYLE_FONT_SIZE_LARGE => KeywordSize::Large,
structs::NS_STYLE_FONT_SIZE_XLARGE => KeywordSize::XLarge,
structs::NS_STYLE_FONT_SIZE_XXLARGE => KeywordSize::XXLarge,
structs::NS_STYLE_FONT_SIZE_XXXLARGE => KeywordSize::XXXLarge,
structs::NS_STYLE_FONT_SIZE_NO_KEYWORD => {
return FontSize {
size: size,
keyword_info: None,
}
}
_ => unreachable!("mFontSizeKeyword should be an absolute keyword or NO_KEYWORD")
};
FontSize {
size: size,
keyword_info: Some(KeywordInfo {
kw: kw,
factor: self.gecko.mFontSizeFactor,
offset: Au(self.gecko.mFontSizeOffset).into()
})
}
}
pub fn set_font_weight(&mut self, v: longhands::font_weight::computed_value::T) {
self.gecko.mFont.weight = v.0;
}
${impl_simple_copy('font_weight', 'mFont.weight')}
pub fn clone_font_weight(&self) -> longhands::font_weight::computed_value::T {
debug_assert!(self.gecko.mFont.weight <= ::std::u16::MAX);
longhands::font_weight::computed_value::T(self.gecko.mFont.weight)
}
${impl_simple_type_with_conversion("font_synthesis", "mFont.synthesis")}
pub fn set_font_size_adjust(&mut self, v: longhands::font_size_adjust::computed_value::T) {
use properties::longhands::font_size_adjust::computed_value::T;
match v {
T::None => self.gecko.mFont.sizeAdjust = -1.0 as f32,
T::Number(n) => self.gecko.mFont.sizeAdjust = n,
}
}
pub fn copy_font_size_adjust_from(&mut self, other: &Self) {
self.gecko.mFont.sizeAdjust = other.gecko.mFont.sizeAdjust;
}
pub fn reset_font_size_adjust(&mut self, other: &Self) {
self.copy_font_size_adjust_from(other)
}
pub fn clone_font_size_adjust(&self) -> longhands::font_size_adjust::computed_value::T {
use properties::longhands::font_size_adjust::computed_value::T;
T::from_gecko_adjust(self.gecko.mFont.sizeAdjust)
}
#[allow(non_snake_case)]
pub fn set__x_lang(&mut self, v: longhands::_x_lang::computed_value::T) {
let ptr = v.0.as_ptr();
forget(v);
unsafe {
Gecko_nsStyleFont_SetLang(&mut self.gecko, ptr);
}
}
#[allow(non_snake_case)]
pub fn copy__x_lang_from(&mut self, other: &Self) {
unsafe {
Gecko_nsStyleFont_CopyLangFrom(&mut self.gecko, &other.gecko);
}
}
#[allow(non_snake_case)]
pub fn set__x_text_zoom(&mut self, v: longhands::_x_text_zoom::computed_value::T) {
self.gecko.mAllowZoom = v.0;
}
#[allow(non_snake_case)]
pub fn copy__x_text_zoom_from(&mut self, other: &Self) {
self.gecko.mAllowZoom = other.gecko.mAllowZoom;
}
#[allow(non_snake_case)]
pub fn reset__x_text_zoom(&mut self, other: &Self) {
self.copy__x_text_zoom_from(other)
}
#[allow(non_snake_case)]
pub fn reset__x_lang(&mut self, other: &Self) {
self.copy__x_lang_from(other)
}
${impl_simple("_moz_script_level", "mScriptLevel")}
<% impl_simple_type_with_conversion("font_language_override", "mFont.languageOverride") %>
pub fn set_font_variant_alternates(&mut self,
v: values::computed::font::FontVariantAlternates,
device: &Device) {
use gecko_bindings::bindings::{Gecko_ClearAlternateValues, Gecko_AppendAlternateValues};
use gecko_bindings::bindings::Gecko_nsFont_ResetFontFeatureValuesLookup;
use gecko_bindings::bindings::Gecko_nsFont_SetFontFeatureValuesLookup;
% for value in "normal swash stylistic ornaments annotation styleset character_variant historical".split():
use gecko_bindings::structs::NS_FONT_VARIANT_ALTERNATES_${value.upper()};
% endfor
use values::specified::font::VariantAlternates;
unsafe {
Gecko_ClearAlternateValues(&mut self.gecko.mFont, v.len());
}
if v.0.is_empty() {
self.gecko.mFont.variantAlternates = NS_FONT_VARIANT_ALTERNATES_NORMAL as u16;
unsafe { Gecko_nsFont_ResetFontFeatureValuesLookup(&mut self.gecko.mFont); }
return;
}
for val in v.0.iter() {
match *val {
% for value in "Swash Stylistic Ornaments Annotation".split():
VariantAlternates::${value}(ref ident) => {
self.gecko.mFont.variantAlternates |= NS_FONT_VARIANT_ALTERNATES_${value.upper()} as u16;
unsafe {
Gecko_AppendAlternateValues(&mut self.gecko.mFont,
NS_FONT_VARIANT_ALTERNATES_${value.upper()},
ident.0.as_ptr());
}
},
% endfor
% for value in "styleset character_variant".split():
VariantAlternates::${to_camel_case(value)}(ref slice) => {
self.gecko.mFont.variantAlternates |= NS_FONT_VARIANT_ALTERNATES_${value.upper()} as u16;
for ident in slice.iter() {
unsafe {
Gecko_AppendAlternateValues(&mut self.gecko.mFont,
NS_FONT_VARIANT_ALTERNATES_${value.upper()},
ident.0.as_ptr());
}
}
},
% endfor
VariantAlternates::HistoricalForms => {
self.gecko.mFont.variantAlternates |= NS_FONT_VARIANT_ALTERNATES_HISTORICAL as u16;
}
}
}
unsafe {
Gecko_nsFont_SetFontFeatureValuesLookup(&mut self.gecko.mFont, device.pres_context());
}
}
#[allow(non_snake_case)]
pub fn copy_font_variant_alternates_from(&mut self, other: &Self) {
use gecko_bindings::bindings::Gecko_CopyAlternateValuesFrom;
self.gecko.mFont.variantAlternates = other.gecko.mFont.variantAlternates;
unsafe {
Gecko_CopyAlternateValuesFrom(&mut self.gecko.mFont, &other.gecko.mFont);
}
}
pub fn reset_font_variant_alternates(&mut self, other: &Self) {
self.copy_font_variant_alternates_from(other)
}
pub fn clone_font_variant_alternates(&self) -> values::computed::font::FontVariantAlternates {
use Atom;
% for value in "normal swash stylistic ornaments annotation styleset character_variant historical".split():
use gecko_bindings::structs::NS_FONT_VARIANT_ALTERNATES_${value.upper()};
% endfor
use values::specified::font::VariantAlternates;
use values::specified::font::VariantAlternatesList;
use values::CustomIdent;
if self.gecko.mFont.variantAlternates == NS_FONT_VARIANT_ALTERNATES_NORMAL as u16 {
return VariantAlternatesList(vec![].into_boxed_slice());
}
let mut alternates = Vec::with_capacity(self.gecko.mFont.alternateValues.len());
if self.gecko.mFont.variantAlternates & (NS_FONT_VARIANT_ALTERNATES_HISTORICAL as u16) != 0 {
alternates.push(VariantAlternates::HistoricalForms);
}
<%
property_need_ident_list = "styleset character_variant".split()
%>
% for value in property_need_ident_list:
let mut ${value}_list = Vec::new();
% endfor
for gecko_alternate_value in self.gecko.mFont.alternateValues.iter() {
let ident = Atom::from(gecko_alternate_value.value.to_string());
match gecko_alternate_value.alternate {
% for value in "Swash Stylistic Ornaments Annotation".split():
NS_FONT_VARIANT_ALTERNATES_${value.upper()} => {
alternates.push(VariantAlternates::${value}(CustomIdent(ident)));
},
% endfor
% for value in property_need_ident_list:
NS_FONT_VARIANT_ALTERNATES_${value.upper()} => {
${value}_list.push(CustomIdent(ident));
},
% endfor
_ => {
panic!("Found unexpected value for font-variant-alternates");
}
}
}
% for value in property_need_ident_list:
if !${value}_list.is_empty() {
alternates.push(VariantAlternates::${to_camel_case(value)}(${value}_list.into_boxed_slice()));
}
% endfor
VariantAlternatesList(alternates.into_boxed_slice())
}
${impl_simple_type_with_conversion("font_variant_ligatures", "mFont.variantLigatures")}
${impl_simple_type_with_conversion("font_variant_east_asian", "mFont.variantEastAsian")}
${impl_simple_type_with_conversion("font_variant_numeric", "mFont.variantNumeric")}
#[allow(non_snake_case)]
pub fn set__moz_min_font_size_ratio(&mut self, v: longhands::_moz_min_font_size_ratio::computed_value::T) {
let scaled = v.0 * 100.;
let percentage = if scaled > 255. {
255.
} else if scaled < 0. {
0.
} else {
scaled
};
self.gecko.mMinFontSizeRatio = percentage as u8;
}
${impl_simple_copy('_moz_min_font_size_ratio', 'mMinFontSizeRatio')}
</%self:impl_trait>
<%def name="impl_copy_animation_or_transition_value(type, ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn copy_${type}_${ident}_from(&mut self, other: &Self) {
self.gecko.m${type.capitalize()}s.ensure_len(other.gecko.m${type.capitalize()}s.len());
let count = other.gecko.m${type.capitalize()}${gecko_ffi_name}Count;
self.gecko.m${type.capitalize()}${gecko_ffi_name}Count = count;
let iter = self.gecko.m${type.capitalize()}s.iter_mut().take(count as usize).zip(
other.gecko.m${type.capitalize()}s.iter()
);
for (ours, others) in iter {
ours.m${gecko_ffi_name} = others.m${gecko_ffi_name};
}
}
#[allow(non_snake_case)]
pub fn reset_${type}_${ident}(&mut self, other: &Self) {
self.copy_${type}_${ident}_from(other)
}
</%def>
<%def name="impl_animation_or_transition_count(type, ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn ${type}_${ident}_count(&self) -> usize {
self.gecko.m${type.capitalize()}${gecko_ffi_name}Count as usize
}
</%def>
<%def name="impl_animation_or_transition_time_value(type, ident, gecko_ffi_name)">
#[allow(non_snake_case)]
pub fn set_${type}_${ident}<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::${type}_${ident}::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator + Clone
{
let v = v.into_iter();
debug_assert!(v.len() != 0);
let input_len = v.len();
self.gecko.m${type.capitalize()}s.ensure_len(input_len);
self.gecko.m${type.capitalize()}${gecko_ffi_name}Count = input_len as u32;
for (gecko, servo) in self.gecko.m${type.capitalize()}s.iter_mut().take(input_len as usize).zip(v) {
gecko.m${gecko_ffi_name} = servo.seconds() * 1000.;
}
}
#[allow(non_snake_case)]
pub fn ${type}_${ident}_at(&self, index: usize)
-> longhands::${type}_${ident}::computed_value::SingleComputedValue {
use values::computed::Time;
Time::from_seconds(self.gecko.m${type.capitalize()}s[index].m${gecko_ffi_name} / 1000.)
}
${impl_animation_or_transition_count(type, ident, gecko_ffi_name)}
${impl_copy_animation_or_transition_value(type, ident, gecko_ffi_name)}
</%def>
<%def name="impl_animation_or_transition_timing_function(type)">
pub fn set_${type}_timing_function<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::${type}_timing_function::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator + Clone
{
let v = v.into_iter();
debug_assert!(v.len() != 0);
let input_len = v.len();
self.gecko.m${type.capitalize()}s.ensure_len(input_len);
self.gecko.m${type.capitalize()}TimingFunctionCount = input_len as u32;
for (gecko, servo) in self.gecko.m${type.capitalize()}s.iter_mut().take(input_len as usize).zip(v) {
gecko.mTimingFunction = servo.into();
}
}
${impl_animation_or_transition_count(type, 'timing_function', 'TimingFunction')}
${impl_copy_animation_or_transition_value(type, 'timing_function', 'TimingFunction')}
pub fn ${type}_timing_function_at(&self, index: usize)
-> longhands::${type}_timing_function::computed_value::SingleComputedValue {
self.gecko.m${type.capitalize()}s[index].mTimingFunction.into()
}
</%def>
<%def name="impl_transition_time_value(ident, gecko_ffi_name)">
${impl_animation_or_transition_time_value('transition', ident, gecko_ffi_name)}
</%def>
<%def name="impl_transition_count(ident, gecko_ffi_name)">
${impl_animation_or_transition_count('transition', ident, gecko_ffi_name)}
</%def>
<%def name="impl_copy_animation_value(ident, gecko_ffi_name)">
${impl_copy_animation_or_transition_value('animation', ident, gecko_ffi_name)}
</%def>
<%def name="impl_transition_timing_function()">
${impl_animation_or_transition_timing_function('transition')}
</%def>
<%def name="impl_animation_count(ident, gecko_ffi_name)">
${impl_animation_or_transition_count('animation', ident, gecko_ffi_name)}
</%def>
<%def name="impl_animation_time_value(ident, gecko_ffi_name)">
${impl_animation_or_transition_time_value('animation', ident, gecko_ffi_name)}
</%def>
<%def name="impl_animation_timing_function()">
${impl_animation_or_transition_timing_function('animation')}
</%def>
<%def name="impl_animation_keyword(ident, gecko_ffi_name, keyword, cast_type='u8')">
#[allow(non_snake_case)]
pub fn set_animation_${ident}<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::animation_${ident}::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator + Clone
{
use properties::longhands::animation_${ident}::single_value::computed_value::T as Keyword;
use gecko_bindings::structs;
let v = v.into_iter();
debug_assert!(v.len() != 0);
let input_len = v.len();
self.gecko.mAnimations.ensure_len(input_len);
self.gecko.mAnimation${gecko_ffi_name}Count = input_len as u32;
for (gecko, servo) in self.gecko.mAnimations.iter_mut().take(input_len as usize).zip(v) {
let result = match servo {
% for value in keyword.gecko_values():
Keyword::${to_camel_case(value)} =>
structs::${keyword.gecko_constant(value)} ${keyword.maybe_cast(cast_type)},
% endfor
};
gecko.m${gecko_ffi_name} = result;
}
}
#[allow(non_snake_case)]
pub fn animation_${ident}_at(&self, index: usize)
-> longhands::animation_${ident}::computed_value::SingleComputedValue {
use properties::longhands::animation_${ident}::single_value::computed_value::T as Keyword;
match self.gecko.mAnimations[index].m${gecko_ffi_name} ${keyword.maybe_cast("u32")} {
% for value in keyword.gecko_values():
structs::${keyword.gecko_constant(value)} => Keyword::${to_camel_case(value)},
% endfor
_ => panic!("Found unexpected value for animation-${ident}"),
}
}
${impl_animation_count(ident, gecko_ffi_name)}
${impl_copy_animation_value(ident, gecko_ffi_name)}
</%def>
<%def name="impl_individual_transform(ident, type, gecko_ffi_name)">
pub fn set_${ident}(&mut self, other: values::computed::${type}) {
unsafe { self.gecko.${gecko_ffi_name}.clear() };
if let Some(operation) = other.to_transform_operation() {
convert_transform(&[operation], &mut self.gecko.${gecko_ffi_name})
}
}
pub fn copy_${ident}_from(&mut self, other: &Self) {
unsafe { self.gecko.${gecko_ffi_name}.set(&other.gecko.${gecko_ffi_name}); }
}
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
pub fn clone_${ident}(&self) -> values::computed::${type} {
use values::generics::transform::${type};
if self.gecko.${gecko_ffi_name}.mRawPtr.is_null() {
return ${type}::None;
}
let list = unsafe { (*self.gecko.${gecko_ffi_name}.to_safe().get()).mHead.as_ref() };
let mut transform = clone_transform_from_list(list);
debug_assert_eq!(transform.0.len(), 1);
${type}::from_transform_operation(&transform.0.pop().unwrap())
}
</%def>
<% skip_box_longhands= """display overflow-y vertical-align
animation-name animation-delay animation-duration
animation-direction animation-fill-mode animation-play-state
animation-iteration-count animation-timing-function
transition-duration transition-delay
transition-timing-function transition-property
page-break-before page-break-after rotate
scroll-snap-points-x scroll-snap-points-y
scroll-snap-type-x scroll-snap-type-y scroll-snap-coordinate
perspective-origin -moz-binding will-change
overscroll-behavior-x overscroll-behavior-y
overflow-clip-box-inline overflow-clip-box-block
perspective-origin -moz-binding will-change
shape-outside contain touch-action translate
scale""" %>
<%self:impl_trait style_struct_name="Box" skip_longhands="${skip_box_longhands}">
// We manually-implement the |display| property until we get general
// infrastructure for preffing certain values.
<% display_keyword = Keyword("display", "inline block inline-block table inline-table table-row-group " +
"table-header-group table-footer-group table-row table-column-group " +
"table-column table-cell table-caption list-item flex none " +
"inline-flex grid inline-grid ruby ruby-base ruby-base-container " +
"ruby-text ruby-text-container contents flow-root -webkit-box " +
"-webkit-inline-box -moz-box -moz-inline-box -moz-grid -moz-inline-grid " +
"-moz-grid-group -moz-grid-line -moz-stack -moz-inline-stack -moz-deck " +
"-moz-popup -moz-groupbox",
gecko_enum_prefix="StyleDisplay",
gecko_strip_moz_prefix=False) %>
fn match_display_keyword(
v: longhands::display::computed_value::T
) -> structs::root::mozilla::StyleDisplay {
use properties::longhands::display::computed_value::T as Keyword;
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
match v {
% for value in display_keyword.values_for('gecko'):
Keyword::${to_camel_case(value)} =>
structs::${display_keyword.gecko_constant(value)},
% endfor
}
}
pub fn set_display(&mut self, v: longhands::display::computed_value::T) {
let result = Self::match_display_keyword(v);
self.gecko.mDisplay = result;
self.gecko.mOriginalDisplay = result;
}
pub fn copy_display_from(&mut self, other: &Self) {
self.gecko.mDisplay = other.gecko.mDisplay;
self.gecko.mOriginalDisplay = other.gecko.mDisplay;
}
pub fn reset_display(&mut self, other: &Self) {
self.copy_display_from(other)
}
pub fn set_adjusted_display(
&mut self,
v: longhands::display::computed_value::T,
_is_item_or_root: bool
) {
self.gecko.mDisplay = Self::match_display_keyword(v);
}
<%call expr="impl_keyword_clone('display', 'mDisplay', display_keyword)"></%call>
<% overflow_x = data.longhands_by_name["overflow-x"] %>
pub fn set_overflow_y(&mut self, v: longhands::overflow_y::computed_value::T) {
use properties::longhands::overflow_x::computed_value::T as BaseType;
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
self.gecko.mOverflowY = match v {
% for value in overflow_x.keyword.values_for('gecko'):
BaseType::${to_camel_case(value)} => structs::${overflow_x.keyword.gecko_constant(value)} as u8,
% endfor
};
}
${impl_simple_copy('overflow_y', 'mOverflowY')}
pub fn clone_overflow_y(&self) -> longhands::overflow_y::computed_value::T {
use properties::longhands::overflow_x::computed_value::T as BaseType;
// FIXME(bholley): Align binary representations and ditch |match| for cast + static_asserts
match self.gecko.mOverflowY as u32 {
% for value in overflow_x.keyword.values_for('gecko'):
structs::${overflow_x.keyword.gecko_constant(value)} => BaseType::${to_camel_case(value)},
% endfor
x => panic!("Found unexpected value in style struct for overflow_y property: {}", x),
}
}
pub fn set_vertical_align(&mut self, v: longhands::vertical_align::computed_value::T) {
use values::generics::box_::VerticalAlign;
let value = match v {
VerticalAlign::Baseline => structs::NS_STYLE_VERTICAL_ALIGN_BASELINE,
VerticalAlign::Sub => structs::NS_STYLE_VERTICAL_ALIGN_SUB,
VerticalAlign::Super => structs::NS_STYLE_VERTICAL_ALIGN_SUPER,
VerticalAlign::Top => structs::NS_STYLE_VERTICAL_ALIGN_TOP,
VerticalAlign::TextTop => structs::NS_STYLE_VERTICAL_ALIGN_TEXT_TOP,
VerticalAlign::Middle => structs::NS_STYLE_VERTICAL_ALIGN_MIDDLE,
VerticalAlign::Bottom => structs::NS_STYLE_VERTICAL_ALIGN_BOTTOM,
VerticalAlign::TextBottom => structs::NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM,
VerticalAlign::MozMiddleWithBaseline => {
structs::NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE
},
VerticalAlign::Length(length) => {
self.gecko.mVerticalAlign.set(length);
return;
},
};
self.gecko.mVerticalAlign.set_value(CoordDataValue::Enumerated(value));
}
pub fn clone_vertical_align(&self) -> longhands::vertical_align::computed_value::T {
use values::computed::LengthOrPercentage;
use values::generics::box_::VerticalAlign;
let gecko = &self.gecko.mVerticalAlign;
match gecko.as_value() {
CoordDataValue::Enumerated(value) => VerticalAlign::from_gecko_keyword(value),
_ => {
VerticalAlign::Length(
LengthOrPercentage::from_gecko_style_coord(gecko).expect(
"expected <length-percentage> for vertical-align",
),
)
},
}
}
<%call expr="impl_coord_copy('vertical_align', 'mVerticalAlign')"></%call>
% for kind in ["before", "after"]:
// Temp fix for Bugzilla bug 24000.
// Map 'auto' and 'avoid' to false, and 'always', 'left', and 'right' to true.
// "A conforming user agent may interpret the values 'left' and 'right'
// as 'always'." - CSS2.1, section 13.3.1
pub fn set_page_break_${kind}(&mut self, v: longhands::page_break_${kind}::computed_value::T) {
use computed_values::page_break_${kind}::T;
let result = match v {
T::Auto => false,
T::Always => true,
T::Avoid => false,
T::Left => true,
T::Right => true
};
self.gecko.mBreak${kind.title()} = result;
}
${impl_simple_copy('page_break_' + kind, 'mBreak' + kind.title())}
// Temp fix for Bugzilla bug 24000.
// See set_page_break_before/after for detail.
pub fn clone_page_break_${kind}(&self) -> longhands::page_break_${kind}::computed_value::T {
use computed_values::page_break_${kind}::T;
if self.gecko.mBreak${kind.title()} { T::Always } else { T::Auto }
}
% endfor
${impl_style_coord("scroll_snap_points_x", "mScrollSnapPointsX")}
${impl_style_coord("scroll_snap_points_y", "mScrollSnapPointsY")}
pub fn set_scroll_snap_coordinate<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::scroll_snap_coordinate::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
let v = v.into_iter();
unsafe { self.gecko.mScrollSnapCoordinate.set_len_pod(v.len() as u32); }
for (gecko, servo) in self.gecko.mScrollSnapCoordinate
.iter_mut()
.zip(v) {
gecko.mXPosition = servo.horizontal.into();
gecko.mYPosition = servo.vertical.into();
}
}
pub fn copy_scroll_snap_coordinate_from(&mut self, other: &Self) {
unsafe {
self.gecko.mScrollSnapCoordinate
.set_len_pod(other.gecko.mScrollSnapCoordinate.len() as u32);
}
for (this, that) in self.gecko.mScrollSnapCoordinate
.iter_mut()
.zip(other.gecko.mScrollSnapCoordinate.iter()) {
*this = *that;
}
}
pub fn reset_scroll_snap_coordinate(&mut self, other: &Self) {
self.copy_scroll_snap_coordinate_from(other)
}
pub fn clone_scroll_snap_coordinate(&self) -> longhands::scroll_snap_coordinate::computed_value::T {
let vec = self.gecko.mScrollSnapCoordinate.iter().map(|f| f.into()).collect();
longhands::scroll_snap_coordinate::computed_value::T(vec)
}
${impl_css_url('_moz_binding', 'mBinding')}
${impl_transition_time_value('delay', 'Delay')}
${impl_transition_time_value('duration', 'Duration')}
${impl_transition_timing_function()}
pub fn transition_combined_duration_at(&self, index: usize) -> f32 {
// https://drafts.csswg.org/css-transitions/#transition-combined-duration
self.gecko.mTransitions[index % self.gecko.mTransitionDurationCount as usize].mDuration.max(0.0)
+ self.gecko.mTransitions[index % self.gecko.mTransitionDelayCount as usize].mDelay
}
pub fn set_transition_property<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::transition_property::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
use gecko_bindings::structs::nsCSSPropertyID::eCSSPropertyExtra_no_properties;
let v = v.into_iter();
if v.len() != 0 {
self.gecko.mTransitions.ensure_len(v.len());
self.gecko.mTransitionPropertyCount = v.len() as u32;
for (servo, gecko) in v.zip(self.gecko.mTransitions.iter_mut()) {
match servo {
TransitionProperty::Unsupported(ref ident) => unsafe {
Gecko_StyleTransition_SetUnsupportedProperty(gecko, ident.0.as_ptr())
},
_ => gecko.mProperty = servo.to_nscsspropertyid().unwrap(),
}
}
} else {
// In gecko |none| is represented by eCSSPropertyExtra_no_properties.
self.gecko.mTransitionPropertyCount = 1;
self.gecko.mTransitions[0].mProperty = eCSSPropertyExtra_no_properties;
}
}
/// Returns whether there are any transitions specified.
pub fn specifies_transitions(&self) -> bool {
use gecko_bindings::structs::nsCSSPropertyID::eCSSPropertyExtra_all_properties;
if self.gecko.mTransitionPropertyCount == 1 &&
self.gecko.mTransitions[0].mProperty == eCSSPropertyExtra_all_properties &&
self.transition_combined_duration_at(0) <= 0.0f32 {
return false;
}
self.gecko.mTransitionPropertyCount > 0
}
pub fn transition_property_at(&self, index: usize)
-> longhands::transition_property::computed_value::SingleComputedValue {
use gecko_bindings::structs::nsCSSPropertyID::eCSSPropertyExtra_no_properties;
use gecko_bindings::structs::nsCSSPropertyID::eCSSPropertyExtra_variable;
use gecko_bindings::structs::nsCSSPropertyID::eCSSProperty_UNKNOWN;
let property = self.gecko.mTransitions[index].mProperty;
if property == eCSSProperty_UNKNOWN || property == eCSSPropertyExtra_variable {
let atom = self.gecko.mTransitions[index].mUnknownProperty.mRawPtr;
debug_assert!(!atom.is_null());
TransitionProperty::Unsupported(CustomIdent(atom.into()))
} else if property == eCSSPropertyExtra_no_properties {
// Actually, we don't expect TransitionProperty::Unsupported also represents "none",
// but if the caller wants to convert it, it is fine. Please use it carefully.
TransitionProperty::Unsupported(CustomIdent(atom!("none")))
} else {
property.into()
}
}
pub fn transition_nscsspropertyid_at(&self, index: usize) -> nsCSSPropertyID {
self.gecko.mTransitions[index].mProperty
}
pub fn copy_transition_property_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsCSSPropertyID::eCSSPropertyExtra_variable;
use gecko_bindings::structs::nsCSSPropertyID::eCSSProperty_UNKNOWN;
self.gecko.mTransitions.ensure_len(other.gecko.mTransitions.len());
let count = other.gecko.mTransitionPropertyCount;
self.gecko.mTransitionPropertyCount = count;
for (index, transition) in self.gecko.mTransitions.iter_mut().enumerate().take(count as usize) {
transition.mProperty = other.gecko.mTransitions[index].mProperty;
if transition.mProperty == eCSSProperty_UNKNOWN ||
transition.mProperty == eCSSPropertyExtra_variable {
let atom = other.gecko.mTransitions[index].mUnknownProperty.mRawPtr;
debug_assert!(!atom.is_null());
unsafe { Gecko_StyleTransition_SetUnsupportedProperty(transition, atom) };
}
}
}
pub fn reset_transition_property(&mut self, other: &Self) {
self.copy_transition_property_from(other)
}
// Hand-written because the Mako helpers transform `Preserve3d` into `PRESERVE3D`.
pub fn set_transform_style(&mut self, v: TransformStyle) {
self.gecko.mTransformStyle = match v {
TransformStyle::Flat => structs::NS_STYLE_TRANSFORM_STYLE_FLAT as u8,
TransformStyle::Preserve3d => structs::NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D as u8,
};
}
// Hand-written because the Mako helpers transform `Preserve3d` into `PRESERVE3D`.
pub fn clone_transform_style(&self) -> TransformStyle {
match self.gecko.mTransformStyle as u32 {
structs::NS_STYLE_TRANSFORM_STYLE_FLAT => TransformStyle::Flat,
structs::NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D => TransformStyle::Preserve3d,
_ => panic!("illegal transform style"),
}
}
${impl_simple_copy('transform_style', 'mTransformStyle')}
${impl_transition_count('property', 'Property')}
pub fn animations_equals(&self, other: &Self) -> bool {
return self.gecko.mAnimationNameCount == other.gecko.mAnimationNameCount
&& self.gecko.mAnimationDelayCount == other.gecko.mAnimationDelayCount
&& self.gecko.mAnimationDirectionCount == other.gecko.mAnimationDirectionCount
&& self.gecko.mAnimationDurationCount == other.gecko.mAnimationDurationCount
&& self.gecko.mAnimationFillModeCount == other.gecko.mAnimationFillModeCount
&& self.gecko.mAnimationIterationCountCount == other.gecko.mAnimationIterationCountCount
&& self.gecko.mAnimationPlayStateCount == other.gecko.mAnimationPlayStateCount
&& self.gecko.mAnimationTimingFunctionCount == other.gecko.mAnimationTimingFunctionCount
&& unsafe { bindings::Gecko_StyleAnimationsEquals(&self.gecko.mAnimations, &other.gecko.mAnimations) }
}
pub fn set_animation_name<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::animation_name::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
let v = v.into_iter();
debug_assert!(v.len() != 0);
self.gecko.mAnimations.ensure_len(v.len());
self.gecko.mAnimationNameCount = v.len() as u32;
for (servo, gecko) in v.zip(self.gecko.mAnimations.iter_mut()) {
let atom = match servo.0 {
None => atom!(""),
Some(ref name) => name.as_atom().clone(),
};
unsafe { bindings::Gecko_SetAnimationName(gecko, atom.into_addrefed()); }
}
}
pub fn animation_name_at(&self, index: usize)
-> longhands::animation_name::computed_value::SingleComputedValue {
use properties::longhands::animation_name::single_value::SpecifiedValue as AnimationName;
let atom = self.gecko.mAnimations[index].mName.mRawPtr;
if atom == atom!("").as_ptr() {
AnimationName(None)
} else {
AnimationName(Some(KeyframesName::from_atom(atom.into())))
}
}
pub fn copy_animation_name_from(&mut self, other: &Self) {
self.gecko.mAnimationNameCount = other.gecko.mAnimationNameCount;
unsafe { bindings::Gecko_CopyAnimationNames(&mut self.gecko.mAnimations, &other.gecko.mAnimations); }
}
pub fn reset_animation_name(&mut self, other: &Self) {
self.copy_animation_name_from(other)
}
${impl_animation_count('name', 'Name')}
${impl_animation_time_value('delay', 'Delay')}
${impl_animation_time_value('duration', 'Duration')}
${impl_animation_keyword('direction', 'Direction',
data.longhands_by_name["animation-direction"].keyword)}
${impl_animation_keyword('fill_mode', 'FillMode',
data.longhands_by_name["animation-fill-mode"].keyword)}
${impl_animation_keyword('play_state', 'PlayState',
data.longhands_by_name["animation-play-state"].keyword)}
pub fn set_animation_iteration_count<I>(&mut self, v: I)
where
I: IntoIterator<Item = values::computed::AnimationIterationCount>,
I::IntoIter: ExactSizeIterator + Clone
{
use std::f32;
use values::generics::box_::AnimationIterationCount;
let v = v.into_iter();
debug_assert_ne!(v.len(), 0);
let input_len = v.len();
self.gecko.mAnimations.ensure_len(input_len);
self.gecko.mAnimationIterationCountCount = input_len as u32;
for (gecko, servo) in self.gecko.mAnimations.iter_mut().take(input_len as usize).zip(v) {
match servo {
AnimationIterationCount::Number(n) => gecko.mIterationCount = n,
AnimationIterationCount::Infinite => gecko.mIterationCount = f32::INFINITY,
}
}
}
pub fn animation_iteration_count_at(
&self,
index: usize,
) -> values::computed::AnimationIterationCount {
use values::generics::box_::AnimationIterationCount;
if self.gecko.mAnimations[index].mIterationCount.is_infinite() {
AnimationIterationCount::Infinite
} else {
AnimationIterationCount::Number(self.gecko.mAnimations[index].mIterationCount)
}
}
${impl_animation_count('iteration_count', 'IterationCount')}
${impl_copy_animation_value('iteration_count', 'IterationCount')}
${impl_animation_timing_function()}
<% scroll_snap_type_keyword = Keyword("scroll-snap-type", "None Mandatory Proximity") %>
${impl_keyword('scroll_snap_type_y', 'mScrollSnapTypeY', scroll_snap_type_keyword)}
${impl_keyword('scroll_snap_type_x', 'mScrollSnapTypeX', scroll_snap_type_keyword)}
<% overscroll_behavior_keyword = Keyword("overscroll-behavior", "Auto Contain None",
gecko_enum_prefix="StyleOverscrollBehavior") %>
${impl_keyword('overscroll_behavior_x', 'mOverscrollBehaviorX', overscroll_behavior_keyword)}
${impl_keyword('overscroll_behavior_y', 'mOverscrollBehaviorY', overscroll_behavior_keyword)}
<% overflow_clip_box_keyword = Keyword("overflow-clip-box", "padding-box content-box") %>
${impl_keyword('overflow_clip_box_inline', 'mOverflowClipBoxInline', overflow_clip_box_keyword)}
${impl_keyword('overflow_clip_box_block', 'mOverflowClipBoxBlock', overflow_clip_box_keyword)}
pub fn set_perspective_origin(&mut self, v: longhands::perspective_origin::computed_value::T) {
self.gecko.mPerspectiveOrigin[0].set(v.horizontal);
self.gecko.mPerspectiveOrigin[1].set(v.vertical);
}
pub fn copy_perspective_origin_from(&mut self, other: &Self) {
self.gecko.mPerspectiveOrigin[0].copy_from(&other.gecko.mPerspectiveOrigin[0]);
self.gecko.mPerspectiveOrigin[1].copy_from(&other.gecko.mPerspectiveOrigin[1]);
}
pub fn reset_perspective_origin(&mut self, other: &Self) {
self.copy_perspective_origin_from(other)
}
pub fn clone_perspective_origin(&self) -> longhands::perspective_origin::computed_value::T {
use properties::longhands::perspective_origin::computed_value::T;
use values::computed::LengthOrPercentage;
T {
horizontal: LengthOrPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[0])
.expect("Expected length or percentage for horizontal value of perspective-origin"),
vertical: LengthOrPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[1])
.expect("Expected length or percentage for vertical value of perspective-origin"),
}
}
${impl_individual_transform('rotate', 'Rotate', 'mSpecifiedRotate')}
${impl_individual_transform('translate', 'Translate', 'mSpecifiedTranslate')}
${impl_individual_transform('scale', 'Scale', 'mSpecifiedScale')}
pub fn set_will_change(&mut self, v: longhands::will_change::computed_value::T) {
use gecko_bindings::bindings::{Gecko_AppendWillChange, Gecko_ClearWillChange};
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_OPACITY;
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_SCROLL;
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_TRANSFORM;
use properties::PropertyId;
use properties::longhands::will_change::computed_value::T;
fn will_change_bitfield_from_prop_flags(prop: &LonghandId) -> u8 {
use properties::PropertyFlags;
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_ABSPOS_CB;
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_FIXPOS_CB;
use gecko_bindings::structs::NS_STYLE_WILL_CHANGE_STACKING_CONTEXT;
let servo_flags = prop.flags();
let mut bitfield = 0;
if servo_flags.contains(PropertyFlags::CREATES_STACKING_CONTEXT) {
bitfield |= NS_STYLE_WILL_CHANGE_STACKING_CONTEXT;
}
if servo_flags.contains(PropertyFlags::FIXPOS_CB) {
bitfield |= NS_STYLE_WILL_CHANGE_FIXPOS_CB;
}
if servo_flags.contains(PropertyFlags::ABSPOS_CB) {
bitfield |= NS_STYLE_WILL_CHANGE_ABSPOS_CB;
}
bitfield as u8
}
self.gecko.mWillChangeBitField = 0;
match v {
T::AnimateableFeatures(features) => {
unsafe {
Gecko_ClearWillChange(&mut self.gecko, features.len());
}
for feature in features.iter() {
if feature.0 == atom!("scroll-position") {
self.gecko.mWillChangeBitField |= NS_STYLE_WILL_CHANGE_SCROLL as u8;
} else if feature.0 == atom!("opacity") {
self.gecko.mWillChangeBitField |= NS_STYLE_WILL_CHANGE_OPACITY as u8;
} else if feature.0 == atom!("transform") {
self.gecko.mWillChangeBitField |= NS_STYLE_WILL_CHANGE_TRANSFORM as u8;
}
unsafe {
Gecko_AppendWillChange(&mut self.gecko, feature.0.as_ptr());
}
if let Ok(prop_id) = PropertyId::parse(&feature.0.to_string()) {
match prop_id.as_shorthand() {
Ok(shorthand) => {
for longhand in shorthand.longhands() {
self.gecko.mWillChangeBitField |=
will_change_bitfield_from_prop_flags(longhand);
}
},
Err(longhand_or_custom) => {
if let PropertyDeclarationId::Longhand(longhand)
= longhand_or_custom {
self.gecko.mWillChangeBitField |=
will_change_bitfield_from_prop_flags(&longhand);
}
},
}
}
}
},
T::Auto => {
unsafe {
Gecko_ClearWillChange(&mut self.gecko, 0);
}
},
};
}
pub fn copy_will_change_from(&mut self, other: &Self) {
use gecko_bindings::bindings::Gecko_CopyWillChangeFrom;
self.gecko.mWillChangeBitField = other.gecko.mWillChangeBitField;
unsafe {
Gecko_CopyWillChangeFrom(&mut self.gecko, &other.gecko as *const _ as *mut _);
}
}
pub fn reset_will_change(&mut self, other: &Self) {
self.copy_will_change_from(other)
}
pub fn clone_will_change(&self) -> longhands::will_change::computed_value::T {
use properties::longhands::will_change::computed_value::T;
use gecko_bindings::structs::nsAtom;
use values::CustomIdent;
if self.gecko.mWillChange.len() == 0 {
T::Auto
} else {
let custom_idents: Vec<CustomIdent> = self.gecko.mWillChange.iter().map(|gecko_atom| {
CustomIdent((gecko_atom.mRawPtr as *mut nsAtom).into())
}).collect();
T::AnimateableFeatures(custom_idents.into_boxed_slice())
}
}
<% impl_shape_source("shape_outside", "mShapeOutside") %>
pub fn set_contain(&mut self, v: longhands::contain::computed_value::T) {
use gecko_bindings::structs::NS_STYLE_CONTAIN_NONE;
use gecko_bindings::structs::NS_STYLE_CONTAIN_STRICT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_LAYOUT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_STYLE;
use gecko_bindings::structs::NS_STYLE_CONTAIN_PAINT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_ALL_BITS;
use properties::longhands::contain::SpecifiedValue;
if v.is_empty() {
self.gecko.mContain = NS_STYLE_CONTAIN_NONE as u8;
return;
}
if v.contains(SpecifiedValue::STRICT) {
self.gecko.mContain = (NS_STYLE_CONTAIN_STRICT | NS_STYLE_CONTAIN_ALL_BITS) as u8;
return;
}
let mut bitfield = 0;
if v.contains(SpecifiedValue::LAYOUT) {
bitfield |= NS_STYLE_CONTAIN_LAYOUT;
}
if v.contains(SpecifiedValue::STYLE) {
bitfield |= NS_STYLE_CONTAIN_STYLE;
}
if v.contains(SpecifiedValue::PAINT) {
bitfield |= NS_STYLE_CONTAIN_PAINT;
}
self.gecko.mContain = bitfield as u8;
}
pub fn clone_contain(&self) -> longhands::contain::computed_value::T {
use gecko_bindings::structs::NS_STYLE_CONTAIN_STRICT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_LAYOUT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_STYLE;
use gecko_bindings::structs::NS_STYLE_CONTAIN_PAINT;
use gecko_bindings::structs::NS_STYLE_CONTAIN_ALL_BITS;
use properties::longhands::contain::{self, SpecifiedValue};
let mut servo_flags = contain::computed_value::T::empty();
let gecko_flags = self.gecko.mContain;
if gecko_flags & (NS_STYLE_CONTAIN_STRICT as u8) != 0 &&
gecko_flags & (NS_STYLE_CONTAIN_ALL_BITS as u8) != 0 {
servo_flags.insert(SpecifiedValue::STRICT | SpecifiedValue::STRICT_BITS);
return servo_flags;
}
if gecko_flags & (NS_STYLE_CONTAIN_LAYOUT as u8) != 0 {
servo_flags.insert(SpecifiedValue::LAYOUT);
}
if gecko_flags & (NS_STYLE_CONTAIN_STYLE as u8) != 0{
servo_flags.insert(SpecifiedValue::STYLE);
}
if gecko_flags & (NS_STYLE_CONTAIN_PAINT as u8) != 0 {
servo_flags.insert(SpecifiedValue::PAINT);
}
return servo_flags;
}
${impl_simple_copy("contain", "mContain")}
${impl_simple_type_with_conversion("touch_action")}
</%self:impl_trait>
<%def name="simple_image_array_property(name, shorthand, field_name)">
<%
image_layers_field = "mImage" if shorthand == "background" else "mMask"
copy_simple_image_array_property(name, shorthand, image_layers_field, field_name)
%>
pub fn set_${shorthand}_${name}<I>(&mut self, v: I)
where I: IntoIterator<Item=longhands::${shorthand}_${name}::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let v = v.into_iter();
unsafe {
Gecko_EnsureImageLayersLength(&mut self.gecko.${image_layers_field}, v.len(),
LayerType::${shorthand.title()});
}
self.gecko.${image_layers_field}.${field_name}Count = v.len() as u32;
for (servo, geckolayer) in v.zip(self.gecko.${image_layers_field}.mLayers.iter_mut()) {
geckolayer.${field_name} = {
${caller.body()}
};
}
}
</%def>
<%def name="copy_simple_image_array_property(name, shorthand, layers_field_name, field_name)">
pub fn copy_${shorthand}_${name}_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let count = other.gecko.${layers_field_name}.${field_name}Count;
unsafe {
Gecko_EnsureImageLayersLength(&mut self.gecko.${layers_field_name},
count as usize,
LayerType::${shorthand.title()});
}
// FIXME(emilio): This may be bogus in the same way as bug 1426246.
for (layer, other) in self.gecko.${layers_field_name}.mLayers.iter_mut()
.zip(other.gecko.${layers_field_name}.mLayers.iter())
.take(count as usize) {
layer.${field_name} = other.${field_name};
}
self.gecko.${layers_field_name}.${field_name}Count = count;
}
pub fn reset_${shorthand}_${name}(&mut self, other: &Self) {
self.copy_${shorthand}_${name}_from(other)
}
</%def>
<%def name="impl_simple_image_array_property(name, shorthand, layer_field_name, field_name, struct_name)">
<%
ident = "%s_%s" % (shorthand, name)
style_struct = next(x for x in data.style_structs if x.name == struct_name)
longhand = next(x for x in style_struct.longhands if x.ident == ident)
keyword = longhand.keyword
%>
<% copy_simple_image_array_property(name, shorthand, layer_field_name, field_name) %>
pub fn set_${ident}<I>(&mut self, v: I)
where I: IntoIterator<Item=longhands::${ident}::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
use properties::longhands::${ident}::single_value::computed_value::T as Keyword;
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let v = v.into_iter();
unsafe {
Gecko_EnsureImageLayersLength(&mut self.gecko.${layer_field_name}, v.len(),
LayerType::${shorthand.title()});
}
self.gecko.${layer_field_name}.${field_name}Count = v.len() as u32;
for (servo, geckolayer) in v.zip(self.gecko.${layer_field_name}.mLayers.iter_mut()) {
geckolayer.${field_name} = {
match servo {
% for value in keyword.values_for("gecko"):
Keyword::${to_camel_case(value)} =>
structs::${keyword.gecko_constant(value)} ${keyword.maybe_cast('u8')},
% endfor
}
};
}
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use properties::longhands::${ident}::single_value::computed_value::T as Keyword;
% if keyword.needs_cast():
% for value in keyword.values_for('gecko'):
const ${keyword.casted_constant_name(value, "u8")} : u8 =
structs::${keyword.gecko_constant(value)} as u8;
% endfor
% endif
longhands::${ident}::computed_value::T (
self.gecko.${layer_field_name}.mLayers.iter()
.take(self.gecko.${layer_field_name}.${field_name}Count as usize)
.map(|ref layer| {
match layer.${field_name} {
% for value in longhand.keyword.values_for("gecko"):
% if keyword.needs_cast():
${keyword.casted_constant_name(value, "u8")}
% else:
structs::${keyword.gecko_constant(value)}
% endif
=> Keyword::${to_camel_case(value)},
% endfor
_ => panic!("Found unexpected value in style struct for ${ident} property"),
}
}).collect()
)
}
</%def>
<%def name="impl_common_image_layer_properties(shorthand)">
<%
if shorthand == "background":
image_layers_field = "mImage"
struct_name = "Background"
else:
image_layers_field = "mMask"
struct_name = "SVG"
%>
<%self:simple_image_array_property name="repeat" shorthand="${shorthand}" field_name="mRepeat">
use values::specified::background::BackgroundRepeatKeyword;
use gecko_bindings::structs::nsStyleImageLayers_Repeat;
use gecko_bindings::structs::StyleImageLayerRepeat;
fn to_ns(repeat: BackgroundRepeatKeyword) -> StyleImageLayerRepeat {
match repeat {
BackgroundRepeatKeyword::Repeat => StyleImageLayerRepeat::Repeat,
BackgroundRepeatKeyword::Space => StyleImageLayerRepeat::Space,
BackgroundRepeatKeyword::Round => StyleImageLayerRepeat::Round,
BackgroundRepeatKeyword::NoRepeat => StyleImageLayerRepeat::NoRepeat,
}
}
let repeat_x = to_ns(servo.0);
let repeat_y = to_ns(servo.1);
nsStyleImageLayers_Repeat {
mXRepeat: repeat_x,
mYRepeat: repeat_y,
}
</%self:simple_image_array_property>
pub fn clone_${shorthand}_repeat(&self) -> longhands::${shorthand}_repeat::computed_value::T {
use properties::longhands::${shorthand}_repeat::single_value::computed_value::T;
use values::specified::background::BackgroundRepeatKeyword;
use gecko_bindings::structs::StyleImageLayerRepeat;
fn to_servo(repeat: StyleImageLayerRepeat) -> BackgroundRepeatKeyword {
match repeat {
StyleImageLayerRepeat::Repeat => BackgroundRepeatKeyword::Repeat,
StyleImageLayerRepeat::Space => BackgroundRepeatKeyword::Space,
StyleImageLayerRepeat::Round => BackgroundRepeatKeyword::Round,
StyleImageLayerRepeat::NoRepeat => BackgroundRepeatKeyword::NoRepeat,
_ => panic!("Found unexpected value in style struct for ${shorthand}_repeat property"),
}
}
longhands::${shorthand}_repeat::computed_value::T (
self.gecko.${image_layers_field}.mLayers.iter()
.take(self.gecko.${image_layers_field}.mRepeatCount as usize)
.map(|ref layer| {
T(to_servo(layer.mRepeat.mXRepeat), to_servo(layer.mRepeat.mYRepeat))
}).collect()
)
}
<% impl_simple_image_array_property("clip", shorthand, image_layers_field, "mClip", struct_name) %>
<% impl_simple_image_array_property("origin", shorthand, image_layers_field, "mOrigin", struct_name) %>
% for orientation in ["x", "y"]:
pub fn copy_${shorthand}_position_${orientation}_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let count = other.gecko.${image_layers_field}.mPosition${orientation.upper()}Count;
unsafe {
Gecko_EnsureImageLayersLength(&mut self.gecko.${image_layers_field},
count as usize,
LayerType::${shorthand.capitalize()});
}
for (layer, other) in self.gecko.${image_layers_field}.mLayers.iter_mut()
.zip(other.gecko.${image_layers_field}.mLayers.iter())
.take(count as usize) {
layer.mPosition.m${orientation.upper()}Position
= other.mPosition.m${orientation.upper()}Position;
}
self.gecko.${image_layers_field}.mPosition${orientation.upper()}Count = count;
}
pub fn reset_${shorthand}_position_${orientation}(&mut self, other: &Self) {
self.copy_${shorthand}_position_${orientation}_from(other)
}
pub fn clone_${shorthand}_position_${orientation}(&self)
-> longhands::${shorthand}_position_${orientation}::computed_value::T {
longhands::${shorthand}_position_${orientation}::computed_value::T(
self.gecko.${image_layers_field}.mLayers.iter()
.take(self.gecko.${image_layers_field}.mPosition${orientation.upper()}Count as usize)
.map(|position| position.mPosition.m${orientation.upper()}Position.into())
.collect()
)
}
pub fn set_${shorthand}_position_${orientation[0]}<I>(&mut self,
v: I)
where I: IntoIterator<Item = longhands::${shorthand}_position_${orientation[0]}
::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let v = v.into_iter();
unsafe {
Gecko_EnsureImageLayersLength(&mut self.gecko.${image_layers_field}, v.len(),
LayerType::${shorthand.capitalize()});
}
self.gecko.${image_layers_field}.mPosition${orientation[0].upper()}Count = v.len() as u32;
for (servo, geckolayer) in v.zip(self.gecko.${image_layers_field}
.mLayers.iter_mut()) {
geckolayer.mPosition.m${orientation[0].upper()}Position = servo.into();
}
}
% endfor
<%self:simple_image_array_property name="size" shorthand="${shorthand}" field_name="mSize">
use gecko_bindings::structs::nsStyleImageLayers_Size_Dimension;
use gecko_bindings::structs::nsStyleImageLayers_Size_DimensionType;
use gecko_bindings::structs::{nsStyleCoord_CalcValue, nsStyleImageLayers_Size};
use values::generics::background::BackgroundSize;
let mut width = nsStyleCoord_CalcValue::new();
let mut height = nsStyleCoord_CalcValue::new();
let (w_type, h_type) = match servo {
BackgroundSize::Explicit { width: explicit_width, height: explicit_height } => {
let mut w_type = nsStyleImageLayers_Size_DimensionType::eAuto;
let mut h_type = nsStyleImageLayers_Size_DimensionType::eAuto;
if let Some(w) = explicit_width.to_calc_value() {
width = w;
w_type = nsStyleImageLayers_Size_DimensionType::eLengthPercentage;
}
if let Some(h) = explicit_height.to_calc_value() {
height = h;
h_type = nsStyleImageLayers_Size_DimensionType::eLengthPercentage;
}
(w_type, h_type)
}
BackgroundSize::Cover => {
(
nsStyleImageLayers_Size_DimensionType::eCover,
nsStyleImageLayers_Size_DimensionType::eCover,
)
},
BackgroundSize::Contain => {
(
nsStyleImageLayers_Size_DimensionType::eContain,
nsStyleImageLayers_Size_DimensionType::eContain,
)
},
};
nsStyleImageLayers_Size {
mWidth: nsStyleImageLayers_Size_Dimension { _base: width },
mHeight: nsStyleImageLayers_Size_Dimension { _base: height },
mWidthType: w_type as u8,
mHeightType: h_type as u8,
}
</%self:simple_image_array_property>
pub fn clone_${shorthand}_size(&self) -> longhands::background_size::computed_value::T {
use gecko_bindings::structs::nsStyleCoord_CalcValue as CalcValue;
use gecko_bindings::structs::nsStyleImageLayers_Size_DimensionType as DimensionType;
use values::computed::LengthOrPercentageOrAuto;
use values::generics::background::BackgroundSize;
fn to_servo(value: CalcValue, ty: u8) -> LengthOrPercentageOrAuto {
if ty == DimensionType::eAuto as u8 {
LengthOrPercentageOrAuto::Auto
} else {
debug_assert!(ty == DimensionType::eLengthPercentage as u8);
value.into()
}
}
longhands::background_size::computed_value::T(
self.gecko.${image_layers_field}.mLayers.iter().map(|ref layer| {
if DimensionType::eCover as u8 == layer.mSize.mWidthType {
debug_assert!(layer.mSize.mHeightType == DimensionType::eCover as u8);
return BackgroundSize::Cover
}
if DimensionType::eContain as u8 == layer.mSize.mWidthType {
debug_assert!(layer.mSize.mHeightType == DimensionType::eContain as u8);
return BackgroundSize::Contain
}
BackgroundSize::Explicit {
width: to_servo(layer.mSize.mWidth._base, layer.mSize.mWidthType),
height: to_servo(layer.mSize.mHeight._base, layer.mSize.mHeightType),
}
}).collect()
)
}
pub fn copy_${shorthand}_image_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
unsafe {
let count = other.gecko.${image_layers_field}.mImageCount;
Gecko_EnsureImageLayersLength(&mut self.gecko.${image_layers_field},
count as usize,
LayerType::${shorthand.capitalize()});
for (layer, other) in self.gecko.${image_layers_field}.mLayers.iter_mut()
.zip(other.gecko.${image_layers_field}.mLayers.iter())
.take(count as usize) {
Gecko_CopyImageValueFrom(&mut layer.mImage, &other.mImage);
}
self.gecko.${image_layers_field}.mImageCount = count;
}
}
pub fn reset_${shorthand}_image(&mut self, other: &Self) {
self.copy_${shorthand}_image_from(other)
}
#[allow(unused_variables)]
pub fn set_${shorthand}_image<I>(&mut self, images: I)
where I: IntoIterator<Item = longhands::${shorthand}_image::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
use gecko_bindings::structs::nsStyleImageLayers_LayerType as LayerType;
let images = images.into_iter();
unsafe {
// Prevent leaking of the last elements we did set
for image in &mut self.gecko.${image_layers_field}.mLayers {
Gecko_SetNullImageValue(&mut image.mImage)
}
// XXXManishearth clear mSourceURI for masks
Gecko_EnsureImageLayersLength(&mut self.gecko.${image_layers_field}, images.len(),
LayerType::${shorthand.title()});
}
self.gecko.${image_layers_field}.mImageCount = images.len() as u32;
for (image, geckoimage) in images.zip(self.gecko.${image_layers_field}
.mLayers.iter_mut()) {
if let Either::Second(image) = image {
geckoimage.mImage.set(image)
}
}
}
pub fn clone_${shorthand}_image(&self) -> longhands::${shorthand}_image::computed_value::T {
use values::None_;
longhands::${shorthand}_image::computed_value::T(
self.gecko.${image_layers_field}.mLayers.iter()
.take(self.gecko.${image_layers_field}.mImageCount as usize)
.map(|ref layer| {
match unsafe { layer.mImage.into_image() } {
Some(image) => Either::Second(image),
None => Either::First(None_),
}
}).collect()
)
}
<%
fill_fields = "mRepeat mClip mOrigin mPositionX mPositionY mImage mSize"
if shorthand == "background":
fill_fields += " mAttachment mBlendMode"
else:
# mSourceURI uses mImageCount
fill_fields += " mMaskMode mComposite"
%>
pub fn fill_arrays(&mut self) {
use gecko_bindings::bindings::Gecko_FillAllImageLayers;
use std::cmp;
let mut max_len = 1;
% for member in fill_fields.split():
max_len = cmp::max(max_len, self.gecko.${image_layers_field}.${member}Count);
% endfor
unsafe {
// While we could do this manually, we'd need to also manually
// run all the copy constructors, so we just delegate to gecko
Gecko_FillAllImageLayers(&mut self.gecko.${image_layers_field}, max_len);
}
}
</%def>
// TODO: Gecko accepts lists in most background-related properties. We just use
// the first element (which is the common case), but at some point we want to
// add support for parsing these lists in servo and pushing to nsTArray's.
<% skip_background_longhands = """background-repeat
background-image background-clip
background-origin background-attachment
background-size background-position
background-blend-mode
background-position-x
background-position-y""" %>
<%self:impl_trait style_struct_name="Background"
skip_longhands="${skip_background_longhands}">
<% impl_common_image_layer_properties("background") %>
<% impl_simple_image_array_property("attachment", "background", "mImage", "mAttachment", "Background") %>
<% impl_simple_image_array_property("blend_mode", "background", "mImage", "mBlendMode", "Background") %>
</%self:impl_trait>
<%self:impl_trait style_struct_name="List"
skip_longhands="list-style-image list-style-type quotes -moz-image-region">
pub fn set_list_style_image(&mut self, image: longhands::list_style_image::computed_value::T) {
use values::Either;
match image {
longhands::list_style_image::computed_value::T(Either::Second(_none)) => {
unsafe {
Gecko_SetListStyleImageNone(&mut self.gecko);
}
}
longhands::list_style_image::computed_value::T(Either::First(ref url)) => {
unsafe {
Gecko_SetListStyleImageImageValue(&mut self.gecko,
url.image_value.clone().unwrap().get());
}
// We don't need to record this struct as uncacheable, like when setting
// background-image to a url() value, since only properties in reset structs
// are re-used from the applicable declaration cache, and the List struct
// is an inherited struct.
}
}
}
pub fn copy_list_style_image_from(&mut self, other: &Self) {
unsafe { Gecko_CopyListStyleImageFrom(&mut self.gecko, &other.gecko); }
}
pub fn reset_list_style_image(&mut self, other: &Self) {
self.copy_list_style_image_from(other)
}
pub fn clone_list_style_image(&self) -> longhands::list_style_image::computed_value::T {
use values::specified::url::SpecifiedUrl;
use values::{Either, None_};
longhands::list_style_image::computed_value::T(
match self.gecko.mListStyleImage.mRawPtr.is_null() {
true => Either::Second(None_),
false => {
unsafe {
let ref gecko_image_request = *self.gecko.mListStyleImage.mRawPtr;
Either::First(SpecifiedUrl::from_image_request(gecko_image_request)
.expect("mListStyleImage could not convert to SpecifiedUrl"))
}
}
}
)
}
pub fn set_list_style_type(&mut self, v: longhands::list_style_type::computed_value::T, device: &Device) {
use gecko_bindings::bindings::Gecko_SetCounterStyleToString;
use nsstring::{nsACString, nsCStr};
use self::longhands::list_style_type::computed_value::T;
match v {
T::CounterStyle(s) => s.to_gecko_value(&mut self.gecko.mCounterStyle, device),
T::String(s) => unsafe {
Gecko_SetCounterStyleToString(&mut self.gecko.mCounterStyle,
&nsCStr::from(&s) as &nsACString)
}
}
}
pub fn copy_list_style_type_from(&mut self, other: &Self) {
unsafe {
Gecko_CopyCounterStyle(&mut self.gecko.mCounterStyle, &other.gecko.mCounterStyle);
}
}
pub fn reset_list_style_type(&mut self, other: &Self) {
self.copy_list_style_type_from(other)
}
pub fn clone_list_style_type(&self) -> longhands::list_style_type::computed_value::T {
use self::longhands::list_style_type::computed_value::T;
use values::Either;
use values::generics::CounterStyleOrNone;
let result = CounterStyleOrNone::from_gecko_value(&self.gecko.mCounterStyle);
match result {
Either::First(counter_style) => T::CounterStyle(counter_style),
Either::Second(string) => T::String(string),
}
}
pub fn set_quotes(&mut self, other: longhands::quotes::computed_value::T) {
use gecko_bindings::bindings::Gecko_NewStyleQuoteValues;
use gecko_bindings::sugar::refptr::UniqueRefPtr;
let mut refptr = unsafe {
UniqueRefPtr::from_addrefed(Gecko_NewStyleQuoteValues(other.0.len() as u32))
};
for (servo, gecko) in other.0.into_iter().zip(refptr.mQuotePairs.iter_mut()) {
gecko.first.assign_utf8(&servo.0);
gecko.second.assign_utf8(&servo.1);
}
self.gecko.mQuotes.set_move(refptr.get())
}
pub fn copy_quotes_from(&mut self, other: &Self) {
unsafe { self.gecko.mQuotes.set(&other.gecko.mQuotes); }
}
pub fn reset_quotes(&mut self, other: &Self) {
self.copy_quotes_from(other)
}
pub fn clone_quotes(&self) -> longhands::quotes::computed_value::T {
unsafe {
let ref gecko_quote_values = *self.gecko.mQuotes.mRawPtr;
longhands::quotes::computed_value::T(
gecko_quote_values.mQuotePairs.iter().map(|gecko_pair| {
(
gecko_pair.first.to_string().into_boxed_str(),
gecko_pair.second.to_string().into_boxed_str(),
)
}).collect::<Vec<_>>().into_boxed_slice()
)
}
}
#[allow(non_snake_case)]
pub fn set__moz_image_region(&mut self, v: longhands::_moz_image_region::computed_value::T) {
use values::Either;
match v {
Either::Second(_auto) => {
self.gecko.mImageRegion.x = 0;
self.gecko.mImageRegion.y = 0;
self.gecko.mImageRegion.width = 0;
self.gecko.mImageRegion.height = 0;
}
Either::First(rect) => {
self.gecko.mImageRegion.x = rect.left.map(Au::from).unwrap_or(Au(0)).0;
self.gecko.mImageRegion.y = rect.top.map(Au::from).unwrap_or(Au(0)).0;
self.gecko.mImageRegion.height = match rect.bottom {
Some(value) => (Au::from(value) - Au(self.gecko.mImageRegion.y)).0,
None => 0,
};
self.gecko.mImageRegion.width = match rect.right {
Some(value) => (Au::from(value) - Au(self.gecko.mImageRegion.x)).0,
None => 0,
};
}
}
}
#[allow(non_snake_case)]
pub fn clone__moz_image_region(&self) -> longhands::_moz_image_region::computed_value::T {
use values::{Auto, Either};
use values::computed::ClipRect;
// There is no ideal way to detect auto type for structs::nsRect and its components, so
// if all components are zero, we use Auto.
if self.gecko.mImageRegion.x == 0 &&
self.gecko.mImageRegion.y == 0 &&
self.gecko.mImageRegion.width == 0 &&
self.gecko.mImageRegion.height == 0 {
return Either::Second(Auto);
}
Either::First(ClipRect {
top: Some(Au(self.gecko.mImageRegion.y).into()),
right: Some(Au(self.gecko.mImageRegion.width + self.gecko.mImageRegion.x).into()),
bottom: Some(Au(self.gecko.mImageRegion.height + self.gecko.mImageRegion.y).into()),
left: Some(Au(self.gecko.mImageRegion.x).into()),
})
}
${impl_simple_copy('_moz_image_region', 'mImageRegion')}
</%self:impl_trait>
<%self:impl_trait style_struct_name="Table" skip_longhands="-x-span">
#[allow(non_snake_case)]
pub fn set__x_span(&mut self, v: longhands::_x_span::computed_value::T) {
self.gecko.mSpan = v.0
}
${impl_simple_copy('_x_span', 'mSpan')}
</%self:impl_trait>
<%self:impl_trait style_struct_name="Effects"
skip_longhands="box-shadow clip filter">
pub fn set_box_shadow<I>(&mut self, v: I)
where I: IntoIterator<Item = BoxShadow>,
I::IntoIter: ExactSizeIterator
{
let v = v.into_iter();
self.gecko.mBoxShadow.replace_with_new(v.len() as u32);
for (servo, gecko_shadow) in v.zip(self.gecko.mBoxShadow.iter_mut()) {
gecko_shadow.set_from_box_shadow(servo);
}
}
pub fn copy_box_shadow_from(&mut self, other: &Self) {
self.gecko.mBoxShadow.copy_from(&other.gecko.mBoxShadow);
}
pub fn reset_box_shadow(&mut self, other: &Self) {
self.copy_box_shadow_from(other)
}
pub fn clone_box_shadow(&self) -> longhands::box_shadow::computed_value::T {
let buf = self.gecko.mBoxShadow.iter().map(|v| v.to_box_shadow()).collect();
longhands::box_shadow::computed_value::T(buf)
}
pub fn set_clip(&mut self, v: longhands::clip::computed_value::T) {
use gecko_bindings::structs::NS_STYLE_CLIP_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_RECT;
use gecko_bindings::structs::NS_STYLE_CLIP_LEFT_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_TOP_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_RIGHT_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_BOTTOM_AUTO;
use values::Either;
match v {
Either::First(rect) => {
self.gecko.mClipFlags = NS_STYLE_CLIP_RECT as u8;
if let Some(left) = rect.left {
self.gecko.mClip.x = left.to_i32_au();
} else {
self.gecko.mClip.x = 0;
self.gecko.mClipFlags |= NS_STYLE_CLIP_LEFT_AUTO as u8;
}
if let Some(top) = rect.top {
self.gecko.mClip.y = top.to_i32_au();
} else {
self.gecko.mClip.y = 0;
self.gecko.mClipFlags |= NS_STYLE_CLIP_TOP_AUTO as u8;
}
if let Some(bottom) = rect.bottom {
self.gecko.mClip.height = (Au::from(bottom) - Au(self.gecko.mClip.y)).0;
} else {
self.gecko.mClip.height = 1 << 30; // NS_MAXSIZE
self.gecko.mClipFlags |= NS_STYLE_CLIP_BOTTOM_AUTO as u8;
}
if let Some(right) = rect.right {
self.gecko.mClip.width = (Au::from(right) - Au(self.gecko.mClip.x)).0;
} else {
self.gecko.mClip.width = 1 << 30; // NS_MAXSIZE
self.gecko.mClipFlags |= NS_STYLE_CLIP_RIGHT_AUTO as u8;
}
},
Either::Second(_auto) => {
self.gecko.mClipFlags = NS_STYLE_CLIP_AUTO as u8;
self.gecko.mClip.x = 0;
self.gecko.mClip.y = 0;
self.gecko.mClip.width = 0;
self.gecko.mClip.height = 0;
}
}
}
pub fn copy_clip_from(&mut self, other: &Self) {
self.gecko.mClip = other.gecko.mClip;
self.gecko.mClipFlags = other.gecko.mClipFlags;
}
pub fn reset_clip(&mut self, other: &Self) {
self.copy_clip_from(other)
}
pub fn clone_clip(&self) -> longhands::clip::computed_value::T {
use gecko_bindings::structs::NS_STYLE_CLIP_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_BOTTOM_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_LEFT_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_RIGHT_AUTO;
use gecko_bindings::structs::NS_STYLE_CLIP_TOP_AUTO;
use values::computed::{ClipRect, ClipRectOrAuto};
use values::Either;
if self.gecko.mClipFlags == NS_STYLE_CLIP_AUTO as u8 {
ClipRectOrAuto::auto()
} else {
let left = if self.gecko.mClipFlags & NS_STYLE_CLIP_LEFT_AUTO as u8 != 0 {
debug_assert!(self.gecko.mClip.x == 0);
None
} else {
Some(Au(self.gecko.mClip.x).into())
};
let top = if self.gecko.mClipFlags & NS_STYLE_CLIP_TOP_AUTO as u8 != 0 {
debug_assert!(self.gecko.mClip.y == 0);
None
} else {
Some(Au(self.gecko.mClip.y).into())
};
let bottom = if self.gecko.mClipFlags & NS_STYLE_CLIP_BOTTOM_AUTO as u8 != 0 {
debug_assert!(self.gecko.mClip.height == 1 << 30); // NS_MAXSIZE
None
} else {
Some(Au(self.gecko.mClip.y + self.gecko.mClip.height).into())
};
let right = if self.gecko.mClipFlags & NS_STYLE_CLIP_RIGHT_AUTO as u8 != 0 {
debug_assert!(self.gecko.mClip.width == 1 << 30); // NS_MAXSIZE
None
} else {
Some(Au(self.gecko.mClip.x + self.gecko.mClip.width).into())
};
Either::First(ClipRect { top: top, right: right, bottom: bottom, left: left, })
}
}
<%
# This array is several filter function which has percentage or
# number value for function of clone / set.
# The setting / cloning process of other function(e.g. Blur / HueRotate) is
# different from these function. So this array don't include such function.
FILTER_FUNCTIONS = [ 'Brightness', 'Contrast', 'Grayscale', 'Invert',
'Opacity', 'Saturate', 'Sepia' ]
%>
pub fn set_filter<I>(&mut self, v: I)
where
I: IntoIterator<Item = Filter>,
I::IntoIter: ExactSizeIterator,
{
use values::generics::effects::Filter::*;
use gecko_bindings::structs::nsCSSShadowArray;
use gecko_bindings::structs::nsStyleFilter;
use gecko_bindings::structs::NS_STYLE_FILTER_BLUR;
use gecko_bindings::structs::NS_STYLE_FILTER_BRIGHTNESS;
use gecko_bindings::structs::NS_STYLE_FILTER_CONTRAST;
use gecko_bindings::structs::NS_STYLE_FILTER_GRAYSCALE;
use gecko_bindings::structs::NS_STYLE_FILTER_INVERT;
use gecko_bindings::structs::NS_STYLE_FILTER_OPACITY;
use gecko_bindings::structs::NS_STYLE_FILTER_SATURATE;
use gecko_bindings::structs::NS_STYLE_FILTER_SEPIA;
use gecko_bindings::structs::NS_STYLE_FILTER_HUE_ROTATE;
use gecko_bindings::structs::NS_STYLE_FILTER_DROP_SHADOW;
fn fill_filter(m_type: u32, value: CoordDataValue, gecko_filter: &mut nsStyleFilter){
gecko_filter.mType = m_type;
gecko_filter.mFilterParameter.set_value(value);
}
let v = v.into_iter();
unsafe {
Gecko_ResetFilters(&mut self.gecko, v.len());
}
debug_assert_eq!(v.len(), self.gecko.mFilters.len());
for (servo, gecko_filter) in v.zip(self.gecko.mFilters.iter_mut()) {
match servo {
% for func in FILTER_FUNCTIONS:
${func}(factor) => fill_filter(NS_STYLE_FILTER_${func.upper()},
CoordDataValue::Factor(factor.0),
gecko_filter),
% endfor
Blur(length) => fill_filter(NS_STYLE_FILTER_BLUR,
CoordDataValue::Coord(length.0.to_i32_au()),
gecko_filter),
HueRotate(angle) => fill_filter(NS_STYLE_FILTER_HUE_ROTATE,
CoordDataValue::from(angle),
gecko_filter),
DropShadow(shadow) => {
gecko_filter.mType = NS_STYLE_FILTER_DROP_SHADOW;
fn init_shadow(filter: &mut nsStyleFilter) -> &mut nsCSSShadowArray {
unsafe {
let ref mut union = filter.__bindgen_anon_1;
let shadow_array: &mut *mut nsCSSShadowArray = union.mDropShadow.as_mut();
*shadow_array = Gecko_NewCSSShadowArray(1);
&mut **shadow_array
}
}
let gecko_shadow = init_shadow(gecko_filter);
gecko_shadow.mArray[0].set_from_simple_shadow(shadow);
},
Url(ref url) => {
unsafe {
bindings::Gecko_nsStyleFilter_SetURLValue(gecko_filter, url.for_ffi());
}
},
}
}
}
pub fn copy_filter_from(&mut self, other: &Self) {
unsafe {
Gecko_CopyFiltersFrom(&other.gecko as *const _ as *mut _, &mut self.gecko);
}
}
pub fn reset_filter(&mut self, other: &Self) {
self.copy_filter_from(other)
}
pub fn clone_filter(&self) -> longhands::filter::computed_value::T {
use values::generics::effects::Filter;
use values::specified::url::SpecifiedUrl;
use gecko_bindings::structs::NS_STYLE_FILTER_BLUR;
use gecko_bindings::structs::NS_STYLE_FILTER_BRIGHTNESS;
use gecko_bindings::structs::NS_STYLE_FILTER_CONTRAST;
use gecko_bindings::structs::NS_STYLE_FILTER_GRAYSCALE;
use gecko_bindings::structs::NS_STYLE_FILTER_INVERT;
use gecko_bindings::structs::NS_STYLE_FILTER_OPACITY;
use gecko_bindings::structs::NS_STYLE_FILTER_SATURATE;
use gecko_bindings::structs::NS_STYLE_FILTER_SEPIA;
use gecko_bindings::structs::NS_STYLE_FILTER_HUE_ROTATE;
use gecko_bindings::structs::NS_STYLE_FILTER_DROP_SHADOW;
use gecko_bindings::structs::NS_STYLE_FILTER_URL;
let mut filters = Vec::new();
for filter in self.gecko.mFilters.iter(){
match filter.mType {
% for func in FILTER_FUNCTIONS:
NS_STYLE_FILTER_${func.upper()} => {
filters.push(Filter::${func}(
GeckoStyleCoordConvertible::from_gecko_style_coord(
&filter.mFilterParameter).unwrap()));
},
% endfor
NS_STYLE_FILTER_BLUR => {
filters.push(Filter::Blur(NonNegativeLength::from_gecko_style_coord(
&filter.mFilterParameter).unwrap()));
},
NS_STYLE_FILTER_HUE_ROTATE => {
filters.push(Filter::HueRotate(
GeckoStyleCoordConvertible::from_gecko_style_coord(
&filter.mFilterParameter).unwrap()));
},
NS_STYLE_FILTER_DROP_SHADOW => {
filters.push(unsafe {
Filter::DropShadow(
(**filter.__bindgen_anon_1.mDropShadow.as_ref()).mArray[0].to_simple_shadow(),
)
});
},
NS_STYLE_FILTER_URL => {
filters.push(unsafe {
Filter::Url(
SpecifiedUrl::from_url_value_data(&(**filter.__bindgen_anon_1.mURL.as_ref())._base).unwrap()
)
});
}
_ => {},
}
}
longhands::filter::computed_value::T(filters)
}
</%self:impl_trait>
<%self:impl_trait style_struct_name="InheritedBox"
skip_longhands="image-orientation">
// FIXME: Gecko uses a tricky way to store computed value of image-orientation
// within an u8. We could inline following glue codes by implementing all
// those tricky parts for Servo as well. But, it's not done yet just for
// convenience.
pub fn set_image_orientation(&mut self, v: longhands::image_orientation::computed_value::T) {
use properties::longhands::image_orientation::computed_value::T;
match v {
T::FromImage => {
unsafe {
bindings::Gecko_SetImageOrientationAsFromImage(&mut self.gecko);
}
},
T::AngleWithFlipped(ref orientation, flipped) => {
unsafe {
bindings::Gecko_SetImageOrientation(&mut self.gecko, *orientation as u8, flipped);
}
}
}
}
pub fn copy_image_orientation_from(&mut self, other: &Self) {
unsafe {
bindings::Gecko_CopyImageOrientationFrom(&mut self.gecko, &other.gecko);
}
}
pub fn reset_image_orientation(&mut self, other: &Self) {
self.copy_image_orientation_from(other)
}
pub fn clone_image_orientation(&self) -> longhands::image_orientation::computed_value::T {
use gecko_bindings::structs::nsStyleImageOrientation_Angles;
use properties::longhands::image_orientation::computed_value::T;
use values::computed::Orientation;
let gecko_orientation = self.gecko.mImageOrientation.mOrientation;
if gecko_orientation & structs::nsStyleImageOrientation_Bits_FROM_IMAGE_MASK as u8 != 0 {
T::FromImage
} else {
const ANGLE0: u8 = nsStyleImageOrientation_Angles::ANGLE_0 as u8;
const ANGLE90: u8 = nsStyleImageOrientation_Angles::ANGLE_90 as u8;
const ANGLE180: u8 = nsStyleImageOrientation_Angles::ANGLE_180 as u8;
const ANGLE270: u8 = nsStyleImageOrientation_Angles::ANGLE_270 as u8;
let flip = gecko_orientation & structs::nsStyleImageOrientation_Bits_FLIP_MASK as u8 != 0;
let orientation =
match gecko_orientation & structs::nsStyleImageOrientation_Bits_ORIENTATION_MASK as u8 {
ANGLE0 => Orientation::Angle0,
ANGLE90 => Orientation::Angle90,
ANGLE180 => Orientation::Angle180,
ANGLE270 => Orientation::Angle270,
_ => unreachable!()
};
T::AngleWithFlipped(orientation, flip)
}
}
</%self:impl_trait>
<%self:impl_trait style_struct_name="InheritedTable"
skip_longhands="border-spacing">
pub fn set_border_spacing(&mut self, v: longhands::border_spacing::computed_value::T) {
self.gecko.mBorderSpacingCol = v.horizontal().0;
self.gecko.mBorderSpacingRow = v.vertical().0;
}
pub fn copy_border_spacing_from(&mut self, other: &Self) {
self.gecko.mBorderSpacingCol = other.gecko.mBorderSpacingCol;
self.gecko.mBorderSpacingRow = other.gecko.mBorderSpacingRow;
}
pub fn reset_border_spacing(&mut self, other: &Self) {
self.copy_border_spacing_from(other)
}
pub fn clone_border_spacing(&self) -> longhands::border_spacing::computed_value::T {
longhands::border_spacing::computed_value::T::new(
Au(self.gecko.mBorderSpacingCol).into(),
Au(self.gecko.mBorderSpacingRow).into()
)
}
</%self:impl_trait>
<%self:impl_trait style_struct_name="InheritedText"
skip_longhands="text-align text-emphasis-style text-shadow line-height letter-spacing word-spacing
-webkit-text-stroke-width text-emphasis-position -moz-tab-size">
<% text_align_keyword = Keyword("text-align",
"start end left right center justify -moz-center -moz-left -moz-right char",
gecko_strip_moz_prefix=False) %>
${impl_keyword('text_align', 'mTextAlign', text_align_keyword)}
pub fn set_text_shadow<I>(&mut self, v: I)
where I: IntoIterator<Item = SimpleShadow>,
I::IntoIter: ExactSizeIterator
{
let v = v.into_iter();
self.gecko.mTextShadow.replace_with_new(v.len() as u32);
for (servo, gecko_shadow) in v.zip(self.gecko.mTextShadow.iter_mut()) {
gecko_shadow.set_from_simple_shadow(servo);
}
}
pub fn copy_text_shadow_from(&mut self, other: &Self) {
self.gecko.mTextShadow.copy_from(&other.gecko.mTextShadow);
}
pub fn reset_text_shadow(&mut self, other: &Self) {
self.copy_text_shadow_from(other)
}
pub fn clone_text_shadow(&self) -> longhands::text_shadow::computed_value::T {
let buf = self.gecko.mTextShadow.iter().map(|v| v.to_simple_shadow()).collect();
longhands::text_shadow::computed_value::T(buf)
}
pub fn set_line_height(&mut self, v: longhands::line_height::computed_value::T) {
use values::generics::text::LineHeight;
// FIXME: Align binary representations and ditch |match| for cast + static_asserts
let en = match v {
LineHeight::Normal => CoordDataValue::Normal,
LineHeight::Length(val) => CoordDataValue::Coord(val.0.to_i32_au()),
LineHeight::Number(val) => CoordDataValue::Factor(val.0),
LineHeight::MozBlockHeight =>
CoordDataValue::Enumerated(structs::NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT),
};
self.gecko.mLineHeight.set_value(en);
}
pub fn clone_line_height(&self) -> longhands::line_height::computed_value::T {
use values::generics::text::LineHeight;
return match self.gecko.mLineHeight.as_value() {
CoordDataValue::Normal => LineHeight::Normal,
CoordDataValue::Coord(coord) => LineHeight::Length(Au(coord).into()),
CoordDataValue::Factor(n) => LineHeight::Number(n.into()),
CoordDataValue::Enumerated(val) if val == structs::NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT =>
LineHeight::MozBlockHeight,
_ => panic!("this should not happen"),
}
}
<%call expr="impl_coord_copy('line_height', 'mLineHeight')"></%call>
pub fn set_letter_spacing(&mut self, v: longhands::letter_spacing::computed_value::T) {
use values::generics::text::Spacing;
match v {
Spacing::Value(value) => self.gecko.mLetterSpacing.set(value),
Spacing::Normal => self.gecko.mLetterSpacing.set_value(CoordDataValue::Normal)
}
}
pub fn clone_letter_spacing(&self) -> longhands::letter_spacing::computed_value::T {
use values::computed::Length;
use values::generics::text::Spacing;
debug_assert!(
matches!(self.gecko.mLetterSpacing.as_value(),
CoordDataValue::Normal |
CoordDataValue::Coord(_)),
"Unexpected computed value for letter-spacing");
Length::from_gecko_style_coord(&self.gecko.mLetterSpacing).map_or(Spacing::Normal, Spacing::Value)
}
<%call expr="impl_coord_copy('letter_spacing', 'mLetterSpacing')"></%call>
pub fn set_word_spacing(&mut self, v: longhands::word_spacing::computed_value::T) {
use values::generics::text::Spacing;
match v {
Spacing::Value(lop) => self.gecko.mWordSpacing.set(lop),
// https://drafts.csswg.org/css-text-3/#valdef-word-spacing-normal
Spacing::Normal => self.gecko.mWordSpacing.set_value(CoordDataValue::Coord(0)),
}
}
pub fn clone_word_spacing(&self) -> longhands::word_spacing::computed_value::T {
use values::computed::LengthOrPercentage;
use values::generics::text::Spacing;
debug_assert!(
matches!(self.gecko.mWordSpacing.as_value(),
CoordDataValue::Normal |
CoordDataValue::Coord(_) |
CoordDataValue::Percent(_) |
CoordDataValue::Calc(_)),
"Unexpected computed value for word-spacing");
LengthOrPercentage::from_gecko_style_coord(&self.gecko.mWordSpacing).map_or(Spacing::Normal, Spacing::Value)
}
<%call expr="impl_coord_copy('word_spacing', 'mWordSpacing')"></%call>
fn clear_text_emphasis_style_if_string(&mut self) {
if self.gecko.mTextEmphasisStyle == structs::NS_STYLE_TEXT_EMPHASIS_STYLE_STRING as u8 {
self.gecko.mTextEmphasisStyleString.truncate();
self.gecko.mTextEmphasisStyle = structs::NS_STYLE_TEXT_EMPHASIS_STYLE_NONE as u8;
}
}
${impl_simple_type_with_conversion("text_emphasis_position")}
pub fn set_text_emphasis_style(&mut self, v: longhands::text_emphasis_style::computed_value::T) {
use properties::longhands::text_emphasis_style::computed_value::T;
use properties::longhands::text_emphasis_style::ShapeKeyword;
self.clear_text_emphasis_style_if_string();
let (te, s) = match v {
T::None => (structs::NS_STYLE_TEXT_EMPHASIS_STYLE_NONE, ""),
T::Keyword(ref keyword) => {
let fill = if keyword.fill {
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_FILLED
} else {
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_OPEN
};
let shape = match keyword.shape {
ShapeKeyword::Dot => structs::NS_STYLE_TEXT_EMPHASIS_STYLE_DOT,
ShapeKeyword::Circle => structs::NS_STYLE_TEXT_EMPHASIS_STYLE_CIRCLE,
ShapeKeyword::DoubleCircle => structs::NS_STYLE_TEXT_EMPHASIS_STYLE_DOUBLE_CIRCLE,
ShapeKeyword::Triangle => structs::NS_STYLE_TEXT_EMPHASIS_STYLE_TRIANGLE,
ShapeKeyword::Sesame => structs::NS_STYLE_TEXT_EMPHASIS_STYLE_SESAME,
};
(shape | fill, keyword.shape.char(keyword.fill))
},
T::String(ref s) => {
(structs::NS_STYLE_TEXT_EMPHASIS_STYLE_STRING, &**s)
},
};
self.gecko.mTextEmphasisStyleString.assign_utf8(s);
self.gecko.mTextEmphasisStyle = te as u8;
}
pub fn copy_text_emphasis_style_from(&mut self, other: &Self) {
self.clear_text_emphasis_style_if_string();
if other.gecko.mTextEmphasisStyle == structs::NS_STYLE_TEXT_EMPHASIS_STYLE_STRING as u8 {
self.gecko.mTextEmphasisStyleString
.assign(&*other.gecko.mTextEmphasisStyleString)
}
self.gecko.mTextEmphasisStyle = other.gecko.mTextEmphasisStyle;
}
pub fn reset_text_emphasis_style(&mut self, other: &Self) {
self.copy_text_emphasis_style_from(other)
}
pub fn clone_text_emphasis_style(&self) -> longhands::text_emphasis_style::computed_value::T {
use properties::longhands::text_emphasis_style::computed_value::{T, KeywordValue};
use properties::longhands::text_emphasis_style::ShapeKeyword;
if self.gecko.mTextEmphasisStyle == structs::NS_STYLE_TEXT_EMPHASIS_STYLE_NONE as u8 {
return T::None;
} else if self.gecko.mTextEmphasisStyle == structs::NS_STYLE_TEXT_EMPHASIS_STYLE_STRING as u8 {
return T::String(self.gecko.mTextEmphasisStyleString.to_string());
}
let fill = self.gecko.mTextEmphasisStyle & structs::NS_STYLE_TEXT_EMPHASIS_STYLE_OPEN as u8 == 0;
let shape =
match self.gecko.mTextEmphasisStyle as u32 & !structs::NS_STYLE_TEXT_EMPHASIS_STYLE_OPEN {
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_DOT => ShapeKeyword::Dot,
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_CIRCLE => ShapeKeyword::Circle,
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_DOUBLE_CIRCLE => ShapeKeyword::DoubleCircle,
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_TRIANGLE => ShapeKeyword::Triangle,
structs::NS_STYLE_TEXT_EMPHASIS_STYLE_SESAME => ShapeKeyword::Sesame,
_ => panic!("Unexpected value in style struct for text-emphasis-style property")
};
T::Keyword(KeywordValue {
fill: fill,
shape: shape
})
}
${impl_non_negative_length('_webkit_text_stroke_width',
'mWebkitTextStrokeWidth')}
#[allow(non_snake_case)]
pub fn set__moz_tab_size(&mut self, v: longhands::_moz_tab_size::computed_value::T) {
use values::Either;
match v {
Either::Second(non_negative_number) => {
self.gecko.mTabSize.set_value(CoordDataValue::Factor(non_negative_number.0));
}
Either::First(non_negative_length) => {
self.gecko.mTabSize.set(non_negative_length);
}
}
}
#[allow(non_snake_case)]
pub fn clone__moz_tab_size(&self) -> longhands::_moz_tab_size::computed_value::T {
use values::Either;
match self.gecko.mTabSize.as_value() {
CoordDataValue::Coord(coord) => Either::First(Au(coord).into()),
CoordDataValue::Factor(number) => Either::Second(From::from(number)),
_ => unreachable!(),
}
}
<%call expr="impl_coord_copy('_moz_tab_size', 'mTabSize')"></%call>
</%self:impl_trait>
<%self:impl_trait style_struct_name="Text"
skip_longhands="text-decoration-line text-overflow initial-letter">
${impl_simple_type_with_conversion("text_decoration_line")}
fn clear_overflow_sides_if_string(&mut self) {
use gecko_bindings::structs::nsStyleTextOverflowSide;
fn clear_if_string(side: &mut nsStyleTextOverflowSide) {
if side.mType == structs::NS_STYLE_TEXT_OVERFLOW_STRING as u8 {
side.mString.truncate();
side.mType = structs::NS_STYLE_TEXT_OVERFLOW_CLIP as u8;
}
}
clear_if_string(&mut self.gecko.mTextOverflow.mLeft);
clear_if_string(&mut self.gecko.mTextOverflow.mRight);
}
pub fn set_text_overflow(&mut self, v: longhands::text_overflow::computed_value::T) {
use gecko_bindings::structs::nsStyleTextOverflowSide;
use values::specified::text::TextOverflowSide;
fn set(side: &mut nsStyleTextOverflowSide, value: &TextOverflowSide) {
let ty = match *value {
TextOverflowSide::Clip => structs::NS_STYLE_TEXT_OVERFLOW_CLIP,
TextOverflowSide::Ellipsis => structs::NS_STYLE_TEXT_OVERFLOW_ELLIPSIS,
TextOverflowSide::String(ref s) => {
side.mString.assign_utf8(s);
structs::NS_STYLE_TEXT_OVERFLOW_STRING
}
};
side.mType = ty as u8;
}
self.clear_overflow_sides_if_string();
self.gecko.mTextOverflow.mLogicalDirections = v.sides_are_logical;
set(&mut self.gecko.mTextOverflow.mLeft, &v.first);
set(&mut self.gecko.mTextOverflow.mRight, &v.second);
}
pub fn copy_text_overflow_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleTextOverflowSide;
fn set(side: &mut nsStyleTextOverflowSide, other: &nsStyleTextOverflowSide) {
if other.mType == structs::NS_STYLE_TEXT_OVERFLOW_STRING as u8 {
side.mString.assign(&*other.mString)
}
side.mType = other.mType
}
self.clear_overflow_sides_if_string();
set(&mut self.gecko.mTextOverflow.mLeft, &other.gecko.mTextOverflow.mLeft);
set(&mut self.gecko.mTextOverflow.mRight, &other.gecko.mTextOverflow.mRight);
self.gecko.mTextOverflow.mLogicalDirections = other.gecko.mTextOverflow.mLogicalDirections;
}
pub fn reset_text_overflow(&mut self, other: &Self) {
self.copy_text_overflow_from(other)
}
pub fn clone_text_overflow(&self) -> longhands::text_overflow::computed_value::T {
use gecko_bindings::structs::nsStyleTextOverflowSide;
use values::specified::text::TextOverflowSide;
fn to_servo(side: &nsStyleTextOverflowSide) -> TextOverflowSide {
match side.mType as u32 {
structs::NS_STYLE_TEXT_OVERFLOW_CLIP => TextOverflowSide::Clip,
structs::NS_STYLE_TEXT_OVERFLOW_ELLIPSIS => TextOverflowSide::Ellipsis,
structs::NS_STYLE_TEXT_OVERFLOW_STRING =>
TextOverflowSide::String(side.mString.to_string().into_boxed_str()),
_ => panic!("Found unexpected value in style struct for text_overflow property"),
}
}
longhands::text_overflow::computed_value::T {
first: to_servo(&self.gecko.mTextOverflow.mLeft),
second: to_servo(&self.gecko.mTextOverflow.mRight),
sides_are_logical: self.gecko.mTextOverflow.mLogicalDirections
}
}
pub fn set_initial_letter(&mut self, v: longhands::initial_letter::computed_value::T) {
use values::generics::text::InitialLetter;
match v {
InitialLetter::Normal => {
self.gecko.mInitialLetterSize = 0.;
self.gecko.mInitialLetterSink = 0;
},
InitialLetter::Specified(size, sink) => {
self.gecko.mInitialLetterSize = size;
if let Some(sink) = sink {
self.gecko.mInitialLetterSink = sink;
} else {
self.gecko.mInitialLetterSink = size.floor() as i32;
}
}
}
}
pub fn copy_initial_letter_from(&mut self, other: &Self) {
self.gecko.mInitialLetterSize = other.gecko.mInitialLetterSize;
self.gecko.mInitialLetterSink = other.gecko.mInitialLetterSink;
}
pub fn reset_initial_letter(&mut self, other: &Self) {
self.copy_initial_letter_from(other)
}
pub fn clone_initial_letter(&self) -> longhands::initial_letter::computed_value::T {
use values::generics::text::InitialLetter;
if self.gecko.mInitialLetterSize == 0. && self.gecko.mInitialLetterSink == 0 {
InitialLetter::Normal
} else if self.gecko.mInitialLetterSize.floor() as i32 == self.gecko.mInitialLetterSink {
InitialLetter::Specified(self.gecko.mInitialLetterSize, None)
} else {
InitialLetter::Specified(self.gecko.mInitialLetterSize, Some(self.gecko.mInitialLetterSink))
}
}
#[inline]
pub fn has_underline(&self) -> bool {
(self.gecko.mTextDecorationLine & (structs::NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE as u8)) != 0
}
#[inline]
pub fn has_overline(&self) -> bool {
(self.gecko.mTextDecorationLine & (structs::NS_STYLE_TEXT_DECORATION_LINE_OVERLINE as u8)) != 0
}
#[inline]
pub fn has_line_through(&self) -> bool {
(self.gecko.mTextDecorationLine & (structs::NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH as u8)) != 0
}
</%self:impl_trait>
<%def name="impl_shape_source(ident, gecko_ffi_name)">
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use gecko_bindings::bindings::{Gecko_NewBasicShape, Gecko_DestroyShapeSource};
use gecko_bindings::structs::{StyleBasicShape, StyleBasicShapeType, StyleShapeSourceType};
use gecko_bindings::structs::{StyleFillRule, StyleGeometryBox, StyleShapeSource};
use gecko::conversions::basic_shape::set_corners_from_radius;
use gecko::values::GeckoStyleCoordConvertible;
use values::generics::basic_shape::{BasicShape, FillRule, ShapeSource};
let ref mut ${ident} = self.gecko.${gecko_ffi_name};
// clean up existing struct
unsafe { Gecko_DestroyShapeSource(${ident}) };
${ident}.mType = StyleShapeSourceType::None;
match v {
% if ident == "clip_path":
ShapeSource::ImageOrUrl(ref url) => {
unsafe {
bindings::Gecko_StyleShapeSource_SetURLValue(${ident}, url.for_ffi())
}
}
% elif ident == "shape_outside":
ShapeSource::ImageOrUrl(image) => {
unsafe {
bindings::Gecko_NewShapeImage(${ident});
let style_image = &mut *${ident}.mShapeImage.mPtr;
style_image.set(image);
}
}
% else:
<% raise Exception("Unknown property: %s" % ident) %>
}
% endif
ShapeSource::None => {} // don't change the type
ShapeSource::Box(reference) => {
${ident}.mReferenceBox = reference.into();
${ident}.mType = StyleShapeSourceType::Box;
}
ShapeSource::Shape(servo_shape, maybe_box) => {
fn init_shape(${ident}: &mut StyleShapeSource, basic_shape_type: StyleBasicShapeType)
-> &mut StyleBasicShape {
unsafe {
// Create StyleBasicShape in StyleShapeSource. mReferenceBox and mType
// will be set manually later.
Gecko_NewBasicShape(${ident}, basic_shape_type);
&mut *${ident}.mBasicShape.mPtr
}
}
match servo_shape {
BasicShape::Inset(inset) => {
let shape = init_shape(${ident}, StyleBasicShapeType::Inset);
unsafe { shape.mCoordinates.set_len(4) };
// set_len() can't call constructors, so the coordinates
// can contain any value. set_value() attempts to free
// allocated coordinates, so we don't want to feed it
// garbage values which it may misinterpret.
// Instead, we use leaky_set_value to blindly overwrite
// the garbage data without
// attempting to clean up.
shape.mCoordinates[0].leaky_set_null();
inset.rect.0.to_gecko_style_coord(&mut shape.mCoordinates[0]);
shape.mCoordinates[1].leaky_set_null();
inset.rect.1.to_gecko_style_coord(&mut shape.mCoordinates[1]);
shape.mCoordinates[2].leaky_set_null();
inset.rect.2.to_gecko_style_coord(&mut shape.mCoordinates[2]);
shape.mCoordinates[3].leaky_set_null();
inset.rect.3.to_gecko_style_coord(&mut shape.mCoordinates[3]);
set_corners_from_radius(inset.round, &mut shape.mRadius);
}
BasicShape::Circle(circ) => {
let shape = init_shape(${ident}, StyleBasicShapeType::Circle);
unsafe { shape.mCoordinates.set_len(1) };
shape.mCoordinates[0].leaky_set_null();
circ.radius.to_gecko_style_coord(&mut shape.mCoordinates[0]);
shape.mPosition = circ.position.into();
}
BasicShape::Ellipse(el) => {
let shape = init_shape(${ident}, StyleBasicShapeType::Ellipse);
unsafe { shape.mCoordinates.set_len(2) };
shape.mCoordinates[0].leaky_set_null();
el.semiaxis_x.to_gecko_style_coord(&mut shape.mCoordinates[0]);
shape.mCoordinates[1].leaky_set_null();
el.semiaxis_y.to_gecko_style_coord(&mut shape.mCoordinates[1]);
shape.mPosition = el.position.into();
}
BasicShape::Polygon(poly) => {
let shape = init_shape(${ident}, StyleBasicShapeType::Polygon);
unsafe {
shape.mCoordinates.set_len(poly.coordinates.len() as u32 * 2);
}
for (i, coord) in poly.coordinates.iter().enumerate() {
shape.mCoordinates[2 * i].leaky_set_null();
shape.mCoordinates[2 * i + 1].leaky_set_null();
coord.0.to_gecko_style_coord(&mut shape.mCoordinates[2 * i]);
coord.1.to_gecko_style_coord(&mut shape.mCoordinates[2 * i + 1]);
}
shape.mFillRule = if poly.fill == FillRule::Evenodd {
StyleFillRule::Evenodd
} else {
StyleFillRule::Nonzero
};
}
}
${ident}.mReferenceBox = maybe_box.map(Into::into)
.unwrap_or(StyleGeometryBox::NoBox);
${ident}.mType = StyleShapeSourceType::Shape;
}
}
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
(&self.gecko.${gecko_ffi_name}).into()
}
pub fn copy_${ident}_from(&mut self, other: &Self) {
use gecko_bindings::bindings::Gecko_CopyShapeSourceFrom;
unsafe {
Gecko_CopyShapeSourceFrom(&mut self.gecko.${gecko_ffi_name}, &other.gecko.${gecko_ffi_name});
}
}
pub fn reset_${ident}(&mut self, other: &Self) {
self.copy_${ident}_from(other)
}
</%def>
<% skip_svg_longhands = """
mask-mode mask-repeat mask-clip mask-origin mask-composite mask-position-x mask-position-y mask-size mask-image
clip-path
"""
%>
<%self:impl_trait style_struct_name="SVG"
skip_longhands="${skip_svg_longhands}">
<% impl_common_image_layer_properties("mask") %>
<% impl_simple_image_array_property("mode", "mask", "mMask", "mMaskMode", "SVG") %>
<% impl_simple_image_array_property("composite", "mask", "mMask", "mComposite", "SVG") %>
<% impl_shape_source("clip_path", "mClipPath") %>
</%self:impl_trait>
<%self:impl_trait style_struct_name="InheritedSVG"
skip_longhands="paint-order stroke-dasharray -moz-context-properties">
pub fn set_paint_order(&mut self, v: longhands::paint_order::computed_value::T) {
self.gecko.mPaintOrder = v.0;
}
${impl_simple_copy('paint_order', 'mPaintOrder')}
pub fn clone_paint_order(&self) -> longhands::paint_order::computed_value::T {
use properties::longhands::paint_order::computed_value::T;
T(self.gecko.mPaintOrder)
}
pub fn set_stroke_dasharray(&mut self, v: longhands::stroke_dasharray::computed_value::T) {
use gecko_bindings::structs::nsStyleSVG_STROKE_DASHARRAY_CONTEXT as CONTEXT_VALUE;
use values::generics::svg::{SVGStrokeDashArray, SvgLengthOrPercentageOrNumber};
match v {
SVGStrokeDashArray::Values(v) => {
let v = v.into_iter();
self.gecko.mContextFlags &= !CONTEXT_VALUE;
unsafe {
bindings::Gecko_nsStyleSVG_SetDashArrayLength(&mut self.gecko, v.len() as u32);
}
for (gecko, servo) in self.gecko.mStrokeDasharray.iter_mut().zip(v) {
match servo {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop) =>
gecko.set(lop),
SvgLengthOrPercentageOrNumber::Number(num) =>
gecko.set_value(CoordDataValue::Factor(num.into())),
}
}
}
SVGStrokeDashArray::ContextValue => {
self.gecko.mContextFlags |= CONTEXT_VALUE;
unsafe {
bindings::Gecko_nsStyleSVG_SetDashArrayLength(&mut self.gecko, 0);
}
}
}
}
pub fn copy_stroke_dasharray_from(&mut self, other: &Self) {
use gecko_bindings::structs::nsStyleSVG_STROKE_DASHARRAY_CONTEXT as CONTEXT_VALUE;
unsafe {
bindings::Gecko_nsStyleSVG_CopyDashArray(&mut self.gecko, &other.gecko);
}
self.gecko.mContextFlags =
(self.gecko.mContextFlags & !CONTEXT_VALUE) |
(other.gecko.mContextFlags & CONTEXT_VALUE);
}
pub fn reset_stroke_dasharray(&mut self, other: &Self) {
self.copy_stroke_dasharray_from(other)
}
pub fn clone_stroke_dasharray(&self) -> longhands::stroke_dasharray::computed_value::T {
use gecko_bindings::structs::nsStyleSVG_STROKE_DASHARRAY_CONTEXT as CONTEXT_VALUE;
use values::computed::LengthOrPercentage;
use values::generics::svg::{SVGStrokeDashArray, SvgLengthOrPercentageOrNumber};
if self.gecko.mContextFlags & CONTEXT_VALUE != 0 {
debug_assert_eq!(self.gecko.mStrokeDasharray.len(), 0);
return SVGStrokeDashArray::ContextValue;
}
let mut vec = vec![];
for gecko in self.gecko.mStrokeDasharray.iter() {
match gecko.as_value() {
CoordDataValue::Factor(number) =>
vec.push(SvgLengthOrPercentageOrNumber::Number(number.into())),
CoordDataValue::Coord(coord) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Length(Au(coord).into()).into())),
CoordDataValue::Percent(p) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Percentage(Percentage(p)).into())),
CoordDataValue::Calc(calc) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::Calc(calc.into()).into())),
_ => unreachable!(),
}
}
SVGStrokeDashArray::Values(vec)
}
#[allow(non_snake_case)]
pub fn set__moz_context_properties<I>(&mut self, v: I)
where I: IntoIterator<Item = longhands::_moz_context_properties::computed_value::single_value::T>,
I::IntoIter: ExactSizeIterator
{
let v = v.into_iter();
unsafe {
bindings::Gecko_nsStyleSVG_SetContextPropertiesLength(&mut self.gecko, v.len() as u32);
}
self.gecko.mContextPropsBits = 0;
for (gecko, servo) in self.gecko.mContextProps.iter_mut().zip(v) {
if (servo.0).0 == atom!("fill") {
self.gecko.mContextPropsBits |= structs::NS_STYLE_CONTEXT_PROPERTY_FILL as u8;
} else if (servo.0).0 == atom!("stroke") {
self.gecko.mContextPropsBits |= structs::NS_STYLE_CONTEXT_PROPERTY_STROKE as u8;
} else if (servo.0).0 == atom!("fill-opacity") {
self.gecko.mContextPropsBits |= structs::NS_STYLE_CONTEXT_PROPERTY_FILL_OPACITY as u8;
} else if (servo.0).0 == atom!("stroke-opacity") {
self.gecko.mContextPropsBits |= structs::NS_STYLE_CONTEXT_PROPERTY_STROKE_OPACITY as u8;
}
gecko.mRawPtr = (servo.0).0.into_addrefed();
}
}
#[allow(non_snake_case)]
pub fn copy__moz_context_properties_from(&mut self, other: &Self) {
unsafe {
bindings::Gecko_nsStyleSVG_CopyContextProperties(&mut self.gecko, &other.gecko);
}
}
#[allow(non_snake_case)]
pub fn reset__moz_context_properties(&mut self, other: &Self) {
self.copy__moz_context_properties_from(other)
}
</%self:impl_trait>
<%self:impl_trait style_struct_name="Color"
skip_longhands="*">
pub fn set_color(&mut self, v: longhands::color::computed_value::T) {
let result = convert_rgba_to_nscolor(&v);
${set_gecko_property("mColor", "result")}
}
<%call expr="impl_simple_copy('color', 'mColor')"></%call>
pub fn clone_color(&self) -> longhands::color::computed_value::T {
let color = ${get_gecko_property("mColor")} as u32;
convert_nscolor_to_rgba(color)
}
</%self:impl_trait>
<%self:impl_trait style_struct_name="Pointing"
skip_longhands="cursor caret-color">
pub fn set_cursor(&mut self, v: longhands::cursor::computed_value::T) {
use style_traits::cursor::CursorKind;
self.gecko.mCursor = match v.keyword {
CursorKind::Auto => structs::NS_STYLE_CURSOR_AUTO,
CursorKind::None => structs::NS_STYLE_CURSOR_NONE,
CursorKind::Default => structs::NS_STYLE_CURSOR_DEFAULT,
CursorKind::Pointer => structs::NS_STYLE_CURSOR_POINTER,
CursorKind::ContextMenu => structs::NS_STYLE_CURSOR_CONTEXT_MENU,
CursorKind::Help => structs::NS_STYLE_CURSOR_HELP,
CursorKind::Progress => structs::NS_STYLE_CURSOR_SPINNING,
CursorKind::Wait => structs::NS_STYLE_CURSOR_WAIT,
CursorKind::Cell => structs::NS_STYLE_CURSOR_CELL,
CursorKind::Crosshair => structs::NS_STYLE_CURSOR_CROSSHAIR,
CursorKind::Text => structs::NS_STYLE_CURSOR_TEXT,
CursorKind::VerticalText => structs::NS_STYLE_CURSOR_VERTICAL_TEXT,
CursorKind::Alias => structs::NS_STYLE_CURSOR_ALIAS,
CursorKind::Copy => structs::NS_STYLE_CURSOR_COPY,
CursorKind::Move => structs::NS_STYLE_CURSOR_MOVE,
CursorKind::NoDrop => structs::NS_STYLE_CURSOR_NO_DROP,
CursorKind::NotAllowed => structs::NS_STYLE_CURSOR_NOT_ALLOWED,
CursorKind::Grab => structs::NS_STYLE_CURSOR_GRAB,
CursorKind::Grabbing => structs::NS_STYLE_CURSOR_GRABBING,
CursorKind::EResize => structs::NS_STYLE_CURSOR_E_RESIZE,
CursorKind::NResize => structs::NS_STYLE_CURSOR_N_RESIZE,
CursorKind::NeResize => structs::NS_STYLE_CURSOR_NE_RESIZE,
CursorKind::NwResize => structs::NS_STYLE_CURSOR_NW_RESIZE,
CursorKind::SResize => structs::NS_STYLE_CURSOR_S_RESIZE,
CursorKind::SeResize => structs::NS_STYLE_CURSOR_SE_RESIZE,
CursorKind::SwResize => structs::NS_STYLE_CURSOR_SW_RESIZE,
CursorKind::WResize => structs::NS_STYLE_CURSOR_W_RESIZE,
CursorKind::EwResize => structs::NS_STYLE_CURSOR_EW_RESIZE,
CursorKind::NsResize => structs::NS_STYLE_CURSOR_NS_RESIZE,
CursorKind::NeswResize => structs::NS_STYLE_CURSOR_NESW_RESIZE,
CursorKind::NwseResize => structs::NS_STYLE_CURSOR_NWSE_RESIZE,
CursorKind::ColResize => structs::NS_STYLE_CURSOR_COL_RESIZE,
CursorKind::RowResize => structs::NS_STYLE_CURSOR_ROW_RESIZE,
CursorKind::AllScroll => structs::NS_STYLE_CURSOR_ALL_SCROLL,
CursorKind::ZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
CursorKind::ZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
// note: the following properties are gecko-only.
CursorKind::MozGrab => structs::NS_STYLE_CURSOR_GRAB,
CursorKind::MozGrabbing => structs::NS_STYLE_CURSOR_GRABBING,
CursorKind::MozZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
CursorKind::MozZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
} as u8;
unsafe {
Gecko_SetCursorArrayLength(&mut self.gecko, v.images.len());
}
for i in 0..v.images.len() {
unsafe {
Gecko_SetCursorImageValue(&mut self.gecko.mCursorImages[i],
v.images[i].url.clone().image_value.unwrap().get());
}
// We don't need to record this struct as uncacheable, like when setting
// background-image to a url() value, since only properties in reset structs
// are re-used from the applicable declaration cache, and the Pointing struct
// is an inherited struct.
match v.images[i].hotspot {
Some((x, y)) => {
self.gecko.mCursorImages[i].mHaveHotspot = true;
self.gecko.mCursorImages[i].mHotspotX = x;
self.gecko.mCursorImages[i].mHotspotY = y;
},
_ => {
self.gecko.mCursorImages[i].mHaveHotspot = false;
}
}
}
}
pub fn copy_cursor_from(&mut self, other: &Self) {
self.gecko.mCursor = other.gecko.mCursor;
unsafe {
Gecko_CopyCursorArrayFrom(&mut self.gecko, &other.gecko);
}
}
pub fn reset_cursor(&mut self, other: &Self) {
self.copy_cursor_from(other)
}
pub fn clone_cursor(&self) -> longhands::cursor::computed_value::T {
use values::computed::pointing::CursorImage;
use style_traits::cursor::CursorKind;
use values::specified::url::SpecifiedUrl;
let keyword = match self.gecko.mCursor as u32 {
structs::NS_STYLE_CURSOR_AUTO => CursorKind::Auto,
structs::NS_STYLE_CURSOR_NONE => CursorKind::None,
structs::NS_STYLE_CURSOR_DEFAULT => CursorKind::Default,
structs::NS_STYLE_CURSOR_POINTER => CursorKind::Pointer,
structs::NS_STYLE_CURSOR_CONTEXT_MENU => CursorKind::ContextMenu,
structs::NS_STYLE_CURSOR_HELP => CursorKind::Help,
structs::NS_STYLE_CURSOR_SPINNING => CursorKind::Progress,
structs::NS_STYLE_CURSOR_WAIT => CursorKind::Wait,
structs::NS_STYLE_CURSOR_CELL => CursorKind::Cell,
structs::NS_STYLE_CURSOR_CROSSHAIR => CursorKind::Crosshair,
structs::NS_STYLE_CURSOR_TEXT => CursorKind::Text,
structs::NS_STYLE_CURSOR_VERTICAL_TEXT => CursorKind::VerticalText,
structs::NS_STYLE_CURSOR_ALIAS => CursorKind::Alias,
structs::NS_STYLE_CURSOR_COPY => CursorKind::Copy,
structs::NS_STYLE_CURSOR_MOVE => CursorKind::Move,
structs::NS_STYLE_CURSOR_NO_DROP => CursorKind::NoDrop,
structs::NS_STYLE_CURSOR_NOT_ALLOWED => CursorKind::NotAllowed,
structs::NS_STYLE_CURSOR_GRAB => CursorKind::Grab,
structs::NS_STYLE_CURSOR_GRABBING => CursorKind::Grabbing,
structs::NS_STYLE_CURSOR_E_RESIZE => CursorKind::EResize,
structs::NS_STYLE_CURSOR_N_RESIZE => CursorKind::NResize,
structs::NS_STYLE_CURSOR_NE_RESIZE => CursorKind::NeResize,
structs::NS_STYLE_CURSOR_NW_RESIZE => CursorKind::NwResize,
structs::NS_STYLE_CURSOR_S_RESIZE => CursorKind::SResize,
structs::NS_STYLE_CURSOR_SE_RESIZE => CursorKind::SeResize,
structs::NS_STYLE_CURSOR_SW_RESIZE => CursorKind::SwResize,
structs::NS_STYLE_CURSOR_W_RESIZE => CursorKind::WResize,
structs::NS_STYLE_CURSOR_EW_RESIZE => CursorKind::EwResize,
structs::NS_STYLE_CURSOR_NS_RESIZE => CursorKind::NsResize,
structs::NS_STYLE_CURSOR_NESW_RESIZE => CursorKind::NeswResize,
structs::NS_STYLE_CURSOR_NWSE_RESIZE => CursorKind::NwseResize,
structs::NS_STYLE_CURSOR_COL_RESIZE => CursorKind::ColResize,
structs::NS_STYLE_CURSOR_ROW_RESIZE => CursorKind::RowResize,
structs::NS_STYLE_CURSOR_ALL_SCROLL => CursorKind::AllScroll,
structs::NS_STYLE_CURSOR_ZOOM_IN => CursorKind::ZoomIn,
structs::NS_STYLE_CURSOR_ZOOM_OUT => CursorKind::ZoomOut,
_ => panic!("Found unexpected value in style struct for cursor property"),
};
let images = self.gecko.mCursorImages.iter().map(|gecko_cursor_image| {
let url = unsafe {
let gecko_image_request = gecko_cursor_image.mImage.mRawPtr.as_ref().unwrap();
SpecifiedUrl::from_image_request(&gecko_image_request)
.expect("mCursorImages.mImage could not convert to SpecifiedUrl")
};
let hotspot =
if gecko_cursor_image.mHaveHotspot {
Some((gecko_cursor_image.mHotspotX, gecko_cursor_image.mHotspotY))
} else {
None
};
CursorImage { url, hotspot }
}).collect::<Vec<_>>().into_boxed_slice();
longhands::cursor::computed_value::T { images, keyword }
}
<%call expr="impl_color('caret_color', 'mCaretColor')"></%call>
</%self:impl_trait>
<%self:impl_trait style_struct_name="Column"
skip_longhands="column-count column-rule-width">
#[allow(unused_unsafe)]
pub fn set_column_count(&mut self, v: longhands::column_count::computed_value::T) {
use gecko_bindings::structs::{NS_STYLE_COLUMN_COUNT_AUTO, nsStyleColumn_kMaxColumnCount};
self.gecko.mColumnCount = match v {
Either::First(integer) => unsafe {
cmp::min(integer.0 as u32, nsStyleColumn_kMaxColumnCount)
},
Either::Second(Auto) => NS_STYLE_COLUMN_COUNT_AUTO
};
}
${impl_simple_copy('column_count', 'mColumnCount')}
pub fn clone_column_count(&self) -> longhands::column_count::computed_value::T {
use gecko_bindings::structs::{NS_STYLE_COLUMN_COUNT_AUTO, nsStyleColumn_kMaxColumnCount};
if self.gecko.mColumnCount != NS_STYLE_COLUMN_COUNT_AUTO {
debug_assert!(self.gecko.mColumnCount >= 1 &&
self.gecko.mColumnCount <= nsStyleColumn_kMaxColumnCount);
Either::First((self.gecko.mColumnCount as i32).into())
} else {
Either::Second(Auto)
}
}
<% impl_non_negative_length("column_rule_width", "mColumnRuleWidth",
round_to_pixels=True) %>
</%self:impl_trait>
<%self:impl_trait style_struct_name="Counters"
skip_longhands="content counter-increment counter-reset">
pub fn ineffective_content_property(&self) -> bool {
self.gecko.mContents.is_empty()
}
pub fn set_content(&mut self, v: longhands::content::computed_value::T, device: &Device) {
use properties::longhands::content::computed_value::T;
use properties::longhands::content::computed_value::ContentItem;
use values::generics::CounterStyleOrNone;
use gecko_bindings::structs::nsStyleContentData;
use gecko_bindings::structs::nsStyleContentType;
use gecko_bindings::structs::nsStyleContentType::*;
use gecko_bindings::bindings::Gecko_ClearAndResizeStyleContents;
// Converts a string as utf16, and returns an owned, zero-terminated raw buffer.
fn as_utf16_and_forget(s: &str) -> *mut u16 {
use std::mem;
let mut vec = s.encode_utf16().collect::<Vec<_>>();
vec.push(0u16);
let ptr = vec.as_mut_ptr();
mem::forget(vec);
ptr
}
fn set_counter_function(data: &mut nsStyleContentData,
content_type: nsStyleContentType,
name: &str, sep: &str,
style: CounterStyleOrNone, device: &Device) {
debug_assert!(content_type == eStyleContentType_Counter ||
content_type == eStyleContentType_Counters);
let counter_func = unsafe {
bindings::Gecko_SetCounterFunction(data, content_type).as_mut().unwrap()
};
counter_func.mIdent.assign_utf8(name);
if content_type == eStyleContentType_Counters {
counter_func.mSeparator.assign_utf8(sep);
}
style.to_gecko_value(&mut counter_func.mCounterStyle, device);
}
match v {
T::None |
T::Normal => {
// Ensure destructors run, otherwise we could leak.
if !self.gecko.mContents.is_empty() {
unsafe {
Gecko_ClearAndResizeStyleContents(&mut self.gecko, 0);
}
}
},
T::MozAltContent => {
unsafe {
Gecko_ClearAndResizeStyleContents(&mut self.gecko, 1);
*self.gecko.mContents[0].mContent.mString.as_mut() = ptr::null_mut();
}
self.gecko.mContents[0].mType = eStyleContentType_AltContent;
},
T::Items(items) => {
unsafe {
Gecko_ClearAndResizeStyleContents(&mut self.gecko,
items.len() as u32);
}
for (i, item) in items.into_iter().enumerate() {
// NB: Gecko compares the mString value if type is not image
// or URI independently of whatever gets there. In the quote
// cases, they set it to null, so do the same here.
unsafe {
*self.gecko.mContents[i].mContent.mString.as_mut() = ptr::null_mut();
}
match item {
ContentItem::String(value) => {
self.gecko.mContents[i].mType = eStyleContentType_String;
unsafe {
// NB: we share allocators, so doing this is fine.
*self.gecko.mContents[i].mContent.mString.as_mut() =
as_utf16_and_forget(&value);
}
}
ContentItem::Attr(attr) => {
self.gecko.mContents[i].mType = eStyleContentType_Attr;
let s = if let Some((_, ns)) = attr.namespace {
format!("{}|{}", ns, attr.attribute)
} else {
attr.attribute.into()
};
unsafe {
// NB: we share allocators, so doing this is fine.
*self.gecko.mContents[i].mContent.mString.as_mut() =
as_utf16_and_forget(&s);
}
}
ContentItem::OpenQuote
=> self.gecko.mContents[i].mType = eStyleContentType_OpenQuote,
ContentItem::CloseQuote
=> self.gecko.mContents[i].mType = eStyleContentType_CloseQuote,
ContentItem::NoOpenQuote
=> self.gecko.mContents[i].mType = eStyleContentType_NoOpenQuote,
ContentItem::NoCloseQuote
=> self.gecko.mContents[i].mType = eStyleContentType_NoCloseQuote,
ContentItem::Counter(name, style) => {
set_counter_function(&mut self.gecko.mContents[i],
eStyleContentType_Counter, &name, "", style, device);
}
ContentItem::Counters(name, sep, style) => {
set_counter_function(&mut self.gecko.mContents[i],
eStyleContentType_Counters, &name, &sep, style, device);
}
ContentItem::Url(ref url) => {
unsafe {
bindings::Gecko_SetContentDataImageValue(&mut self.gecko.mContents[i],
url.image_value.clone().unwrap().get())
}
}
}
}
}
}
}
pub fn copy_content_from(&mut self, other: &Self) {
use gecko_bindings::bindings::Gecko_CopyStyleContentsFrom;
unsafe {
Gecko_CopyStyleContentsFrom(&mut self.gecko, &other.gecko)
}
}
pub fn reset_content(&mut self, other: &Self) {
self.copy_content_from(other)
}
pub fn clone_content(&self) -> longhands::content::computed_value::T {
use gecko::conversions::string_from_chars_pointer;
use gecko_bindings::structs::nsStyleContentType::*;
use properties::longhands::content::computed_value::{T, ContentItem};
use values::Either;
use values::generics::CounterStyleOrNone;
use values::specified::url::SpecifiedUrl;
use values::specified::Attr;
if self.gecko.mContents.is_empty() {
return T::Normal;
}
if self.gecko.mContents.len() == 1 &&
self.gecko.mContents[0].mType == eStyleContentType_AltContent {
return T::MozAltContent;
}
T::Items(
self.gecko.mContents.iter().map(|gecko_content| {
match gecko_content.mType {
eStyleContentType_OpenQuote => ContentItem::OpenQuote,
eStyleContentType_CloseQuote => ContentItem::CloseQuote,
eStyleContentType_NoOpenQuote => ContentItem::NoOpenQuote,
eStyleContentType_NoCloseQuote => ContentItem::NoCloseQuote,
eStyleContentType_String => {
let gecko_chars = unsafe { gecko_content.mContent.mString.as_ref() };
let string = unsafe { string_from_chars_pointer(*gecko_chars) };
ContentItem::String(string)
},
eStyleContentType_Attr => {
let gecko_chars = unsafe { gecko_content.mContent.mString.as_ref() };
let string = unsafe { string_from_chars_pointer(*gecko_chars) };
let (namespace, attribute) =
match string.find('|') {
None => (None, string),
Some(index) => {
let (_, val) = string.split_at(index);
// FIXME: We should give NamespaceId as well to make Attr
// struct. However, there is no field for it in Gecko.
debug_assert!(false, "Attr with namespace does not support yet");
(None, val.to_string())
}
};
ContentItem::Attr(Attr { namespace, attribute })
},
eStyleContentType_Counter | eStyleContentType_Counters => {
let gecko_function =
unsafe { &**gecko_content.mContent.mCounters.as_ref() };
let ident = gecko_function.mIdent.to_string();
let style =
CounterStyleOrNone::from_gecko_value(&gecko_function.mCounterStyle);
let style = match style {
Either::First(counter_style) => counter_style,
Either::Second(_) =>
unreachable!("counter function shouldn't have single string type"),
};
if gecko_content.mType == eStyleContentType_Counter {
ContentItem::Counter(ident, style)
} else {
let separator = gecko_function.mSeparator.to_string();
ContentItem::Counters(ident, separator, style)
}
},
eStyleContentType_Image => {
unsafe {
let gecko_image_request =
&**gecko_content.mContent.mImage.as_ref();
ContentItem::Url(
SpecifiedUrl::from_image_request(gecko_image_request)
.expect("mContent could not convert to SpecifiedUrl")
)
}
},
_ => panic!("Found unexpected value in style struct for content property"),
}
}).collect()
)
}
% for counter_property in ["Increment", "Reset"]:
pub fn set_counter_${counter_property.lower()}(
&mut self,
v: longhands::counter_${counter_property.lower()}::computed_value::T
) {
unsafe {
bindings::Gecko_ClearAndResizeCounter${counter_property}s(&mut self.gecko,
v.get_values().len() as u32);
for (i, &(ref name, value)) in v.get_values().into_iter().enumerate() {
self.gecko.m${counter_property}s[i].mCounter.assign(name.0.as_slice());
self.gecko.m${counter_property}s[i].mValue = value;
}
}
}
pub fn copy_counter_${counter_property.lower()}_from(&mut self, other: &Self) {
unsafe {
bindings::Gecko_CopyCounter${counter_property}sFrom(&mut self.gecko, &other.gecko)
}
}
pub fn reset_counter_${counter_property.lower()}(&mut self, other: &Self) {
self.copy_counter_${counter_property.lower()}_from(other)
}
pub fn clone_counter_${counter_property.lower()}(
&self
) -> longhands::counter_${counter_property.lower()}::computed_value::T {
use values::CustomIdent;
use gecko_string_cache::Atom;
longhands::counter_${counter_property.lower()}::computed_value::T::new(
self.gecko.m${counter_property}s.iter().map(|ref gecko_counter| {
(CustomIdent(Atom::from(gecko_counter.mCounter.to_string())), gecko_counter.mValue)
}).collect()
)
}
% endfor
</%self:impl_trait>
<%self:impl_trait style_struct_name="UI" skip_longhands="-moz-force-broken-image-icon">
${impl_simple_type_with_conversion("_moz_force_broken_image_icon", "mForceBrokenImageIcon")}
</%self:impl_trait>
<%self:impl_trait style_struct_name="XUL"
skip_longhands="-moz-box-ordinal-group">
#[allow(non_snake_case)]
pub fn set__moz_box_ordinal_group(&mut self, v: i32) {
self.gecko.mBoxOrdinal = v as u32;
}
${impl_simple_copy("_moz_box_ordinal_group", "mBoxOrdinal")}
#[allow(non_snake_case)]
pub fn clone__moz_box_ordinal_group(&self) -> i32 {
self.gecko.mBoxOrdinal as i32
}
</%self:impl_trait>
% for style_struct in data.style_structs:
${declare_style_struct(style_struct)}
${impl_style_struct(style_struct)}
% endfor<｜fim▁end｜> | pub fn set_${ident}(&mut self, other: values::computed::Transform) { |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜># Copyright 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import inspect
import os
import re
import urlparse
_next_page_id = 0
class Page(object):
def __init__(self, url, page_set=None, base_dir=None, name=''):
self._url = url
self._page_set = page_set
# Default value of base_dir is the directory of the file that defines the
# class of this page instance.
if base_dir is None:
base_dir = os.path.dirname(inspect.getfile(self.__class__))
self._base_dir = base_dir
self._name = name
global _next_page_id
self._id = _next_page_id
_next_page_id += 1
# These attributes can be set dynamically by the page.
self.synthetic_delays = dict()<｜fim▁hole｜> self.credentials = None
self.disabled = False
self.skip_waits = False
self.script_to_evaluate_on_commit = None
self._SchemeErrorCheck()
def _SchemeErrorCheck(self):
if not self._scheme:
raise ValueError('Must prepend the URL with scheme (e.g. file://)')
if self.startup_url:
startup_url_scheme = urlparse.urlparse(self.startup_url).scheme
if not startup_url_scheme:
raise ValueError('Must prepend the URL with scheme (e.g. http://)')
if startup_url_scheme == 'file':
raise ValueError('startup_url with local file scheme is not supported')
def TransferToPageSet(self, another_page_set):
""" Transfer this page to another page set.
Args:
another_page_set: an instance of telemetry.page.PageSet to transfer this
page to.
Note:
This method removes this page instance from the pages list of its current
page_set, so one should be careful not to iterate through the list of
pages of a page_set and calling this method.
For example, the below loop is erroneous:
for p in page_set_A.pages:
p.TransferToPageSet(page_set_B.pages)
"""
assert self._page_set
if another_page_set is self._page_set:
return
self._page_set.pages.remove(self)
self._page_set = another_page_set
self._page_set.AddPage(self)
def RunNavigateSteps(self, action_runner):
action_runner.NavigateToPage(self)
def CanRunOnBrowser(self, browser_info):
"""Override this to returns whether this page can be run on specific
browser.
Args:
browser_info: an instance of telemetry.core.browser_info.BrowserInfo
"""
assert browser_info
return True
def AsDict(self):
"""Converts a page object to a dict suitable for JSON output."""
d = {
'id': self._id,
'url': self._url,
}
if self._name:
d['name'] = self._name
return d
@property
def page_set(self):
return self._page_set
@property
def name(self):
return self._name
@property
def url(self):
return self._url
@property
def id(self):
return self._id
def GetSyntheticDelayCategories(self):
result = []
for delay, options in self.synthetic_delays.items():
options = '%f;%s' % (options.get('target_duration', 0),
options.get('mode', 'static'))
result.append('DELAY(%s;%s)' % (delay, options))
return result
def __lt__(self, other):
return self.url < other.url
def __cmp__(self, other):
x = cmp(self.name, other.name)
if x != 0:
return x
return cmp(self.url, other.url)
def __str__(self):
return self.url
def AddCustomizeBrowserOptions(self, options):
""" Inherit page overrides this to add customized browser options."""
pass
@property
def _scheme(self):
return urlparse.urlparse(self.url).scheme
@property
def is_file(self):
"""Returns True iff this URL points to a file."""
return self._scheme == 'file'
@property
def is_local(self):
"""Returns True iff this URL is local. This includes chrome:// URLs."""
return self._scheme in ['file', 'chrome', 'about']
@property
def file_path(self):
"""Returns the path of the file, stripping the scheme and query string."""
assert self.is_file
# Because ? is a valid character in a filename,
# we have to treat the url as a non-file by removing the scheme.
parsed_url = urlparse.urlparse(self.url[7:])
return os.path.normpath(os.path.join(
self._base_dir, parsed_url.netloc + parsed_url.path))
@property
def file_path_url(self):
"""Returns the file path, including the params, query, and fragment."""
assert self.is_file
file_path_url = os.path.normpath(os.path.join(self._base_dir, self.url[7:]))
# Preserve trailing slash or backslash.
# It doesn't matter in a file path, but it does matter in a URL.
if self.url.endswith('/'):
file_path_url += os.sep
return file_path_url
@property
def serving_dir(self):
file_path = os.path.realpath(self.file_path)
if os.path.isdir(file_path):
return file_path
else:
return os.path.dirname(file_path)
@property
def file_safe_name(self):
"""A version of display_name that's safe to use as a filename."""
# Just replace all special characters in the url with underscore.
return re.sub('[^a-zA-Z0-9]', '_', self.display_name)
@property
def display_name(self):
if self.name:
return self.name
if not self.is_file:
return self.url
all_urls = [p.url.rstrip('/') for p in self.page_set if p.is_file]
common_prefix = os.path.dirname(os.path.commonprefix(all_urls))
return self.url[len(common_prefix):].strip('/')
@property
def archive_path(self):
return self.page_set.WprFilePathForPage(self)<｜fim▁end｜> | self.startup_url = page_set.startup_url if page_set else '' |
<|file_name|>gulpfile.js<|end_file_name|><｜fim▁begin｜>/**
*
* Web Starter Kit
* Copyright 2014 Google Inc. 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
*
*/
'use strict';
// Include Gulp & Tools We'll Use
var gulp = require('gulp');
var $ = require('gulp-load-plugins')();
var del = require('del');
var runSequence = require('run-sequence');
var browserSync = require('browser-sync');
var reload = browserSync.reload;
// Clean Output Directory
gulp.task('clean', del.bind(null, ['./index.js', './assertRank.js', './specs.js']));
gulp.task('es6', ['clean'], function () {
return gulp.src(['./src/**/*.js'])
// .pipe($.sourcemaps.init({loadMaps: true}))
.pipe($['6to5']()).on('error', console.error.bind(console))
// .pipe($.sourcemaps.write())
.pipe(gulp.dest('.'))
.pipe($.size({title: 'es6'}))
})
gulp.task('browserify', ['es6'], function () {
return gulp.src(['./specs.js'])
.pipe($.browserify({debug: false}))
.pipe(gulp.dest('.'))
.pipe($.size({title: 'browserify'}))
})
// Watch Files For Changes & Reload<｜fim▁hole｜> browserSync({
notify: false, browser: 'skip', ghostMode: false,
// Customize the BrowserSync console logging prefix
logPrefix: 'WSK',
port: 3010,
// Run as an https by uncommenting 'https: true'
// Note: this uses an unsigned certificate which on first access
// will present a certificate warning in the browser.
// https: true,
server: ['.', 'src']
});
gulp.watch(['gulpfile.js'], process.exit)
gulp.watch(['./src/**/*.{js,html}'], ['browserify', reload]);
});
gulp.task('default', ['es6'])
// Load custom tasks from the `tasks` directory
// try { require('require-dir')('tasks'); } catch (err) { console.error(err); }<｜fim▁end｜> | gulp.task('serve', ['browserify'], function () { |
<|file_name|>base.py<|end_file_name|><｜fim▁begin｜>from django import http
from django.contrib.messages import constants, get_level, set_level, utils
from django.contrib.messages.api import MessageFailure
from django.contrib.messages.constants import DEFAULT_LEVELS
from django.contrib.messages.storage import base, default_storage
from django.contrib.messages.storage.base import Message
from django.test import modify_settings, override_settings
from django.urls import reverse
from django.utils.translation import gettext_lazy
def add_level_messages(storage):
"""
Add 6 messages from different levels (including a custom one) to a storage
instance.
"""
storage.add(constants.INFO, 'A generic info message')
storage.add(29, 'Some custom level')
storage.add(constants.DEBUG, 'A debugging message', extra_tags='extra-tag')
storage.add(constants.WARNING, 'A warning')
storage.add(constants.ERROR, 'An error')
storage.add(constants.SUCCESS, 'This was a triumph.')
class override_settings_tags(override_settings):
def enable(self):
super().enable()
# LEVEL_TAGS is a constant defined in the
# django.contrib.messages.storage.base module, so after changing
# settings.MESSAGE_TAGS, update that constant also.
self.old_level_tags = base.LEVEL_TAGS
base.LEVEL_TAGS = utils.get_level_tags()
def disable(self):
super().disable()
base.LEVEL_TAGS = self.old_level_tags
class BaseTests:
storage_class = default_storage
levels = {
'debug': constants.DEBUG,
'info': constants.INFO,
'success': constants.SUCCESS,
'warning': constants.WARNING,
'error': constants.ERROR,
}
def setUp(self):
self.settings_override = override_settings_tags(
TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': (
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
),
},
}],
ROOT_URLCONF='messages_tests.urls',
MESSAGE_TAGS='',
MESSAGE_STORAGE='%s.%s' % (self.storage_class.__module__, self.storage_class.__name__),
SESSION_SERIALIZER='django.contrib.sessions.serializers.JSONSerializer',
)
self.settings_override.enable()
def tearDown(self):
self.settings_override.disable()
def get_request(self):
return http.HttpRequest()
def get_response(self):
return http.HttpResponse()
def get_storage(self, data=None):
"""
Return the storage backend, setting its loaded data to the ``data``
argument.
This method avoids the storage ``_get`` method from getting called so
that other parts of the storage backend can be tested independent of
the message retrieval logic.
"""
storage = self.storage_class(self.get_request())
storage._loaded_data = data or []
return storage
def test_add(self):
storage = self.get_storage()
self.assertFalse(storage.added_new)
storage.add(constants.INFO, 'Test message 1')
self.assertTrue(storage.added_new)
storage.add(constants.INFO, 'Test message 2', extra_tags='tag')
self.assertEqual(len(storage), 2)
def test_add_lazy_translation(self):
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, gettext_lazy('lazy message'))
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 1)
def test_no_update(self):
storage = self.get_storage()
response = self.get_response()
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 0)
def test_add_update(self):
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, 'Test message 1')
storage.add(constants.INFO, 'Test message 1', extra_tags='tag')
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 2)
def test_existing_add_read_update(self):
storage = self.get_existing_storage()
response = self.get_response()
storage.add(constants.INFO, 'Test message 3')
list(storage) # Simulates a read
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 0)
def test_existing_read_add_update(self):
storage = self.get_existing_storage()
response = self.get_response()
list(storage) # Simulates a read
storage.add(constants.INFO, 'Test message 3')
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 1)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_full_request_response_cycle(self):
"""
With the message middleware enabled, messages are properly stored and
retrieved across the full request/redirect/response cycle.
"""
data = {
'messages': ['Test message %d' % x for x in range(5)],
}
show_url = reverse('show_message')
for level in ('debug', 'info', 'success', 'warning', 'error'):
add_url = reverse('add_message', args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertIn('messages', response.context)
messages = [Message(self.levels[level], msg) for msg in data['messages']]
self.assertEqual(list(response.context['messages']), messages)
for msg in data['messages']:
self.assertContains(response, msg)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_with_template_response(self):
data = {
'messages': ['Test message %d' % x for x in range(5)],
}
show_url = reverse('show_template_response')
for level in self.levels.keys():
add_url = reverse('add_template_response', args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertIn('messages', response.context)
for msg in data['messages']:
self.assertContains(response, msg)
# there shouldn't be any messages on second GET request
response = self.client.get(show_url)
for msg in data['messages']:
self.assertNotContains(response, msg)
def test_context_processor_message_levels(self):
show_url = reverse('show_template_response')
response = self.client.get(show_url)
self.assertIn('DEFAULT_MESSAGE_LEVELS', response.context)
self.assertEqual(response.context['DEFAULT_MESSAGE_LEVELS'], DEFAULT_LEVELS)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_multiple_posts(self):
"""
Messages persist properly when multiple POSTs are made before a GET.
"""
data = {
'messages': ['Test message %d' % x for x in range(5)],
}
show_url = reverse('show_message')
messages = []
for level in ('debug', 'info', 'success', 'warning', 'error'):
messages.extend(Message(self.levels[level], msg) for msg in data['messages'])
add_url = reverse('add_message', args=(level,))
self.client.post(add_url, data)
response = self.client.get(show_url)
self.assertIn('messages', response.context)
self.assertEqual(list(response.context['messages']), messages)
for msg in data['messages']:
self.assertContains(response, msg)
@modify_settings(
INSTALLED_APPS={'remove': 'django.contrib.messages'},
MIDDLEWARE={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
)
@override_settings(
MESSAGE_LEVEL=constants.DEBUG,
TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
}],
)
def test_middleware_disabled(self):
"""
When the middleware is disabled, an exception is raised when one
attempts to store a message.
"""
data = {
'messages': ['Test message %d' % x for x in range(5)],
}
reverse('show_message')
for level in ('debug', 'info', 'success', 'warning', 'error'):
add_url = reverse('add_message', args=(level,))
with self.assertRaises(MessageFailure):
self.client.post(add_url, data, follow=True)
@modify_settings(
INSTALLED_APPS={'remove': 'django.contrib.messages'},
MIDDLEWARE={'remove': 'django.contrib.messages.middleware.MessageMiddleware'},
)
@override_settings(
TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
}],
)
def test_middleware_disabled_fail_silently(self):
"""
When the middleware is disabled, an exception is not raised
if 'fail_silently' = True
"""
data = {
'messages': ['Test message %d' % x for x in range(5)],
'fail_silently': True,
}
show_url = reverse('show_message')
for level in ('debug', 'info', 'success', 'warning', 'error'):
add_url = reverse('add_message', args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertNotIn('messages', response.context)
def stored_messages_count(self, storage, response):
"""
Return the number of messages being stored after a
``storage.update()`` call.
"""
raise NotImplementedError('This method must be set by a subclass.')
def test_get(self):
raise NotImplementedError('This method must be set by a subclass.')
def get_existing_storage(self):
return self.get_storage([
Message(constants.INFO, 'Test message 1'),
Message(constants.INFO, 'Test message 2', extra_tags='tag'),
])
def test_existing_read(self):
"""
Reading the existing storage doesn't cause the data to be lost.<｜fim▁hole｜> # After iterating the storage engine directly, the used flag is set.
data = list(storage)
self.assertTrue(storage.used)
# The data does not disappear because it has been iterated.
self.assertEqual(data, list(storage))
def test_existing_add(self):
storage = self.get_existing_storage()
self.assertFalse(storage.added_new)
storage.add(constants.INFO, 'Test message 3')
self.assertTrue(storage.added_new)
def test_default_level(self):
# get_level works even with no storage on the request.
request = self.get_request()
self.assertEqual(get_level(request), constants.INFO)
# get_level returns the default level if it hasn't been set.
storage = self.get_storage()
request._messages = storage
self.assertEqual(get_level(request), constants.INFO)
# Only messages of sufficient level get recorded.
add_level_messages(storage)
self.assertEqual(len(storage), 5)
def test_low_level(self):
request = self.get_request()
storage = self.storage_class(request)
request._messages = storage
self.assertTrue(set_level(request, 5))
self.assertEqual(get_level(request), 5)
add_level_messages(storage)
self.assertEqual(len(storage), 6)
def test_high_level(self):
request = self.get_request()
storage = self.storage_class(request)
request._messages = storage
self.assertTrue(set_level(request, 30))
self.assertEqual(get_level(request), 30)
add_level_messages(storage)
self.assertEqual(len(storage), 2)
@override_settings(MESSAGE_LEVEL=29)
def test_settings_level(self):
request = self.get_request()
storage = self.storage_class(request)
self.assertEqual(get_level(request), 29)
add_level_messages(storage)
self.assertEqual(len(storage), 3)
def test_tags(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(tags, ['info', '', 'extra-tag debug', 'warning', 'error', 'success'])
def test_level_tag(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.level_tag for msg in storage]
self.assertEqual(tags, ['info', '', 'debug', 'warning', 'error', 'success'])
@override_settings_tags(MESSAGE_TAGS={
constants.INFO: 'info',
constants.DEBUG: '',
constants.WARNING: '',
constants.ERROR: 'bad',
29: 'custom',
})
def test_custom_tags(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(tags, ['info', 'custom', 'extra-tag', '', 'bad', 'success'])<｜fim▁end｜> | """
storage = self.get_existing_storage()
self.assertFalse(storage.used) |
<|file_name|>random.rs<|end_file_name|><｜fim▁begin｜>// The MIT License (MIT)
//
// Copyright (c) 2015 dinowernli<｜fim▁hole｜>// 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.
use rand::{Rng, SeedableRng, StdRng};
/// Basic random number generator (not necessarily cryptographically secure).
pub trait Random {
/// Returns a random number in the range [0, limit - 1].
fn next_modulo(&mut self, limit: u64) -> u64;
}
/// Default implementation of the Random trait.
pub struct RandomImpl {
generator: StdRng,
}
impl RandomImpl {
pub fn create(seed: usize) -> Self {
let seed_slice: &[_] = &[seed as usize];
return RandomImpl {
generator: SeedableRng::from_seed(seed_slice),
};
}
/// Returns a new random number generator seeded with the
/// next random number produced by this generator.
pub fn new_child(&mut self) -> Self {
return RandomImpl::create(self.next() as usize);
}
/// Returns a random number.
fn next(&mut self) -> u64 {
self.generator.gen::<u64>()
}
}
impl Random for RandomImpl {
fn next_modulo(&mut self, limit: u64) -> u64 {
return self.next() % limit;
}
}<｜fim▁end｜> | //
// Permission is hereby granted, free of charge, to any person obtaining a copy |
<|file_name|>ServerEventHandler.java<|end_file_name|><｜fim▁begin｜>/*******************************************************************************
* Copyright (c) 2012, 2015 Pivotal Software, Inc.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of 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.
*
* Contributors:
* Pivotal Software, Inc. - initial API and implementation
********************************************************************************/
package cn.dockerfoundry.ide.eclipse.server.core.internal;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import org.cloudfoundry.client.lib.domain.CloudService;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.wst.server.core.IModule;
import cn.dockerfoundry.ide.eclipse.server.core.internal.application.ModuleChangeEvent;
import cn.dockerfoundry.ide.eclipse.server.core.internal.client.CloudRefreshEvent;
/**
* Fires server refresh events. Only one handler is active per workbench runtime
* session.
*
*/
public class ServerEventHandler {
private static ServerEventHandler handler;
public static ServerEventHandler getDefault() {
if (handler == null) {
handler = new ServerEventHandler();
}
return handler;
}
private final List<CloudServerListener> applicationListeners = new CopyOnWriteArrayList<CloudServerListener>();
public synchronized void addServerListener(CloudServerListener listener) {
if (listener != null && !applicationListeners.contains(listener)) {
applicationListeners.add(listener);
}
}
public synchronized void removeServerListener(CloudServerListener listener) {
applicationListeners.remove(listener);<｜fim▁hole｜> public void fireServicesUpdated(DockerFoundryServer server, List<DockerApplicationService> services) {
fireServerEvent(new CloudRefreshEvent(server, null, CloudServerEvent.EVENT_UPDATE_SERVICES, services));
}
public void firePasswordUpdated(DockerFoundryServer server) {
fireServerEvent(new CloudServerEvent(server, CloudServerEvent.EVENT_UPDATE_PASSWORD));
}
public void fireServerRefreshed(DockerFoundryServer server) {
fireServerEvent(new CloudServerEvent(server, CloudServerEvent.EVENT_SERVER_REFRESHED));
}
public void fireAppInstancesChanged(DockerFoundryServer server, IModule module) {
fireServerEvent(new ModuleChangeEvent(server, CloudServerEvent.EVENT_INSTANCES_UPDATED, module,
Status.OK_STATUS));
}
public void fireApplicationRefreshed(DockerFoundryServer server, IModule module) {
fireServerEvent(new ModuleChangeEvent(server, CloudServerEvent.EVENT_APPLICATION_REFRESHED, module,
Status.OK_STATUS));
}
public void fireAppDeploymentChanged(DockerFoundryServer server, IModule module) {
fireServerEvent(new ModuleChangeEvent(server, CloudServerEvent.EVENT_APP_DEPLOYMENT_CHANGED, module,
Status.OK_STATUS));
}
public void fireError(DockerFoundryServer server, IModule module, IStatus status) {
fireServerEvent(new ModuleChangeEvent(server, CloudServerEvent.EVENT_CLOUD_OP_ERROR, module, status));
}
public synchronized void fireServerEvent(CloudServerEvent event) {
CloudServerListener[] listeners = applicationListeners.toArray(new CloudServerListener[0]);
for (CloudServerListener listener : listeners) {
listener.serverChanged(event);
}
}
}<｜fim▁end｜> | }
|
<|file_name|>XMLModelParserException.java<|end_file_name|><｜fim▁begin｜>/**
* This program and the accompanying materials
* are made available under the terms of the License
* which accompanies this distribution in the file LICENSE.txt
*/
package org.opengroup.archimate.xmlexchange;
/**
* XML Exception
*
* @author Phillip Beauvoir
*/
public class XMLModelParserException extends Exception {
public XMLModelParserException() {
super(Messages.XMLModelParserException_0);
}
public XMLModelParserException(String message) {
super(message);
}
public XMLModelParserException(String message, Throwable cause) {<｜fim▁hole｜><｜fim▁end｜> | super(message, cause);
}
} |
<|file_name|>MainActivity.java<|end_file_name|><｜fim▁begin｜>package com.jota.patterns.singleton;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.TextView;
import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;
import com.jota.patterns.singleton.singleton.User;
public class MainActivity extends AppCompatActivity {
@BindView(R.id.user1) TextView user1Text;
@BindView(R.id.user2) TextView user2Text;
@BindView(R.id.user3) TextView user3Text;
private User user, user1, user2, user3;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);<｜fim▁hole｜> ButterKnife.bind(this);
user = User.getInstance();
user.setToken("token");
user.setSocialNetwork("Facebook");
user1 = User.getInstance();
user2 = User.getInstance();
user3 = User.getInstance();
}
private void showUsers() {
user1Text.setText(user1.getSocialNetwork() + " - " + user1.getToken());
user2Text.setText(user2.getSocialNetwork() + " - " + user2.getToken());
user3Text.setText(user3.getSocialNetwork() + " - " + user3.getToken());
}
@OnClick(R.id.change_social_button) public void changeSocial() {
user.setSocialNetwork("Twitter");
showUsers();
}
@OnClick(R.id.change_token_button) public void changeToken() {
user.setToken("Token token");
showUsers();
}
}<｜fim▁end｜> | setContentView(R.layout.activity_main); |
<|file_name|>mod.rs<|end_file_name|><｜fim▁begin｜>pub use self::dependency::Dependency;
pub use self::features::{
enable_nightly_features, maybe_allow_nightly_features, nightly_features_allowed,
};
pub use self::features::{CliUnstable, Edition, Feature, Features};
pub use self::interning::InternedString;
pub use self::manifest::{EitherManifest, VirtualManifest};
pub use self::manifest::{LibKind, Manifest, Target, TargetKind};
pub use self::package::{Package, PackageSet};
pub use self::package_id::PackageId;
pub use self::package_id_spec::PackageIdSpec;
pub use self::registry::Registry;
pub use self::resolver::{Resolve, ResolveVersion};
pub use self::shell::{Shell, Verbosity};
pub use self::source::{GitReference, Source, SourceId, SourceMap};
pub use self::summary::{FeatureMap, FeatureValue, Summary};
pub use self::workspace::{Members, Workspace, WorkspaceConfig, WorkspaceRootConfig};
pub mod compiler;<｜fim▁hole｜>pub mod features;
mod interning;
pub mod manifest;
pub mod package;
pub mod package_id;
mod package_id_spec;
pub mod profiles;
pub mod registry;
pub mod resolver;
pub mod shell;
pub mod source;
pub mod summary;
mod workspace;<｜fim▁end｜> | pub mod dependency; |
<|file_name|>test_svn.py<|end_file_name|><｜fim▁begin｜># coding=utf-8
import os
import unittest
from hashlib import md5
from django.conf import settings
from djblets.testing.decorators import add_fixtures
from kgb import SpyAgency
from reviewboard.diffviewer.diffutils import patch
from reviewboard.diffviewer.testing.mixins import DiffParserTestingMixin
from reviewboard.scmtools.core import (Branch, Commit, Revision, HEAD,
PRE_CREATION)
from reviewboard.scmtools.errors import SCMError, FileNotFoundError
from reviewboard.scmtools.models import Repository, Tool
from reviewboard.scmtools.svn import SVNTool, recompute_svn_backend
from reviewboard.scmtools.svn.utils import (collapse_svn_keywords,
has_expanded_svn_keywords)
from reviewboard.scmtools.tests.testcases import SCMTestCase
from reviewboard.testing.testcase import TestCase
class _CommonSVNTestCase(DiffParserTestingMixin, SpyAgency, SCMTestCase):
"""Common unit tests for Subversion.
This is meant to be subclassed for each backend that wants to run
the common set of tests.
"""
backend = None
backend_name = None
fixtures = ['test_scmtools']
__test__ = False
def setUp(self):
super(_CommonSVNTestCase, self).setUp()
self._old_backend_setting = settings.SVNTOOL_BACKENDS
settings.SVNTOOL_BACKENDS = [self.backend]
recompute_svn_backend()
self.svn_repo_path = os.path.abspath(
os.path.join(os.path.dirname(__file__),
'..', 'testdata', 'svn_repo'))
self.svn_ssh_path = ('svn+ssh://localhost%s'
% self.svn_repo_path.replace('\\', '/'))
self.repository = Repository.objects.create(
name='Subversion SVN',
path='file://%s' % self.svn_repo_path,
tool=Tool.objects.get(name='Subversion'))
try:
self.tool = self.repository.get_scmtool()
except ImportError:
raise unittest.SkipTest('The %s backend could not be used. A '
'dependency may be missing.'
% self.backend)
assert self.tool.client.__class__.__module__ == self.backend
def tearDown(self):
super(_CommonSVNTestCase, self).tearDown()
settings.SVNTOOL_BACKENDS = self._old_backend_setting
recompute_svn_backend()
def shortDescription(self):
desc = super(_CommonSVNTestCase, self).shortDescription()
desc = desc.replace('<backend>', self.backend_name)
return desc
def test_get_repository_info(self):
"""Testing SVN (<backend>) get_repository_info"""
info = self.tool.get_repository_info()
self.assertIn('uuid', info)
self.assertIsInstance(info['uuid'], str)
self.assertEqual(info['uuid'], '41215d38-f5a5-421f-ba17-e0be11e6c705')
self.assertIn('root_url', info)
self.assertIsInstance(info['root_url'], str)
self.assertEqual(info['root_url'], self.repository.path)
self.assertIn('url', info)
self.assertIsInstance(info['url'], str)
self.assertEqual(info['url'], self.repository.path)
def test_ssh(self):
"""Testing SVN (<backend>) with a SSH-backed Subversion repository"""
self._test_ssh(self.svn_ssh_path, 'trunk/doc/misc-docs/Makefile')
def test_ssh_with_site(self):
"""Testing SVN (<backend>) with a SSH-backed Subversion repository
with a LocalSite
"""
self._test_ssh_with_site(self.svn_ssh_path,
'trunk/doc/misc-docs/Makefile')
def test_get_file(self):
"""Testing SVN (<backend>) get_file"""
tool = self.tool
expected = (b'include ../tools/Makefile.base-vars\n'
b'NAME = misc-docs\n'
b'OUTNAME = svn-misc-docs\n'
b'INSTALL_DIR = $(DESTDIR)/usr/share/doc/subversion\n'
b'include ../tools/Makefile.base-rules\n')
# There are 3 versions of this test in order to get 100% coverage of
# the svn module.
rev = Revision('2')
filename = 'trunk/doc/misc-docs/Makefile'
value = tool.get_file(filename, rev)
self.assertIsInstance(value, bytes)
self.assertEqual(value, expected)
value = tool.get_file('/%s' % filename, rev)
self.assertIsInstance(value, bytes)
self.assertEqual(value, expected)
value = tool.get_file('%s/%s' % (self.repository.path, filename), rev)
self.assertIsInstance(value, bytes)
self.assertEqual(value, expected)
with self.assertRaises(FileNotFoundError):
tool.get_file('')
def test_file_exists(self):
"""Testing SVN (<backend>) file_exists"""
tool = self.tool
self.assertTrue(tool.file_exists('trunk/doc/misc-docs/Makefile'))
self.assertFalse(tool.file_exists('trunk/doc/misc-docs/Makefile2'))
with self.assertRaises(FileNotFoundError):
tool.get_file('hello', PRE_CREATION)
def test_get_file_with_special_url_chars(self):
"""Testing SVN (<backend>) get_file with filename containing
characters that are special in URLs and repository path as a URI
"""
value = self.tool.get_file('trunk/crazy& ?#.txt', Revision('12'))
self.assertTrue(isinstance(value, bytes))
self.assertEqual(value, b'Lots of characters in this one.\n')
def test_file_exists_with_special_url_chars(self):
"""Testing SVN (<backend>) file_exists with filename containing
characters that are special in URLs
"""
self.assertTrue(self.tool.file_exists('trunk/crazy& ?#.txt',
Revision('12')))
# These should not crash. We'll be testing both file:// URLs
# (which fail for anything lower than ASCII code 32) and for actual
# URLs (which support all characters).
self.assertFalse(self.tool.file_exists('trunk/%s.txt' % ''.join(
chr(c)
for c in range(32, 128)
)))
self.tool.client.repopath = 'svn+ssh://localhost:0/svn'
try:
self.assertFalse(self.tool.file_exists('trunk/%s.txt' % ''.join(
chr(c)
for c in range(128)
)))
except SCMError:
# Couldn't connect. Valid result.
pass
def test_normalize_path_with_special_chars_and_remote_url(self):
"""Testing SVN (<backend>) normalize_path with special characters
and remote URL
"""
client = self.tool.client
client.repopath = 'svn+ssh://example.com/svn'
path = client.normalize_path(''.join(
chr(c)
for c in range(128)
))
# This URL was generated based on modified code that directly used
# Subversion's lookup take explicitly, ensuring we're getting the
# results we want from urllib.quote() and our list of safe characters.
self.assertEqual(
path,
"svn+ssh://example.com/svn/%00%01%02%03%04%05%06%07%08%09%0A"
"%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E"
"%1F%20!%22%23$%25&'()*+,-./0123456789:%3B%3C=%3E%3F@ABCDEFGH"
"IJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz"
"%7B%7C%7D~%7F")
def test_normalize_path_with_special_chars_and_file_url(self):
"""Testing SVN (<backend>) normalize_path with special characters
and local file:// URL
"""
client = self.tool.client
client.repopath = 'file:///tmp/svn'
path = client.normalize_path(''.join(
chr(c)
for c in range(32, 128)
))
# This URL was generated based on modified code that directly used
# Subversion's lookup take explicitly, ensuring we're getting the
# results we want from urllib.quote() and our list of safe characters.
self.assertEqual(
path,
"file:///tmp/svn/%20!%22%23$%25&'()*+,-./0123456789:%3B%3C=%3E"
"%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmno"
"pqrstuvwxyz%7B%7C%7D~%7F")
# This should provide a reasonable error for each code in 0..32.
for i in range(32):
c = chr(i)
message = (
'Invalid character code %s found in path %r.'
% (i, c)
)
with self.assertRaisesMessage(SCMError, message):
client.normalize_path(c)
def test_normalize_path_with_absolute_repo_path(self):
"""Testing SVN (<backend>) normalize_path with absolute path"""
client = self.tool.client
client.repopath = '/var/lib/svn'
path = '/var/lib/svn/foo/bar'
self.assertEqual(client.normalize_path(path), path)
client.repopath = 'svn+ssh://example.com/svn/'
path = 'svn+ssh://example.com/svn/foo/bar'
self.assertEqual(client.normalize_path(path), path)
def test_normalize_path_with_rel_path(self):
"""Testing SVN (<backend>) normalize_path with relative path"""
client = self.tool.client
client.repopath = 'svn+ssh://example.com/svn'
self.assertEqual(client.normalize_path('foo/bar'),
'svn+ssh://example.com/svn/foo/bar')
self.assertEqual(client.normalize_path('/foo/bar'),
'svn+ssh://example.com/svn/foo/bar')
self.assertEqual(client.normalize_path('//foo/bar'),
'svn+ssh://example.com/svn/foo/bar')
self.assertEqual(client.normalize_path('foo&/b ar?/#file#.txt'),
'svn+ssh://example.com/svn/foo&/b%20ar%3F/'
'%23file%23.txt')
def test_revision_parsing(self):
"""Testing SVN (<backend>) revision number parsing"""
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(working copy)'),
(b'', HEAD))
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b' (revision 0)'),
(b'', PRE_CREATION))
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(revision 1)'),
(b'', b'1'))
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(revision 23)'),
(b'', b'23'))
# Fix for bug 2176
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'\t(revision 4)'),
(b'', b'4'))
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision=b'2007-06-06 15:32:23 UTC (rev 10958)'),
(b'', b'10958'))
# Fix for bug 2632
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(revision )'),
(b'', PRE_CREATION))
with self.assertRaises(SCMError):
self.tool.parse_diff_revision(filename=b'',
revision=b'hello')
# Verify that 'svn diff' localized revision strings parse correctly.
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision='(revisión: 5)'.encode('utf-8')),
(b'', b'5'))
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision='(リビジョン 6)'.encode('utf-8')),
(b'', b'6'))
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision='(版本 7)'.encode('utf-8')),
(b'', b'7'))
def test_revision_parsing_with_nonexistent(self):
"""Testing SVN (<backend>) revision parsing with "(nonexistent)"
revision indicator
"""
# English
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(nonexistent)'),
(b'', PRE_CREATION))
# German
self.assertEqual(
self.tool.parse_diff_revision(filename=b'',
revision=b'(nicht existent)'),
(b'', PRE_CREATION))
# Simplified Chinese
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision='(不存在的)'.encode('utf-8')),
(b'', PRE_CREATION))
def test_revision_parsing_with_nonexistent_and_branches(self):
"""Testing SVN (<backend>) revision parsing with relocation
information and nonexistent revision specifier
"""
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision=b'(.../trunk) (nonexistent)'),
(b'trunk/', PRE_CREATION))
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision=b'(.../branches/branch-1.0) (nicht existent)'),
(b'branches/branch-1.0/', PRE_CREATION))
self.assertEqual(
self.tool.parse_diff_revision(
filename=b'',
revision=' (.../trunk) (不存在的)'.encode('utf-8')),
(b'trunk/', PRE_CREATION))
def test_interface(self):
"""Testing SVN (<backend>) with basic SVNTool API"""
self.assertFalse(self.tool.diffs_use_absolute_paths)
self.assertRaises(NotImplementedError,
lambda: self.tool.get_changeset(1))
def test_binary_diff(self):
"""Testing SVN (<backend>) parsing SVN diff with binary file"""
diff = (
b'Index: binfile\n'
b'============================================================'
b'=======\n'
b'Cannot display: file marked as a binary type.\n'
b'svn:mime-type = application/octet-stream\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'binfile',
orig_file_details=b'(unknown)',
modified_filename=b'binfile',
modified_file_details=b'(working copy)',
index_header_value=b'binfile',
binary=True,
data=diff)
def test_binary_diff_with_property_change(self):
"""Testing SVN (<backend>) parsing SVN diff with binary file with
property change
"""
diff = (
b'Index: binfile\n'
b'============================================================'
b'=======\n'
b'Cannot display: file marked as a binary type.\n'
b'svn:mime-type = application/octet-stream\n'
b'\n'
b'Property changes on: binfile\n'
b'____________________________________________________________'
b'_______\n'
b'Added: svn:mime-type\n'
b'## -0,0 +1 ##\n'
b'+application/octet-stream\n'
b'\\ No newline at end of property\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'binfile',
orig_file_details=b'(unknown)',
modified_filename=b'binfile',
modified_file_details=b'(working copy)',
index_header_value=b'binfile',
binary=True,
insert_count=1,
data=diff)
def test_keyword_diff(self):
"""Testing SVN (<backend>) parsing diff with keywords"""
# 'svn cat' will expand special variables in svn:keywords,
# but 'svn diff' doesn't expand anything. This causes the
# patch to fail if those variables appear in the patch context.
diff = (b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Rev$\n'
b' # $Revision:: $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n')
filename = 'trunk/doc/misc-docs/Makefile'
rev = Revision('4')
file = self.tool.get_file(filename, rev)
patch(diff, file, filename)
def test_unterminated_keyword_diff(self):
"""Testing SVN (<backend>) parsing diff with unterminated keywords"""
diff = (b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Id:\n'
b' # $Rev$\n'
b' # $Revision:: $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n')
filename = 'trunk/doc/misc-docs/Makefile'
rev = Revision('5')
file = self.tool.get_file(filename, rev)
patch(diff, file, filename)
def test_svn16_property_diff(self):
"""Testing SVN (<backend>) parsing SVN 1.6 diff with property changes
"""
diff = (
b'Index:\n'
b'======================================================'
b'=============\n'
b'--- (revision 123)\n'
b'+++ (working copy)\n'
b'Property changes on: .\n'
b'______________________________________________________'
b'_____________\n'
b'Modified: reviewboard:url\n'
b'## -1 +1 ##\n'
b'-http://reviews.reviewboard.org\n'
b'+http://reviews.reviewboard.org\n'
b'Index: binfile\n'
b'======================================================='
b'============\nCannot display: file marked as a '
b'binary type.\nsvn:mime-type = application/octet-stream\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'binfile',
orig_file_details=b'(unknown)',
modified_filename=b'binfile',
modified_file_details=b'(working copy)',
index_header_value=b'binfile',
binary=True,
data=diff)
def test_svn17_property_diff(self):
"""Testing SVN (<backend>) parsing SVN 1.7+ diff with property changes
"""
diff = (
b'Index .:\n'
b'======================================================'
b'=============\n'
b'--- . (revision 123)\n'
b'+++ . (working copy)\n'
b'\n'
b'Property changes on: .\n'
b'______________________________________________________'
b'_____________\n'
b'Modified: reviewboard:url\n'
b'## -0,0 +1,3 ##\n'
b'-http://reviews.reviewboard.org\n'
b'+http://reviews.reviewboard.org\n'
b'Added: myprop\n'
b'## -0,0 +1 ##\n'
b'+Property test.\n'
b'Index: binfile\n'
b'======================================================='
b'============\nCannot display: file marked as a '
b'binary type.\nsvn:mime-type = application/octet-stream\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'binfile',
orig_file_details=b'(unknown)',
modified_filename=b'binfile',
modified_file_details=b'(working copy)',
index_header_value=b'binfile',
binary=True,
data=diff)
def test_unicode_diff(self):
"""Testing SVN (<backend>) parsing diff with unicode characters"""
diff = (
'Index: Filé\n'
'==========================================================='
'========\n'
'--- Filé (revision 4)\n'
'+++ Filé (working copy)\n'
'@@ -1,6 +1,7 @@\n'
'+# foó\n'
' include ../tools/Makefile.base-vars\n'
' NAME = misc-docs\n'
' OUTNAME = svn-misc-docs\n'
).encode('utf-8')
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename='Filé'.encode('utf-8'),
orig_file_details=b'(revision 4)',
modified_filename='Filé'.encode('utf-8'),
modified_file_details=b'(working copy)',
index_header_value='Filé'.encode('utf-8'),
insert_count=1,
data=diff)
def test_diff_with_spaces_in_filenames(self):
"""Testing SVN (<backend>) parsing diff with spaces in filenames"""
diff = (
b'Index: File with spaces\n'
b'==========================================================='
b'========\n'
b'--- File with spaces (revision 4)\n'
b'+++ File with spaces (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'File with spaces',
orig_file_details=b'(revision 4)',
modified_filename=b'File with spaces',
modified_file_details=b'(working copy)',
index_header_value=b'File with spaces',
insert_count=1,
data=diff)
def test_diff_with_added_empty_file(self):
"""Testing parsing SVN diff with added empty file"""
diff = (
b'Index: empty-file\t(added)\n'
b'==========================================================='
b'========\n'
b'--- empty-file\t(revision 0)\n'
b'+++ empty-file\t(revision 0)\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'empty-file',
orig_file_details=b'(revision 0)',
modified_filename=b'empty-file',
modified_file_details=b'(revision 0)',
index_header_value=b'empty-file\t(added)',
data=diff)
def test_diff_with_deleted_empty_file(self):
"""Testing parsing SVN diff with deleted empty file"""
diff = (
b'Index: empty-file\t(deleted)\n'
b'==========================================================='
b'========\n'
b'--- empty-file\t(revision 4)\n'
b'+++ empty-file\t(working copy)\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'empty-file',
orig_file_details=b'(revision 4)',
modified_filename=b'empty-file',
modified_file_details=b'(working copy)',
index_header_value=b'empty-file\t(deleted)',
deleted=True,
data=diff)
def test_diff_with_nonexistent_revision_for_dest_file(self):
"""Testing parsing SVN diff with deleted file using "nonexistent"
destination revision
"""
diff = (
b'Index: deleted-file\n'
b'==========================================================='
b'========\n'
b'--- deleted-file\t(revision 4)\n'
b'+++ deleted-file\t(nonexistent)\n'
b'@@ -1,2 +0,0 @@\n'
b'-line 1\n'
b'-line 2\n'
)
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 1)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'deleted-file',
orig_file_details=b'(revision 4)',
modified_filename=b'deleted-file',
modified_file_details=b'(nonexistent)',
index_header_value=b'deleted-file',
deleted=True,
delete_count=2,
data=diff)
def test_idea_diff(self):
"""Testing parsing SVN diff with multi-file diff generated by IDEA
IDEs
"""
diff1 = (
b'Index: path/to/README\n'
b'IDEA additional info:\n'
b'Subsystem: org.reviewboard.org.test\n'
b'<+>ISO-8859-1\n'
b'=============================================================='
b'=====\n'
b'--- path/to/README\t(revision 4)\n'
b'+++ path/to/README\t(revision )\n'
b'@@ -1,6 +1,7 @@\n'
b' #\n'
b' #\n'
b' #\n'
b'+# test\n'
b' #\n'
b' #\n'
b' #\n'
)
diff2 = (
b'Index: path/to/README2\n'
b'IDEA additional info:\n'
b'Subsystem: org.reviewboard.org.test\n'
b'<+>ISO-8859-1\n'
b'=============================================================='
b'=====\n'
b'--- path/to/README2\t(revision 4)\n'
b'+++ path/to/README2\t(revision )\n'
b'@@ -1,6 +1,7 @@\n'
b' #\n'
b' #\n'
b' #\n'
b'+# test\n'
b' #\n'
b' #\n'
b' #\n'
)
diff = diff1 + diff2
parsed_files = self.tool.get_parser(diff).parse()
self.assertEqual(len(parsed_files), 2)
self.assert_parsed_diff_file(
parsed_files[0],
orig_filename=b'path/to/README',
orig_file_details=b'(revision 4)',
modified_filename=b'path/to/README',
modified_file_details=b'(revision )',
index_header_value=b'path/to/README',
insert_count=1,
data=diff1)
self.assert_parsed_diff_file(
parsed_files[1],
orig_filename=b'path/to/README2',
orig_file_details=b'(revision 4)',
modified_filename=b'path/to/README2',
modified_file_details=b'(revision )',
index_header_value=b'path/to/README2',
insert_count=1,
data=diff2)
def test_get_branches(self):
"""Testing SVN (<backend>) get_branches"""
branches = self.tool.get_branches()
self.assertEqual(len(branches), 3)
self.assertEqual(branches[0], Branch(id='trunk', name='trunk',
commit='12', default=True))
self.assertEqual(branches[1], Branch(id='branches/branch1',
name='branch1',
commit='7', default=False))
self.assertEqual(branches[2], Branch(id='top-level-branch',
name='top-level-branch',
commit='10', default=False))
def test_get_commits(self):
"""Testing SVN (<backend>) get_commits"""
commits = self.tool.get_commits(start='5')
self.assertEqual(len(commits), 5)
self.assertEqual(
commits[0],
Commit('chipx86',
'5',
'2010-05-21T09:33:40.893946',
'Add an unterminated keyword for testing bug #1523\n',
'4'))
commits = self.tool.get_commits(start='7')
self.assertEqual(len(commits), 7)
self.assertEqual(
commits[1],
Commit('david',
'6',
'2013-06-13T07:43:04.725088',
'Add a branches directory',
'5'))
def test_get_commits_with_branch(self):<｜fim▁hole｜> commits = self.tool.get_commits(branch='/branches/branch1', start='5')
self.assertEqual(len(commits), 5)
self.assertEqual(
commits[0],
Commit('chipx86',
'5',
'2010-05-21T09:33:40.893946',
'Add an unterminated keyword for testing bug #1523\n',
'4'))
commits = self.tool.get_commits(branch='/branches/branch1', start='7')
self.assertEqual(len(commits), 6)
self.assertEqual(
commits[0],
Commit('david',
'7',
'2013-06-13T07:43:27.259554',
'Add a branch',
'5'))
self.assertEqual(
commits[1],
Commit('chipx86',
'5',
'2010-05-21T09:33:40.893946',
'Add an unterminated keyword for testing bug #1523\n',
'4'))
def test_get_commits_with_no_date(self):
"""Testing SVN (<backend>) get_commits with no date in commit"""
def _get_log(*args, **kwargs):
return [
{
'author': 'chipx86',
'revision': '5',
'message': 'Commit 1',
},
]
self.spy_on(self.tool.client.get_log, _get_log)
commits = self.tool.get_commits(start='5')
self.assertEqual(len(commits), 1)
self.assertEqual(
commits[0],
Commit('chipx86',
'5',
'',
'Commit 1'))
def test_get_commits_with_exception(self):
"""Testing SVN (<backend>) get_commits with exception"""
def _get_log(*args, **kwargs):
raise Exception('Bad things happened')
self.spy_on(self.tool.client.get_log, _get_log)
with self.assertRaisesMessage(SCMError, 'Bad things happened'):
self.tool.get_commits(start='5')
def test_get_change(self):
"""Testing SVN (<backend>) get_change"""
commit = self.tool.get_change('5')
self.assertEqual(md5(commit.message.encode('utf-8')).hexdigest(),
'928336c082dd756e3f7af4cde4724ebf')
self.assertEqual(md5(commit.diff).hexdigest(),
'56e50374056931c03a333f234fa63375')
def test_utf8_keywords(self):
"""Testing SVN (<backend>) with UTF-8 files with keywords"""
self.repository.get_file('trunk/utf8-file.txt', '9')
def test_normalize_patch_with_svn_and_expanded_keywords(self):
"""Testing SVN (<backend>) normalize_patch with expanded keywords"""
diff = (
b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Rev: 123$\n'
b' # $Revision:: 123 $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n'
)
normalized = self.tool.normalize_patch(
patch=diff,
filename='trunk/doc/misc-docs/Makefile',
revision='4')
self.assertEqual(
normalized,
b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Rev$\n'
b' # $Revision:: $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n')
def test_normalize_patch_with_svn_and_no_expanded_keywords(self):
"""Testing SVN (<backend>) normalize_patch with no expanded keywords"""
diff = (
b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Rev$\n'
b' # $Revision:: $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n'
)
normalized = self.tool.normalize_patch(
patch=diff,
filename='trunk/doc/misc-docs/Makefile',
revision='4')
self.assertEqual(
normalized,
b'Index: Makefile\n'
b'==========================================================='
b'========\n'
b'--- Makefile (revision 4)\n'
b'+++ Makefile (working copy)\n'
b'@@ -1,6 +1,7 @@\n'
b' # $Id$\n'
b' # $Rev$\n'
b' # $Revision:: $\n'
b'+# foo\n'
b' include ../tools/Makefile.base-vars\n'
b' NAME = misc-docs\n'
b' OUTNAME = svn-misc-docs\n')
class PySVNTests(_CommonSVNTestCase):
backend = 'reviewboard.scmtools.svn.pysvn'
backend_name = 'pysvn'
class SubvertpyTests(_CommonSVNTestCase):
backend = 'reviewboard.scmtools.svn.subvertpy'
backend_name = 'subvertpy'
class UtilsTests(SCMTestCase):
"""Unit tests for reviewboard.scmtools.svn.utils."""
def test_collapse_svn_keywords(self):
"""Testing collapse_svn_keywords"""
keyword_test_data = [
(b'Id',
b'/* $Id: test2.c 3 2014-08-04 22:55:09Z david $ */',
b'/* $Id$ */'),
(b'id',
b'/* $Id: test2.c 3 2014-08-04 22:55:09Z david $ */',
b'/* $Id$ */'),
(b'id',
b'/* $id: test2.c 3 2014-08-04 22:55:09Z david $ */',
b'/* $id$ */'),
(b'Id',
b'/* $id: test2.c 3 2014-08-04 22:55:09Z david $ */',
b'/* $id$ */')
]
for keyword, data, result in keyword_test_data:
self.assertEqual(collapse_svn_keywords(data, keyword),
result)
def test_has_expanded_svn_keywords(self):
"""Testing has_expanded_svn_keywords"""
self.assertTrue(has_expanded_svn_keywords(b'.. $ID: 123$ ..'))
self.assertTrue(has_expanded_svn_keywords(b'.. $id:: 123$ ..'))
self.assertFalse(has_expanded_svn_keywords(b'.. $Id:: $ ..'))
self.assertFalse(has_expanded_svn_keywords(b'.. $Id$ ..'))
self.assertFalse(has_expanded_svn_keywords(b'.. $Id ..'))
self.assertFalse(has_expanded_svn_keywords(b'.. $Id Here$ ..'))
class SVNAuthFormTests(TestCase):
"""Unit tests for SVNTool's authentication form."""
def test_fields(self):
"""Testing SVNTool authentication form fields"""
form = SVNTool.create_auth_form()
self.assertEqual(list(form.fields), ['username', 'password'])
self.assertEqual(form['username'].help_text, '')
self.assertEqual(form['username'].label, 'Username')
self.assertEqual(form['password'].help_text, '')
self.assertEqual(form['password'].label, 'Password')
@add_fixtures(['test_scmtools'])
def test_load(self):
"""Tetting SVNTool authentication form load"""
repository = self.create_repository(
tool_name='Subversion',
username='test-user',
password='test-pass')
form = SVNTool.create_auth_form(repository=repository)
form.load()
self.assertEqual(form['username'].value(), 'test-user')
self.assertEqual(form['password'].value(), 'test-pass')
@add_fixtures(['test_scmtools'])
def test_save(self):
"""Tetting SVNTool authentication form save"""
repository = self.create_repository(tool_name='Subversion')
form = SVNTool.create_auth_form(
repository=repository,
data={
'username': 'test-user',
'password': 'test-pass',
})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(repository.username, 'test-user')
self.assertEqual(repository.password, 'test-pass')
class SVNRepositoryFormTests(TestCase):
"""Unit tests for SVNTool's repository form."""
def test_fields(self):
"""Testing SVNTool repository form fields"""
form = SVNTool.create_repository_form()
self.assertEqual(list(form.fields), ['path', 'mirror_path'])
self.assertEqual(form['path'].help_text,
'The path to the repository. This will generally be '
'the URL you would use to check out the repository.')
self.assertEqual(form['path'].label, 'Path')
self.assertEqual(form['mirror_path'].help_text, '')
self.assertEqual(form['mirror_path'].label, 'Mirror Path')
@add_fixtures(['test_scmtools'])
def test_load(self):
"""Tetting SVNTool repository form load"""
repository = self.create_repository(
tool_name='Subversion',
path='https://svn.example.com/',
mirror_path='https://svn.mirror.example.com')
form = SVNTool.create_repository_form(repository=repository)
form.load()
self.assertEqual(form['path'].value(), 'https://svn.example.com/')
self.assertEqual(form['mirror_path'].value(),
'https://svn.mirror.example.com')
@add_fixtures(['test_scmtools'])
def test_save(self):
"""Tetting SVNTool repository form save"""
repository = self.create_repository(tool_name='Subversion')
form = SVNTool.create_repository_form(
repository=repository,
data={
'path': 'https://svn.example.com/',
'mirror_path': 'https://svn.mirror.example.com',
})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(repository.path, 'https://svn.example.com/')
self.assertEqual(repository.mirror_path,
'https://svn.mirror.example.com')<｜fim▁end｜> | """Testing SVN (<backend>) get_commits with branch""" |
<|file_name|>ClangCompiler.java<|end_file_name|><｜fim▁begin｜>/*
* Copyright 2015-present Facebook, 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<｜fim▁hole｜> * License for the specific language governing permissions and limitations
* under the License.
*/
package com.facebook.buck.cxx;
import com.facebook.buck.rules.Tool;
import com.google.common.collect.ImmutableList;
import java.util.Optional;
public class ClangCompiler extends DefaultCompiler {
public ClangCompiler(Tool tool) {
super(tool);
}
@Override
public Optional<ImmutableList<String>> debugCompilationDirFlags(String debugCompilationDir) {
return Optional.of(
ImmutableList.of("-Xclang", "-fdebug-compilation-dir", "-Xclang", debugCompilationDir));
}
@Override
public Optional<ImmutableList<String>> getFlagsForColorDiagnostics() {
return Optional.of(ImmutableList.of("-fcolor-diagnostics"));
}
@Override
public boolean isArgFileSupported() {
return true;
}
}<｜fim▁end｜> | |
<|file_name|>issue-61801-path-pattern-can-infer.rs<|end_file_name|><｜fim▁begin｜>// In this regression test we check that a path pattern referring to a unit variant
// through a type alias is successful in inferring the generic argument.
// check-pass
enum Opt<T> {
N,
S(T),
}
type OptAlias<T> = Opt<T>;
fn f1(x: OptAlias<u8>) {
match x {
OptAlias::N // We previously failed to infer `T` to `u8`.
=> (),
_ => (),
}
match x {
<
OptAlias<_> // And we failed to infer this type also.
>::N => (),
_ => (),
}<｜fim▁hole｜>}
fn main() {}<｜fim▁end｜> | |
<|file_name|>pyunit_NOFEATURE_prostateGLM.py<|end_file_name|><｜fim▁begin｜>import sys
sys.path.insert(1, "../../../")
import h2o
import pandas as pd
import statsmodels.api as sm
def prostate(ip,port):
# Log.info("Importing prostate.csv data...\n")
h2o_data = h2o.upload_file(path=h2o.locate("smalldata/logreg/prostate.csv"))
#prostate.summary()
sm_data = pd.read_csv(h2o.locate("smalldata/logreg/prostate.csv")).as_matrix()
sm_data_response = sm_data[:,1]
sm_data_features = sm_data[:,2:]
#Log.info(cat("B)H2O GLM (binomial) with parameters:\nX:", myX, "\nY:", myY, "\n"))
h2o_glm = h2o.glm(y=h2o_data[1], x=h2o_data[2:], family="binomial", n_folds=10, alpha=[0.5])
h2o_glm.show()
sm_glm = sm.GLM(endog=sm_data_response, exog=sm_data_features, family=sm.families.Binomial()).fit()
assert abs(sm_glm.null_deviance - h2o_glm._model_json['output']['training_metrics']['null_deviance']) < 1e-5, "Expected null deviances to be the same"<｜fim▁hole｜>
if __name__ == "__main__":
h2o.run_test(sys.argv, prostate)<｜fim▁end｜> | |
<|file_name|>mnist_mlp.py<|end_file_name|><｜fim▁begin｜>import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('data', one_hot=True)<｜fim▁hole｜>mnist_train = mnist.train
mnist_val = mnist.validation
p = 28 * 28
n = 10
h1 = 300
func_act = tf.nn.sigmoid
x_pl = tf.placeholder(dtype=tf.float32, shape=[None, p])
y_pl = tf.placeholder(dtype=tf.float32, shape=[None, n])
w1 = tf.Variable(tf.truncated_normal(shape=[p, h1], stddev=0.1))
b1 = tf.Variable(tf.zeros(shape=[h1]))
w2 = tf.Variable(tf.truncated_normal(shape=[h1, n], stddev=0.1))
b2 = tf.Variable(tf.zeros(shape=[n]))
hidden1 = func_act(tf.matmul(x_pl, w1) + b1)
y_pre = tf.matmul(hidden1, w2) + b2
y_ = tf.nn.softmax(y_pre)
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_pl, logits=y_pre))
correct_prediction = tf.equal(tf.argmax(y_pl, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
eta = 0.3
train_op = tf.train.AdagradOptimizer(learning_rate=0.3).minimize(cross_entropy)
batch_size = 50
batch_per_epoch = mnist_train.num_examples // batch_size
epoch = 2
with tf.Session() as sess:
tf.global_variables_initializer().run()
x_val = mnist_val.images
y_val = mnist_val.labels
val_fd = {x_pl: x_val, y_pl: y_val}
for ep in range(epoch):
print(f'Epoch {ep+1}:')
for sp in range(batch_per_epoch):
xtr, ytr = mnist_train.next_batch(batch_size)
loss_value, _ = sess.run([cross_entropy, train_op], feed_dict={x_pl: xtr, y_pl: ytr})
if sp == 0 or (sp + 1) % 100 == 0:
print(f'Loss: {loss_value:.4f}')
acc = sess.run(accuracy, feed_dict=val_fd)
print(f'Validation Acc: {acc:.4f}')<｜fim▁end｜> | |
<|file_name|>GUIINV.py<|end_file_name|><｜fim▁begin｜># -*-python-*-
# GemRB - Infinity Engine Emulator
# Copyright (C) 2003-2004 The GemRB Project
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# GUIINV.py - scripts to control inventory windows from GUIINV winpack
###################################################
import GemRB
import GUICommon
import GUICommonWindows
import InventoryCommon
from GUIDefines import *
from ie_stats import *
from ie_slots import *
from ie_spells import *
from ie_restype import RES_BAM
InventoryWindow = None
def InitInventoryWindow (Window):
global InventoryWindow
Window.AddAlias("WIN_INV")
InventoryWindow = Window
#ground items scrollbar
ScrollBar = Window.GetControl (66)
ScrollBar.SetEvent (IE_GUI_SCROLLBAR_ON_CHANGE, RefreshInventoryWindow)
# Ground Items (6)
for i in range (5):
Button = Window.GetControl (i+68)
Button.SetEvent (IE_GUI_MOUSE_ENTER_BUTTON, InventoryCommon.MouseEnterGround)
Button.SetEvent (IE_GUI_MOUSE_LEAVE_BUTTON, InventoryCommon.MouseLeaveGround)
Button.SetVarAssoc ("GroundItemButton", i)
Button.SetFont ("NUMFONT")
Button = Window.GetControl (81)
Button.SetTooltip (12011)
Button.SetVarAssoc ("GroundItemButton", 6)
Button.SetFont ("NUMFONT")
Button.SetFlags (IE_GUI_BUTTON_ALIGN_RIGHT | IE_GUI_BUTTON_ALIGN_BOTTOM | IE_GUI_BUTTON_PICTURE, OP_OR)
#major & minor clothing color
Button = Window.GetControl (62)
Button.SetFlags (IE_GUI_BUTTON_PICTURE,OP_OR)
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, InventoryCommon.MajorPress)
Button.SetTooltip (12007)
Button = Window.GetControl (63)
Button.SetFlags (IE_GUI_BUTTON_PICTURE,OP_OR)
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, InventoryCommon.MinorPress)
Button.SetTooltip (12008)
#hair & skin color
Button = Window.GetControl (82)
Button.SetFlags (IE_GUI_BUTTON_PICTURE,OP_OR)
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, InventoryCommon.HairPress)
Button.SetTooltip (37560)
Button = Window.GetControl (83)
Button.SetFlags (IE_GUI_BUTTON_PICTURE,OP_OR)
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, InventoryCommon.SkinPress)
Button.SetTooltip (37559)
# paperdoll
Button = Window.GetControl (50)
Button.SetState (IE_GUI_BUTTON_LOCKED)
Button.SetFlags (IE_GUI_BUTTON_NO_IMAGE | IE_GUI_BUTTON_PICTURE | IE_GUI_BUTTON_ANIMATED, OP_SET)
Button.SetEvent (IE_GUI_BUTTON_ON_DRAG_DROP, InventoryCommon.OnAutoEquip)
# portrait
Button = Window.GetControl (84)
Button.SetState (IE_GUI_BUTTON_LOCKED)
Button.SetFlags (IE_GUI_BUTTON_NO_IMAGE | IE_GUI_BUTTON_PICTURE, OP_SET)
# armor class
Label = Window.GetControl (0x10000038)
Label.SetTooltip (17183)
# hp current
Label = Window.GetControl (0x10000039)
Label.SetTooltip (17184)
# hp max
Label = Window.GetControl (0x1000003a)
Label.SetTooltip (17378)
# info label, game paused, etc
Label = Window.GetControl (0x1000003f)
Label.SetText ("")
SlotCount = GemRB.GetSlotType (-1)["Count"]
for slot in range (SlotCount):
SlotType = GemRB.GetSlotType (slot+1)
if SlotType["ID"]:
Button = Window.GetControl (SlotType["ID"])
Button.SetEvent (IE_GUI_MOUSE_ENTER_BUTTON, InventoryCommon.MouseEnterSlot)
Button.SetEvent (IE_GUI_MOUSE_LEAVE_BUTTON, InventoryCommon.MouseLeaveSlot)
Button.SetVarAssoc ("ItemButton", slot+1)
Button.SetFont ("NUMFONT")
GemRB.SetVar ("TopIndex", 0)
for i in range (4):
Button = Window.GetControl (109+i)
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, ChangeWeaponPressed)
Button.SetVarAssoc("Equipped", i)
Button.SetFlags (IE_GUI_BUTTON_RADIOBUTTON, OP_OR)
#Why they mess up .chu's i don't know
Button.SetSprites("INVBUT3", i, 0, 1, 2, 3)
return
def ChangeWeaponPressed ():
pc = GemRB.GameGetSelectedPCSingle ()
Equipped = GemRB.GetVar ("Equipped")
GemRB.SetEquippedQuickSlot (pc, Equipped, -1)
return
#complete update
def UpdateInventoryWindow (Window):
pc = GemRB.GameGetSelectedPCSingle ()
Container = GemRB.GetContainer (pc, 1)
ScrollBar = Window.GetControl (66)
Count = Container['ItemCount']
if Count<1:
Count=1
ScrollBar.SetVarAssoc ("TopIndex", Count)
Equipped = GemRB.GetEquippedQuickSlot (pc, 1)
GemRB.SetVar ("Equipped", Equipped)
for i in range (4):
Button = Window.GetControl (109+i)
Button.SetVarAssoc("Equipped", i)
RefreshInventoryWindow ()
# populate inventory slot controls
SlotCount = GemRB.GetSlotType (-1)["Count"]
for i in range (SlotCount):
InventoryCommon.UpdateSlot (pc, i)
return
InventoryCommon.UpdateInventoryWindow = UpdateInventoryWindow
ToggleInventoryWindow = GUICommonWindows.CreateTopWinLoader(2, "GUIINV", GUICommonWindows.ToggleWindow, InitInventoryWindow, UpdateInventoryWindow)
OpenInventoryWindow = GUICommonWindows.CreateTopWinLoader(2, "GUIINV", GUICommonWindows.OpenWindowOnce, InitInventoryWindow, UpdateInventoryWindow)
def RefreshInventoryWindow ():
Window = InventoryWindow
pc = GemRB.GameGetSelectedPCSingle ()
# name
Label = Window.GetControl (0x10000032)
Label.SetText (GemRB.GetPlayerName (pc, 0))
# paperdoll
Button = Window.GetControl (50)
Color1 = GemRB.GetPlayerStat (pc, IE_METAL_COLOR)
Color2 = GemRB.GetPlayerStat (pc, IE_MINOR_COLOR)
Color3 = GemRB.GetPlayerStat (pc, IE_MAJOR_COLOR)
Color4 = GemRB.GetPlayerStat (pc, IE_SKIN_COLOR)
Color5 = GemRB.GetPlayerStat (pc, IE_LEATHER_COLOR)
Color6 = GemRB.GetPlayerStat (pc, IE_ARMOR_COLOR)
Color7 = GemRB.GetPlayerStat (pc, IE_HAIR_COLOR)
Button.SetFlags (IE_GUI_BUTTON_CENTER_PICTURES, OP_OR)
pdoll = GUICommonWindows.GetActorPaperDoll (pc)+"G11"
if GemRB.HasResource (pdoll, RES_BAM):
Button.SetAnimation (pdoll)
Button.SetAnimationPalette (Color1, Color2, Color3, Color4, Color5, Color6, Color7, 0)
# portrait
Button = Window.GetControl (84)
Button.SetPicture (GemRB.GetPlayerPortrait (pc, 0)["Sprite"])
# encumbrance
GUICommon.SetEncumbranceLabels (Window, 0x10000042, None, pc)
# armor class
ac = GemRB.GetPlayerStat (pc, IE_ARMORCLASS)
Label = Window.GetControl (0x10000038)
Label.SetText (str (ac))
# hp current
hp = GemRB.GetPlayerStat (pc, IE_HITPOINTS)
Label = Window.GetControl (0x10000039)
Label.SetText (str (hp))
# hp max
hpmax = GemRB.GetPlayerStat (pc, IE_MAXHITPOINTS)
Label = Window.GetControl (0x1000003a)
Label.SetText (str (hpmax))
# party gold
Label = Window.GetControl (0x10000040)
Label.SetText (str (GemRB.GameGetPartyGold ()))
Button = Window.GetControl (62)
Color = GemRB.GetPlayerStat (pc, IE_MAJOR_COLOR, 1) & 0xFF
Button.SetBAM ("COLGRAD", 0, 0, Color)
Button = Window.GetControl (63)
Color = GemRB.GetPlayerStat (pc, IE_MINOR_COLOR, 1) & 0xFF
Button.SetBAM ("COLGRAD", 0, 0, Color)
Button = Window.GetControl (82)
Color = GemRB.GetPlayerStat (pc, IE_HAIR_COLOR, 1) & 0xFF
Button.SetBAM ("COLGRAD", 0, 0, Color)
Button = Window.GetControl (83)
Color = GemRB.GetPlayerStat (pc, IE_SKIN_COLOR, 1) & 0xFF
Button.SetBAM ("COLGRAD", 0, 0, Color)
# update ground inventory slots
Container = GemRB.GetContainer(pc, 1)
TopIndex = GemRB.GetVar ("TopIndex")
for i in range (6):
if i<5:
Button = Window.GetControl (i+68)
else:
Button = Window.GetControl (i+76)
if GemRB.IsDraggingItem ()==1:
Button.SetState (IE_GUI_BUTTON_FAKEPRESSED)
else:
Button.SetState (IE_GUI_BUTTON_ENABLED)
Button.SetEvent (IE_GUI_BUTTON_ON_DRAG_DROP, InventoryCommon.OnDragItemGround)
Slot = GemRB.GetContainerItem (pc, i+TopIndex)
if Slot == None:<｜fim▁hole｜> Button.SetEvent (IE_GUI_BUTTON_ON_SHIFT_PRESS, None)
else:
Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, InventoryCommon.OnDragItemGround)
Button.SetEvent (IE_GUI_BUTTON_ON_RIGHT_PRESS, InventoryCommon.OpenGroundItemInfoWindow)
Button.SetEvent (IE_GUI_BUTTON_ON_SHIFT_PRESS, InventoryCommon.OpenGroundItemAmountWindow)
GUICommon.UpdateInventorySlot (pc, Button, Slot, "ground")
#if actor is uncontrollable, make this grayed
GUICommon.AdjustWindowVisibility (Window, pc, False)
return
###################################################
# End of file GUIINV.py<｜fim▁end｜> | Button.SetEvent (IE_GUI_BUTTON_ON_PRESS, None)
Button.SetEvent (IE_GUI_BUTTON_ON_RIGHT_PRESS, None) |
<|file_name|>geo.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
import math
EARTH_RADIUS = 6367009
METERS_PER_DEGREE = 111319.0
FEET_PER_METER = 3.2808399
<｜fim▁hole｜>
def geographic_distance(loc1, loc2):
"""
Calculate the great circle distance between two points
on the earth (specified in decimal degrees)
"""
# convert decimal degrees to radians
lat1, lon1, lat2, lon2 = map(math.radians,
[loc1.latitude, loc1.longitude,
loc2.latitude, loc2.longitude])
# haversine formula
dlon = lon2 - lon1
dlat = lat2 - lat1
a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * \
math.cos(lat2) * math.sin(dlon / 2) ** 2
c = 2 * math.asin(math.sqrt(a))
return EARTH_RADIUS * c<｜fim▁end｜> | |
<|file_name|>forms.py<|end_file_name|><｜fim▁begin｜>from ampadb.support import Forms
from django import forms
from django.core.exceptions import ValidationError
from . import ies_format
from .ampacsv import InvalidFormat
from .import_fmts import IEFormats
class ExportForm(Forms.Form):
FORMAT_CHOICES = [(IEFormats.CSV, 'CSV (E-mail)'), (IEFormats.AMPACSV,
'CSV (Importació)'),
(IEFormats.JSON, 'JSON'), (IEFormats.PICKLE, 'Pickle')]
format = forms.ChoiceField(
required=True, choices=FORMAT_CHOICES, widget=forms.RadioSelect)
classe = forms.CharField(required=False, widget=forms.HiddenInput)
contrasenya = forms.CharField(required=False, widget=forms.PasswordInput)
repeteix_la_contrasenya = forms.CharField(
required=False, widget=forms.PasswordInput)
def clean(self):
cleaned_data = super().clean()
contrasenya = cleaned_data.get('contrasenya')
if contrasenya and (contrasenya !=
cleaned_data.get('repeteix_la_contrasenya')):
self.add_error('repeteix_la_contrasenya',
ValidationError('La contrasenya no coincideix'))
class ImportForm(Forms.Form):
FORMAT_CHOICES = [(IEFormats.AUTO, 'Autodetectar'),
(IEFormats.AMPACSV, 'CSV'), (IEFormats.EXCELCSV,
'CSV (Excel)'),
(IEFormats.JSON, 'JSON'), (IEFormats.PICKLE, 'Pickle')]
PREEXISTENT_CHOICES = [('', 'Conservar'), ('DEL',
'Eliminar no mencionades'),
('DEL_ALL', 'Eliminar tot (no recomanat)')]
format = forms.ChoiceField(
required=False, choices=FORMAT_CHOICES, widget=forms.RadioSelect)
contrasenya = forms.CharField(
required=False,
widget=forms.PasswordInput,
help_text=("Si és un arxiu Pickle xifrat, s'intentarà desxifrar amb"
" aquesta contrasenya. Si el format no és Pickle,"
" aquest camp s'ignorarà."))
preexistents = forms.ChoiceField(<｜fim▁hole｜> choices=PREEXISTENT_CHOICES,
label='Entrades preexistents',
widget=forms.RadioSelect,
help_text=(
"Què fer amb les entrades preexistents que no es mencionen a "
"l'arxiu. \"Conservar\" no les modifica; \"Eliminar no "
"mencionades\" les elimina, però, si la entrada existeix i conté "
"dades que l'arxiu no té, aquestes es conserven (ex. si un alumne "
"té el correu de l'alumne però l'arxiu no té aquest camp, es "
"conserva el que ja tenia); \"Eliminar tot\" només deixa les "
"dades que hi ha a l'arxiu."))
ifile = forms.FileField(required=True, label="Arxiu d'importació")
class Ies: # pylint: disable=too-few-public-methods
class UploadForm(Forms.Form):
ifile = forms.FileField(
required=True,
label="Arxiu d'importació",
widget=forms.FileInput(attrs={
'accept': '.csv'
}))<｜fim▁end｜> | required=False, # 'Conservar' per defecte |
<|file_name|>1.cc<|end_file_name|><｜fim▁begin｜>// { dg-options "-std=gnu++11" }
// Copyright (C) 2011-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
<｜fim▁hole｜>// <http://www.gnu.org/licenses/>.
#include <memory>
#include <scoped_allocator>
#include <vector>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
struct Element
{
typedef uneq_allocator<Element> allocator_type;
allocator_type alloc;
Element(const allocator_type& a = allocator_type()) : alloc(a) { }
Element(std::allocator_arg_t, const allocator_type& a, int = 0)
: alloc(a) { }
Element(std::allocator_arg_t, const allocator_type& a, const Element&)
: alloc(a) { }
const allocator_type& get_allocator() const { return alloc; }
};
void test01()
{
bool test __attribute((unused)) = false;
typedef std::scoped_allocator_adaptor<Element::allocator_type> alloc1_type;
typedef std::vector<Element, alloc1_type> EltVec;
alloc1_type a1(1);
Element e;
EltVec ev1(1, e, a1);
VERIFY( ev1.get_allocator().get_personality() == 1 );
VERIFY( ev1[0].get_allocator().get_personality() == 1 );
}
void test02()
{
bool test __attribute((unused)) = false;
typedef std::scoped_allocator_adaptor<Element::allocator_type> inner_alloc_type;
typedef std::vector<Element, inner_alloc_type> EltVec;
typedef std::scoped_allocator_adaptor<Element::allocator_type,
Element::allocator_type> alloc_type;
typedef std::vector<EltVec, alloc_type> EltVecVec;
alloc_type a(1, Element::allocator_type(2)); // outer=1, inner=2
Element e;
EltVec ev(1, e);
EltVecVec evv(1, ev, a);
VERIFY( evv.get_allocator().get_personality() == 1 );
VERIFY( evv[0].get_allocator().get_personality() == 2 );
VERIFY( evv[0][0].get_allocator().get_personality() == 2 );
alloc_type a2(3, Element::allocator_type(4)); // outer=3, inner=4
EltVecVec evv2(evv, a2); // copy with a different allocator
VERIFY( evv2.get_allocator().get_personality() == 3 );
VERIFY( evv2[0].get_allocator().get_personality() == 4 );
VERIFY( evv2[0][0].get_allocator().get_personality() == 4 );
EltVecVec evv3(std::move(evv), a2); // move with a different allocator
VERIFY( evv3.get_allocator().get_personality() == 3 );
VERIFY( evv3[0].get_allocator().get_personality() == 4 );
VERIFY( evv3[0][0].get_allocator().get_personality() == 4 );
}
int main()
{
test01();
test02();
}<｜fim▁end｜> | // You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see |
<|file_name|>people.server.controller.js<|end_file_name|><｜fim▁begin｜>'use strict';
/**
* Module dependencies.
*/
var path = require('path'),
mongoose = require('mongoose'),
Person = mongoose.model('Person'),
errorHandler = require(path.resolve('./modules/core/server/controllers/errors.server.controller')),
_ = require('lodash');
/**
* Create a Person
*/
exports.create = function(req, res) {
var person = new Person(req.body);
person.user = req.user;
person.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(person);
}
});
};
/**
* Show the current Person
*/
exports.read = function(req, res) {
// convert mongoose document to JSON
var person = req.person ? req.person.toJSON() : {};
// Add a custom field to the Article, for determining if the current User is the "owner".
// NOTE: This field is NOT persisted to the database, since it doesn't exist in the Article model.
// person.isCurrentUserOwner = req.user && person.user && person.user._id.toString() === req.user._id.toString();
<｜fim▁hole｜>
/**
* Update a Person
*/
exports.update = function(req, res) {
var person = req.person;
person = _.extend(person, req.body);
person.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(person);
}
});
};
/**
* Delete a Person
*/
exports.delete = function(req, res) {
var person = req.person;
person.remove(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.jsonp(person);
}
});
};
/**
* List of People
*/
exports.list = function(req, res) {
var search = {};
if (req.query.full_name) {
search.full_name = new RegExp(req.query.full_name, 'i');
}
if (req.query.url) {
search.url = new RegExp(req.query.url, 'i');
}
if (req.query.email) {
search.email = new RegExp(req.query.email, 'i');
}
if (req.query.job) {
search.job = new RegExp(req.query.job, 'i');
}
if (req.query.location_safe) {
search.location_safe = new RegExp(req.query.location_safe, 'i');
}
if (req.query.phone) {
search.phone = new RegExp(req.query.phone, 'i');
}
if (req.query.notes) {
search.notes = new RegExp(req.query.notes, 'i');
}
if (req.query.keywords) {
search.keywords = new RegExp(req.query.keywords, 'i');
}
Person.find(search).sort('-created').exec(function (err, people) {
if (err) {
return res.status(400).send({
message: err.message
});
} else {
res.json(people);
}
});
};
/**
* List of Dupliacte People
*/
exports.duplicates = function (req, res) {
var aggregate = [
{
$group: {
_id: { url: '$url' },
count: { $sum: 1 }
}
}, {
$match: {
count: { $gte: 2 }
}
}
];
Person.aggregate(aggregate, function (err, groups) {
if (err) {
return res.status(400).send({
message: err.message
});
} else {
var dup_urls = [];
for (var i = 0; i < groups.length; i++) {
var group = groups[i];
var _id = group._id;
dup_urls.push(_id.url);
}
Person.find({ url: { $in: dup_urls } }).sort('url').exec(function (err, people) {
if (err) {
return res.status(400).send({
message: err.message
});
} else {
res.json(people);
}
});
}
});
};
/**
* Person middleware
*/
exports.personByID = function(req, res, next, id) {
if (!mongoose.Types.ObjectId.isValid(id)) {
return res.status(400).send({
message: 'Person is invalid'
});
}
Person.findById(id).populate('user', 'displayName').exec(function (err, person) {
if (err) {
return next(err);
} else if (!person) {
return res.status(404).send({
message: 'No Person with that identifier has been found'
});
}
req.person = person;
next();
});
};<｜fim▁end｜> | res.jsonp(person);
}; |
<|file_name|>importer_test.py<|end_file_name|><｜fim▁begin｜>from StringIO import StringIO
import textwrap
import importer
def test_import_csv():
current = StringIO(textwrap.dedent('''\
status,qty,type,transaction_date,posting_date,description,amount
A,,,2016/11/02,,This is a test,$4.53
'''))
new = StringIO(textwrap.dedent('''\
"Trans Date", "Summary", "Amount"<｜fim▁hole｜>
mapping = {
'Trans Date': 'transaction_date',
'Summary': 'description',
'Amount': 'amount'
}
importer.save_csv(current, new, mapping, '%m/%d/%Y')
lines = current.getvalue().splitlines()
assert lines[0].rstrip() == 'status,qty,type,transaction_date,posting_date,description,amount'
assert lines[1].rstrip() == 'N,2,,2007/05/02,,Regal Theaters,$15.99'
assert lines[2].rstrip() == 'A,,,2016/11/02,,This is a test,$4.53'
assert len(lines) == 3<｜fim▁end｜> | 5/2/2007, Regal Theaters, $15.99
11/2/2016, This is a test , $4.53
5/2/2007, Regal Theaters, $15.99
''')) |
<|file_name|>trees.py<|end_file_name|><｜fim▁begin｜>'''
@author: Michael Wan
@since : 2014-11-08
'''
from math import log
import operator
def createDataSet():
dataSet = [[1, 1, 'yes'],
[1, 1, 'yes'],
[1, 0, 'no'],
[0, 1, 'no'],
[0, 1, 'no']]
labels = ['no surfacing','flippers']
#change to discrete values
return dataSet, labels
def calcShannonEnt(dataSet):
numEntries = len(dataSet)
<｜fim▁hole｜> labelCounts = {}
for featVec in dataSet: #the the number of unique elements and their occurance
currentLabel = featVec[-1]
if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1
shannonEnt = 0.0
for key in labelCounts:
prob = float(labelCounts[key])/numEntries
shannonEnt -= prob * log(prob,2) #log base 2
return shannonEnt
def splitDataSet(dataSet, axis, value):
retDataSet = []
for featVec in dataSet:
if featVec[axis] == value:
reducedFeatVec = featVec[:axis] #chop out axis used for splitting
reducedFeatVec.extend(featVec[axis+1:])
retDataSet.append(reducedFeatVec)
return retDataSet
def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0]) - 1 #the last column is used for the labels
baseEntropy = calcShannonEnt(dataSet)
bestInfoGain = 0.0; bestFeature = -1
for i in range(numFeatures): #iterate over all the features
featList = [example[i] for example in dataSet]#create a list of all the examples of this feature
uniqueVals = set(featList) #get a set of unique values
newEntropy = 0.0
for value in uniqueVals:
subDataSet = splitDataSet(dataSet, i, value)
prob = len(subDataSet)/float(len(dataSet))
newEntropy += prob * calcShannonEnt(subDataSet)
infoGain = baseEntropy - newEntropy #calculate the info gain; ie reduction in entropy
if (infoGain > bestInfoGain): #compare this to the best gain so far
bestInfoGain = infoGain #if better than current best, set to best
bestFeature = i
return bestFeature #returns an integer
def majorityCnt(classList):
classCount={}
for vote in classList:
if vote not in classCount.keys(): classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
return sortedClassCount[0][0]
def createTree(dataSet,labels):
classList = [example[-1] for example in dataSet]
if classList.count(classList[0]) == len(classList):
return classList[0]#stop splitting when all of the classes are equal
if len(dataSet[0]) == 1: #stop splitting when there are no more features in dataSet
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet)
bestFeatLabel = labels[bestFeat]
myTree = {bestFeatLabel:{}}
del(labels[bestFeat])
featValues = [example[bestFeat] for example in dataSet]
uniqueVals = set(featValues)
for value in uniqueVals:
subLabels = labels[:] #copy all of labels, so trees don't mess up existing labels
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
return myTree
def classify(inputTree,featLabels,testVec):
firstStr = inputTree.keys()[0]
secondDict = inputTree[firstStr]
featIndex = featLabels.index(firstStr)
key = testVec[featIndex]
valueOfFeat = secondDict[key]
if isinstance(valueOfFeat, dict):
classLabel = classify(valueOfFeat, featLabels, testVec)
else: classLabel = valueOfFeat
return classLabel
def storeTree(inputTree,filename):
import pickle
fw = open(filename,'w')
pickle.dump(inputTree,fw)
fw.close()
def grabTree(filename):
import pickle
fr = open(filename)
return pickle.load(fr)<｜fim▁end｜> | |
<|file_name|>MessageUtils.java<|end_file_name|><｜fim▁begin｜>package org.cohorte.herald.core.utils;
import java.util.Iterator;
import org.cohorte.herald.Message;
import org.cohorte.herald.MessageReceived;
import org.jabsorb.ng.JSONSerializer;
import org.jabsorb.ng.serializer.MarshallException;
import org.jabsorb.ng.serializer.UnmarshallException;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class MessageUtils {
/** The Jabsorb serializer */
private static JSONSerializer pSerializer = new JSONSerializer();
static {
try {
pSerializer.registerDefaultSerializers();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static String toJSON(Message aMsg) throws MarshallException {
JSONObject json = new JSONObject();
try {
// headers
JSONObject headers = new JSONObject();
for (String key : aMsg.getHeaders().keySet()) {
headers.put(key, aMsg.getHeaders().get(key));
}
json.put(Message.MESSAGE_HEADERS, headers);
// subject
json.put(Message.MESSAGE_SUBJECT, aMsg.getSubject());
// content
if (aMsg.getContent() != null) {
if (aMsg.getContent() instanceof String) {
json.put(Message.MESSAGE_CONTENT, aMsg.getContent());
} else {
JSONObject content = new JSONObject(pSerializer.toJSON(aMsg.getContent()));
json.put(Message.MESSAGE_CONTENT, content);
}
}
// metadata
JSONObject metadata = new JSONObject();
for (String key : aMsg.getMetadata().keySet()) {
metadata.put(key, aMsg.getMetadata().get(key));
}
json.put(Message.MESSAGE_METADATA, metadata);
} catch (JSONException e) {
e.printStackTrace();
return null;
}
return json.toString();
}
@SuppressWarnings("unchecked")
public static MessageReceived fromJSON(String json) throws UnmarshallException {
try {
JSONObject wParsedMsg = new JSONObject(json);
{
try {
// check if valid herald message (respects herald specification version)
int heraldVersion = -1;
JSONObject jHeader = wParsedMsg.getJSONObject(Message.MESSAGE_HEADERS);
if (jHeader != null) {
if (jHeader.has(Message.MESSAGE_HERALD_VERSION)) {
heraldVersion = jHeader.getInt(Message.MESSAGE_HERALD_VERSION);
}
}
if (heraldVersion != Message.HERALD_SPECIFICATION_VERSION) {
throw new JSONException("Herald specification of the received message is not supported!");
}
MessageReceived wMsg = new MessageReceived(
wParsedMsg.getJSONObject(Message.MESSAGE_HEADERS).getString(Message.MESSAGE_HEADER_UID),
wParsedMsg.getString(Message.MESSAGE_SUBJECT),
null,
null,
null,
null,
null,
null);
// content
Object cont = wParsedMsg.opt(Message.MESSAGE_CONTENT);<｜fim▁hole｜> } else
wMsg.setContent(cont);
} else {
wMsg.setContent(null);
}
// headers
Iterator<String> wKeys;
if (wParsedMsg.getJSONObject(Message.MESSAGE_HEADERS) != null) {
wKeys = wParsedMsg.getJSONObject(Message.MESSAGE_HEADERS).keys();
while(wKeys.hasNext()) {
String key = wKeys.next();
wMsg.addHeader(key, wParsedMsg.getJSONObject(Message.MESSAGE_HEADERS).get(key));
}
}
// metadata
Iterator<String> wKeys2;
if (wParsedMsg.getJSONObject(Message.MESSAGE_METADATA) != null) {
wKeys2 = wParsedMsg.getJSONObject(Message.MESSAGE_METADATA).keys();
while(wKeys2.hasNext()) {
String key = wKeys2.next();
wMsg.addMetadata(key, wParsedMsg.getJSONObject(Message.MESSAGE_METADATA).get(key));
}
}
return wMsg;
} catch (JSONException e) {
e.printStackTrace();
return null;
}
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}<｜fim▁end｜> | if (cont != null) {
if (cont instanceof JSONObject || cont instanceof JSONArray) {
wMsg.setContent(pSerializer.fromJSON(cont.toString())); |
<|file_name|>test_strings.py<|end_file_name|><｜fim▁begin｜># Copyright (c) 2010-2015 openpyxl
# package imports
from openpyxl.reader.strings import read_string_table
from openpyxl.tests.helper import compare_xml
def test_read_string_table(datadir):
datadir.join('reader').chdir()
src = 'sharedStrings.xml'
with open(src) as content:
assert read_string_table(content.read()) == [
'This is cell A1 in Sheet 1', 'This is cell G5']
def test_empty_string(datadir):
datadir.join('reader').chdir()
src = 'sharedStrings-emptystring.xml'
with open(src) as content:
assert read_string_table(content.read()) == ['Testing empty cell', '']
def test_formatted_string_table(datadir):
datadir.join('reader').chdir()
src = 'shared-strings-rich.xml'
with open(src) as content:
assert read_string_table(content.read()) == [
'Welcome', 'to the best shop in town', " let's play "]<｜fim▁hole｜>
datadir.join("reader").chdir()
table = ['This is cell A1 in Sheet 1', 'This is cell G5']
content = write_string_table(table)
with open('sharedStrings.xml') as expected:
diff = compare_xml(content, expected.read())
assert diff is None, diff<｜fim▁end｜> |
def test_write_string_table(datadir):
from openpyxl.writer.strings import write_string_table |
<|file_name|>count_zeros.rs<|end_file_name|><｜fim▁begin｜>use num::logic::traits::CountZeros;<｜fim▁hole｜> #[inline]
fn count_zeros(self) -> u64 {
u64::from($t::count_zeros(self))
}
}
};
}
apply_to_primitive_ints!(impl_count_zeros);<｜fim▁end｜> |
macro_rules! impl_count_zeros {
($t:ident) => {
impl CountZeros for $t { |
<|file_name|>intensity_regression_test.py<|end_file_name|><｜fim▁begin｜>import unittest
import pandas as pd
import nose.tools
from mia.features.blobs import detect_blobs
from mia.features.intensity import detect_intensity
from mia.utils import preprocess_image
from ..test_utils import get_file_path
class IntensityTests(unittest.TestCase):
@classmethod
def setupClass(cls):
img_path = get_file_path("mias/mdb154.png")<｜fim▁hole｜> # def test_detect_intensity(self):
# blobs = detect_blobs(self._img, self._msk)
# intensity = detect_intensity(self._img, blobs)
#
# nose.tools.assert_true(isinstance(intensity, pd.DataFrame))
# nose.tools.assert_equal(intensity.shape[1], 10)<｜fim▁end｜> | msk_path = get_file_path("mias/masks/mdb154_mask.png")
cls._img, cls._msk = preprocess_image(img_path, msk_path)
|
<|file_name|>BeaconIndexType.java<|end_file_name|><｜fim▁begin｜>// ===================================================================================================
// _ __ _ _
// | |/ /__ _| | |_ _ _ _ _ __ _
// | ' </ _` | | _| || | '_/ _` |
// |_|\_\__,_|_|\__|\_,_|_| \__,_|
//<｜fim▁hole｜>// This file is part of the Kaltura Collaborative Media Suite which allows users
// to do with audio, video, and animation what Wiki platforms allow them to do with
// text.
//
// Copyright (C) 2006-2022 Kaltura Inc.
//
// 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/>.
//
// @ignore
// ===================================================================================================
package com.kaltura.client.enums;
/**
* This class was generated using generate.php
* against an XML schema provided by Kaltura.
*
* MANUAL CHANGES TO THIS CLASS WILL BE OVERWRITTEN.
*/
public enum BeaconIndexType implements EnumAsString {
LOG("Log"),
STATE("State");
private String value;
BeaconIndexType(String value) {
this.value = value;
}
@Override
public String getValue() {
return this.value;
}
public void setValue(String value) {
this.value = value;
}
public static BeaconIndexType get(String value) {
if(value == null)
{
return null;
}
// goes over BeaconIndexType defined values and compare the inner value with the given one:
for(BeaconIndexType item: values()) {
if(item.getValue().equals(value)) {
return item;
}
}
// in case the requested value was not found in the enum values, we return the first item as default.
return BeaconIndexType.values().length > 0 ? BeaconIndexType.values()[0]: null;
}
}<｜fim▁end｜> | |
<|file_name|>server-map-diagram-with-cytoscapejs.class.ts<|end_file_name|><｜fim▁begin｜>import cytoscape from 'cytoscape';
import dagre from 'cytoscape-dagre';
import { from as fromArray, fromEvent, iif, zip, merge, Observable } from 'rxjs';
import { mergeMap, map, pluck, switchMap, take, reduce } from 'rxjs/operators';
import ServerMapTheme from './server-map-theme';
import { ServerMapDiagram } from './server-map-diagram.class';
import { ServerMapData } from './server-map-data.class';
import { IServerMapOption } from './server-map-factory';
import { ServerMapTemplate } from './server-map-template';
import { NodeGroup } from './node-group.class';
export class ServerMapDiagramWithCytoscapejs extends ServerMapDiagram {
private cy: any;
constructor(
private option: IServerMapOption
) {
super();
ServerMapTheme.general.common.funcServerMapImagePath = this.option.funcServerMapImagePath;
this.makeDiagram();
}
private makeDiagram(): void {
cytoscape.use(dagre);
this.cy = cytoscape({
container: this.option.container,
elements: null,
style: [
{
selector: 'core',
style: {
'active-bg-size': 0,
// 'active-bg-color': PropertyValueCore<Colour>;
'active-bg-opacity': 0
// 'active-bg-size': PropertyValueCore<number>;
// 'selection-box-color': PropertyValueCore<Colour>;
// 'selection-box-border-color': PropertyValueCore<Colour>;
// 'selection-box-border-width': PropertyValueCore<number>;
// 'selection-box-opacity': PropertyValueCore<number>;
// 'outside-texture-bg-color': PropertyValueCore<Colour>;
// 'outside-texture-bg-opacity': PropertyValueCore<number>;
}
},
{
// TODO: Restructure ServerMapTheme and replace the style string with constant from it
selector: 'node',
style: {
width: 100,
height: 100,
'background-color': '#fff',
'border-width': '3',
'border-color': '#D0D7DF',
'text-valign': 'bottom',
'text-halign': 'center',
'text-margin-y': 4,
'background-clip': 'node',
'background-image': (ele: any) => ele.data('imgStr'),
label: 'data(label)',
'overlay-opacity': 0,
'font-family': 'Helvetica, Arial, avn85, NanumGothic, ng, dotum, AppleGothic, sans-serif',
'font-size': (ele: any) => ele.id() === this.baseApplicationKey ? '14px' : '12px',
'font-weight': (ele: any) => ele.id() === this.baseApplicationKey ? 'bold' : 'normal'
}
},
{
selector: 'edge',
style: {
width: 1.5,
'line-color': '#C0C3C8',
'target-arrow-shape': 'triangle',
'curve-style': 'bezier',
// icon unicode: f0b0
label: 'data(label)',
// label: String.fromCharCode(0xe903),
// 'font-family': 'Font Awesome 5 Free',
// 'font-size': 13,
// 'font-weight': 900,
'text-background-color': getComputedStyle(this.option.container).getPropertyValue('--background-color'),
'text-background-opacity': 1,
// 'text-wrap': 'wrap',
// 'font-family': 'FontAwesome, helvetica neue',
// 'font-style': 'normal',
'overlay-opacity': 0,
color: (ele: any) => ele.data('hasAlert') ? '#FF1300' : '#000'
}
},
{
selector: 'edge:loop',
style: {
'control-point-step-size': 70,
'loop-direction': '0deg',
'loop-sweep': '-90deg'
}
}
],
wheelSensitivity: 0.3
});
}
private bindEvent(): void {
this.cy.on('layoutready', () => {
this.resetViewport();
this.selectBaseApp();
this.outRenderCompleted.emit();
});
this.cy.nodes().on('select', ({target}: any) => {
const nodeKey = target.id();
const nodeData = this.getNodeData(nodeKey);
this.outClickNode.emit(nodeData);
this.initStyle();
this.setStyle(target, 'node');
});
this.cy.edges().on('select', ({target}: any) => {
const edgeKey = target.id();
const linkData = this.getLinkData(edgeKey);
this.outClickLink.emit(linkData);
this.initStyle();
this.setStyle(target, 'edge');
});
this.cy.on('cxttap', ({target, originalEvent}: any) => {
const {clientX, clientY} = originalEvent;
setTimeout(() => {
if (target === this.cy) {
this.outContextClickBackground.emit({coordX: clientX, coordY: clientY});
} else if (target.isEdge() && !NodeGroup.isGroupKey(target.id())) {
this.outContextClickLink.emit({
key: target.id(),
coord: {coordX: clientX, coordY: clientY}
});
}
});
});
this.cy.on('mousemove', ({target}: any) => {
this.setCursorStyle(target === this.cy ? 'default' : 'pointer');
});<｜fim▁hole｜> this.baseApplicationKey = baseApplicationKey;
const edges = serverMapData.getLinkList().map((link: {[key: string]: any}) => {
const {from, to, key, totalCount, isFiltered, hasAlert} = link;
return {
data: {
id: key,
source: from,
target: to,
// [임시]label에서 이미지를 지원하지않아서, filteredMap페이지에서 필터아이콘을 "Filtered" 텍스트로 대체.
// label: isFiltered ? ` [Filtered]\n${totalCount.toLocaleString()} ` : ` ${totalCount.toLocaleString()} `,
// TODO: Filter Icon 처리
label: totalCount.toLocaleString(),
hasAlert
}
};
});
const nodeList = serverMapData.getNodeList();
const nodes$ = this.getNodesObs(nodeList);
nodes$.subscribe((nodes: {[key: string]: any}[]) => {
this.cy.elements().remove();
this.cy.add({nodes, edges});
this.bindEvent();
this.cy.layout({
name: 'dagre',
rankDir: 'LR',
fit: false,
rankSep: 200
}).run();
});
}
private getMergedNodeLabel(topCountNodes: {[key: string]: any}[]): string {
return topCountNodes[0].applicationName;
}
private getNodesObs(nodeList: {[key: string]: any}[]): Observable<{[key: string]: any}> {
return fromArray(nodeList).pipe(
mergeMap((node: {[key: string]: any}) => {
const {key, applicationName, serviceType, isAuthorized, hasAlert, topCountNodes} = node;
const isMergedNode = NodeGroup.isGroupKey(key);
const serviceTypeImg = new Image();
serviceTypeImg.src = ServerMapTheme.general.common.funcServerMapImagePath(serviceType);
const serviceTypeImgLoadEvent$ = merge(
fromEvent(serviceTypeImg, 'load'),
fromEvent(serviceTypeImg, 'error').pipe(
switchMap(() => {
// If there is no image file for a serviceType, use NO_IMAGE_FOUND image file instead.
const tempImg = new Image();
tempImg.src = ServerMapTheme.general.common.funcServerMapImagePath('NO_IMAGE_FOUND');
return fromEvent(tempImg, 'load');
})
)
);
const innerObs$ = iif(() => hasAlert && isAuthorized,
(() => {
const alertImg = new Image();
alertImg.src = ServerMapTheme.general.common.funcServerMapImagePath(ServerMapTheme.general.common.icon.error);
return zip(
serviceTypeImgLoadEvent$.pipe(pluck('target')),
fromEvent(alertImg, 'load').pipe(pluck('target'))
);
})(),
serviceTypeImgLoadEvent$.pipe(map((v: Event) => [v.target]))
);
return innerObs$.pipe(
map((img: HTMLImageElement[]) => {
const svg = ServerMapTemplate.getSVGString(img, node);
return 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);
}),
map((imgStr: string) => {
return {
data: {
id: key,
label: isMergedNode ? this.getMergedNodeLabel(topCountNodes) : applicationName,
imgStr
},
};
})
);
}),
take(nodeList.length),
reduce((acc: {[key: string]: any}[], curr: {[key: string]: any}) => {
return [...acc, curr];
}, [])
);
}
private getNodeData(key: string): {[key: string]: any} {
return NodeGroup.isGroupKey(key) ? this.serverMapData.getMergedNodeData(key) : this.serverMapData.getNodeData(key);
}
private getLinkData(key: string): {[key: string]: any} {
return NodeGroup.isGroupKey(key) ? this.serverMapData.getMergedLinkData(key) : this.serverMapData.getLinkData(key);
}
private isNodeInDiagram(key: string): boolean {
return this.cy.getElementById(key).length !== 0;
}
private setCursorStyle(cursorStyle: string): void {
this.option.container.style.cursor = cursorStyle;
}
private resetViewport(): void {
this.cy.zoom(1);
this.cy.center(this.cy.getElementById(this.baseApplicationKey));
}
private selectBaseApp(): void {
this.cy.getElementById(this.baseApplicationKey).emit('select');
}
private initStyle(): void {
this.cy.nodes().style(this.getInActiveNodeStyle());
this.cy.edges().style(this.getInActiveEdgeStyle());
}
private setStyle(target: any, type: string): void {
if (type === 'node') {
target.style(this.getActiveNodeStyle());
target.connectedEdges().style(this.getActiveEdgeStyle());
} else {
target.style(this.getActiveEdgeStyle());
target.connectedNodes().style(this.getActiveNodeStyle());
}
}
private getInActiveNodeStyle(): {[key: string]: any} {
return {
'border-color': '#D0D7DF'
};
}
private getInActiveEdgeStyle(): {[key: string]: any} {
return {
'font-size': '12px',
'font-weight': 'normal',
'line-color': '#C0C3C8',
'target-arrow-color': '#C0C3C8'
};
}
private getActiveNodeStyle(): {[key: string]: any} {
return {
'border-color': '#4A61D1',
};
}
private getActiveEdgeStyle(): {[key: string]: any} {
return {
'font-size': '14px',
'font-weight': 'bold',
'line-color': '#4763d0',
'target-arrow-color': '#4763d0'
};
}
redraw(): void {
this.setMapData(this.serverMapData, this.baseApplicationKey);
}
refresh(): void {
this.resetViewport();
this.selectBaseApp();
}
clear(): void {
this.cy.destroy();
}
selectNodeBySearch(selectedAppKey: string): void {
let selectedNodeId = selectedAppKey;
const isMergedNode = !this.isNodeInDiagram(selectedAppKey);
if (isMergedNode) {
const selectedMergedNode = this.serverMapData.getNodeList().find(({key, mergedNodes}: {key: string, mergedNodes: {[key: string]: any}[]}) => {
return NodeGroup.isGroupKey(key) && mergedNodes.some(({key: nodeKey}: {key: string}) => nodeKey === selectedAppKey);
});
selectedNodeId = selectedMergedNode.key;
}
this.cy.center(this.cy.getElementById(selectedNodeId));
this.cy.getElementById(selectedNodeId).emit('select');
}
}<｜fim▁end｜> | }
setMapData(serverMapData: ServerMapData, baseApplicationKey = ''): void {
this.serverMapData = serverMapData; |
<|file_name|>main.rs<|end_file_name|><｜fim▁begin｜><｜fim▁hole｜><｜fim▁end｜> | uucore::bin!(uu_base32); |
<|file_name|>no-control-regex.js<|end_file_name|><｜fim▁begin｜>/**
* @fileoverview Rule to forbid control charactes from regular expressions.
* @author Nicholas C. Zakas
*/
"use strict";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = {
meta: {
docs: {
description: "disallow control characters in regular expressions",
category: "Possible Errors",
recommended: true
},
schema: []
},
create: function(context) {
/**
* Get the regex expression
* @param {ASTNode} node node to evaluate
* @returns {*} Regex if found else null
* @private
*/
function getRegExp(node) {
if (node.value instanceof RegExp) {
return node.value;
} else if (typeof node.value === "string") {
var parent = context.getAncestors().pop();
if ((parent.type === "NewExpression" || parent.type === "CallExpression") &&
parent.callee.type === "Identifier" && parent.callee.name === "RegExp"
) {
// there could be an invalid regular expression string
try {
return new RegExp(node.value);
} catch (ex) {
return null;
}
}
}
return null;
}
/**<｜fim▁hole｜> * @returns {boolean} returns true if finds control characters on given string
* @private
*/
function hasControlCharacters(regexStr) {
// check control characters, if RegExp object used
var hasControlChars = /[\x00-\x1f]/.test(regexStr); // eslint-disable-line no-control-regex
// check substr, if regex literal used
var subStrIndex = regexStr.search(/\\x[01][0-9a-f]/i);
if (!hasControlChars && subStrIndex > -1) {
// is it escaped, check backslash count
var possibleEscapeCharacters = regexStr.substr(0, subStrIndex).match(/\\+$/gi);
hasControlChars = possibleEscapeCharacters === null || !(possibleEscapeCharacters[0].length % 2);
}
return hasControlChars;
}
return {
Literal: function(node) {
var computedValue,
regex = getRegExp(node);
if (regex) {
computedValue = regex.toString();
if (hasControlCharacters(computedValue)) {
context.report(node, "Unexpected control character in regular expression.");
}
}
}
};
}
};<｜fim▁end｜> | * Check if given regex string has control characters in it
* @param {string} regexStr regex as string to check |
<|file_name|>generated.pb.go<|end_file_name|><｜fim▁begin｜>/*
Copyright 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.
*/
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto
/*
Package v1beta1 is a generated protocol buffer package.
It is generated from these files:
k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto
It has these top-level messages:
MutatingWebhook
MutatingWebhookConfiguration
MutatingWebhookConfigurationList
Rule
RuleWithOperations
ServiceReference
ValidatingWebhook
ValidatingWebhookConfiguration
ValidatingWebhookConfigurationList
WebhookClientConfig
*/
package v1beta1
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
import strings "strings"
import reflect "reflect"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
func (m *MutatingWebhook) Reset() { *m = MutatingWebhook{} }
func (*MutatingWebhook) ProtoMessage() {}
func (*MutatingWebhook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
func (m *MutatingWebhookConfiguration) Reset() { *m = MutatingWebhookConfiguration{} }
func (*MutatingWebhookConfiguration) ProtoMessage() {}
func (*MutatingWebhookConfiguration) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{1}
}
func (m *MutatingWebhookConfigurationList) Reset() { *m = MutatingWebhookConfigurationList{} }
func (*MutatingWebhookConfigurationList) ProtoMessage() {}
func (*MutatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{2}
}
func (m *Rule) Reset() { *m = Rule{} }
func (*Rule) ProtoMessage() {}
func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
func (m *RuleWithOperations) Reset() { *m = RuleWithOperations{} }
func (*RuleWithOperations) ProtoMessage() {}
func (*RuleWithOperations) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
func (m *ServiceReference) Reset() { *m = ServiceReference{} }
func (*ServiceReference) ProtoMessage() {}
func (*ServiceReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
func (m *ValidatingWebhook) Reset() { *m = ValidatingWebhook{} }
func (*ValidatingWebhook) ProtoMessage() {}
func (*ValidatingWebhook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
func (m *ValidatingWebhookConfiguration) Reset() { *m = ValidatingWebhookConfiguration{} }
func (*ValidatingWebhookConfiguration) ProtoMessage() {}
func (*ValidatingWebhookConfiguration) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{7}
}
func (m *ValidatingWebhookConfigurationList) Reset() { *m = ValidatingWebhookConfigurationList{} }
func (*ValidatingWebhookConfigurationList) ProtoMessage() {}
func (*ValidatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{8}
}
func (m *WebhookClientConfig) Reset() { *m = WebhookClientConfig{} }
func (*WebhookClientConfig) ProtoMessage() {}
func (*WebhookClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
func init() {
proto.RegisterType((*MutatingWebhook)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhook")
proto.RegisterType((*MutatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfiguration")
proto.RegisterType((*MutatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfigurationList")
proto.RegisterType((*Rule)(nil), "k8s.io.api.admissionregistration.v1beta1.Rule")
proto.RegisterType((*RuleWithOperations)(nil), "k8s.io.api.admissionregistration.v1beta1.RuleWithOperations")
proto.RegisterType((*ServiceReference)(nil), "k8s.io.api.admissionregistration.v1beta1.ServiceReference")
proto.RegisterType((*ValidatingWebhook)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhook")
proto.RegisterType((*ValidatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration")
proto.RegisterType((*ValidatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfigurationList")
proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.api.admissionregistration.v1beta1.WebhookClientConfig")
}
func (m *MutatingWebhook) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MutatingWebhook) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ClientConfig.Size()))
n1, err := m.ClientConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
if len(m.Rules) > 0 {
for _, msg := range m.Rules {
dAtA[i] = 0x1a
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.FailurePolicy != nil {
dAtA[i] = 0x22
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
i += copy(dAtA[i:], *m.FailurePolicy)
}
if m.NamespaceSelector != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
n2, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
if m.SideEffects != nil {
dAtA[i] = 0x32
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
i += copy(dAtA[i:], *m.SideEffects)
}
if m.TimeoutSeconds != nil {
dAtA[i] = 0x38
i++
i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
}
if len(m.AdmissionReviewVersions) > 0 {
for _, s := range m.AdmissionReviewVersions {
dAtA[i] = 0x42
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if m.MatchPolicy != nil {
dAtA[i] = 0x4a
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MatchPolicy)))
i += copy(dAtA[i:], *m.MatchPolicy)
}
if m.ReinvocationPolicy != nil {
dAtA[i] = 0x52
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ReinvocationPolicy)))
i += copy(dAtA[i:], *m.ReinvocationPolicy)
}
if m.ObjectSelector != nil {
dAtA[i] = 0x5a
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectSelector.Size()))
n3, err := m.ObjectSelector.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n3
}
return i, nil
}
func (m *MutatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MutatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n4
if len(m.Webhooks) > 0 {
for _, msg := range m.Webhooks {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *MutatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MutatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
n5, err := m.ListMeta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
if len(m.Items) > 0 {
for _, msg := range m.Items {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *Rule) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.APIGroups) > 0 {
for _, s := range m.APIGroups {
dAtA[i] = 0xa
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if len(m.APIVersions) > 0 {
for _, s := range m.APIVersions {
dAtA[i] = 0x12
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if len(m.Resources) > 0 {
for _, s := range m.Resources {
dAtA[i] = 0x1a
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if m.Scope != nil {
dAtA[i] = 0x22
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Scope)))
i += copy(dAtA[i:], *m.Scope)
}
return i, nil
}
func (m *RuleWithOperations) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *RuleWithOperations) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Operations) > 0 {
for _, s := range m.Operations {
dAtA[i] = 0xa
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.Rule.Size()))
n6, err := m.Rule.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
return i, nil
}
func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
i += copy(dAtA[i:], m.Namespace)
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
if m.Path != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
i += copy(dAtA[i:], *m.Path)
}
if m.Port != nil {
dAtA[i] = 0x20
i++
i = encodeVarintGenerated(dAtA, i, uint64(*m.Port))
}
return i, nil
}
func (m *ValidatingWebhook) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ValidatingWebhook) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ClientConfig.Size()))
n7, err := m.ClientConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
if len(m.Rules) > 0 {
for _, msg := range m.Rules {
dAtA[i] = 0x1a
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.FailurePolicy != nil {
dAtA[i] = 0x22
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
i += copy(dAtA[i:], *m.FailurePolicy)
}
if m.NamespaceSelector != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
n8, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
}
if m.SideEffects != nil {
dAtA[i] = 0x32
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
i += copy(dAtA[i:], *m.SideEffects)
}
if m.TimeoutSeconds != nil {
dAtA[i] = 0x38
i++
i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
}
if len(m.AdmissionReviewVersions) > 0 {
for _, s := range m.AdmissionReviewVersions {
dAtA[i] = 0x42
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if m.MatchPolicy != nil {
dAtA[i] = 0x4a
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MatchPolicy)))
i += copy(dAtA[i:], *m.MatchPolicy)
}
if m.ObjectSelector != nil {
dAtA[i] = 0x52
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectSelector.Size()))
n9, err := m.ObjectSelector.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
}
return i, nil
}
func (m *ValidatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ValidatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
n10, err := m.ObjectMeta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
if len(m.Webhooks) > 0 {
for _, msg := range m.Webhooks {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *ValidatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ValidatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
n11, err := m.ListMeta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n11
if len(m.Items) > 0 {
for _, msg := range m.Items {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Service != nil {
dAtA[i] = 0xa
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.Service.Size()))
n12, err := m.Service.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n12
}
if m.CABundle != nil {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
i += copy(dAtA[i:], m.CABundle)
}
if m.URL != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
i += copy(dAtA[i:], *m.URL)
}
return i, nil
}
func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *MutatingWebhook) Size() (n int) {
var l int
_ = l
l = len(m.Name)
n += 1 + l + sovGenerated(uint64(l))
l = m.ClientConfig.Size()
n += 1 + l + sovGenerated(uint64(l))
if len(m.Rules) > 0 {
for _, e := range m.Rules {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
if m.FailurePolicy != nil {
l = len(*m.FailurePolicy)
n += 1 + l + sovGenerated(uint64(l))
}
if m.NamespaceSelector != nil {
l = m.NamespaceSelector.Size()
n += 1 + l + sovGenerated(uint64(l))
}
if m.SideEffects != nil {
l = len(*m.SideEffects)
n += 1 + l + sovGenerated(uint64(l))
}
if m.TimeoutSeconds != nil {
n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
}
if len(m.AdmissionReviewVersions) > 0 {
for _, s := range m.AdmissionReviewVersions {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
if m.MatchPolicy != nil {
l = len(*m.MatchPolicy)
n += 1 + l + sovGenerated(uint64(l))
}
if m.ReinvocationPolicy != nil {
l = len(*m.ReinvocationPolicy)
n += 1 + l + sovGenerated(uint64(l))
}
if m.ObjectSelector != nil {
l = m.ObjectSelector.Size()
n += 1 + l + sovGenerated(uint64(l))
}
return n
}
func (m *MutatingWebhookConfiguration) Size() (n int) {<｜fim▁hole｜> if len(m.Webhooks) > 0 {
for _, e := range m.Webhooks {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
return n
}
func (m *MutatingWebhookConfigurationList) Size() (n int) {
var l int
_ = l
l = m.ListMeta.Size()
n += 1 + l + sovGenerated(uint64(l))
if len(m.Items) > 0 {
for _, e := range m.Items {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
return n
}
func (m *Rule) Size() (n int) {
var l int
_ = l
if len(m.APIGroups) > 0 {
for _, s := range m.APIGroups {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
if len(m.APIVersions) > 0 {
for _, s := range m.APIVersions {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
if len(m.Resources) > 0 {
for _, s := range m.Resources {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
if m.Scope != nil {
l = len(*m.Scope)
n += 1 + l + sovGenerated(uint64(l))
}
return n
}
func (m *RuleWithOperations) Size() (n int) {
var l int
_ = l
if len(m.Operations) > 0 {
for _, s := range m.Operations {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
l = m.Rule.Size()
n += 1 + l + sovGenerated(uint64(l))
return n
}
func (m *ServiceReference) Size() (n int) {
var l int
_ = l
l = len(m.Namespace)
n += 1 + l + sovGenerated(uint64(l))
l = len(m.Name)
n += 1 + l + sovGenerated(uint64(l))
if m.Path != nil {
l = len(*m.Path)
n += 1 + l + sovGenerated(uint64(l))
}
if m.Port != nil {
n += 1 + sovGenerated(uint64(*m.Port))
}
return n
}
func (m *ValidatingWebhook) Size() (n int) {
var l int
_ = l
l = len(m.Name)
n += 1 + l + sovGenerated(uint64(l))
l = m.ClientConfig.Size()
n += 1 + l + sovGenerated(uint64(l))
if len(m.Rules) > 0 {
for _, e := range m.Rules {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
if m.FailurePolicy != nil {
l = len(*m.FailurePolicy)
n += 1 + l + sovGenerated(uint64(l))
}
if m.NamespaceSelector != nil {
l = m.NamespaceSelector.Size()
n += 1 + l + sovGenerated(uint64(l))
}
if m.SideEffects != nil {
l = len(*m.SideEffects)
n += 1 + l + sovGenerated(uint64(l))
}
if m.TimeoutSeconds != nil {
n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
}
if len(m.AdmissionReviewVersions) > 0 {
for _, s := range m.AdmissionReviewVersions {
l = len(s)
n += 1 + l + sovGenerated(uint64(l))
}
}
if m.MatchPolicy != nil {
l = len(*m.MatchPolicy)
n += 1 + l + sovGenerated(uint64(l))
}
if m.ObjectSelector != nil {
l = m.ObjectSelector.Size()
n += 1 + l + sovGenerated(uint64(l))
}
return n
}
func (m *ValidatingWebhookConfiguration) Size() (n int) {
var l int
_ = l
l = m.ObjectMeta.Size()
n += 1 + l + sovGenerated(uint64(l))
if len(m.Webhooks) > 0 {
for _, e := range m.Webhooks {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
return n
}
func (m *ValidatingWebhookConfigurationList) Size() (n int) {
var l int
_ = l
l = m.ListMeta.Size()
n += 1 + l + sovGenerated(uint64(l))
if len(m.Items) > 0 {
for _, e := range m.Items {
l = e.Size()
n += 1 + l + sovGenerated(uint64(l))
}
}
return n
}
func (m *WebhookClientConfig) Size() (n int) {
var l int
_ = l
if m.Service != nil {
l = m.Service.Size()
n += 1 + l + sovGenerated(uint64(l))
}
if m.CABundle != nil {
l = len(m.CABundle)
n += 1 + l + sovGenerated(uint64(l))
}
if m.URL != nil {
l = len(*m.URL)
n += 1 + l + sovGenerated(uint64(l))
}
return n
}
func sovGenerated(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozGenerated(x uint64) (n int) {
return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *MutatingWebhook) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&MutatingWebhook{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
`Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + `,`,
`FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
`SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
`TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
`AdmissionReviewVersions:` + fmt.Sprintf("%v", this.AdmissionReviewVersions) + `,`,
`MatchPolicy:` + valueToStringGenerated(this.MatchPolicy) + `,`,
`ReinvocationPolicy:` + valueToStringGenerated(this.ReinvocationPolicy) + `,`,
`ObjectSelector:` + strings.Replace(fmt.Sprintf("%v", this.ObjectSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
`}`,
}, "")
return s
}
func (this *MutatingWebhookConfiguration) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&MutatingWebhookConfiguration{`,
`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
`Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "MutatingWebhook", "MutatingWebhook", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *MutatingWebhookConfigurationList) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&MutatingWebhookConfigurationList{`,
`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "MutatingWebhookConfiguration", "MutatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *Rule) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Rule{`,
`APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
`APIVersions:` + fmt.Sprintf("%v", this.APIVersions) + `,`,
`Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
`Scope:` + valueToStringGenerated(this.Scope) + `,`,
`}`,
}, "")
return s
}
func (this *RuleWithOperations) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&RuleWithOperations{`,
`Operations:` + fmt.Sprintf("%v", this.Operations) + `,`,
`Rule:` + strings.Replace(strings.Replace(this.Rule.String(), "Rule", "Rule", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *ServiceReference) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ServiceReference{`,
`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`Path:` + valueToStringGenerated(this.Path) + `,`,
`Port:` + valueToStringGenerated(this.Port) + `,`,
`}`,
}, "")
return s
}
func (this *ValidatingWebhook) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ValidatingWebhook{`,
`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
`ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
`Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + `,`,
`FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
`SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
`TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
`AdmissionReviewVersions:` + fmt.Sprintf("%v", this.AdmissionReviewVersions) + `,`,
`MatchPolicy:` + valueToStringGenerated(this.MatchPolicy) + `,`,
`ObjectSelector:` + strings.Replace(fmt.Sprintf("%v", this.ObjectSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
`}`,
}, "")
return s
}
func (this *ValidatingWebhookConfiguration) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ValidatingWebhookConfiguration{`,
`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
`Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "ValidatingWebhook", "ValidatingWebhook", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *ValidatingWebhookConfigurationList) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ValidatingWebhookConfigurationList{`,
`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ValidatingWebhookConfiguration", "ValidatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *WebhookClientConfig) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&WebhookClientConfig{`,
`Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "ServiceReference", "ServiceReference", 1) + `,`,
`CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
`URL:` + valueToStringGenerated(this.URL) + `,`,
`}`,
}, "")
return s
}
func valueToStringGenerated(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *MutatingWebhook) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MutatingWebhook: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MutatingWebhook: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Rules = append(m.Rules, RuleWithOperations{})
if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := FailurePolicyType(dAtA[iNdEx:postIndex])
m.FailurePolicy = &s
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.NamespaceSelector == nil {
m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
}
if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := SideEffectClass(dAtA[iNdEx:postIndex])
m.SideEffects = &s
iNdEx = postIndex
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
}
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.TimeoutSeconds = &v
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AdmissionReviewVersions", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AdmissionReviewVersions = append(m.AdmissionReviewVersions, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field MatchPolicy", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := MatchPolicyType(dAtA[iNdEx:postIndex])
m.MatchPolicy = &s
iNdEx = postIndex
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ReinvocationPolicy", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := ReinvocationPolicyType(dAtA[iNdEx:postIndex])
m.ReinvocationPolicy = &s
iNdEx = postIndex
case 11:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ObjectSelector", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ObjectSelector == nil {
m.ObjectSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
}
if err := m.ObjectSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MutatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MutatingWebhookConfiguration: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MutatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Webhooks = append(m.Webhooks, MutatingWebhook{})
if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MutatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MutatingWebhookConfigurationList: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MutatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Items = append(m.Items, MutatingWebhookConfiguration{})
if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Rule) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Rule: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field APIVersions", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.APIVersions = append(m.APIVersions, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := ScopeType(dAtA[iNdEx:postIndex])
m.Scope = &s
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *RuleWithOperations) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: RuleWithOperations: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RuleWithOperations: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Operations = append(m.Operations, OperationType(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ServiceReference) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Namespace = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := string(dAtA[iNdEx:postIndex])
m.Path = &s
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
}
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Port = &v
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ValidatingWebhook) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ValidatingWebhook: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ValidatingWebhook: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Rules = append(m.Rules, RuleWithOperations{})
if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := FailurePolicyType(dAtA[iNdEx:postIndex])
m.FailurePolicy = &s
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.NamespaceSelector == nil {
m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
}
if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := SideEffectClass(dAtA[iNdEx:postIndex])
m.SideEffects = &s
iNdEx = postIndex
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
}
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.TimeoutSeconds = &v
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AdmissionReviewVersions", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AdmissionReviewVersions = append(m.AdmissionReviewVersions, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field MatchPolicy", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := MatchPolicyType(dAtA[iNdEx:postIndex])
m.MatchPolicy = &s
iNdEx = postIndex
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ObjectSelector", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ObjectSelector == nil {
m.ObjectSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
}
if err := m.ObjectSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ValidatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ValidatingWebhookConfiguration: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ValidatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Webhooks = append(m.Webhooks, ValidatingWebhook{})
if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ValidatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ValidatingWebhookConfigurationList: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ValidatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Items = append(m.Items, ValidatingWebhookConfiguration{})
if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Service == nil {
m.Service = &ServiceReference{}
}
if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
if m.CABundle == nil {
m.CABundle = []byte{}
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
s := string(dAtA[iNdEx:postIndex])
m.URL = &s
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipGenerated(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenerated
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenerated
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenerated
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthGenerated
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowGenerated
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipGenerated(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
)
func init() {
proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto", fileDescriptorGenerated)
}
var fileDescriptorGenerated = []byte{
// 1113 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0x4d, 0x6f, 0x1b, 0xc5,
0x1b, 0xcf, 0xc6, 0x76, 0x6d, 0x8f, 0x93, 0xa6, 0x99, 0xff, 0x9f, 0xd6, 0x84, 0xca, 0x6b, 0xf9,
0x80, 0x2c, 0x41, 0x77, 0x9b, 0x80, 0x10, 0x14, 0x10, 0xca, 0x06, 0x0a, 0x91, 0x92, 0x36, 0x4c,
0xfa, 0x22, 0xf1, 0x22, 0x75, 0xbc, 0x1e, 0xdb, 0x83, 0xed, 0x9d, 0xd5, 0xce, 0xac, 0x43, 0x6e,
0x7c, 0x04, 0xbe, 0x02, 0x27, 0x3e, 0x05, 0x07, 0x6e, 0xe1, 0xd6, 0x63, 0x2f, 0xac, 0xc8, 0x72,
0xe2, 0xc0, 0x81, 0x6b, 0x4e, 0x68, 0x66, 0xc7, 0xeb, 0x97, 0x4d, 0x8a, 0x29, 0xa2, 0x17, 0x7a,
0xdb, 0xf9, 0x3d, 0xf3, 0xfc, 0x9e, 0x97, 0xd9, 0xe7, 0xf9, 0x81, 0x4f, 0xfb, 0x6f, 0x73, 0x8b,
0x32, 0xbb, 0x1f, 0xb6, 0x48, 0xe0, 0x11, 0x41, 0xb8, 0x3d, 0x22, 0x5e, 0x9b, 0x05, 0xb6, 0x36,
0x60, 0x9f, 0xda, 0xb8, 0x3d, 0xa4, 0x9c, 0x53, 0xe6, 0x05, 0xa4, 0x4b, 0xb9, 0x08, 0xb0, 0xa0,
0xcc, 0xb3, 0x47, 0x9b, 0x2d, 0x22, 0xf0, 0xa6, 0xdd, 0x25, 0x1e, 0x09, 0xb0, 0x20, 0x6d, 0xcb,
0x0f, 0x98, 0x60, 0xb0, 0x99, 0x78, 0x5a, 0xd8, 0xa7, 0xd6, 0xb9, 0x9e, 0x96, 0xf6, 0xdc, 0xb8,
0xd1, 0xa5, 0xa2, 0x17, 0xb6, 0x2c, 0x97, 0x0d, 0xed, 0x2e, 0xeb, 0x32, 0x5b, 0x11, 0xb4, 0xc2,
0x8e, 0x3a, 0xa9, 0x83, 0xfa, 0x4a, 0x88, 0x37, 0xde, 0x9c, 0xa4, 0x34, 0xc4, 0x6e, 0x8f, 0x7a,
0x24, 0x38, 0xb6, 0xfd, 0x7e, 0x57, 0x02, 0xdc, 0x1e, 0x12, 0x81, 0xed, 0x51, 0x26, 0x9d, 0x0d,
0xfb, 0x22, 0xaf, 0x20, 0xf4, 0x04, 0x1d, 0x92, 0x8c, 0xc3, 0x5b, 0x7f, 0xe5, 0xc0, 0xdd, 0x1e,
0x19, 0xe2, 0x79, 0xbf, 0xc6, 0x4f, 0x45, 0xb0, 0xb6, 0x1f, 0x0a, 0x2c, 0xa8, 0xd7, 0x7d, 0x48,
0x5a, 0x3d, 0xc6, 0xfa, 0xb0, 0x0e, 0xf2, 0x1e, 0x1e, 0x92, 0xaa, 0x51, 0x37, 0x9a, 0x65, 0x67,
0xe5, 0x24, 0x32, 0x97, 0xe2, 0xc8, 0xcc, 0xdf, 0xc1, 0x43, 0x82, 0x94, 0x05, 0x1e, 0x81, 0x15,
0x77, 0x40, 0x89, 0x27, 0x76, 0x98, 0xd7, 0xa1, 0xdd, 0xea, 0x72, 0xdd, 0x68, 0x56, 0xb6, 0xde,
0xb7, 0x16, 0x6d, 0xa2, 0xa5, 0x43, 0xed, 0x4c, 0x91, 0x38, 0xff, 0xd7, 0x81, 0x56, 0xa6, 0x51,
0x34, 0x13, 0x08, 0x62, 0x50, 0x08, 0xc2, 0x01, 0xe1, 0xd5, 0x5c, 0x3d, 0xd7, 0xac, 0x6c, 0xbd,
0xb7, 0x78, 0x44, 0x14, 0x0e, 0xc8, 0x43, 0x2a, 0x7a, 0x77, 0x7d, 0x92, 0x58, 0xb8, 0xb3, 0xaa,
0x03, 0x16, 0xa4, 0x8d, 0xa3, 0x84, 0x19, 0xee, 0x81, 0xd5, 0x0e, 0xa6, 0x83, 0x30, 0x20, 0x07,
0x6c, 0x40, 0xdd, 0xe3, 0x6a, 0x5e, 0xb5, 0xe1, 0xd5, 0x38, 0x32, 0x57, 0x6f, 0x4f, 0x1b, 0xce,
0x22, 0x73, 0x7d, 0x06, 0xb8, 0x77, 0xec, 0x13, 0x34, 0xeb, 0x0c, 0xbf, 0x06, 0xeb, 0xb2, 0x63,
0xdc, 0xc7, 0x2e, 0x39, 0x24, 0x03, 0xe2, 0x0a, 0x16, 0x54, 0x0b, 0xaa, 0x5d, 0x6f, 0x4c, 0x25,
0x9f, 0xbe, 0x99, 0xe5, 0xf7, 0xbb, 0x12, 0xe0, 0x96, 0xfc, 0x35, 0xac, 0xd1, 0xa6, 0xb5, 0x87,
0x5b, 0x64, 0x30, 0x76, 0x75, 0x5e, 0x8a, 0x23, 0x73, 0xfd, 0xce, 0x3c, 0x23, 0xca, 0x06, 0x81,
0x1f, 0x82, 0x0a, 0xa7, 0x6d, 0xf2, 0x51, 0xa7, 0x43, 0x5c, 0xc1, 0xab, 0x97, 0x54, 0x15, 0x8d,
0x38, 0x32, 0x2b, 0x87, 0x13, 0xf8, 0x2c, 0x32, 0xd7, 0x26, 0xc7, 0x9d, 0x01, 0xe6, 0x1c, 0x4d,
0xbb, 0xc1, 0x5b, 0xe0, 0xb2, 0xfc, 0x7d, 0x58, 0x28, 0x0e, 0x89, 0xcb, 0xbc, 0x36, 0xaf, 0x16,
0xeb, 0x46, 0xb3, 0xe0, 0xc0, 0x38, 0x32, 0x2f, 0xdf, 0x9b, 0xb1, 0xa0, 0xb9, 0x9b, 0xf0, 0x3e,
0xb8, 0x96, 0xbe, 0x09, 0x22, 0x23, 0x4a, 0x8e, 0x1e, 0x90, 0x40, 0x1e, 0x78, 0xb5, 0x54, 0xcf,
0x35, 0xcb, 0xce, 0x2b, 0x71, 0x64, 0x5e, 0xdb, 0x3e, 0xff, 0x0a, 0xba, 0xc8, 0x57, 0x16, 0x36,
0xc4, 0xc2, 0xed, 0xe9, 0xe7, 0x29, 0x4f, 0x0a, 0xdb, 0x9f, 0xc0, 0xb2, 0xb0, 0xa9, 0xa3, 0x7a,
0x9a, 0x69, 0x37, 0xf8, 0x08, 0xc0, 0x80, 0x50, 0x6f, 0xc4, 0x5c, 0xf5, 0x37, 0x68, 0x32, 0xa0,
0xc8, 0x6e, 0xc6, 0x91, 0x09, 0x51, 0xc6, 0x7a, 0x16, 0x99, 0x57, 0xb3, 0xa8, 0xa2, 0x3e, 0x87,
0x0b, 0x32, 0x70, 0x99, 0xb5, 0xbe, 0x22, 0xae, 0x48, 0xdf, 0xbd, 0xf2, 0xec, 0xef, 0xae, 0xfa,
0x7d, 0x77, 0x86, 0x0e, 0xcd, 0xd1, 0x37, 0x7e, 0x36, 0xc0, 0xf5, 0xb9, 0x59, 0x4e, 0xc6, 0x26,
0x4c, 0xfe, 0x78, 0xf8, 0x08, 0x94, 0x24, 0x7b, 0x1b, 0x0b, 0xac, 0x86, 0xbb, 0xb2, 0x75, 0x73,
0xb1, 0x5c, 0x92, 0xc0, 0xfb, 0x44, 0x60, 0x07, 0xea, 0xa1, 0x01, 0x13, 0x0c, 0xa5, 0xac, 0xf0,
0x73, 0x50, 0xd2, 0x91, 0x79, 0x75, 0x59, 0x8d, 0xe8, 0x3b, 0x8b, 0x8f, 0xe8, 0x5c, 0xee, 0x4e,
0x5e, 0x86, 0x42, 0xa5, 0x23, 0x4d, 0xd8, 0xf8, 0xdd, 0x00, 0xf5, 0xa7, 0xd5, 0xb7, 0x47, 0xb9,
0x80, 0x5f, 0x64, 0x6a, 0xb4, 0x16, 0xec, 0x37, 0xe5, 0x49, 0x85, 0x57, 0x74, 0x85, 0xa5, 0x31,
0x32, 0x55, 0x5f, 0x1f, 0x14, 0xa8, 0x20, 0xc3, 0x71, 0x71, 0xb7, 0x9f, 0xb9, 0xb8, 0x99, 0xc4,
0x27, 0x9b, 0x68, 0x57, 0x92, 0xa3, 0x24, 0x46, 0xe3, 0x47, 0x03, 0xe4, 0xe5, 0x6a, 0x82, 0xaf,
0x81, 0x32, 0xf6, 0xe9, 0xc7, 0x01, 0x0b, 0x7d, 0x5e, 0x35, 0xd4, 0xe8, 0xac, 0xc6, 0x91, 0x59,
0xde, 0x3e, 0xd8, 0x4d, 0x40, 0x34, 0xb1, 0xc3, 0x4d, 0x50, 0xc1, 0x3e, 0x4d, 0x27, 0x6d, 0x59,
0x5d, 0x5f, 0x93, 0xe3, 0xb1, 0x7d, 0xb0, 0x9b, 0x4e, 0xd7, 0xf4, 0x1d, 0xc9, 0x1f, 0x10, 0xce,
0xc2, 0xc0, 0xd5, 0x9b, 0x55, 0xf3, 0xa3, 0x31, 0x88, 0x26, 0x76, 0xf8, 0x3a, 0x28, 0x70, 0x97,
0xf9, 0x44, 0xef, 0xc5, 0xab, 0x32, 0xed, 0x43, 0x09, 0x9c, 0x45, 0x66, 0x59, 0x7d, 0xa8, 0x89,
0x48, 0x2e, 0x35, 0xbe, 0x37, 0x00, 0xcc, 0xae, 0x5e, 0xf8, 0x01, 0x00, 0x2c, 0x3d, 0xe9, 0x92,
0x4c, 0xf5, 0x57, 0xa5, 0xe8, 0x59, 0x64, 0xae, 0xa6, 0x27, 0x45, 0x39, 0xe5, 0x02, 0x0f, 0x40,
0x5e, 0xae, 0x6b, 0xad, 0x3c, 0xd6, 0xdf, 0xd3, 0x81, 0x89, 0xa6, 0xc9, 0x13, 0x52, 0x4c, 0x8d,
0xef, 0x0c, 0x70, 0xe5, 0x90, 0x04, 0x23, 0xea, 0x12, 0x44, 0x3a, 0x24, 0x20, 0x9e, 0x4b, 0xa0,
0x0d, 0xca, 0xe9, 0x66, 0xd5, 0x7a, 0xb8, 0xae, 0x7d, 0xcb, 0xe9, 0x16, 0x46, 0x93, 0x3b, 0xa9,
0x76, 0x2e, 0x5f, 0xa8, 0x9d, 0xd7, 0x41, 0xde, 0xc7, 0xa2, 0x57, 0xcd, 0xa9, 0x1b, 0x25, 0x69,
0x3d, 0xc0, 0xa2, 0x87, 0x14, 0xaa, 0xac, 0x2c, 0x10, 0xaa, 0xb9, 0x05, 0x6d, 0x65, 0x81, 0x40,
0x0a, 0x6d, 0xfc, 0x76, 0x09, 0xac, 0x3f, 0xc0, 0x03, 0xda, 0x7e, 0xa1, 0xd7, 0x2f, 0xf4, 0xfa,
0xbf, 0xa5, 0xd7, 0x59, 0x35, 0x05, 0xff, 0xae, 0x9a, 0x9e, 0x1a, 0xa0, 0x96, 0x99, 0xb5, 0xe7,
0xad, 0xa7, 0x5f, 0x66, 0xf4, 0xf4, 0xdd, 0xc5, 0x47, 0x28, 0x93, 0x7d, 0x46, 0x51, 0xff, 0x30,
0x40, 0xe3, 0xe9, 0x35, 0x3e, 0x07, 0x4d, 0x1d, 0xce, 0x6a, 0xea, 0x27, 0xff, 0xa0, 0xc0, 0x45,
0x54, 0xf5, 0x07, 0x03, 0xfc, 0xef, 0x9c, 0x75, 0x06, 0x31, 0x28, 0xf2, 0x64, 0xfd, 0xeb, 0x1a,
0x6f, 0x2d, 0x9e, 0xc8, 0xbc, 0x6e, 0x38, 0x95, 0x38, 0x32, 0x8b, 0x63, 0x74, 0xcc, 0x0b, 0x9b,
0xa0, 0xe4, 0x62, 0x27, 0xf4, 0xda, 0x5a, 0xb8, 0x56, 0x9c, 0x15, 0xd9, 0x93, 0x9d, 0xed, 0x04,
0x43, 0xa9, 0x15, 0xbe, 0x0c, 0x72, 0x61, 0x30, 0xd0, 0x1a, 0x51, 0x8c, 0x23, 0x33, 0x77, 0x1f,
0xed, 0x21, 0x89, 0x39, 0x37, 0x4e, 0x4e, 0x6b, 0x4b, 0x8f, 0x4f, 0x6b, 0x4b, 0x4f, 0x4e, 0x6b,
0x4b, 0xdf, 0xc4, 0x35, 0xe3, 0x24, 0xae, 0x19, 0x8f, 0xe3, 0x9a, 0xf1, 0x24, 0xae, 0x19, 0xbf,
0xc4, 0x35, 0xe3, 0xdb, 0x5f, 0x6b, 0x4b, 0x9f, 0x15, 0x75, 0x6a, 0x7f, 0x06, 0x00, 0x00, 0xff,
0xff, 0xc3, 0x6f, 0x8b, 0x7e, 0x2c, 0x0f, 0x00, 0x00,
}<｜fim▁end｜> | var l int
_ = l
l = m.ObjectMeta.Size()
n += 1 + l + sovGenerated(uint64(l)) |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
@date: 2014-07-02
@author: shell.xu
'''
import os, sys, json, logging
import bottle
from bottle import request, template, redirect
from db import *
logger = logging.getLogger('utils')
app = bottle.default_app()
sess = app.config.get('db.session')
LOGFMT = '%(asctime)s.%(msecs)03d[%(levelname)s](%(module)s:%(lineno)d): %(message)s'
def initlog(lv, logfile=None, stream=None, longdate=False):
if isinstance(lv, basestring): lv = getattr(logging, lv)
kw = {'format': LOGFMT, 'datefmt': '%H:%M:%S', 'level': lv}
if logfile: kw['filename'] = logfile
if stream: kw['stream'] = stream
if longdate: kw['datefmt'] = '%Y-%m-%d %H:%M:%S'
logging.basicConfig(**kw)
def chklogin(perm=None, next=None):
def receiver(func):
def _inner(*p, **kw):
session = request.environ.get('beaker.session')
if 'username' not in session or 'perms' not in session:
return redirect('/usr/login?next=%s' % (next or request.path))
if perm:
if hasattr(perm, '__iter__'):
if not all([p in session['perms'] for p in perm]):
return "you don't have %s permissions" % perm
elif perm not in session['perms']:
return "you don't have %s permissions" % perm
return func(session, *p, **kw)
return _inner
return receiver
def jsonenc(func):
def _inner(*p, **kw):
try: r = func(*p, **kw)
except Exception, err:
r = {'errmsg': str(err)}
r = json.dumps(r)
logger.debug(r)
return r
return _inner
def log(logger, log):
session = request.environ.get('beaker.session')
logger.info(log)
sess.add(AuditLogs(username=session['username'], log=log))
def paged_template(tmpl, **kw):
for k, v in kw.items():
if k.startswith('_'):
name, objs = k[1:], v
break
del kw['_' + name]
page = int(request.query.page or 1)
cnt = objs.count()
pagenum = int(app.config.get('page.number'))<｜fim▁hole｜> kw[name] = objs.slice(start, stop)
return template(tmpl, page=page, **kw)<｜fim▁end｜> |
start = (page - 1) * pagenum
stop = min(start + pagenum, cnt)
kw['pagemax'] = int((cnt-1) / pagenum) + 1 |
<|file_name|>DebuggerTestingTransform.cpp<|end_file_name|><｜fim▁begin｜>//===--- DebuggerTestingTransform.cpp - Transform for debugger testing ----===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
///
/// \file This transform inserts instrumentation which the debugger can use to
/// test its expression evaluation facilities.
///
//===----------------------------------------------------------------------===//
#include "swift/AST/ASTContext.h"
#include "swift/AST/ASTNode.h"
#include "swift/AST/ASTWalker.h"
#include "swift/AST/Decl.h"
#include "swift/AST/DeclContext.h"
#include "swift/AST/Expr.h"
#include "swift/AST/Module.h"
#include "swift/AST/ParameterList.h"
#include "swift/AST/Stmt.h"
#include "swift/Subsystems.h"
#include "TypeChecker.h"
using namespace swift;
namespace {
/// Find available closure discriminators.
///
/// The parser typically takes care of assigning unique discriminators to
/// closures, but the parser is unavailable to this transform.
class DiscriminatorFinder : public ASTWalker {
unsigned NextDiscriminator = 0;
public:
Expr *walkToExprPost(Expr *E) override {
auto *ACE = dyn_cast<AbstractClosureExpr>(E);
if (!ACE)
return E;
unsigned Discriminator = ACE->getDiscriminator();
assert(Discriminator != AbstractClosureExpr::InvalidDiscriminator &&
"Existing closures should have valid discriminators");
if (Discriminator >= NextDiscriminator)
NextDiscriminator = Discriminator + 1;
return E;
}
// Get the next available closure discriminator.
unsigned getNextDiscriminator() {
if (NextDiscriminator == AbstractClosureExpr::InvalidDiscriminator)
llvm::report_fatal_error("Out of valid closure discriminators");
return NextDiscriminator++;
}
};
/// Instrument decls with sanity-checks which the debugger can evaluate.
class DebuggerTestingTransform : public ASTWalker {
ASTContext &Ctx;
DiscriminatorFinder &DF;
std::vector<DeclContext *> LocalDeclContextStack;
public:
DebuggerTestingTransform(ASTContext &Ctx, DiscriminatorFinder &DF)
: Ctx(Ctx), DF(DF) {}
bool walkToDeclPre(Decl *D) override {
pushLocalDeclContext(D);
// Whitelist the kinds of decls to transform.
// TODO: Expand the set of decls visited here.
if (auto *FD = dyn_cast<AbstractFunctionDecl>(D))
return !FD->isImplicit() && FD->getBody();
if (auto *TLCD = dyn_cast<TopLevelCodeDecl>(D))
return !TLCD->isImplicit() && TLCD->getBody();
return false;
}
bool walkToDeclPost(Decl *D) override {
popLocalDeclContext(D);
return true;
}
std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
pushLocalDeclContext(E);
// Whitelist the kinds of exprs to transform.
// TODO: Expand the set of exprs visited here.
if (auto *AE = dyn_cast<AssignExpr>(E))
return insertCheckExpect(AE, AE->getDest());
return {true, E};
}
Expr *walkToExprPost(Expr *E) override {
popLocalDeclContext(E);
return E;
}
private:
/// Return N as a local DeclContext if possible, or return nullptr.
DeclContext *getLocalDeclContext(ASTNode N) const {
DeclContext *DC = N.getAsDeclContext();
return (DC && DC->isLocalContext()) ? DC : nullptr;
}
/// If N is a local DeclContext, push it onto the context stack.
void pushLocalDeclContext(ASTNode N) {
if (auto *LDC = getLocalDeclContext(N))
LocalDeclContextStack.push_back(LDC);
}
/// If N is a local DeclContext, pop it off the context stack.
void popLocalDeclContext(ASTNode N) {
if (getLocalDeclContext(N))
LocalDeclContextStack.pop_back();
}
/// Get the current local DeclContext. This is used to create closures in the
/// right context.
DeclContext *getCurrentDeclContext() const {
assert(!LocalDeclContextStack.empty() && "Missing decl context");
return LocalDeclContextStack.back();
}
/// Try to extract a DeclRefExpr from the expression.
DeclRefExpr *extractDecl(Expr *E) {
while (!isa<DeclRefExpr>(E)) {
// TODO: Try more ways to extract interesting decl refs.
if (auto *Subscript = dyn_cast<SubscriptExpr>(E))
E = Subscript->getBase();
else if (auto *InOut = dyn_cast<InOutExpr>(E))
E = InOut->getSubExpr();
else
return nullptr;
}
return cast<DeclRefExpr>(E);
}
/// Attempt to create a functionally-equivalent replacement for OriginalExpr,
/// given that DstExpr identifies the target of some mutating update, and that
/// DstExpr is a subexpression of OriginalExpr.
///
/// The return value contains 1) a flag indicating whether or not to
/// recursively transform the children of the transformed expression, and 2)
/// the transformed expression itself.
std::pair<bool, Expr *> insertCheckExpect(Expr *OriginalExpr, Expr *DstExpr) {
auto *DstDRE = extractDecl(DstExpr);
if (!DstDRE)
return {true, OriginalExpr};
ValueDecl *DstDecl = DstDRE->getDecl();
if (!DstDecl->hasName())
return {true, OriginalExpr};
// Don't capture variables which aren't default-initialized.
if (auto *VD = dyn_cast<VarDecl>(DstDecl))
if (!VD->getParentInitializer() && !VD->isInOut())
return {true, OriginalExpr};
// Rewrite the original expression into this:
// call
// closure {
// $OriginalExpr
// checkExpect("$Varname", _stringForPrintObject($Varname))
// }
// Create "$Varname".
llvm::SmallString<256> DstNameBuf;
DeclName DstDN = DstDecl->getFullName();
StringRef DstName = Ctx.AllocateCopy(DstDN.getString(DstNameBuf));
assert(!DstName.empty() && "Varname must be non-empty");
Expr *Varname = new (Ctx) StringLiteralExpr(DstName, SourceRange());
Varname->setImplicit(true);
// Create _stringForPrintObject($Varname).
auto *PODeclRef = new (Ctx)
UnresolvedDeclRefExpr(Ctx.getIdentifier("_stringForPrintObject"),
DeclRefKind::Ordinary, DeclNameLoc());
Expr *POArgs[] = {DstDRE};
Identifier POLabels[] = {Identifier()};
auto *POCall = CallExpr::createImplicit(Ctx, PODeclRef, POArgs, POLabels);
POCall->setThrows(false);
// Create the call to checkExpect.
Identifier CheckExpectLabels[] = {Identifier(), Identifier()};
Expr *CheckExpectArgs[] = {Varname, POCall};
UnresolvedDeclRefExpr *CheckExpectDRE = new (Ctx)
UnresolvedDeclRefExpr(Ctx.getIdentifier("_debuggerTestingCheckExpect"),
DeclRefKind::Ordinary, DeclNameLoc());
auto *CheckExpectExpr = CallExpr::createImplicit(
Ctx, CheckExpectDRE, CheckExpectArgs, CheckExpectLabels);
CheckExpectExpr->setThrows(false);
// Create the closure.
TypeChecker TC{Ctx};
auto *Params = ParameterList::createEmpty(Ctx);
auto *Closure = new (Ctx)
ClosureExpr(Params, SourceLoc(), SourceLoc(), SourceLoc(), TypeLoc(),
DF.getNextDiscriminator(), getCurrentDeclContext());
Closure->setImplicit(true);
// TODO: Save and return the value of $OriginalExpr.
ASTNode ClosureElements[] = {OriginalExpr, CheckExpectExpr};
auto *ClosureBody = BraceStmt::create(Ctx, SourceLoc(), ClosureElements,
SourceLoc(), /*Implicit=*/true);
Closure->setBody(ClosureBody, /*isSingleExpression=*/false);
// Call the closure.
auto *ClosureCall = CallExpr::createImplicit(Ctx, Closure, {}, {});
ClosureCall->setThrows(false);
// TODO: typeCheckExpression() seems to assign types to everything here,
// but may not be sufficient in some cases.
Expr *FinalExpr = ClosureCall;
if (!TC.typeCheckExpression(FinalExpr, getCurrentDeclContext()))
llvm::report_fatal_error("Could not type-check instrumentation");
// Captures have to be computed after the closure is type-checked. This
// ensures that the type checker can infer <noescape> for captured values.
TC.computeCaptures(Closure);
return {false, FinalExpr};
}
};
<｜fim▁hole｜> // Walk over all decls in the file to find the next available closure
// discriminator.
DiscriminatorFinder DF;
for (Decl *D : SF.Decls)
D->walk(DF);
// Instrument the decls with checkExpect() sanity-checks.
for (Decl *D : SF.Decls) {
DebuggerTestingTransform Transform{D->getASTContext(), DF};
D->walk(Transform);
swift::verify(D);
}
}<｜fim▁end｜> | } // end anonymous namespace
void swift::performDebuggerTestingTransform(SourceFile &SF) { |
<|file_name|>_configuration.py<|end_file_name|><｜fim▁begin｜># coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.<｜fim▁hole｜>from typing import Any, TYPE_CHECKING
from azure.core.configuration import Configuration
from azure.core.pipeline import policies
from azure.mgmt.core.policies import ARMHttpLoggingPolicy
from .._version import VERSION
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials_async import AsyncTokenCredential
class OperationsManagementClientConfiguration(Configuration):
"""Configuration for OperationsManagementClient.
Note that all parameters used to create this instance are saved as instance
attributes.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials_async.AsyncTokenCredential
:param subscription_id: Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
:type subscription_id: str
:param provider_name: Provider name for the parent resource.
:type provider_name: str
:param resource_type: Resource type for the parent resource.
:type resource_type: str
:param resource_name: Parent resource name.
:type resource_name: str
"""
def __init__(
self,
credential: "AsyncTokenCredential",
subscription_id: str,
provider_name: str,
resource_type: str,
resource_name: str,
**kwargs: Any
) -> None:
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if subscription_id is None:
raise ValueError("Parameter 'subscription_id' must not be None.")
if provider_name is None:
raise ValueError("Parameter 'provider_name' must not be None.")
if resource_type is None:
raise ValueError("Parameter 'resource_type' must not be None.")
if resource_name is None:
raise ValueError("Parameter 'resource_name' must not be None.")
super(OperationsManagementClientConfiguration, self).__init__(**kwargs)
self.credential = credential
self.subscription_id = subscription_id
self.provider_name = provider_name
self.resource_type = resource_type
self.resource_name = resource_name
self.api_version = "2015-11-01-preview"
self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default'])
kwargs.setdefault('sdk_moniker', 'mgmt-operationsmanagement/{}'.format(VERSION))
self._configure(**kwargs)
def _configure(
self,
**kwargs: Any
) -> None:
self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs)
self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs)
self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs)
self.authentication_policy = kwargs.get('authentication_policy')
if self.credential and not self.authentication_policy:
self.authentication_policy = policies.AsyncBearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs)<｜fim▁end｜> | # Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
|
<|file_name|>mod.rs<|end_file_name|><｜fim▁begin｜>//! Resolution of the entire dependency graph for a crate
//!
//! This module implements the core logic in taking the world of crates and
//! constraints and creating a resolved graph with locked versions for all
//! crates and their dependencies. This is separate from the registry module
//! which is more worried about discovering crates from various sources, this
//! module just uses the Registry trait as a source to learn about crates from.
//!
//! Actually solving a constraint graph is an NP-hard (or NP-complete, I forget
//! which) problem, this the algorithm is basically a nice heuristic to make
//! sure we get roughly the best answer most of the time. The constraints that
//! we're working with are:
//!
//! 1. Each crate can have any number of dependencies. Each dependency can
//! declare a version range that it is compatible with.
//! 2. Crates can be activated with multiple version (e.g. show up in the
//! dependency graph twice) so long as each pairwise instance have
//! semver-incompatible versions.
//!
//! The algorithm employed here is fairly simple, we simply do a DFS, activating
//! the "newest crate" (highest version) first and then going to the next
//! option. The heuristics we employ are:
//!
//! * Never try to activate a crate version which is incompatible. This means we
//! only try crates which will actually satisfy a dependency and we won't ever
//! try to activate a crate that's semver compatible with something else
//! activatd (as we're only allowed to have one).
//! * Always try to activate the highest version crate first. The default
//! dependency in Cargo (e.g. when you write `foo = "0.1.2"`) is
//! semver-compatible, so selecting the highest version possible will allow us
//! to hopefully satisfy as many dependencies at once.
//!
//! Beyond that, what's implemented below is just a naive backtracking version
//! which should in theory try all possible combinations of dependencies and
//! versions to see if one works. The first resolution that works causes
//! everything to bail out immediately and return success, and only if *nothing*
//! works do we actually return an error up the stack.
//!
//! ## Performance
//!
//! Note that this is a relatively performance-critical portion of Cargo. The
//! data that we're processing is proportional to the size of the dependency
//! graph, which can often be quite large (e.g. take a look at Servo). To make
//! matters worse the DFS algorithm we're implemented is inherently quite
//! inefficient and recursive. When we add the requirement of backtracking on
//! top it means that we're implementing something that's very recursive and
//! probably shouldn't be allocating all over the place.
//!
//! Once we've avoided too many unnecessary allocations, however (e.g. using
//! references, using reference counting, etc), it turns out that the
//! performance in this module largely comes down to stack sizes due to the
//! recursive nature of the implementation.
//!
//! ### Small Stack Sizes (e.g. y u inline(never))
//!
//! One of the most important optimizations in this module right now is the
//! attempt to minimize the stack space taken up by the `activate` and
//! `activate_deps` functions. These two functions are mutually recursive in a
//! CPS fashion.
//!
//! The recursion depth, if I'm getting this right, is something along the order
//! of O(E) where E is the number of edges in the dependency graph, and that's
//! on the order of O(N^2) where N is the number of crates in the graph. As a
//! result we need to watch our stack size!
//!
//! Currently rustc is not great at producing small stacks because of landing
//! pads and filling drop, so the first attempt at making small stacks is having
//! literally small functions with very few owned values on the stack. This is
//! also why there are many #[inline(never)] annotations in this module. By
//! preventing these functions from being inlined we can make sure that these
//! stack sizes stay small as the number of locals are under control.
//!
//! Another hazard when watching out for small stacks is passing around large
//! structures by value. For example the `Context` below is a relatively large
//! struct, so we always place it behind a `Box` to ensure the size at runtime
//! is just a word (e.g. very easy to pass around).
//!
//! Combined together these tricks (plus a very recent version of LLVM) allow us
//! to have a relatively small stack footprint for this implementation. Possible
//! future optimizations include:
//!
//! * Turn off landing pads for all of Cargo
//! * Wait for dynamic drop
//! * Use a manual stack instead of the OS stack (I suspect this will be super
//! painful to implement)
//! * Spawn a new thread with a very large stack (this is what the compiler
//! does)
//! * Implement a form of segmented stacks where we manually check the stack
//! limit every so often.
//!
//! For now the current implementation of this module gets us past Servo's
//! dependency graph (one of the largest known ones), so hopefully it'll work
//! for a bit longer as well!
use std::cell::RefCell;
use std::collections::HashSet;
use std::collections::hash_map::HashMap;
use std::fmt;
use std::rc::Rc;
use std::slice;
use semver;
use core::{PackageId, Registry, SourceId, Summary, Dependency};
use core::PackageIdSpec;
use util::{CargoResult, Graph, human, ChainError, CargoError};
use util::profile;
use util::graph::{Nodes, Edges};
pub use self::encode::{EncodableResolve, EncodableDependency, EncodablePackageId};
pub use self::encode::Metadata;
mod encode;
/// Represents a fully resolved package dependency graph. Each node in the graph
/// is a package and edges represent dependencies between packages.
///
/// Each instance of `Resolve` also understands the full set of features used
/// for each package as well as what the root package is.
#[derive(PartialEq, Eq, Clone)]
pub struct Resolve {
graph: Graph<PackageId>,
features: HashMap<PackageId, HashSet<String>>,
root: PackageId,
metadata: Option<Metadata>,
}
#[derive(Clone, Copy)]
pub enum Method<'a> {
Everything,
Required {
dev_deps: bool,
features: &'a [String],
uses_default_features: bool,
target_platform: Option<&'a str>,
},
}
// Err(..) == standard transient error (e.g. I/O error)
// Ok(Err(..)) == resolve error, but is human readable
// Ok(Ok(..)) == success in resolving
type ResolveResult = CargoResult<CargoResult<Box<Context>>>;
// Information about the dependencies for a crate, a tuple of:
//
// (dependency info, candidates, features activated)
type DepInfo<'a> = (&'a Dependency, Vec<Rc<Summary>>, Vec<String>);
impl Resolve {
fn new(root: PackageId) -> Resolve {
let mut g = Graph::new();
g.add(root.clone(), &[]);
Resolve { graph: g, root: root, features: HashMap::new(), metadata: None }
}
pub fn copy_metadata(&mut self, other: &Resolve) {
self.metadata = other.metadata.clone();
}
pub fn iter(&self) -> Nodes<PackageId> {
self.graph.iter()
}
pub fn root(&self) -> &PackageId { &self.root }
pub fn deps(&self, pkg: &PackageId) -> Option<Edges<PackageId>> {
self.graph.edges(pkg)
}
pub fn query(&self, spec: &str) -> CargoResult<&PackageId> {
let spec = try!(PackageIdSpec::parse(spec).chain_error(|| {
human(format!("invalid package id specification: `{}`", spec))
}));
let mut ids = self.iter().filter(|p| spec.matches(*p));
let ret = match ids.next() {
Some(id) => id,
None => return Err(human(format!("package id specification `{}` \
matched no packages", spec))),
};
return match ids.next() {
Some(other) => {
let mut msg = format!("There are multiple `{}` packages in \
your project, and the specification \
`{}` is ambiguous.\n\
Please re-run this command \
with `-p <spec>` where `<spec>` is one \
of the following:",
spec.name(), spec);
let mut vec = vec![ret, other];
vec.extend(ids);
minimize(&mut msg, vec, &spec);
Err(human(msg))
}
None => Ok(ret)
};
fn minimize(msg: &mut String,
ids: Vec<&PackageId>,
spec: &PackageIdSpec) {
let mut version_cnt = HashMap::new();
for id in ids.iter() {
*version_cnt.entry(id.version()).or_insert(0) += 1;
}
for id in ids.iter() {
if version_cnt[id.version()] == 1 {
msg.push_str(&format!("\n {}:{}", spec.name(),
id.version()));
} else {
msg.push_str(&format!("\n {}",
PackageIdSpec::from_package_id(*id)));
}
}
}
}
pub fn features(&self, pkg: &PackageId) -> Option<&HashSet<String>> {
self.features.get(pkg)
}
}
impl fmt::Debug for Resolve {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "graph: {:?}\n", self.graph));
try!(write!(fmt, "\nfeatures: {{\n"));
for (pkg, features) in &self.features {
try!(write!(fmt, " {}: {:?}\n", pkg, features));
}
write!(fmt, "}}")
}
}
#[derive(Clone)]
struct Context {
activations: HashMap<(String, SourceId), Vec<Rc<Summary>>>,
resolve: Resolve,
visited: Rc<RefCell<HashSet<PackageId>>>,
}
/// Builds the list of all packages required to build the first argument.
pub fn resolve(summary: &Summary, method: Method,
registry: &mut Registry) -> CargoResult<Resolve> {
trace!("resolve; summary={}", summary.package_id());
let summary = Rc::new(summary.clone());
let cx = Box::new(Context {
resolve: Resolve::new(summary.package_id().clone()),
activations: HashMap::new(),
visited: Rc::new(RefCell::new(HashSet::new())),
});
let _p = profile::start(format!("resolving: {}", summary.package_id()));
match try!(activate(cx, registry, &summary, method, &mut |cx, _| Ok(Ok(cx)))) {
Ok(cx) => {
debug!("resolved: {:?}", cx.resolve);
Ok(cx.resolve)
}
Err(e) => Err(e),
}
}
/// Attempts to activate the summary `parent` in the context `cx`.
///
/// This function will pull dependency summaries from the registry provided, and
/// the dependencies of the package will be determined by the `method` provided.
/// Once the resolution of this package has finished **entirely**, the current
/// context will be passed to the `finished` callback provided.
fn activate(mut cx: Box<Context>,
registry: &mut Registry,
parent: &Rc<Summary>,
method: Method,
finished: &mut FnMut(Box<Context>, &mut Registry) -> ResolveResult)
-> ResolveResult {
// Dependency graphs are required to be a DAG, so we keep a set of
// packages we're visiting and bail if we hit a dupe.
let id = parent.package_id();
if !cx.visited.borrow_mut().insert(id.clone()) {
return Err(human(format!("cyclic package dependency: package `{}` \
depends on itself", id)))
}
// If we're already activated, then that was easy!
if cx.flag_activated(parent, &method) {
cx.visited.borrow_mut().remove(id);
return finished(cx, registry)
}
debug!("activating {}", parent.package_id());
let deps = try!(cx.build_deps(registry, parent, method));
// Extracting the platform request.
let platform = match method {
Method::Required { target_platform, .. } => target_platform,
Method::Everything => None,
};
activate_deps(cx, registry, parent, platform, deps.iter(), 0,
&mut |cx, registry| {
cx.visited.borrow_mut().remove(parent.package_id());
finished(cx, registry)
})
}
/// Activates the dependencies for a package, one by one in turn.
///
/// This function will attempt to activate all possible candidates for each
/// dependency of the package specified by `parent`. The `deps` iterator
/// provided is an iterator over all dependencies where each element yielded
/// informs us what the candidates are for the dependency in question.
///
/// The `platform` argument is the target platform that the dependencies are
/// being activated for.
///
/// If all dependencies can be activated and resolved to a version in the
/// dependency graph the `finished` callback is invoked with the current state
/// of the world.
fn activate_deps<'a>(cx: Box<Context>,
registry: &mut Registry,
parent: &Summary,
platform: Option<&'a str>,
mut deps: slice::Iter<'a, DepInfo>,
cur: usize,
finished: &mut FnMut(Box<Context>, &mut Registry) -> ResolveResult)
-> ResolveResult {
let &(dep, ref candidates, ref features) = match deps.next() {
Some(info) => info,
None => return finished(cx, registry),
};
let method = Method::Required {
dev_deps: false,
features: features,
uses_default_features: dep.uses_default_features(),
target_platform: platform,
};
let prev_active = cx.prev_active(dep);
trace!("{}[{}]>{} {} candidates", parent.name(), cur, dep.name(),
candidates.len());
trace!("{}[{}]>{} {} prev activations", parent.name(), cur,
dep.name(), prev_active.len());
// Filter the set of candidates based on the previously activated
// versions for this dependency. We can actually use a version if it
// precisely matches an activated version or if it is otherwise
// incompatible with all other activated versions. Note that we define
// "compatible" here in terms of the semver sense where if the left-most
// nonzero digit is the same they're considered compatible.
let my_candidates = candidates.iter().filter(|&b| {
prev_active.iter().any(|a| a == b) ||
prev_active.iter().all(|a| {
!compatible(a.version(), b.version())
})
});
// Alright, for each candidate that's gotten this far, it meets the
// following requirements:
//
// 1. The version matches the dependency requirement listed for this
// package
// 2. There are no activated versions for this package which are
// semver-compatible, or there's an activated version which is
// precisely equal to `candidate`.
//
// This means that we're going to attempt to activate each candidate in
// turn. We could possibly fail to activate each candidate, so we try
// each one in turn.
let mut last_err = None;
for candidate in my_candidates {
trace!("{}[{}]>{} trying {}", parent.name(), cur, dep.name(),
candidate.version());
let mut my_cx = cx.clone();
my_cx.resolve.graph.link(parent.package_id().clone(),
candidate.package_id().clone());
// If we hit an intransitive dependency then clear out the visitation
// list as we can't induce a cycle through transitive dependencies.
if !dep.is_transitive() {
my_cx.visited.borrow_mut().clear();
}
let my_cx = try!(activate(my_cx, registry, candidate, method,
&mut |cx, registry| {
activate_deps(cx, registry, parent, platform, deps.clone(), cur + 1,
finished)
}));
match my_cx {
Ok(cx) => return Ok(Ok(cx)),
Err(e) => { last_err = Some(e); }
}
}
trace!("{}[{}]>{} -- {:?}", parent.name(), cur, dep.name(), last_err);
// Oh well, we couldn't activate any of the candidates, so we just can't
// activate this dependency at all
Ok(activation_error(&cx, registry, last_err, parent, dep, prev_active,
&candidates))
}
#[inline(never)] // see notes at the top of the module
#[allow(deprecated)] // connect => join in 1.3
fn activation_error(cx: &Context,
registry: &mut Registry,
err: Option<Box<CargoError>>,
parent: &Summary,
dep: &Dependency,
prev_active: &[Rc<Summary>],
candidates: &[Rc<Summary>]) -> CargoResult<Box<Context>> {
match err {
Some(e) => return Err(e),
None => {}
}
if candidates.len() > 0 {
let mut msg = format!("failed to select a version for `{}` \
(required by `{}`):\n\
all possible versions conflict with \
previously selected versions of `{}`",
dep.name(), parent.name(),
dep.name());
'outer: for v in prev_active.iter() {
for node in cx.resolve.graph.iter() {
let edges = match cx.resolve.graph.edges(node) {
Some(edges) => edges,
None => continue,
};
for edge in edges {
if edge != v.package_id() { continue }
msg.push_str(&format!("\n version {} in use by {}",
v.version(), edge));
continue 'outer;
}
}
msg.push_str(&format!("\n version {} in use by ??",
v.version()));
}
msg.push_str(&format!("\n possible versions to select: {}",
candidates.iter()
.map(|v| v.version())
.map(|v| v.to_string())
.collect::<Vec<_>>()
.connect(", ")));
return Err(human(msg))
}
// Once we're all the way down here, we're definitely lost in the
// weeds! We didn't actually use any candidates above, so we need to
// give an error message that nothing was found.
//
// Note that we re-query the registry with a new dependency that
// allows any version so we can give some nicer error reporting
// which indicates a few versions that were actually found.
let msg = format!("no matching package named `{}` found \
(required by `{}`)\n\
location searched: {}\n\
version required: {}",
dep.name(), parent.name(),
dep.source_id(),
dep.version_req());
let mut msg = msg;
let all_req = semver::VersionReq::parse("*").unwrap();
let new_dep = dep.clone().set_version_req(all_req);
let mut candidates = try!(registry.query(&new_dep));
candidates.sort_by(|a, b| {
b.version().cmp(a.version())
});
if candidates.len() > 0 {
msg.push_str("\nversions found: ");
for (i, c) in candidates.iter().take(3).enumerate() {
if i != 0 { msg.push_str(", "); }
msg.push_str(&c.version().to_string());
}
if candidates.len() > 3 {
msg.push_str(", ...");
}
}
// If we have a path dependency with a locked version, then this may
// indicate that we updated a sub-package and forgot to run `cargo
// update`. In this case try to print a helpful error!
if dep.source_id().is_path() &&
dep.version_req().to_string().starts_with("=") &&
candidates.len() > 0 {
msg.push_str("\nconsider running `cargo update` to update \
a path dependency's locked version");
}
Err(human(msg))
}
// Returns if `a` and `b` are compatible in the semver sense. This is a
// commutative operation.
//
// Versions `a` and `b` are compatible if their left-most nonzero digit is the
// same.
fn compatible(a: &semver::Version, b: &semver::Version) -> bool {
if a.major != b.major { return false }
if a.major != 0 { return true }
if a.minor != b.minor { return false }
if a.minor != 0 { return true }
a.patch == b.patch
}
// Returns a pair of (feature dependencies, all used features)
//
// The feature dependencies map is a mapping of package name to list of features
// enabled. Each package should be enabled, and each package should have the
// specified set of features enabled.
//
// The all used features set is the set of features which this local package had
// enabled, which is later used when compiling to instruct the code what
// features were enabled.
fn build_features(s: &Summary, method: Method)
-> CargoResult<(HashMap<String, Vec<String>>, HashSet<String>)> {
let mut deps = HashMap::new();
let mut used = HashSet::new();
let mut visited = HashSet::new();
match method {
Method::Everything => {
for key in s.features().keys() {
try!(add_feature(s, key, &mut deps, &mut used, &mut visited));
}
for dep in s.dependencies().iter().filter(|d| d.is_optional()) {
try!(add_feature(s, dep.name(), &mut deps, &mut used,
&mut visited));
}
}
Method::Required { features: requested_features, .. } => {
for feat in requested_features.iter() {
try!(add_feature(s, feat, &mut deps, &mut used, &mut visited));
}
}
}
match method {
Method::Everything |
Method::Required { uses_default_features: true, .. } => {
if s.features().get("default").is_some() {
try!(add_feature(s, "default", &mut deps, &mut used,
&mut visited));
}
}
Method::Required { uses_default_features: false, .. } => {}
}
return Ok((deps, used));
fn add_feature(s: &Summary, feat: &str,
deps: &mut HashMap<String, Vec<String>>,
used: &mut HashSet<String>,
visited: &mut HashSet<String>) -> CargoResult<()> {
if feat.is_empty() { return Ok(()) }
// If this feature is of the form `foo/bar`, then we just lookup package
// `foo` and enable its feature `bar`. Otherwise this feature is of the
// form `foo` and we need to recurse to enable the feature `foo` for our
// own package, which may end up enabling more features or just enabling
// a dependency.
let mut parts = feat.splitn(2, '/');
let feat_or_package = parts.next().unwrap();
match parts.next() {
Some(feat) => {
let package = feat_or_package;
deps.entry(package.to_string())
.or_insert(Vec::new())
.push(feat.to_string());
}
None => {
let feat = feat_or_package;
if !visited.insert(feat.to_string()) {
return Err(human(format!("Cyclic feature dependency: \
feature `{}` depends on itself",
feat)))
}
used.insert(feat.to_string());
match s.features().get(feat) {
Some(recursive) => {
for f in recursive {
try!(add_feature(s, f, deps, used, visited));
}
}
None => {
deps.entry(feat.to_string()).or_insert(Vec::new());
}
}
visited.remove(&feat.to_string());
}
}
Ok(())
}
}
impl Context {
// Activate this summary by inserting it into our list of known activations.
//
// Returns if this summary with the given method is already activated.
#[inline(never)] // see notes at the top of the module
fn flag_activated(&mut self,
summary: &Rc<Summary>,
method: &Method) -> bool {
let id = summary.package_id();<｜fim▁hole｜> if !prev.iter().any(|c| c == summary) {
self.resolve.graph.add(id.clone(), &[]);
prev.push(summary.clone());
return false
}
debug!("checking if {} is already activated", summary.package_id());
let (features, use_default) = match *method {
Method::Required { features, uses_default_features, .. } => {
(features, uses_default_features)
}
Method::Everything => return false,
};
let has_default_feature = summary.features().contains_key("default");
match self.resolve.features(id) {
Some(prev) => {
features.iter().all(|f| prev.contains(f)) &&
(!use_default || prev.contains("default") ||
!has_default_feature)
}
None => features.len() == 0 && (!use_default || !has_default_feature)
}
}
#[inline(never)] // see notes at the top of the module
fn build_deps<'a>(&mut self, registry: &mut Registry,
parent: &'a Summary,
method: Method) -> CargoResult<Vec<DepInfo<'a>>> {
// First, figure out our set of dependencies based on the requsted set
// of features. This also calculates what features we're going to enable
// for our own dependencies.
let deps = try!(self.resolve_features(parent, method));
// Next, transform all dependencies into a list of possible candidates
// which can satisfy that dependency.
let mut deps = try!(deps.into_iter().map(|(dep, features)| {
let mut candidates = try!(registry.query(dep));
// When we attempt versions for a package, we'll want to start at
// the maximum version and work our way down.
candidates.sort_by(|a, b| {
b.version().cmp(a.version())
});
let candidates = candidates.into_iter().map(Rc::new).collect();
Ok((dep, candidates, features))
}).collect::<CargoResult<Vec<DepInfo<'a>>>>());
// When we recurse, attempt to resolve dependencies with fewer
// candidates before recursing on dependencies with more candidates.
// This way if the dependency with only one candidate can't be resolved
// we don't have to do a bunch of work before we figure that out.
deps.sort_by(|&(_, ref a, _), &(_, ref b, _)| {
a.len().cmp(&b.len())
});
Ok(deps)
}
#[inline(never)] // see notes at the top of the module
fn prev_active(&self, dep: &Dependency) -> &[Rc<Summary>] {
let key = (dep.name().to_string(), dep.source_id().clone());
self.activations.get(&key).map(|v| &v[..]).unwrap_or(&[])
}
#[allow(deprecated)] // connect => join in 1.3
fn resolve_features<'a>(&mut self, parent: &'a Summary, method: Method)
-> CargoResult<Vec<(&'a Dependency, Vec<String>)>> {
let dev_deps = match method {
Method::Everything => true,
Method::Required { dev_deps, .. } => dev_deps,
};
// First, filter by dev-dependencies
let deps = parent.dependencies();
let deps = deps.iter().filter(|d| d.is_transitive() || dev_deps);
// Second, ignoring dependencies that should not be compiled for this
// platform
let deps = deps.filter(|d| {
match method {
Method::Required{target_platform: Some(ref platform), ..} => {
d.is_active_for_platform(platform)
},
_ => true
}
});
let (mut feature_deps, used_features) = try!(build_features(parent,
method));
let mut ret = Vec::new();
// Next, sanitize all requested features by whitelisting all the
// requested features that correspond to optional dependencies
for dep in deps {
// weed out optional dependencies, but not those required
if dep.is_optional() && !feature_deps.contains_key(dep.name()) {
continue
}
let mut base = feature_deps.remove(dep.name()).unwrap_or(vec![]);
for feature in dep.features().iter() {
base.push(feature.clone());
if feature.contains("/") {
return Err(human(format!("features in dependencies \
cannot enable features in \
other dependencies: `{}`",
feature)));
}
}
ret.push((dep, base));
}
// All features can only point to optional dependencies, in which case
// they should have all been weeded out by the above iteration. Any
// remaining features are bugs in that the package does not actually
// have those features.
if feature_deps.len() > 0 {
let unknown = feature_deps.keys().map(|s| &s[..])
.collect::<Vec<&str>>();
if unknown.len() > 0 {
let features = unknown.connect(", ");
return Err(human(format!("Package `{}` does not have these \
features: `{}`", parent.package_id(),
features)))
}
}
// Record what list of features is active for this package.
if used_features.len() > 0 {
let pkgid = parent.package_id();
self.resolve.features.entry(pkgid.clone())
.or_insert(HashSet::new())
.extend(used_features);
}
Ok(ret)
}
}<｜fim▁end｜> | let key = (id.name().to_string(), id.source_id().clone());
let prev = self.activations.entry(key).or_insert(Vec::new()); |
<|file_name|>dashboard.py<|end_file_name|><｜fim▁begin｜>"""
This file was generated with the customdashboard management command and
contains the class for the main dashboard.
To activate your index dashboard add the following to your settings.py::
GRAPPELLI_INDEX_DASHBOARD = 'version3.dashboard.CustomIndexDashboard'
"""
from django.utils.translation import ugettext_lazy as _
from django.core.urlresolvers import reverse
from grappelli.dashboard import modules, Dashboard
from grappelli.dashboard.utils import get_admin_site_name
class CustomIndexDashboard(Dashboard):
"""
Custom index dashboard for www.
"""
def init_with_context(self, context):
site_name = get_admin_site_name(context)
# append a group for "Administration" & "Applications"
# self.children.append(modules.Group(
# _('Group: Administration & Applications'),
# column=1,
# collapsible=True,
# children = [
# modules.AppList(
# _('Administration'),
# column=1,
# collapsible=False,
# models=('django.contrib.*',),
# ),
# modules.AppList(
# _('Applications'),
# column=1,
# css_classes=('collapse closed',),
# exclude=('django.contrib.*',),
# )
# ]
# ))
# append an app list module for "Applications"
# self.children.append(modules.AppList(
# _('AppList: Applications'),
# collapsible=True,
# column=1,
# css_classes=('collapse closed',),
# exclude=('django.contrib.*',),
# ))
# append an app list module for "Administration"
# self.children.append(modules.ModelList(
# _('ModelList: Administration'),
# column=1,
# collapsible=False,
# models=('django.contrib.*',),
# ))
# append another link list module for "support".
# self.children.append(modules.LinkList(
# _('Media Management'),
# column=2,
# children=[
# {
# 'title': _('FileBrowser'),
# 'url': '/admin/filebrowser/browse/',
# 'external': False,
# },
# ]
# ))
# append another link list module for "support".
# self.children.append(modules.LinkList(
# _('Support'),
# column=2,
# children=[
# {
# 'title': _('Django Documentation'),
# 'url': 'http://docs.djangoproject.com/',
# 'external': True,
# },
# {
# 'title': _('Grappelli Documentation'),
# 'url': 'http://packages.python.org/django-grappelli/',
# 'external': True,
# },
# {
# 'title': _('Grappelli Google-Code'),
# 'url': 'http://code.google.com/p/django-grappelli/',
# 'external': True,
# },
# ]
# ))
# append a feed module
# self.children.append(modules.Feed(
# _('Latest Django News'),
# column=2,
# feed_url='http://www.djangoproject.com/rss/weblog/',<｜fim▁hole｜> # self.children.append(modules.RecentActions(
# _('Recent Actions'),
# limit=5,
# collapsible=False,
# column=3,
# ))
self.children.append(modules.ModelList(
title='Office Files / Parties',
column=1,
models=('bittscmsapp.models.CoreInstruction',
'bittscmsapp.models.CoreParty',)
))
self.children.append(modules.ModelList(
title='Lookup Values',
collapsible=True,
column=2,
models=()
))<｜fim▁end｜> | # limit=5
# ))
# append a recent actions module |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜># Copyright (C) 2016 ycmd contributors
#
# This file is part of ycmd.
#
# ycmd is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ycmd 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ycmd. If not, see <http://www.gnu.org/licenses/>.
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
from future import standard_library
standard_library.install_aliases()
from builtins import * # noqa
import functools
import os
from ycmd.tests.test_utils import BuildRequest, ClearCompletionsCache, SetUpApp
shared_app = None
def PathToTestFile( *args ):
dir_of_current_script = os.path.dirname( os.path.abspath( __file__ ) )
return os.path.join( dir_of_current_script, 'testdata', *args )
def StopGoCodeServer( app ):
app.post_json( '/run_completer_command',
BuildRequest( completer_target = 'filetype_default',
command_arguments = [ 'StopServer' ],
filetype = 'go' ) )
def setUpPackage():
"""Initializes the ycmd server as a WebTest application that will be shared
by all tests using the SharedYcmd decorator in this package. Additional
configuration that is common to these tests, like starting a semantic
subserver, should be done here."""
global shared_app
shared_app = SetUpApp()
def tearDownPackage():
global shared_app
StopGoCodeServer( shared_app )
def SharedYcmd( test ):
"""Defines a decorator to be attached to tests of this package. This decorator
passes the shared ycmd application as a parameter.
Do NOT attach it to test generators but directly to the yielded tests."""
global shared_app
@functools.wraps( test )<｜fim▁hole｜> ClearCompletionsCache()
return test( shared_app, *args, **kwargs )
return Wrapper<｜fim▁end｜> | def Wrapper( *args, **kwargs ): |
<|file_name|>generic-exterior-unique.rs<|end_file_name|><｜fim▁begin｜>// 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.
struct Recbox<T> {x: ~T}
fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
pub fn main() {
let foo: int = 17;<｜fim▁hole｜>}<｜fim▁end｜> | let rbfoo: Recbox<int> = reclift::<int>(foo);
assert_eq!(*rbfoo.x, foo); |
<|file_name|>views.py<|end_file_name|><｜fim▁begin｜>import datetime
import json
from brake.decorators import ratelimit
from django.utils.decorators import method_decorator
from django.utils.translation import get_language
from django.conf import settings
from django.core.urlresolvers import reverse_lazy
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import redirect
from django.views.generic import FormView
from django.template import RequestContext
import logging
logger = logging.getLogger(__name__)
from django.contrib.admin.views.decorators import staff_member_required
from apps.forms.stages import MultiStageForm
from apps.forms.views import StorageView
from make_a_plea.helpers import (
filter_cases_by_month,
get_supported_language_from_request,
parse_date_or_400,
staff_or_404,
)
from .models import Case, Court, CaseTracker
from .forms import CourtFinderForm
from .stages import (URNEntryStage,
AuthenticationStage,
NoticeTypeStage,
CaseStage,
YourDetailsStage,
CompanyDetailsStage,
PleaStage,
YourStatusStage,
YourEmploymentStage,
YourSelfEmploymentStage,
YourOutOfWorkBenefitsStage,
AboutYourIncomeStage,
YourBenefitsStage,
YourPensionCreditStage,
YourIncomeStage,
HardshipStage,
HouseholdExpensesStage,
OtherExpensesStage,
CompanyFinancesStage,
ReviewStage,
CompleteStage)
from .fields import ERROR_MESSAGES
class PleaOnlineForms(MultiStageForm):
url_name = "plea_form_step"
stage_classes = [URNEntryStage,
AuthenticationStage,
NoticeTypeStage,
CaseStage,
YourDetailsStage,
CompanyDetailsStage,
PleaStage,
YourStatusStage,
YourEmploymentStage,
YourSelfEmploymentStage,
YourOutOfWorkBenefitsStage,
AboutYourIncomeStage,
YourBenefitsStage,
YourPensionCreditStage,
YourIncomeStage,
HardshipStage,
HouseholdExpensesStage,
OtherExpensesStage,
CompanyFinancesStage,
ReviewStage,
CompleteStage]
def __init__(self, *args, **kwargs):
super(PleaOnlineForms, self).__init__(*args, **kwargs)
self._urn_invalid = False
def save(self, *args, **kwargs):
"""
Check that the URN has not already been used.
"""
saved_urn = self.all_data.get("case", {}).get("urn")
saved_first_name = self.all_data.get("your_details", {}).get("first_name")
saved_last_name = self.all_data.get("your_details", {}).get("last_name")
if all([
saved_urn,
saved_first_name,
saved_last_name,
not Case.objects.can_use_urn(saved_urn, saved_first_name, saved_last_name)
]):
self._urn_invalid = True
else:
return super(PleaOnlineForms, self).save(*args, **kwargs)
def render(self, request, request_context=None):
request_context = request_context if request_context else {}
if self._urn_invalid:
return redirect("urn_already_used")
return super(PleaOnlineForms, self).render(request)
class PleaOnlineViews(StorageView):
start = "enter_urn"
def __init__(self, *args, **kwargs):
super(PleaOnlineViews, self).__init__(*args, **kwargs)
self.index = None
self.storage = None
def dispatch(self, request, *args, **kwargs):
# If the session has timed out, redirect to start page
if all([
not request.session.get("plea_data"),
kwargs.get("stage", self.start) != self.start,
]):
return HttpResponseRedirect("/")
# Store the index if we've got one
idx = kwargs.pop("index", None)
try:
self.index = int(idx)
except (ValueError, TypeError):
self.index = 0
# Load storage
self.storage = self.get_storage(request, "plea_data")
return super(PleaOnlineViews, self).dispatch(request, *args, **kwargs)
def get(self, request, stage=None):
if not stage:
stage = PleaOnlineForms.stage_classes[0].name
return HttpResponseRedirect(reverse_lazy("plea_form_step", args=(stage,)))
form = PleaOnlineForms(self.storage, stage, self.index)
case_redirect = form.load(RequestContext(request))
if case_redirect:
return case_redirect
form.process_messages(request)
if stage == "complete":
self.clear_storage(request, "plea_data")
return form.render(request)
@method_decorator(ratelimit(block=True, rate=settings.RATE_LIMIT))
def post(self, request, stage):
nxt = request.GET.get("next", None)
form = PleaOnlineForms(self.storage, stage, self.index)
form.save(request.POST, RequestContext(request), nxt)
if not form._urn_invalid:
form.process_messages(request)
request.session.modified = True
return form.render(request)
def render(self, request, request_context=None):
request_context = request_context if request_context else {}
return super(PleaOnlineViews, self).render(request)
class UrnAlreadyUsedView(StorageView):
template_name = "urn_used.html"
def post(self, request):
del request.session["plea_data"]
return redirect("plea_form_step", stage="case")
class CourtFinderView(FormView):
template_name = "court_finder.html"
form_class = CourtFinderForm
def form_valid(self, form):
try:
court = Court.objects.get_court_dx(form.cleaned_data["urn"])
except Court.DoesNotExist:
court = False
return self.render_to_response(
self.get_context_data(
form=form,
court=court,
submitted=True,
)
)
@staff_or_404
def stats(request):
"""
Generate usage statistics (optionally by language) and send via email
"""
filter_params = {
"sent": True,
"language": get_supported_language_from_request(request),
}
if "end_date" in request.GET:
end_date = parse_date_or_400(request.GET["end_date"])
else:
now = datetime.datetime.utcnow()
last_day_of_last_month = now - datetime.timedelta(days=now.day)
end_date = datetime.datetime(
last_day_of_last_month.year,
last_day_of_last_month.month,
last_day_of_last_month.day,
23, 59, 59)
filter_params["completed_on__lte"] = end_date
if "start_date" in request.GET:
start_date = parse_date_or_400(request.GET["start_date"])
else:
start_date = datetime.datetime(1970, 1, 1)
filter_params["completed_on__gte"] = start_date
journies = Case.objects.filter(**filter_params).order_by("completed_on")
count = journies.count()
journies_by_month = filter_cases_by_month(journies)
earliest_journey = journies[0] if journies else None
latest_journey = journies.reverse()[0] if journies else None
response = {
"summary": {
"language": filter_params["language"],
"total": count,
"start_date": start_date.isoformat(),
"end_date": end_date.isoformat(),
"earliest_journey": earliest_journey.completed_on.isoformat() if earliest_journey else None,
"latest_journey": latest_journey.completed_on.isoformat() if latest_journey else None,
"by_month": journies_by_month,
},
"latest_example": {<｜fim▁hole｜> k: v
for k, v in latest_journey.extra_data.items()
if k in [
"Forename1",
"Forename2",
"Surname",
"DOB",
]
},
}
} if count else {}
return HttpResponse(
json.dumps(response, indent=4),
content_type="application/json",
)<｜fim▁end｜> | "urn": latest_journey.urn,
"name": latest_journey.name,
"extra_data": { |
<|file_name|>wm_touch.py<|end_file_name|><｜fim▁begin｜>'''
Support for WM_TOUCH messages (Windows platform)
================================================
'''
__all__ = ('WM_MotionEventProvider', 'WM_MotionEvent')
import os
from kivy.input.providers.wm_common import WNDPROC, \
SetWindowLong_WndProc_wrapper, RECT, POINT, WM_TABLET_QUERYSYSTEMGESTURE, \
QUERYSYSTEMGESTURE_WNDPROC, WM_TOUCH, WM_MOUSEMOVE, WM_MOUSELAST, \
TOUCHINPUT, PEN_OR_TOUCH_MASK, PEN_OR_TOUCH_SIGNATURE, PEN_EVENT_TOUCH_MASK
from kivy.input.motionevent import MotionEvent
from kivy.input.shape import ShapeRect
Window = None
class WM_MotionEvent(MotionEvent):
'''MotionEvent representing the WM_MotionEvent event.
Supports pos, shape and size profiles.
'''
__attrs__ = ('size', )
def __init__(self, *args, **kwargs):
kwargs.setdefault('is_touch', True)
kwargs.setdefault('type_id', 'touch')
super().__init__(*args, **kwargs)
self.profile = ('pos', 'shape', 'size')
def depack(self, args):
self.shape = ShapeRect()
self.sx, self.sy = args[0], args[1]
self.shape.width = args[2][0]
self.shape.height = args[2][1]
self.size = self.shape.width * self.shape.height
super().depack(args)
def __str__(self):
args = (self.id, self.uid, str(self.spos), self.device)
return '<WMMotionEvent id:%d uid:%d pos:%s device:%s>' % args
if 'KIVY_DOC' in os.environ:
# documentation hack
WM_MotionEventProvider = None
else:
from ctypes.wintypes import HANDLE
from ctypes import (windll, sizeof, byref)
from collections import deque
from kivy.input.provider import MotionEventProvider
from kivy.input.factory import MotionEventFactory
class WM_MotionEventProvider(MotionEventProvider):
def start(self):
global Window
if not Window:
from kivy.core.window import Window
self.touch_events = deque()
self.touches = {}
self.uid = 0
# get window handle, and register to receive WM_TOUCH messages
self.hwnd = windll.user32.GetActiveWindow()
windll.user32.RegisterTouchWindow(self.hwnd, 1)
# inject our own wndProc to handle messages
# before window manager does
self.new_windProc = WNDPROC(self._touch_wndProc)
self.old_windProc = SetWindowLong_WndProc_wrapper(
self.hwnd, self.new_windProc)
def update(self, dispatch_fn):
c_rect = RECT()
windll.user32.GetClientRect(self.hwnd, byref(c_rect))
pt = POINT(x=0, y=0)
windll.user32.ClientToScreen(self.hwnd, byref(pt))
x_offset, y_offset = pt.x, pt.y
usable_w, usable_h = float(c_rect.w), float(c_rect.h)
while True:
try:
t = self.touch_events.pop()
except:
break
# adjust x,y to window coordinates (0.0 to 1.0)
x = (t.screen_x() - x_offset) / usable_w
y = 1.0 - (t.screen_y() - y_offset) / usable_h
# actually dispatch input
if t.event_type == 'begin':
self.uid += 1
self.touches[t.id] = WM_MotionEvent(
self.device, self.uid, [x, y, t.size()])
dispatch_fn('begin', self.touches[t.id])
if t.event_type == 'update' and t.id in self.touches:
self.touches[t.id].move([x, y, t.size()])
dispatch_fn('update', self.touches[t.id])
if t.event_type == 'end' and t.id in self.touches:
touch = self.touches[t.id]<｜fim▁hole｜> touch.move([x, y, t.size()])
touch.update_time_end()
dispatch_fn('end', touch)
del self.touches[t.id]
def stop(self):
windll.user32.UnregisterTouchWindow(self.hwnd)
self.new_windProc = SetWindowLong_WndProc_wrapper(
self.hwnd, self.old_windProc)
# we inject this wndProc into our main window, to process
# WM_TOUCH and mouse messages before the window manager does
def _touch_wndProc(self, hwnd, msg, wParam, lParam):
done = False
if msg == WM_TABLET_QUERYSYSTEMGESTURE:
return QUERYSYSTEMGESTURE_WNDPROC
if msg == WM_TOUCH:
done = self._touch_handler(msg, wParam, lParam)
if msg >= WM_MOUSEMOVE and msg <= WM_MOUSELAST:
done = self._mouse_handler(msg, wParam, lParam)
if not done:
return windll.user32.CallWindowProcW(self.old_windProc,
hwnd, msg, wParam,
lParam)
return 1
# this on pushes WM_TOUCH messages onto our event stack
def _touch_handler(self, msg, wParam, lParam):
touches = (TOUCHINPUT * wParam)()
windll.user32.GetTouchInputInfo(HANDLE(lParam),
wParam,
touches,
sizeof(TOUCHINPUT))
for i in range(wParam):
self.touch_events.appendleft(touches[i])
windll.user32.CloseTouchInputHandle(HANDLE(lParam))
return True
# filter fake mouse events, because touch and stylus
# also make mouse events
def _mouse_handler(self, msg, wparam, lParam):
info = windll.user32.GetMessageExtraInfo()
# its a touch or a pen
if (info & PEN_OR_TOUCH_MASK) == PEN_OR_TOUCH_SIGNATURE:
if info & PEN_EVENT_TOUCH_MASK:
return True
MotionEventFactory.register('wm_touch', WM_MotionEventProvider)<｜fim▁end｜> | |
<|file_name|>logging_ops.py<|end_file_name|><｜fim▁begin｜># Copyright 2015 Google Inc. 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.
# ==============================================================================
"""Logging Operations."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensorflow.python.framework import ops
from tensorflow.python.ops import common_shapes
from tensorflow.python.ops import gen_logging_ops
# pylint: disable=wildcard-import
from tensorflow.python.ops.gen_logging_ops import *
# pylint: enable=wildcard-import
# Assert and Print are special symbols in python, so we must
# use an upper-case version of them.
def Assert(condition, data, summarize=None, name=None):
"""Asserts that the given condition is true.
If `condition` evaluates to false, print the list of tensors in `data`.
`summarize` determines how many entries of the tensors to print.
Args:
condition: The condition to evaluate.
data: The tensors to print out when condition is false.
summarize: Print this many entries of each tensor.
name: A name for this operation (optional).
"""
return gen_logging_ops._assert(condition, data, summarize, name)
def Print(input_, data, message=None, first_n=None, summarize=None,
name=None):
"""Prints a list of tensors.
This is an identity op with the side effect of printing `data` when
evaluating.
Args:<｜fim▁hole｜> message: A string, prefix of the error message.
first_n: Only log `first_n` number of times. Negative numbers log always;
this is the default.
summarize: Only print this many entries of each tensor. If None, then a
maximum of 3 elements are printed per input tensor.
name: A name for the operation (optional).
Returns:
Same tensor as `input_`.
"""
return gen_logging_ops._print(input_, data, message, first_n, summarize, name)
@ops.RegisterGradient("Print")
def _PrintGrad(op, *grad):
return list(grad) + [None] * (len(op.inputs) - 1)
ops.RegisterShape("Assert")(common_shapes.no_outputs)
ops.RegisterShape("Print")(common_shapes.unchanged_shape)<｜fim▁end｜> | input_: A tensor passed through this op.
data: A list of tensors to print out when op is evaluated. |
<|file_name|>UpdateFieldFlags.cpp<|end_file_name|><｜fim▁begin｜>#pragma once
#ifndef __TRINITY_UPDATEFIELDFLAGS_H__
#define __TRINITY_UPDATEFIELDFLAGS_H__
#include "UpdateFieldFlags.h"
// Auto generated for version 17359
// > Object
uint32 ObjectUpdateFieldFlags[OBJECT_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
};
// > Object > Item
uint32 ItemUpdateFieldFlags[ITEM_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // ITEM_FIELD_OWNER
UF_FLAG_PUBLIC, // ITEM_FIELD_OWNER
UF_FLAG_PUBLIC, // ITEM_FIELD_CONTAINED_IN
UF_FLAG_PUBLIC, // ITEM_FIELD_CONTAINED_IN
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_GIFT_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_GIFT_CREATOR
UF_FLAG_OWNER, // ITEM_FIELD_STACK_COUNT
UF_FLAG_OWNER, // ITEM_FIELD_EXPIRATION
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_PUBLIC, // ITEM_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_PROPERTY_SEED
UF_FLAG_PUBLIC, // ITEM_FIELD_RANDOM_PROPERTIES_ID
UF_FLAG_OWNER, // ITEM_FIELD_DURABILITY
UF_FLAG_OWNER, // ITEM_FIELD_MAX_DURABILITY
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATE_PLAYED_TIME
UF_FLAG_OWNER, // ITEM_FIELD_MODIFIERS_MASK
};
// > Object > Item > Container
uint32 ContainerUpdateFieldFlags[CONTAINER_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // ITEM_FIELD_OWNER
UF_FLAG_PUBLIC, // ITEM_FIELD_OWNER
UF_FLAG_PUBLIC, // ITEM_FIELD_CONTAINED_IN
UF_FLAG_PUBLIC, // ITEM_FIELD_CONTAINED_IN
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_GIFT_CREATOR
UF_FLAG_PUBLIC, // ITEM_FIELD_GIFT_CREATOR
UF_FLAG_OWNER, // ITEM_FIELD_STACK_COUNT
UF_FLAG_OWNER, // ITEM_FIELD_EXPIRATION
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_OWNER, // ITEM_FIELD_SPELL_CHARGES
UF_FLAG_PUBLIC, // ITEM_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_ENCHANTMENT
UF_FLAG_PUBLIC, // ITEM_FIELD_PROPERTY_SEED
UF_FLAG_PUBLIC, // ITEM_FIELD_RANDOM_PROPERTIES_ID
UF_FLAG_OWNER, // ITEM_FIELD_DURABILITY
UF_FLAG_OWNER, // ITEM_FIELD_MAX_DURABILITY
UF_FLAG_PUBLIC, // ITEM_FIELD_CREATE_PLAYED_TIME
UF_FLAG_OWNER, // ITEM_FIELD_MODIFIERS_MASK
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_SLOTS
UF_FLAG_PUBLIC, // CONTAINER_FIELD_NUM_SLOTS
};
// > Object > Unit
uint32 UnitUpdateFieldFlags[UNIT_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_PUBLIC | UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARM
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARM
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMON
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMON
UF_FLAG_PRIVATE, // UNIT_FIELD_CRITTER
UF_FLAG_PRIVATE, // UNIT_FIELD_CRITTER
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARMED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARMED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_DEMON_CREATOR
UF_FLAG_PUBLIC, // UNIT_FIELD_DEMON_CREATOR
UF_FLAG_PUBLIC, // UNIT_FIELD_TARGET
UF_FLAG_PUBLIC, // UNIT_FIELD_TARGET
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_GUID
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_GUID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_OBJECT
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_OBJECT
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_SPELL
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY_HOME_REALM
UF_FLAG_PUBLIC, // UNIT_FIELD_SEX
UF_FLAG_PUBLIC, // UNIT_FIELD_DISPLAY_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_OVERRIDE_DISPLAY_POWER_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PUBLIC, // UNIT_FIELD_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_EFFECTIVE_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_FACTION_TEMPLATE
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_FLAGS2
UF_FLAG_PUBLIC, // UNIT_FIELD_AURA_STATE
UF_FLAG_PUBLIC, // UNIT_FIELD_ATTACK_ROUND_BASE_TIME
UF_FLAG_PUBLIC, // UNIT_FIELD_ATTACK_ROUND_BASE_TIME
UF_FLAG_PRIVATE, // UNIT_FIELD_RANGED_ATTACK_ROUND_BASE_TIME
UF_FLAG_PUBLIC, // UNIT_FIELD_BOUNDING_RADIUS
UF_FLAG_PUBLIC, // UNIT_FIELD_COMBAT_REACH
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // UNIT_FIELD_DISPLAY_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_NATIVE_DISPLAY_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_MOUNT_DISPLAY_ID
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MIN_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MAX_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MIN_OFF_HAND_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MAX_OFF_HAND_DAMAGE
UF_FLAG_PUBLIC, // UNIT_FIELD_ANIM_TIER
UF_FLAG_PUBLIC, // UNIT_FIELD_PET_NUMBER
UF_FLAG_PUBLIC, // UNIT_FIELD_PET_NAME_TIMESTAMP
UF_FLAG_OWNER, // UNIT_FIELD_PET_EXPERIENCE
UF_FLAG_OWNER, // UNIT_FIELD_PET_NEXT_LEVEL_EXPERIENCE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_CASTING_SPEED
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_SPELL_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_RANGED_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_HASTE_REGEN
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY_SPELL
UF_FLAG_PUBLIC | UF_FLAG_VIEWER_DEPENDENT, // UNIT_FIELD_NPC_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_NPC_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_EMOTE_STATE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PUBLIC, // UNIT_FIELD_BASE_MANA
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_BASE_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_SHAPESHIFT_FORM
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MOD_POS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MOD_NEG
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MIN_RANGED_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MAX_RANGED_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MAX_HEALTH_MODIFIER
UF_FLAG_PUBLIC, // UNIT_FIELD_HOVER_HEIGHT
UF_FLAG_PUBLIC, // UNIT_FIELD_MIN_ITEM_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_ITEM_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_WILD_BATTLE_PET_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_NAME_TIMESTAMP
UF_FLAG_PUBLIC, // UNIT_FIELD_INTERACT_SPELL_ID
};
// > Object > Unit > Player
uint32 PlayerUpdateFieldFlags[PLAYER_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_PUBLIC | UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARM
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARM
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMON
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMON
UF_FLAG_PRIVATE, // UNIT_FIELD_CRITTER
UF_FLAG_PRIVATE, // UNIT_FIELD_CRITTER
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARMED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CHARMED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // UNIT_FIELD_DEMON_CREATOR
UF_FLAG_PUBLIC, // UNIT_FIELD_DEMON_CREATOR
UF_FLAG_PUBLIC, // UNIT_FIELD_TARGET
UF_FLAG_PUBLIC, // UNIT_FIELD_TARGET
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_GUID
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_GUID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_OBJECT
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_OBJECT
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_CHANNEL_SPELL
UF_FLAG_PUBLIC, // UNIT_FIELD_SUMMONED_BY_HOME_REALM
UF_FLAG_PUBLIC, // UNIT_FIELD_SEX
UF_FLAG_PUBLIC, // UNIT_FIELD_DISPLAY_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_OVERRIDE_DISPLAY_POWER_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_ALL_UNITS, // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER
UF_FLAG_PUBLIC, // UNIT_FIELD_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_EFFECTIVE_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_FACTION_TEMPLATE
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_VIRTUAL_ITEM_ID
UF_FLAG_PUBLIC, // UNIT_FIELD_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_FLAGS2
UF_FLAG_PUBLIC, // UNIT_FIELD_AURA_STATE
UF_FLAG_PUBLIC, // UNIT_FIELD_ATTACK_ROUND_BASE_TIME
UF_FLAG_PUBLIC, // UNIT_FIELD_ATTACK_ROUND_BASE_TIME
UF_FLAG_PRIVATE, // UNIT_FIELD_RANGED_ATTACK_ROUND_BASE_TIME
UF_FLAG_PUBLIC, // UNIT_FIELD_BOUNDING_RADIUS
UF_FLAG_PUBLIC, // UNIT_FIELD_COMBAT_REACH
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // UNIT_FIELD_DISPLAY_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_NATIVE_DISPLAY_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // UNIT_FIELD_MOUNT_DISPLAY_ID
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MIN_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MAX_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MIN_OFF_HAND_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_MAX_OFF_HAND_DAMAGE
UF_FLAG_PUBLIC, // UNIT_FIELD_ANIM_TIER
UF_FLAG_PUBLIC, // UNIT_FIELD_PET_NUMBER
UF_FLAG_PUBLIC, // UNIT_FIELD_PET_NAME_TIMESTAMP
UF_FLAG_OWNER, // UNIT_FIELD_PET_EXPERIENCE
UF_FLAG_OWNER, // UNIT_FIELD_PET_NEXT_LEVEL_EXPERIENCE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_CASTING_SPEED
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_SPELL_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_RANGED_HASTE
UF_FLAG_PUBLIC, // UNIT_FIELD_MOD_HASTE_REGEN
UF_FLAG_PUBLIC, // UNIT_FIELD_CREATED_BY_SPELL
UF_FLAG_PUBLIC | UF_FLAG_VIEWER_DEPENDENT, // UNIT_FIELD_NPC_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_NPC_FLAGS
UF_FLAG_PUBLIC, // UNIT_FIELD_EMOTE_STATE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STATS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_POS_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_STAT_NEG_BUFF
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_EMPATH, // UNIT_FIELD_RESISTANCES
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_POSITIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RESISTANCE_BUFF_MODS_NEGATIVE<｜fim▁hole｜> UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_BASE_HEALTH
UF_FLAG_PUBLIC, // UNIT_FIELD_SHAPESHIFT_FORM
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MOD_POS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MOD_NEG
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_ATTACK_POWER_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MIN_RANGED_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MAX_RANGED_DAMAGE
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MODIFIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_POWER_COST_MULTIPLIER
UF_FLAG_PRIVATE | UF_FLAG_OWNER, // UNIT_FIELD_MAX_HEALTH_MODIFIER
UF_FLAG_PUBLIC, // UNIT_FIELD_HOVER_HEIGHT
UF_FLAG_PUBLIC, // UNIT_FIELD_MIN_ITEM_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_MAX_ITEM_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_WILD_BATTLE_PET_LEVEL
UF_FLAG_PUBLIC, // UNIT_FIELD_BATTLE_PET_COMPANION_NAME_TIMESTAMP
UF_FLAG_PUBLIC, // UNIT_FIELD_INTERACT_SPELL_ID
UF_FLAG_PUBLIC, // PLAYER_FIELD_DUEL_ARBITER
UF_FLAG_PUBLIC, // PLAYER_FIELD_DUEL_ARBITER
UF_FLAG_PUBLIC, // PLAYER_FIELD_PLAYER_FLAGS
UF_FLAG_PUBLIC, // PLAYER_FIELD_GUILD_RANK_ID
UF_FLAG_PUBLIC, // PLAYER_FIELD_GUILD_DELETE_DATE
UF_FLAG_PUBLIC, // PLAYER_FIELD_GUILD_LEVEL
UF_FLAG_PUBLIC, // PLAYER_FIELD_HAIR_COLOR_ID
UF_FLAG_PUBLIC, // PLAYER_FIELD_REST_STATE
UF_FLAG_PUBLIC, // PLAYER_FIELD_ARENA_FACTION
UF_FLAG_PUBLIC, // PLAYER_FIELD_DUEL_TEAM
UF_FLAG_PUBLIC, // PLAYER_FIELD_GUILD_TIME_STAMP
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PARTY_MEMBER, // PLAYER_FIELD_QUEST_LOG
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_VISIBLE_ITEMS
UF_FLAG_PUBLIC, // PLAYER_FIELD_PLAYER_TITLE
UF_FLAG_PUBLIC, // PLAYER_FIELD_FAKE_INEBRIATION
UF_FLAG_PUBLIC, // PLAYER_FIELD_VIRTUAL_PLAYER_REALM
UF_FLAG_PUBLIC, // PLAYER_FIELD_CURRENT_SPEC_ID
UF_FLAG_PUBLIC, // PLAYER_FIELD_TAXI_MOUNT_ANIM_KIT_ID
UF_FLAG_PUBLIC, // PLAYER_FIELD_CURRENT_BATTLE_PET_BREED_QUALITY
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_INV_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_FARSIGHT_OBJECT
UF_FLAG_PRIVATE, // PLAYER_FIELD_FARSIGHT_OBJECT
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_KNOWN_TITLES
UF_FLAG_PRIVATE, // PLAYER_FIELD_COINAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_COINAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_XP
UF_FLAG_PRIVATE, // PLAYER_FIELD_NEXT_LEVEL_XP
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_SKILL
UF_FLAG_PRIVATE, // PLAYER_FIELD_CHARACTER_POINTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MAX_TALENT_TIERS
UF_FLAG_PRIVATE, // PLAYER_FIELD_TRACK_CREATURE_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_TRACK_RESOURCE_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_MAINHAND_EXPERTISE
UF_FLAG_PRIVATE, // PLAYER_FIELD_OFFHAND_EXPERTISE
UF_FLAG_PRIVATE, // PLAYER_FIELD_RANGED_EXPERTISE
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATING_EXPERTISE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BLOCK_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_DODGE_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_PARRY_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_RANGED_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SPELL_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SHIELD_BLOCK
UF_FLAG_PRIVATE, // PLAYER_FIELD_SHIELD_BLOCK_CRIT_PERCENTAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_MASTERY
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_POWER_DAMAGE
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_POWER_HEALING
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_EXPLORED_ZONES
UF_FLAG_PRIVATE, // PLAYER_FIELD_REST_STATE_BONUS_POOL
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_DAMAGE_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_HEALING_DONE_POS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_HEALING_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_HEALING_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS
UF_FLAG_PRIVATE, // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS
UF_FLAG_PRIVATE, // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_SPELL_POWER_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_RESILIENCE_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_APPERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_OVERRIDE_APBY_SPELL_POWER_PERCENT
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_TARGET_RESISTANCE
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE
UF_FLAG_PRIVATE, // PLAYER_FIELD_LIFETIME_MAX_RANK
UF_FLAG_PRIVATE, // PLAYER_FIELD_SELF_RES_SPELL
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_MEDALS
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_PRICE
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_BUYBACK_TIMESTAMP
UF_FLAG_PRIVATE, // PLAYER_FIELD_YESTERDAY_HONORABLE_KILLS
UF_FLAG_PRIVATE, // PLAYER_FIELD_LIFETIME_HONORABLE_KILLS
UF_FLAG_PRIVATE, // PLAYER_FIELD_WATCHED_FACTION_INDEX
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_COMBAT_RATINGS
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_PVP_INFO
UF_FLAG_PRIVATE, // PLAYER_FIELD_MAX_LEVEL
UF_FLAG_PRIVATE, // PLAYER_FIELD_RUNE_REGEN
UF_FLAG_PRIVATE, // PLAYER_FIELD_RUNE_REGEN
UF_FLAG_PRIVATE, // PLAYER_FIELD_RUNE_REGEN
UF_FLAG_PRIVATE, // PLAYER_FIELD_RUNE_REGEN
UF_FLAG_PRIVATE, // PLAYER_FIELD_NO_REAGENT_COST_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_NO_REAGENT_COST_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_NO_REAGENT_COST_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_NO_REAGENT_COST_MASK
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPHS
UF_FLAG_PRIVATE, // PLAYER_FIELD_GLYPH_SLOTS_ENABLED
UF_FLAG_PRIVATE, // PLAYER_FIELD_PET_SPELL_POWER
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_RESEARCHING
UF_FLAG_PRIVATE, // PLAYER_FIELD_PROFESSION_SKILL_LINE
UF_FLAG_PRIVATE, // PLAYER_FIELD_PROFESSION_SKILL_LINE
UF_FLAG_PRIVATE, // PLAYER_FIELD_UI_HIT_MODIFIER
UF_FLAG_PRIVATE, // PLAYER_FIELD_UI_SPELL_HIT_MODIFIER
UF_FLAG_PRIVATE, // PLAYER_FIELD_HOME_REALM_TIME_OFFSET
UF_FLAG_PRIVATE, // PLAYER_FIELD_MOD_PET_HASTE
UF_FLAG_PRIVATE, // PLAYER_FIELD_SUMMONED_BATTLE_PET_GUID
UF_FLAG_PRIVATE, // PLAYER_FIELD_SUMMONED_BATTLE_PET_GUID
UF_FLAG_PRIVATE | UF_FLAG_URGENT_SELF_ONLY, // PLAYER_FIELD_OVERRIDE_SPELLS_ID
UF_FLAG_PRIVATE, // PLAYER_FIELD_LFG_BONUS_FACTION_ID
UF_FLAG_PRIVATE, // PLAYER_FIELD_LOOT_SPEC_ID
UF_FLAG_PRIVATE | UF_FLAG_URGENT_SELF_ONLY, // PLAYER_FIELD_OVERRIDE_ZONE_PVPTYPE
UF_FLAG_PRIVATE, // PLAYER_FIELD_ITEM_LEVEL_DELTA
};
// > Object > GameObject
uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_DISPLAY_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // GAMEOBJECT_FIELD_FLAGS
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_PARENT_ROTATION
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_PARENT_ROTATION
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_PARENT_ROTATION
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_PARENT_ROTATION
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_FACTION_TEMPLATE
UF_FLAG_PUBLIC, // GAMEOBJECT_FIELD_LEVEL
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // GAMEOBJECT_FIELD_PERCENT_HEALTH
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // GAMEOBJECT_FIELD_STATE_SPELL_VISUAL_ID
};
// > Object > DynamicObject
uint32 DynamicObjectUpdateFieldFlags[DYNAMICOBJECT_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // DYNAMICOBJECT_FIELD_CASTER
UF_FLAG_PUBLIC, // DYNAMICOBJECT_FIELD_CASTER
UF_FLAG_VIEWER_DEPENDENT, // DYNAMICOBJECT_FIELD_TYPE_AND_VISUAL_ID
UF_FLAG_PUBLIC, // DYNAMICOBJECT_FIELD_SPELL_ID
UF_FLAG_PUBLIC, // DYNAMICOBJECT_FIELD_RADIUS
UF_FLAG_PUBLIC, // DYNAMICOBJECT_FIELD_CAST_TIME
};
// > Object > Corpse
uint32 CorpseUpdateFieldFlags[CORPSE_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // CORPSE_FIELD_OWNER
UF_FLAG_PUBLIC, // CORPSE_FIELD_OWNER
UF_FLAG_PUBLIC, // CORPSE_FIELD_PARTY_GUID
UF_FLAG_PUBLIC, // CORPSE_FIELD_PARTY_GUID
UF_FLAG_PUBLIC, // CORPSE_FIELD_DISPLAY_ID
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_ITEMS
UF_FLAG_PUBLIC, // CORPSE_FIELD_SKIN_ID
UF_FLAG_PUBLIC, // CORPSE_FIELD_FACIAL_HAIR_STYLE_ID
UF_FLAG_PUBLIC, // CORPSE_FIELD_FLAGS
UF_FLAG_VIEWER_DEPENDENT, // CORPSE_FIELD_DYNAMIC_FLAGS
};
// > Object > AreaTrigger
uint32 AreaTriggerUpdateFieldFlags[AREATRIGGER_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // AREATRIGGER_FIELD_CASTER
UF_FLAG_PUBLIC, // AREATRIGGER_FIELD_CASTER
UF_FLAG_PUBLIC, // AREATRIGGER_FIELD_DURATION
UF_FLAG_PUBLIC, // AREATRIGGER_FIELD_SPELL_ID
UF_FLAG_VIEWER_DEPENDENT, // AREATRIGGER_FIELD_SPELL_VISUAL_ID
UF_FLAG_PUBLIC | UF_FLAG_URGENT, // AREATRIGGER_FIELD_EXPLICIT_SCALE
};
// > Object > SceneObject
uint32 SceneObjectUpdateFieldFlags[SCENE_END] =
{
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_GUID
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_DATA
UF_FLAG_PUBLIC, // OBJECT_FIELD_TYPE
UF_FLAG_VIEWER_DEPENDENT, // OBJECT_FIELD_ENTRY_ID
UF_FLAG_VIEWER_DEPENDENT | UF_FLAG_URGENT, // OBJECT_FIELD_DYNAMIC_FLAGS
UF_FLAG_PUBLIC, // OBJECT_FIELD_SCALE
UF_FLAG_PUBLIC, // SCENEOBJECT_FIELD_SCRIPT_PACKAGE_ID
UF_FLAG_PUBLIC, // SCENEOBJECT_FIELD_RND_SEED_VAL
UF_FLAG_PUBLIC, // SCENEOBJECT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // SCENEOBJECT_FIELD_CREATED_BY
UF_FLAG_PUBLIC, // SCENEOBJECT_FIELD_SCENE_TYPE
};
#endif<｜fim▁end｜> | UF_FLAG_PUBLIC, // UNIT_FIELD_BASE_MANA |
<|file_name|>retrieve_stats.py<|end_file_name|><｜fim▁begin｜>import sys, csv, string<｜fim▁hole｜>def generate_R_input(report_path, output_path):
confidence_values = []
report_file = open(report_path, 'r')
first_line = True
for line in report_file:
if first_line:
first_line = False
continue
line = line.strip().split(',')
if line[5] == 'Yes':
confidence_values.append(line[6])
elif line[5] == 'No':
confid = 1 - float(line[6])
confidence_values.append(confid)
output_file = open(output_path, 'w')
output_file.write('Confidence' + '\n')
first_val = True
for confid in confidence_values:
if not first_val:
output_file.write(str(confid) + '\n')
else:
output_file.write(str(confid) + '\n')
first_val = False
output_file.close()
if __name__ =="__main__":
_report_path = sys.argv[1]
_output_path = sys.argv[2]
generate_R_input(_report_path, _output_path)<｜fim▁end｜> | |
<|file_name|>mahalanobis.py<|end_file_name|><｜fim▁begin｜>import numpy as np
### 1: IH
### 2: EH
### 3: AE
### 4: AO
### 6: AH
### 7: UH
###
### 11: iyC beat
### 12: iyF be
### 21: eyC bait
### 22: eyF bay
### 41: ayV buy
### 47: ayO bite
### 61: oy boy
### 42: aw bough
### 62: owC boat
### 63: owF bow
### 72: uwC boot
### 73: uwF too
### 82: iw suit
### 43: ah father
### 53: oh bought
MEANS = {'1': [525.2877, 1941.229, 4.429892, 4.79822],
'2': [663.079, 1847.689, 4.542639, 4.867548],
'3': [728.7752, 1893.15, 4.615404, 4.989836],
'5': [810.9155, 1336.642, 4.839556, 4.933221],
'6': [714.8795, 1448.528, 4.671836, 4.831577],
'7': [543.7372, 1288.546, 4.424041, 4.69879],
'11': [411.3944, 2275.093, 4.39259, 4.796765],
'12': [440.3333, 2197.091, 4.476098, 4.667141],
'14': [441.1307, 2233.011, 4.403062, 4.860253],
'21': [599.2163, 1978.542, 4.40423, 4.894037],
'22': [592.5507, 1959.899, 4.087865, 4.802181],
'24': [569.8613, 1991.994, 4.516866, 4.941955],
'33': [620.1378, 2059.224, 4.347911, 5.027536],
'39': [766.087, 1829.261, 4.693657, 5.013284],
'41': [808.0645, 1449.711, 4.8443, 4.95776],
'42': [782.8331, 1672.451, 4.788051, 5.007045],
'43': [780.8631, 1326.295, 4.705, 4.908504],
'44': [718.2819, 1273.59, 4.702502, 4.840136],
'47': [777.8737, 1478.317, 4.718795, 4.919554],
'53': [740.2186, 1167.617, 4.744859, 4.794929],
'54': [557.1122, 975.9273, 4.660808, 4.762645],
'61': [539.7747, 982.9505, 4.592872, 4.76811],
'62': [628.9169, 1342.568, 4.514038, 4.772455],
'63': [620.0192, 1332.923, 4.057321, 4.700364],
'64': [528.9181, 953.4962, 4.608001, 4.762555],
'72': [452.4824, 1282.609, 4.364288, 4.775122],
'73': [445.9345, 1819.35, 4.312133, 4.828277],
'74': [467.2353, 1204.176, 4.356453, 4.634414],
'82': [416.0622, 1873.91, 4.364174, 4.858582],
'94': [553.9443, 1486.107, 4.564759, 4.965292]}
COVS = {'1': np.matrix([[8156.961,4075.974,13.05440,6.823964],
[4075.974,85957.07,23.81249,31.39354],
[13.05440,23.81249,0.425308,0.02637788],
[6.823964,31.39354,0.02637788,0.2685742]]),
'2': np.matrix([[12610.98, 4598.212, 15.72022, 10.93343],
[4598.212, 76695.1, 35.53953, 32.24821],
[15.72022, 35.53953, 0.3856857, 0.04138077],
[10.93343, 32.24821, 0.04138077, 0.2402458]]),
'3': np.matrix([[20287.03, -945.841, 23.69788, 19.12778],
[-945.841, 85500.7, 32.35261, 42.61164],
[23.69788, 32.35261, 0.408185, 0.05798509],
[19.12778, 42.61164, 0.05798509, 0.2402007]]),
'5': np.matrix([[14899.38, 14764.41, 31.29953, 25.64715],
[14764.41, 33089.55, 30.80144, 35.65717],
[31.29953, 30.80144, 0.3399745, 0.1391051],
[25.64715, 35.65717, 0.1391051, 0.2939521]]),
'6': np.matrix([[10963.32, 11881.45, 24.02174, 14.15601],
[11881.45, 50941.8, 30.80307, 29.26477],
[24.02174, 30.80307, 0.356582, 0.08377454],
[14.15601, 29.26477, 0.08377454, 0.2798376]]),
'7': np.matrix([[7374.7, 6907.065, 14.77475, 6.575189],
[6907.065, 103775.4, -6.194884, 33.8729],
[14.77475, -6.194884, 0.3619565, 0.08537324],
[6.575189, 33.8729, 0.08537324, 0.3309069]]),
'11': np.matrix([[7398.308, 111.3878, 14.47063, 5.261133],
[111.3878, 112484.4, 4.204222, 27.97763],
[14.47063, 4.204222, 0.439087, 0.01820014],
[5.261133, 27.97763, 0.01820014, 0.2864814]]),
'12': np.matrix([[8980.604, 16.4375, 12.43177, 6.508381],
[16.4375, 68185.02, -41.39826, 43.07926],
[12.43177, -41.39826, 0.4922286, 0.04943888],
[6.508381, 43.07926, 0.04943888, 0.2746969]]),
'14': np.matrix([[5766.88, 1678.53, 13.6561, 6.172833],
[1678.53, 97981.07, -18.30658, 5.520951],
[13.6561, -18.30658, 0.391424, 0.02907505],
[6.172833, 5.520951, 0.02907505, 0.2467823]]),
'21': np.matrix([[11345.63, 902.1107, 15.79774, 8.412416],
[902.1107, 94016.08, 21.16553, 52.47692],
[15.79774, 21.16553, 0.3749903, 0.04202547],
[8.412416, 52.47692, 0.04202547, 0.2549386]]),
'22': np.matrix([[7981.016, 7101.174, 15.52651, 7.784475],
[7101.174, 67936.53, 30.4288, 81.06186],<｜fim▁hole｜> [4778.768, 97292.62, 24.02699, 46.71447],
[11.81843, 24.02699, 0.3862976, 0.05487306],
[8.616023, 46.71447, 0.05487306, 0.2361443]]),
'33': np.matrix([[13020.63, -808.1123, 24.56315, 8.443287],
[-808.1123, 86325.97, 40.21192, 34.7022],
[24.56315, 40.21192, 0.4743995, 0.04472998],
[8.443287, 34.7022, 0.04472998, 0.2473551]]),
'39': np.matrix([[9703.72, 5470.067, 24.62053, 27.96038],
[5470.067, 24951.84, 1.931964, 29.95240],
[24.62053, 1.931964, 0.2513445, 0.06440874],
[27.96038, 29.95240, 0.06440874, 0.1886862]]),
'41': np.matrix([[15762.87, 13486.23, 34.61164, 22.15451],
[13486.23, 36003.67, 33.8431, 30.52712],
[34.61164, 33.8431, 0.4143354, 0.1125765],
[22.15451, 30.52712, 0.1125765, 0.2592451]]),
'42': np.matrix([[17034.35, 8582.368, 28.08871, 21.32564],
[8582.368, 83324.55, 22.75919, 38.33975],
[28.08871, 22.75919, 0.3619946, 0.06974927],
[21.32564, 38.33975, 0.06974927, 0.2425371]]),
'43': np.matrix([[12651.21, 14322.93, 32.66122, 27.76152],
[14322.93, 31322.54, 35.98834, 42.55531],
[32.66122, 35.98834, 0.3651260, 0.1821268],
[27.76152, 42.55531, 0.1821268, 0.3104338]]),
'44': np.matrix([[11222.69, 12217.39, 25.91937, 20.97844],
[12217.39, 42712.38, 31.49909, 51.63623],
[25.91937, 31.49909, 0.3007976, 0.1284959],
[20.97844, 51.63623, 0.1284959, 0.3128419]]),
'47': np.matrix([[14093.57, 9982.23, 34.45142, 19.68046],
[9982.23, 45110.74, 35.51612, 32.38417],
[34.45142, 35.51612, 0.3875129, 0.1126590],
[19.68046, 32.38417, 0.1126590, 0.2684052]]),
'53': np.matrix([[13901.81, 14774.98, 29.65039, 23.37561],
[14774.98, 28293.08, 26.55524, 28.10525],
[29.65039, 26.55524, 0.3192664, 0.1368551],
[23.37561, 28.10525, 0.1368551, 0.3102375]]),
'54': np.matrix([[9024.312, 11004.40, 14.01676, 6.774474],
[11004.40, 31347.50, 0.5099728, 1.338353],
[14.01676, 0.5099728, 0.3226124, 0.1001887],
[6.774474, 1.338353, 0.1001887, 0.3517336]]),
'61': np.matrix([[8717.966, 8360.663, 9.581423, -3.629271],
[8360.663, 32997.70, -18.37126, -13.78926],
[9.581423, -18.37126, 0.31812, 0.09862598],
[-3.629271, -13.78926, 0.09862598, 0.3626406]]),
'62': np.matrix([[11036.78, 18957.63, 21.16886, 10.91295],
[18957.63, 86701.64, 15.58485, 35.06782],
[21.16886, 15.58485, 0.3620286, 0.08347947],
[10.91295, 35.06782, 0.08347947, 0.2859568]]),
'63': np.matrix([[11190.96, 16442.24, 34.42818, 9.032116],
[16442.24, 53108.15, 44.34654, 47.59889],
[34.42818, 44.34654, 0.2837371, -0.000626268],
[9.032116, 47.59889, -0.000626268, 0.4513407]]),
'64': np.matrix([[7020.379, 9304.635, 11.09179, 2.643800],
[9304.635, 34884.03, -2.304886, -0.4383724],
[11.09179, -2.304886, 0.3025123, 0.09179999],
[2.643800, -0.4383724, 0.09179999, 0.3638192]]),
'72': np.matrix([[5302.16, 8112.09, 11.229, -1.767770],
[8112.09, 142019.8, -1.869954, 25.76638],
[11.229, -1.869954, 0.4222974, 0.03546093],
[-1.767770, 25.76638, 0.03546093, 0.3773977]]),
'73': np.matrix([[5441.397, 6032.27, 6.348957, 0.7710968],
[6032.27, 89482.47, -10.52576, 19.44117],
[6.348957, -10.52576, 0.418909, 0.01018179],
[0.7710968, 19.44117, 0.01018179, 0.2577171]]),
'74': np.matrix([[3658.316, -3584.357, 6.224247, 9.464968],
[-3584.357, 51303.03, -78.23124, 26.34888],
[6.224247, -78.23124, 0.3590685, 0.04111837],
[9.464968, 26.34888, 0.04111837, 0.2657895]]),
'82': np.matrix([[5067.216, 3725.284, 8.112584, -2.087986],
[3725.284, 95441.09, 4.191305, 8.484181],
[8.112584, 4.191305, 0.4392269, 0.02049446],
[-2.087986, 8.484181, 0.02049446, 0.284428]]),
'94': np.matrix([[7035.538, 4075.101, 14.86012, 4.748889],
[4075.101, 41818.21, 26.42395, 26.1902],
[14.86012, 26.42395, 0.3585293, 0.03962729],
[4.748889, 26.1902, 0.03962729, 0.2598092]])}<｜fim▁end｜> | [15.52651, 30.4288, 0.4057237, 0.07124884],
[7.784475, 81.06186, 0.07124884, 0.4493804]]),
'24': np.matrix([[7187.811, 4778.768, 11.81843, 8.616023], |
<|file_name|>mod.rs<|end_file_name|><｜fim▁begin｜>mod serialize;
/// Handle to a dock
#[derive(Debug, PartialEq, Clone, Copy)]
pub struct DockHandle(pub u64);
/// Holds information about the plugin view, data and handle
#[derive(Debug, Clone)]
pub struct Dock {
pub handle: DockHandle,
pub plugin_name: String,
pub plugin_data: Option<Vec<String>>,
}
impl Dock {
pub fn new(dock_handle: DockHandle, plugin_name: &str) -> Dock {
Dock {
handle: dock_handle,
plugin_name: plugin_name.to_owned(),
plugin_data: None,
}<｜fim▁hole｜>
#[cfg(test)]
mod test {
extern crate serde_json;
use super::{Dock, DockHandle};
#[test]
fn test_dockhandle_serialize() {
let handle_in = DockHandle(0x1337);
let serialized = serde_json::to_string(&handle_in).unwrap();
let handle_out: DockHandle = serde_json::from_str(&serialized).unwrap();
assert_eq!(handle_in, handle_out);
}
#[test]
fn test_dock_serialize_0() {
let dock_in = Dock {
handle: DockHandle(1),
plugin_name: "disassembly".to_owned(),
plugin_data: None,
};
let serialized = serde_json::to_string(&dock_in).unwrap();
let dock_out: Dock = serde_json::from_str(&serialized).unwrap();
assert_eq!(dock_in.handle, dock_out.handle);
assert_eq!(dock_in.plugin_name, dock_out.plugin_name);
assert_eq!(dock_in.plugin_data, dock_out.plugin_data);
}
#[test]
fn test_dock_serialize_1() {
let dock_in = Dock {
handle: DockHandle(1),
plugin_name: "registers".to_owned(),
plugin_data: Some(vec!["some_data".to_owned(), "more_data".to_owned()]),
};
let serialized = serde_json::to_string(&dock_in).unwrap();
let dock_out: Dock = serde_json::from_str(&serialized).unwrap();
assert_eq!(dock_in.handle, dock_out.handle);
assert_eq!(dock_in.plugin_name, dock_out.plugin_name);
assert_eq!(dock_in.plugin_data, dock_out.plugin_data);
let plugin_data = dock_out.plugin_data.as_ref().unwrap();
assert_eq!(plugin_data.len(), 2);
assert_eq!(plugin_data[0], "some_data");
assert_eq!(plugin_data[1], "more_data");
}
}<｜fim▁end｜> | }
} |
<|file_name|>setup.py<|end_file_name|><｜fim▁begin｜>from setuptools import setup, find_packages
setup(
name="RaspberryRacer",
version="0.1",
description="Raspberry Racer",
author="Diez B. Roggisch",
author_email="[email protected]",
entry_points= {
'console_scripts' : [
'rracer = rracer.main:main',
]},
install_requires = [
],
zip_safe=True,
packages=find_packages(),
classifiers = [<｜fim▁hole｜> 'Development Status :: 3 - Alpha',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
)<｜fim▁end｜> | |
<|file_name|>reproduce_state.py<|end_file_name|><｜fim▁begin｜>"""Reproduce an Switch state."""
import asyncio
import logging
from typing import Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from . import DOMAIN
<｜fim▁hole｜>VALID_STATES = {STATE_ON, STATE_OFF}
async def _async_reproduce_state(
hass: HomeAssistantType, state: State, context: Optional[Context] = None
) -> None:
"""Reproduce a single state."""
cur_state = hass.states.get(state.entity_id)
if cur_state is None:
_LOGGER.warning("Unable to find entity %s", state.entity_id)
return
if state.state not in VALID_STATES:
_LOGGER.warning(
"Invalid state specified for %s: %s", state.entity_id, state.state
)
return
# Return if we are already at the right state.
if cur_state.state == state.state:
return
service_data = {ATTR_ENTITY_ID: state.entity_id}
if state.state == STATE_ON:
service = SERVICE_TURN_ON
elif state.state == STATE_OFF:
service = SERVICE_TURN_OFF
await hass.services.async_call(
DOMAIN, service, service_data, context=context, blocking=True
)
async def async_reproduce_states(
hass: HomeAssistantType, states: Iterable[State], context: Optional[Context] = None
) -> None:
"""Reproduce Switch states."""
await asyncio.gather(
*(_async_reproduce_state(hass, state, context) for state in states)
)<｜fim▁end｜> | _LOGGER = logging.getLogger(__name__)
|
<|file_name|>toc.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright © 2014 René Samselnig
#
# This file is part of Database Navigator.
#
# Database Navigator is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Database Navigator 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Database Navigator. If not, see <http://www.gnu.org/licenses/>.
#
import sys
import re
import codecs
from collections import Counter
filename = sys.argv[1]
with codecs.open(filename, encoding='utf-8') as f:
text = f.read()
m = re.findall(r'^#{2,3} .*$', text, re.MULTILINE)
def title(s):
return re.sub(r'#+ ', '', s)
def fragment(s):
return '#' + re.sub(r'[^a-z-]', '', re.sub(r'#+ ', '', s).replace(' ', '-').lower())
def depth(s):
return len(re.match(r'(#*)', s).group(0))
c = Counter()
toc = []
for header in m:
t = title(header)
f = fragment(header)
d = depth(header)
if c[f] > 0:<｜fim▁hole｜> else:
toc.append('{}- [{}]({})'.format('\t'*(d-2), t, f))
c[f] += 1
with codecs.open(filename, 'w', encoding='utf-8') as f:
f.write(text.replace('[TOC]', '\n'.join(toc)))<｜fim▁end｜> | toc.append('{}- [{}]({}-{})'.format('\t'*(d-2), t, f, c[f])) |
<|file_name|>sites.py<|end_file_name|><｜fim▁begin｜>import numpy as np
class Site(object):
"""A class for general single site
Use this class to create a single site object. The site comes with identity
operator for a given dimension. To build specific site, additional operators
need be add with add_operator method.
"""
def __init__(self, dim):
"""Creates an empty site of dimension dim.
Parameters
----------
dim : an int
Size of the Hilbert space for single site. The dimension must be at
least 1. A site of dim = 1 is trival which represents the vaccum
operators : a dictionary of string and numpy array (with ndim = 2).
Operators for the site.
"""
super(Site, self).__init__()
self.dim = dim
self.states = {}
self.operators = { "id" : np.eye(self.dim, self.dim) }
def add_operator(self, operator_name):
"""Adds an operator to the site with zero matrix.
Parameters
----------
operator_name : string
The operator name.
"""
self.operators[str(operator_name)] = np.zeros((self.dim, self.dim))
def add_state(self, state_name):
"""Adds an state to the site with zero list.
Parameters
----------
operator_name : string
The operator name.
"""
self.states[str(state_name)] = np.zeros(self.dim)
class SpinlessFermionSite(Site):
"""A site for spinless fermion models.
Use this class for spinless fermion sites. The Hilbert space is ordered
such as:
- the first state is empty site
- the second state is occupied site.
Notes
-----
Postcondition : The site has already built-in the operators for
c, c_dag, n.
"""
def __init__(self):
"""Creates the spin one-half site.
Notes
-----
Postcond : the dimension is set to 2
"""
super(SpinlessFermionSite, self).__init__(2)
# add the operators
self.add_operator("c")
self.add_operator("c_dag")
self.add_operator("n")
# for clarity
c = self.operators["c"]
c_dag = self.operators["c_dag"]
n = self.operators["n"]
# set the matrix elements different from zero to the right values
c[0, 1] = 1
c_dag[1, 0] = 1
n[1, 1] = 1
# add the states
self.add_state("empty")
self.add_state("occupied")
# for clarity
state_empty = self.states["empty"]
state_occupied = self.states["occupied"]
# set the list elements different from zero to the right values
state_empty[0] = 1.0
state_occupied[1] = 1.0
class SpinOneHalfSite(Site):
"""A site for spin 1/2 models.
Use this class for spin one-half sites. The Hilbert space is ordered
such as the first state is the spin down, and the second state is the
spin up.
Notes
-----
Postcondition : The site has already built-in the spin operators for
s_x, s_y, s_z, s_p, s_m.
"""
def __init__(self):
"""Creates the spin one-half site.
Notes
-----
Postcond : the dimension is set to 2
"""
super(SpinOneHalfSite, self).__init__(2)
# add the operators
self.add_operator("s_x")
self.add_operator("s_y")
self.add_operator("s_z")
self.add_operator("s_p")
self.add_operator("s_m")
# for clarity
s_x = self.operators["s_x"]
s_y = self.operators["s_y"]
s_y = s_y.astype(np.complex)
s_z = self.operators["s_z"]
s_p = self.operators["s_p"]
s_m = self.operators["s_m"]
# set the matrix elements different from zero to the right values
s_x[0, 1] = 0.5
s_x[1, 0] = 0.5
s_y[0, 1] = 1j*(-0.5)
s_y[1, 0] = 1j*0.5
s_z[0, 0] = -0.5
s_z[1, 1] = 0.5
s_p[1, 0] = 1.0
s_m[0, 1] = 1.0
# add the states
self.add_state("spin_up")
self.add_state("spin_down")
self.add_state("empty")
self.add_state("occupied")
# for clarity
state_up = self.states["spin_up"]
state_down = self.states["spin_down"]
state_empty = self.states["empty"]
state_occupied = self.states["occupied"]
# set the list elements different from zero to the right values
state_up[1] = 1.0
state_down[0] = 1.0
state_occupied[1] = 1.0
state_empty[0] = 1.0
class ElectronicSite(Site):
"""A site for electronic models
You use this site for models where the single sites are electron
sites. The Hilbert space is ordered such as:
- the first state, labelled 0, is the empty site,
- the second, labelled 1, is spin down,
- the third, labelled 2, is spin up, and
- the fourth, labelled 3, is double occupancy.
Notes
-----
Postcond: The site has already built-in the spin operators for:
- c_up : destroys an spin up electron,
- c_up_dag, creates an spin up electron,
- c_down, destroys an spin down electron,
- c_down_dag, creates an spin down electron,
- s_z, component z of spin,
- s_p, raises the component z of spin,
- s_m, lowers the component z of spin,
- n_up, number of electrons with spin up,
- n_down, number of electrons with spin down,
- n, number of electrons, i.e. n_up+n_down, and
- u, number of double occupancies, i.e. n_up*n_down.
"""
def __init__(self):
super(ElectronicSite, self).__init__(4)
# add the operators
self.add_operator("c_up")
self.add_operator("c_up_dag")
self.add_operator("c_down")
self.add_operator("c_down_dag")
self.add_operator("s_z")
self.add_operator("n_up")
self.add_operator("n_down")
self.add_operator("n")
self.add_operator("u")
# for clarity
c_up = self.operators["c_up"]
c_up_dag = self.operators["c_up_dag"]
c_down = self.operators["c_down"]
c_down_dag = self.operators["c_down_dag"]
s_z = self.operators["s_z"]<｜fim▁hole｜> n = self.operators["n"]
u = self.operators["u"]
# set the matrix elements different from zero to the right values
c_up[0,2] = 1.0
c_up[1,3] = 1.0
c_up_dag[2,0] = 1.0
c_up_dag[3,1] = 1.0
c_down[0,1] = 1.0
c_down[2,3] = 1.0
c_down_dag[1,0] = 1.0
c_down_dag[3,2] = 1.0
s_z[1,1] = -1.0
s_z[2,2] = 1.0
n_up[2,2] = 1.0
n_up[3,3] = 1.0
n_down[1,1] = 1.0
n_down[3,3] = 1.0
n[1,1] = 1.0
n[2,2] = 1.0
n[3,3] = 2.0
u[3,3] = 1.0
# add the states
self.add_state("empty")
self.add_state("spin_down")
self.add_state("spin_up")
self.add_state("double")
# for clarity
state_empty = self.states["empty"]
state_down = self.states["spin_down"]
state_up = self.states["spin_up"]
state_double = self.states["double"]
# set the list elements different from zero to the right values
state_empty[0] = 1.0
state_down[1] = 1.0
state_up[2] = 1.0
state_double[3] = 1.0<｜fim▁end｜> | n_up = self.operators["n_up"]
n_down = self.operators["n_down"] |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>import factory
from test_utils import TestCase as BaseTestCase
from mozillians.announcements import models
class TestCase(BaseTestCase):
pass
class AnnouncementFactory(factory.DjangoModelFactory):
FACTORY_FOR = models.Announcement
title = factory.Sequence(lambda n: 'Test Announcement {0}'.format(n))<｜fim▁hole｜><｜fim▁end｜> | text = factory.Sequence(lambda n: 'Text for Announcement {0}'.format(n)) |
<|file_name|>ease.rs<|end_file_name|><｜fim▁begin｜>use std::f64::NAN;
use std::f64::consts::{PI, FRAC_PI_2};
#[deriving(Clone)]
pub enum Mode {
In,
Out,
InOut
}
/// A trait for "easing" from one value to another. Easing is an interpolation
/// between two values, usually non-linear.
pub trait Ease: Clone {
/// Map t = 0..1 to an `alpha` value.
/// That value is then used to lerp the value in question.
#[inline]
fn ease_in(&self, t: f64) -> f64;
/// Ease out, by default based on ease_in.
#[inline]
fn ease_out(&self, t: f64) -> f64 {
1.0 - self.ease_in(1.0 - t)
}
/// Ease both in and out, in for the first half, and out for the second
/// half.
#[inline]
fn ease_in_out(&self, t: f64) -> f64 {
if t < 0.5 {
self.ease_in(2.0 * t) / 2.0
} else {
0.5 + self.ease_out(2.0 * t - 1.0) / 2.0
}
}
/// Do an ease with a given `Mode`.
#[inline]
fn ease(&self, mode: Mode, t: f64) -> f64 {
match mode {
In => self.ease_in(t),
Out => self.ease_out(t),
InOut => self.ease_in_out(t)
}
}
}
impl Ease for fn(f64) -> f64 {
fn ease_in(&self, t: f64) -> f64 {
(*self)(t)
}
}
#[deriving(Clone)]
pub struct LinearEase;
impl Ease for LinearEase {
fn ease_in(&self, t: f64) -> f64 {
t
}
fn ease_out(&self, t: f64) -> f64 {
t
}
fn ease_in_out(&self, t: f64) -> f64 {
t
}
}
pub fn linear() -> LinearEase {
LinearEase
}
#[deriving(Clone)]
pub struct QuadEase;
impl Ease for QuadEase {
fn ease_in(&self, t: f64) -> f64 {<｜fim▁hole｜> }
fn ease_out(&self, t: f64) -> f64 {
-t * (t - 2.)
}
fn ease_in_out(&self, t: f64) -> f64 {
let mut t = t;
if {t *= 2.;t} < 1. {
0.5 * t * t
} else {
-0.5 * ({t -= 1.;t} * (t - 2.) - 1.)
}
}
}
pub fn quad() -> QuadEase {
QuadEase
}
#[deriving(Clone)]
pub struct CubicEase;
impl Ease for CubicEase {
fn ease_in(&self, t: f64) -> f64 {
t * t * t
}
fn ease_out(&self, t: f64) -> f64 {
let s = t - 1.;
s * s * s + 1.
}
fn ease_in_out(&self, t: f64) -> f64 {
let s = t * 2.;
if s < 1. {
0.5 * s * s * s
} else {
let u = s - 2.;
0.5 * (u * u * u + 2.)
}
}
}
pub fn cubic() -> CubicEase {
CubicEase
}
#[deriving(Clone)]
pub struct QuartEase;
impl Ease for QuartEase {
fn ease_in(&self, t: f64) -> f64 {
t * t * t * t
}
fn ease_out(&self, t: f64) -> f64 {
let s = t - 1.;
-(s * s * s * s - 1.)
}
fn ease_in_out(&self, t: f64) -> f64 {
let mut t = t;
if {t *= 2.;t} < 1. {
0.5 * t * t * t * t
} else {
-0.5 * ({t -= 2.;t} * t * t * t - 2.)
}
}
}
pub fn quart() -> QuartEase {
QuartEase
}
#[deriving(Clone)]
pub struct QuintEase;
impl Ease for QuintEase {
fn ease_in(&self, t: f64) -> f64 {
t * t * t * t * t
}
fn ease_out(&self, t: f64) -> f64 {
let s = t - 1.;
s * s * s * s * s + 1.
}
fn ease_in_out(&self, t: f64) -> f64 {
let mut t = t;
if {t *= 2.;t} < 1. {
0.5 * t * t * t * t * t
} else {
0.5 * ({t -= 2.;t} * t * t * t * t + 2.)
}
}
}
pub fn quint() -> QuintEase {
QuintEase
}
#[deriving(Clone)]
pub struct SineEase;
impl Ease for SineEase {
fn ease_in(&self, t: f64) -> f64 {
-(t * FRAC_PI_2).cos() + 1.
}
fn ease_out(&self, t: f64) -> f64 {
(t * FRAC_PI_2).sin()
}
fn ease_in_out(&self, t: f64) -> f64 {
-0.5 * ((PI * t).cos() - 1.)
}
}
pub fn sine() -> SineEase {
SineEase
}
#[deriving(Clone)]
pub struct CircEase;
impl Ease for CircEase {
fn ease_in(&self, t: f64) -> f64 {
-(1. - t * t).sqrt() + 1.
}
fn ease_out(&self, t: f64) -> f64 {
let mut t = t;
(1. - {t -= 1.;t} * t).sqrt()
}
fn ease_in_out(&self, t: f64) -> f64 {
let mut t = t;
if {t *= 2.;t} < 1. {
-0.5 * ((1. - t * t).sqrt() - 1.)
} else {
0.5 * ((1. - {t -= 2.;t} * t).sqrt() + 1.)
}
}
}
pub fn circ() -> CircEase {
CircEase
}
#[deriving(Clone)]
pub struct BounceEase;
impl Ease for BounceEase {
fn ease_in(&self, t: f64) -> f64 {
1. - self.ease_out(1. - t)
}
fn ease_out(&self, t: f64) -> f64 {
if t < 1. / 2.75 {
7.5625 * t * t
} else if t < 2. / 2.75 {
let s = t - 1.5 / 2.75;
7.5625 * s * s + 0.75
} else if t < 2.5/2.75 {
let s = t - 2.25 / 2.75;
7.5625 * s * s + 0.9375
} else {
let s = t - 2.625 / 2.75;
7.5625 * s * s + 0.984375
}
}
fn ease_in_out(&self, t: f64) -> f64 {
if t < 0.5 {
self.ease_in(t * 2.) * 0.5
} else {
self.ease_out(t * 2. - 1.) * 0.5 + 0.5
}
}
}
pub fn bounce() -> BounceEase {
BounceEase
}
#[deriving(Clone)]
pub struct ElasticEase {
a: f64,
p: f64
}
impl Ease for ElasticEase {
fn ease_in(&self, t: f64) -> f64 {
let mut t = t;
let p = if self.p.is_nan() {0.3} else {self.p};
let a = if self.a.is_nan() || self.a < 1. {1.} else {self.a};
if t == 0. {return 0.;}
if t == 1. {return 1.;}
let s = if self.a.is_nan() || self.a < 1. {p / 4.} else {
p / (2. * PI) * (1. / a).asin()
};
-(a * 2.0f64.powf(10. * {t -= 1.;t}) * ((t - s) * (2. * PI) / p).sin())
}
fn ease_out(&self, t: f64) -> f64 {
let p = if self.p.is_nan() {0.3} else {self.p};
let a = if self.a.is_nan() || self.a < 1. {1.} else {self.a};
if t == 0. {return 0.;}
if t == 1. {return 1.;}
let s = if self.a.is_nan() || self.a < 1. {p / 4.} else {
p / (2. * PI) * (1. / a).asin()
};
a * 2.0f64.powf(-10. * t) * ((t - s) * (2. * PI) / p).sin() + 1.
}
fn ease_in_out(&self, t: f64) -> f64 {
let mut t = t;
let p = if self.p.is_nan() {0.3 * 1.5} else {self.p};
let a = if self.a.is_nan() || self.a < 1. {1.} else {self.a};
if t == 0. {return 0.;}
if {t *= 2.;t} == 2. {return 1.;}
let s = if self.a.is_nan() || self.a < 1. {p / 4.} else {
p / (2. * PI) * (1. / a).asin()
};
if t < 1. {
-0.5 * (a * 2.0f64.powf(10. * {t -= 1.;t}) * ((t - s) * (2. * PI) / p).sin())
} else {
a * 2.0f64.powf(-10. * {t -= 1.;t}) * ((t - s) * (2. * PI) / p).sin() * 0.5 + 1.
}
}
}
pub fn elastic() -> ElasticEase {
ElasticEase {
a: NAN,
p: NAN
}
}
#[deriving(Clone)]
pub struct BackEase {
s: f64
}
impl Ease for BackEase {
fn ease_in(&self, t: f64) -> f64 {
let s = self.s;
t * t * ((s + 1.) * t - s)
}
fn ease_out(&self, t: f64) -> f64 {
let s = self.s;
let u = t - 1.;
u * u * ((s + 1.) * u + s) + 1.
}
fn ease_in_out(&self, t: f64) -> f64 {
let s = self.s;
let u = t * 2.;
if u < 1. {
let q = s * 1.525;
0.5 * (u * u * ((q + 1.) * u - q))
} else {
let r = u - 2.;
let q = s * 1.525;
0.5 * (r * r * ((q + 1.) * r + q) + 2.)
}
}
}
pub fn back() -> BackEase {
BackEase {
s: 1.70158
}
}<｜fim▁end｜> | t * t |
<|file_name|>italian.py<|end_file_name|><｜fim▁begin｜># Italian / Italiano - Translations - Python 3 Only!
from seleniumbase import BaseCase
from seleniumbase import MasterQA
class CasoDiProva(BaseCase):
def __init__(self, *args, **kwargs):
super(CasoDiProva, self).__init__(*args, **kwargs)
self._language = "Italian"
def apri(self, *args, **kwargs):
# open(url)
return self.open(*args, **kwargs)
def apri_url(self, *args, **kwargs):
# open_url(url)
return self.open_url(*args, **kwargs)
def fare_clic(self, *args, **kwargs):
# click(selector)
return self.click(*args, **kwargs)
def doppio_clic(self, *args, **kwargs):
# double_click(selector)
return self.double_click(*args, **kwargs)
def clic_lentamente(self, *args, **kwargs):
# slow_click(selector)
return self.slow_click(*args, **kwargs)
def clic_se_visto(self, *args, **kwargs):
# click_if_visible(selector, by=By.CSS_SELECTOR)
return self.click_if_visible(*args, **kwargs)
def clic_testo_del_collegamento(self, *args, **kwargs):
# click_link_text(link_text)
return self.click_link_text(*args, **kwargs)
def aggiornare_testo(self, *args, **kwargs):
# update_text(selector, text)
return self.update_text(*args, **kwargs)
def digitare(self, *args, **kwargs):
# type(selector, text) # Same as update_text()
return self.type(*args, **kwargs)
def aggiungi_testo(self, *args, **kwargs):
# add_text(selector, text)
return self.add_text(*args, **kwargs)
def ottenere_testo(self, *args, **kwargs):
# get_text(selector, text)
return self.get_text(*args, **kwargs)
def verificare_testo(self, *args, **kwargs):
# assert_text(text, selector)
return self.assert_text(*args, **kwargs)
def verificare_testo_esatto(self, *args, **kwargs):
# assert_exact_text(text, selector)
return self.assert_exact_text(*args, **kwargs)
def verificare_testo_del_collegamento(self, *args, **kwargs):
# assert_link_text(link_text)
return self.assert_link_text(*args, **kwargs)
def verificare_elemento(self, *args, **kwargs):
# assert_element(selector)
return self.assert_element(*args, **kwargs)
def verificare_elemento_visto(self, *args, **kwargs):
# assert_element_visible(selector) # Same as self.assert_element()
return self.assert_element_visible(*args, **kwargs)
def verificare_elemento_non_visto(self, *args, **kwargs):
# assert_element_not_visible(selector)
return self.assert_element_not_visible(*args, **kwargs)
def verificare_elemento_presente(self, *args, **kwargs):
# assert_element_present(selector)
return self.assert_element_present(*args, **kwargs)
def verificare_elemento_assente(self, *args, **kwargs):
# assert_element_absent(selector)
return self.assert_element_absent(*args, **kwargs)
def verificare_titolo(self, *args, **kwargs):
# assert_title(title)
return self.assert_title(*args, **kwargs)
def ottenere_titolo(self, *args, **kwargs):
# get_title()
return self.get_title(*args, **kwargs)
def verificare_vero(self, *args, **kwargs):
# assert_true(expr)
return self.assert_true(*args, **kwargs)
def verificare_falso(self, *args, **kwargs):
# assert_false(expr)
return self.assert_false(*args, **kwargs)
def verificare_uguale(self, *args, **kwargs):
# assert_equal(first, second)
return self.assert_equal(*args, **kwargs)
def verificare_non_uguale(self, *args, **kwargs):
# assert_not_equal(first, second)
return self.assert_not_equal(*args, **kwargs)
def aggiorna_la_pagina(self, *args, **kwargs):
# refresh_page()
return self.refresh_page(*args, **kwargs)
def ottenere_url_corrente(self, *args, **kwargs):
# get_current_url()
return self.get_current_url(*args, **kwargs)
def ottenere_la_pagina_html(self, *args, **kwargs):
# get_page_source()
return self.get_page_source(*args, **kwargs)
def indietro(self, *args, **kwargs):
# go_back()
return self.go_back(*args, **kwargs)
def avanti(self, *args, **kwargs):
# go_forward()
return self.go_forward(*args, **kwargs)
def è_testo_visto(self, *args, **kwargs): # noqa
# is_text_visible(text, selector="html")
return self.is_text_visible(*args, **kwargs)
def è_elemento_visto(self, *args, **kwargs):
# is_element_visible(selector)
return self.is_element_visible(*args, **kwargs)
def è_elemento_presente(self, *args, **kwargs):
# is_element_present(selector)
return self.is_element_present(*args, **kwargs)
def attendere_il_testo(self, *args, **kwargs):
# wait_for_text(text, selector)
return self.wait_for_text(*args, **kwargs)
def attendere_un_elemento(self, *args, **kwargs):
# wait_for_element(selector)
return self.wait_for_element(*args, **kwargs)
def attendere_un_elemento_visto(self, *args, **kwargs):
# wait_for_element_visible(selector) # Same as wait_for_element()
return self.wait_for_element_visible(*args, **kwargs)
def attendere_un_elemento_non_visto(self, *args, **kwargs):
# wait_for_element_not_visible(selector)
return self.wait_for_element_not_visible(*args, **kwargs)
def attendere_un_elemento_presente(self, *args, **kwargs):
# wait_for_element_present(selector)
return self.wait_for_element_present(*args, **kwargs)
def attendere_un_elemento_assente(self, *args, **kwargs):
# wait_for_element_absent(selector)
return self.wait_for_element_absent(*args, **kwargs)
def dormire(self, *args, **kwargs):
# sleep(seconds)
return self.sleep(*args, **kwargs)
def attendere(self, *args, **kwargs):
# wait(seconds) # Same as sleep(seconds)
return self.wait(*args, **kwargs)
def inviare(self, *args, **kwargs):
# submit(selector)
return self.submit(*args, **kwargs)
def cancellare(self, *args, **kwargs):
# clear(selector)
return self.clear(*args, **kwargs)
def js_fare_clic(self, *args, **kwargs):
# js_click(selector)
return self.js_click(*args, **kwargs)
def js_aggiornare_testo(self, *args, **kwargs):
# js_update_text(selector, text)
return self.js_update_text(*args, **kwargs)
def js_digitare(self, *args, **kwargs):
# js_type(selector, text)
return self.js_type(*args, **kwargs)
def controlla_html(self, *args, **kwargs):
# inspect_html()
return self.inspect_html(*args, **kwargs)
def salva_screenshot(self, *args, **kwargs):
# save_screenshot(name)
return self.save_screenshot(*args, **kwargs)
def seleziona_file(self, *args, **kwargs):
# choose_file(selector, file_path)
return self.choose_file(*args, **kwargs)
def eseguire_script(self, *args, **kwargs):
# execute_script(script)
return self.execute_script(*args, **kwargs)
def eseguire_script_sicuro(self, *args, **kwargs):
# safe_execute_script(script)
return self.safe_execute_script(*args, **kwargs)
def attiva_jquery(self, *args, **kwargs):
# activate_jquery()
return self.activate_jquery(*args, **kwargs)
def bloccare_gli_annunci(self, *args, **kwargs):
# ad_block()
return self.ad_block(*args, **kwargs)
def saltare(self, *args, **kwargs):
# skip(reason="")
return self.skip(*args, **kwargs)
def verificare_i_collegamenti(self, *args, **kwargs):
# assert_no_404_errors()
return self.assert_no_404_errors(*args, **kwargs)
def controlla_errori_js(self, *args, **kwargs):
# assert_no_js_errors()
return self.assert_no_js_errors(*args, **kwargs)
def passa_al_frame(self, *args, **kwargs):
# switch_to_frame(frame)
return self.switch_to_frame(*args, **kwargs)
def passa_al_contenuto_predefinito(self, *args, **kwargs):
# switch_to_default_content()
return self.switch_to_default_content(*args, **kwargs)
def apri_una_nuova_finestra(self, *args, **kwargs):
# open_new_window()
return self.open_new_window(*args, **kwargs)
def passa_alla_finestra(self, *args, **kwargs):
# switch_to_window(window)
return self.switch_to_window(*args, **kwargs)
def passa_alla_finestra_predefinita(self, *args, **kwargs):
# switch_to_default_window()
return self.switch_to_default_window(*args, **kwargs)
def ingrandisci_finestra(self, *args, **kwargs):
# maximize_window()
return self.maximize_window(*args, **kwargs)
def illuminare(self, *args, **kwargs):
# highlight(selector)
return self.highlight(*args, **kwargs)
def illuminare_clic(self, *args, **kwargs):
# highlight_click(selector)
return self.highlight_click(*args, **kwargs)
def scorrere_fino_a(self, *args, **kwargs):
# scroll_to(selector)
return self.scroll_to(*args, **kwargs)
def scorri_verso_alto(self, *args, **kwargs):
# scroll_to_top()
return self.scroll_to_top(*args, **kwargs)
def scorri_verso_il_basso(self, *args, **kwargs):
# scroll_to_bottom()
return self.scroll_to_bottom(*args, **kwargs)
def passa_il_mouse_sopra_e_fai_clic(self, *args, **kwargs):
# hover_and_click(hover_selector, click_selector)
return self.hover_and_click(*args, **kwargs)
def è_selezionato(self, *args, **kwargs):
# is_selected(selector)
return self.is_selected(*args, **kwargs)
def premere_la_freccia_su(self, *args, **kwargs):
# press_up_arrow(selector="html", times=1)
return self.press_up_arrow(*args, **kwargs)
def premere_la_freccia_giù(self, *args, **kwargs):
# press_down_arrow(selector="html", times=1)
return self.press_down_arrow(*args, **kwargs)
def premere_la_freccia_sinistra(self, *args, **kwargs):
# press_left_arrow(selector="html", times=1)
return self.press_left_arrow(*args, **kwargs)
def premere_la_freccia_destra(self, *args, **kwargs):
# press_right_arrow(selector="html", times=1)
return self.press_right_arrow(*args, **kwargs)
def clic_sugli_elementi_visibili(self, *args, **kwargs):
# click_visible_elements(selector)
return self.click_visible_elements(*args, **kwargs)
def selezionare_opzione_per_testo(self, *args, **kwargs):
# select_option_by_text(dropdown_selector, option)
return self.select_option_by_text(*args, **kwargs)
def selezionare_opzione_per_indice(self, *args, **kwargs):
# select_option_by_index(dropdown_selector, option)
return self.select_option_by_index(*args, **kwargs)
def selezionare_opzione_per_valore(self, *args, **kwargs):
# select_option_by_value(dropdown_selector, option)
return self.select_option_by_value(*args, **kwargs)
def creare_una_presentazione(self, *args, **kwargs):
# create_presentation(name=None, theme="default", transition="default")
return self.create_presentation(*args, **kwargs)
def aggiungere_una_diapositiva(self, *args, **kwargs):
# add_slide(content=None, image=None, code=None, iframe=None,
# content2=None, notes=None, transition=None, name=None)
return self.add_slide(*args, **kwargs)
def salva_la_presentazione(self, *args, **kwargs):
# save_presentation(name=None, filename=None,
# show_notes=False, interval=0)
return self.save_presentation(*args, **kwargs)
def avviare_la_presentazione(self, *args, **kwargs):
# begin_presentation(name=None, filename=None,
# show_notes=False, interval=0)
return self.begin_presentation(*args, **kwargs)
def creare_un_grafico_a_torta(self, *args, **kwargs):
# create_pie_chart(chart_name=None, title=None, subtitle=None,
# data_name=None, unit=None, libs=True)
return self.create_pie_chart(*args, **kwargs)
def creare_un_grafico_a_barre(self, *args, **kwargs):
# create_bar_chart(chart_name=None, title=None, subtitle=None,
# data_name=None, unit=None, libs=True)
return self.create_bar_chart(*args, **kwargs)
def creare_un_grafico_a_colonne(self, *args, **kwargs):
# create_column_chart(chart_name=None, title=None, subtitle=None,
# data_name=None, unit=None, libs=True)
return self.create_column_chart(*args, **kwargs)
def creare_un_grafico_a_linee(self, *args, **kwargs):
# create_line_chart(chart_name=None, title=None, subtitle=None,
# data_name=None, unit=None, zero=False, libs=True)
return self.create_line_chart(*args, **kwargs)
def creare_un_grafico_ad_area(self, *args, **kwargs):
# create_area_chart(chart_name=None, title=None, subtitle=None,
# data_name=None, unit=None, zero=False, libs=True)
return self.create_area_chart(*args, **kwargs)
def aggiungere_serie_al_grafico(self, *args, **kwargs):
# add_series_to_chart(data_name=None, chart_name=None)
return self.add_series_to_chart(*args, **kwargs)
def aggiungi_punto_dati(self, *args, **kwargs):
# add_data_point(label, value, color=None, chart_name=None)
return self.add_data_point(*args, **kwargs)
def salva_il_grafico(self, *args, **kwargs):
# save_chart(chart_name=None, filename=None)
return self.save_chart(*args, **kwargs)
def mostra_il_grafico(self, *args, **kwargs):
# display_chart(chart_name=None, filename=None, interval=0)
return self.display_chart(*args, **kwargs)
def estrarre_il_grafico(self, *args, **kwargs):
# extract_chart(chart_name=None)
return self.extract_chart(*args, **kwargs)
def creare_un_tour(self, *args, **kwargs):
# create_tour(name=None, theme=None)
return self.create_tour(*args, **kwargs)
def creare_un_tour_shepherd(self, *args, **kwargs):
# create_shepherd_tour(name=None, theme=None)
return self.create_shepherd_tour(*args, **kwargs)
def creare_un_tour_bootstrap(self, *args, **kwargs):
# create_bootstrap_tour(name=None, theme=None)
return self.create_bootstrap_tour(*args, **kwargs)
def creare_un_tour_driverjs(self, *args, **kwargs):
# create_driverjs_tour(name=None, theme=None)
return self.create_driverjs_tour(*args, **kwargs)
def creare_un_tour_hopscotch(self, *args, **kwargs):
# create_hopscotch_tour(name=None, theme=None)
return self.create_hopscotch_tour(*args, **kwargs)
def creare_un_tour_introjs(self, *args, **kwargs):
# create_introjs_tour(name=None, theme=None)
return self.create_introjs_tour(*args, **kwargs)
def aggiungere_passo_al_tour(self, *args, **kwargs):
# add_tour_step(message, selector=None, name=None,
# title=None, theme=None, alignment=None)
return self.add_tour_step(*args, **kwargs)
def riprodurre_il_tour(self, *args, **kwargs):
# play_tour(name=None)
return self.play_tour(*args, **kwargs)
def esportare_il_tour(self, *args, **kwargs):
# export_tour(name=None, filename="my_tour.js", url=None)
return self.export_tour(*args, **kwargs)
def ottenere_testo_pdf(self, *args, **kwargs):
# get_pdf_text(pdf, page=None, maxpages=None, password=None,
# codec='utf-8', wrap=False, nav=False, override=False)
return self.get_pdf_text(*args, **kwargs)
def verificare_testo_pdf(self, *args, **kwargs):
# assert_pdf_text(pdf, text, page=None, maxpages=None, password=None,
# codec='utf-8', wrap=True, nav=False, override=False)
return self.assert_pdf_text(*args, **kwargs)
def verificare_file_scaricato(self, *args, **kwargs):
# assert_downloaded_file(file)
return self.assert_downloaded_file(*args, **kwargs)
def fallire(self, *args, **kwargs):
# fail(msg=None) # Inherited from "unittest"
return self.fail(*args, **kwargs)
def ottenere(self, *args, **kwargs):
# get(url) # Same as open(url)
return self.get(*args, **kwargs)
def visita(self, *args, **kwargs):
# visit(url) # Same as open(url)
return self.visit(*args, **kwargs)
def visita_url(self, *args, **kwargs):
# visit_url(url) # Same as open(url)
return self.visit_url(*args, **kwargs)
def ottenere_elemento(self, *args, **kwargs):
# get_element(selector) # Element can be hidden
return self.get_element(*args, **kwargs)
def trovare_elemento(self, *args, **kwargs):
# find_element(selector) # Element must be visible
return self.find_element(*args, **kwargs)
def rimuovere_elemento(self, *args, **kwargs):
# remove_element(selector)
return self.remove_element(*args, **kwargs)
def rimuovere_elementi(self, *args, **kwargs):
# remove_elements(selector)
return self.remove_elements(*args, **kwargs)
def trovare_testo(self, *args, **kwargs):
# find_text(text, selector="html") # Same as wait_for_text
return self.find_text(*args, **kwargs)
def impostare_testo(self, *args, **kwargs):
# set_text(selector, text)
return self.set_text(*args, **kwargs)
def ottenere_attributo(self, *args, **kwargs):
# get_attribute(selector, attribute)
return self.get_attribute(*args, **kwargs)
def imposta_attributo(self, *args, **kwargs):
# set_attribute(selector, attribute, value)
return self.set_attribute(*args, **kwargs)
def impostare_gli_attributi(self, *args, **kwargs):
# set_attributes(selector, attribute, value)
return self.set_attributes(*args, **kwargs)
def scrivere(self, *args, **kwargs):
# write(selector, text) # Same as update_text()
return self.write(*args, **kwargs)
def impostare_tema_del_messaggio(self, *args, **kwargs):
# set_messenger_theme(theme="default", location="default")
return self.set_messenger_theme(*args, **kwargs)
def visualizza_messaggio(self, *args, **kwargs):
# post_message(message, duration=None, pause=True, style="info")
return self.post_message(*args, **kwargs)
def stampare(self, *args, **kwargs):
# _print(msg) # Same as Python print()
return self._print(*args, **kwargs)
def differita_verificare_elemento(self, *args, **kwargs):
# deferred_assert_element(selector)
return self.deferred_assert_element(*args, **kwargs)
def differita_verificare_testo(self, *args, **kwargs):
# deferred_assert_text(text, selector="html")
return self.deferred_assert_text(*args, **kwargs)
def elaborare_differita_verificari(self, *args, **kwargs):
# process_deferred_asserts(print_only=False)
return self.process_deferred_asserts(*args, **kwargs)
def accetta_avviso(self, *args, **kwargs):
# accept_alert(timeout=None)
return self.accept_alert(*args, **kwargs)
def elimina_avviso(self, *args, **kwargs):
# dismiss_alert(timeout=None)
return self.dismiss_alert(*args, **kwargs)
def passa_al_avviso(self, *args, **kwargs):
# switch_to_alert(timeout=None)
return self.switch_to_alert(*args, **kwargs)
def trascinare_e_rilasciare(self, *args, **kwargs):
# drag_and_drop(drag_selector, drop_selector)
return self.drag_and_drop(*args, **kwargs)
def caricare_html_file(self, *args, **kwargs):
# load_html_file(html_file, new_page=True)
return self.load_html_file(*args, **kwargs)
def apri_html_file(self, *args, **kwargs):
# open_html_file(html_file)
return self.open_html_file(*args, **kwargs)
def elimina_tutti_i_cookie(self, *args, **kwargs):
# delete_all_cookies()
return self.delete_all_cookies(*args, **kwargs)
def ottenere_agente_utente(self, *args, **kwargs):
# get_user_agent()
return self.get_user_agent(*args, **kwargs)
def ottenere_codice_lingua(self, *args, **kwargs):
# get_locale_code()
return self.get_locale_code(*args, **kwargs)
class MasterQA_Italiano(MasterQA, CasoDiProva):
def verificare(self, *args, **kwargs):<｜fim▁hole｜> # "Does the page look good?"
self.DEFAULT_VALIDATION_MESSAGE = "La pagina ha un bell'aspetto?"
# verify(QUESTION)
return self.verify(*args, **kwargs)<｜fim▁end｜> | # "Manual Check"
self.DEFAULT_VALIDATION_TITLE = "Controllo manuale" |
<|file_name|>protocol_trait.rs<|end_file_name|><｜fim▁begin｜>// Copyright 2016 Alexander Reece
//
// 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.
use std::io;
use inflections::Inflect;
use WriteRust;
use common::Specs;
pub struct ProtocolTraitWriter<'a> {
specs: &'a Specs<'a>,
}<｜fim▁hole｜>
impl<'a> WriteRust for ProtocolTraitWriter<'a> {
fn write_rust_to<W>(&self, writer: &mut W) -> io::Result<()>
where W: io::Write
{
try!(writeln!(
writer,
"pub trait Protocol<'a> {{\n\
type Frame: 'a;\n\
\n\
fn protocol_header() -> &'static [u8];\n"
));
for method in self.specs.methods() {
try!(writeln!(
writer,
"fn {class}_{snake_method}() -> <Self as ::method::{class}::{pascal_method}Method{lifetimes}>::Payload\n\
where Self: ::method::{class}::{pascal_method}Method{lifetimes}\n\
{{\n\
Default::default()\n\
}}",
lifetimes = if method.has_lifetimes() { "<'a>" } else { "" },
class = method.class_name().to_snake_case(),
snake_method = method.method_name().to_snake_case(),
pascal_method = method.method_name().to_pascal_case(),
))
}
try!(writeln!(writer, "}} // pub trait Protocol<'a>"));
Ok(())
}
}
impl<'a> ProtocolTraitWriter<'a> {
pub fn new(specs: &'a Specs<'a>) -> Self {
ProtocolTraitWriter {
specs: specs
}
}
}<｜fim▁end｜> | |
<|file_name|>_35_TreeMapTest.java<|end_file_name|><｜fim▁begin｜>package edu.ptu.javatest._60_dsa;
import org.junit.Test;
import java.util.TreeMap;
import static edu.ptu.javatest._20_ooad._50_dynamic._00_ReflectionTest.getRefFieldBool;
import static edu.ptu.javatest._20_ooad._50_dynamic._00_ReflectionTest.getRefFieldObj;
public class _35_TreeMapTest {
@Test
public void testPrintTreeMap() {
TreeMap hashMapTest = new TreeMap<>();
for (int i = 0; i < 6; i++) {
hashMapTest.put(new TMHashObj(1,i*2 ), i*2 );
}
Object table = getRefFieldObj(hashMapTest, hashMapTest.getClass(), "root");
printTreeMapNode(table);
hashMapTest.put(new TMHashObj(1,9), 9);<｜fim▁hole｜> printTreeMapNode(table);
System.out.println();
}
public static int getTreeDepth(Object rootNode) {
if (rootNode == null || !rootNode.getClass().toString().equals("class java.util.TreeMap$Entry"))
return 0;
return rootNode == null ? 0 : (1 + Math.max(getTreeDepth(getRefFieldObj(rootNode, rootNode.getClass(), "left")), getTreeDepth(getRefFieldObj(rootNode, rootNode.getClass(), "right"))));
}
public static void printTreeMapNode(Object rootNode) {//转化为堆
if (rootNode == null || !rootNode.getClass().toString().equals("class java.util.TreeMap$Entry"))
return;
int treeDepth = getTreeDepth(rootNode);
Object[] objects = new Object[(int) (Math.pow(2, treeDepth) - 1)];
objects[0] = rootNode;
// objects[0]=rootNode;
// objects[1]=getRefFieldObj(objects,objects.getClass(),"left");
// objects[2]=getRefFieldObj(objects,objects.getClass(),"right");
//
// objects[3]=getRefFieldObj(objects[1],objects[1].getClass(),"left");
// objects[4]=getRefFieldObj(objects[1],objects[1].getClass(),"right");
// objects[5]=getRefFieldObj(objects[2],objects[3].getClass(),"left");
// objects[6]=getRefFieldObj(objects[2],objects[4].getClass(),"right");
for (int i = 1; i < objects.length; i++) {//数组打印
int index = (i - 1) / 2;//parent
if (objects[index] != null) {
if (i % 2 == 1)
objects[i] = getRefFieldObj(objects[index], objects[index].getClass(), "left");
else
objects[i] = getRefFieldObj(objects[index], objects[index].getClass(), "right");
}
}
StringBuilder sb = new StringBuilder();
StringBuilder outSb = new StringBuilder();
String space = " ";
for (int i = 0; i < treeDepth + 1; i++) {
sb.append(space);
}
int nextlineIndex = 0;
for (int i = 0; i < objects.length; i++) {//new line: 0,1 ,3,7
//print space
//print value
if (nextlineIndex == i) {
outSb.append("\n\n");
if (sb.length() >= space.length()) {
sb.delete(0, space.length());
}
nextlineIndex = i * 2 + 1;
}
outSb.append(sb.toString());
if (objects[i] != null) {
Object value = getRefFieldObj(objects[i], objects[i].getClass(), "value");
boolean red = !getRefFieldBool(objects[i], objects[i].getClass(), "color");// BLACK = true;
String result = "" + value + "(" + (red ? "r" : "b") + ")";
outSb.append(result);
} else {
outSb.append("nil");
}
}
System.out.println(outSb.toString());
}
public static class TMHashObj implements Comparable{
int hash;
int value;
TMHashObj(int hash, int value) {
this.hash = hash;
this.value = value;
}
@Override
public int hashCode() {
return hash;
}
@Override
public int compareTo(Object o) {
if (o instanceof TMHashObj){
return this.value-((TMHashObj) o).value;
}
return value-o.hashCode();
}
}
}<｜fim▁end｜> | |
<|file_name|>BenchmarkTest16926.java<|end_file_name|><｜fim▁begin｜>/**
* OWASP Benchmark Project v1.1
*
* This file is part of the Open Web Application Security Project (OWASP)
* Benchmark Project. For details, please see
* <a href="https://www.owasp.org/index.php/Benchmark">https://www.owasp.org/index.php/Benchmark</a>.
*
* The Benchmark is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation, version 2.
*
* The Benchmark 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 General Public License for more details
*
* @author Nick Sanidas <a href="https://www.aspectsecurity.com">Aspect Security</a>
* @created 2015
*/
package org.owasp.benchmark.testcode;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/BenchmarkTest16926")
public class BenchmarkTest16926 extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
@Override
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String param = request.getParameter("foo");
String bar = doSomething(param);
String a1 = "";
String a2 = "";
String osName = System.getProperty("os.name");
if (osName.indexOf("Windows") != -1) {
a1 = "cmd.exe";
a2 = "/c";
} else {
a1 = "sh";
a2 = "-c";
}
String[] args = {a1, a2, "echo", bar};
ProcessBuilder pb = new ProcessBuilder();
pb.command(args);
try {
Process p = pb.start();
org.owasp.benchmark.helpers.Utils.printOSCommandResults(p);
} catch (IOException e) {
System.out.println("Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
throw new ServletException(e);
}
} // end doPost
private static String doSomething(String param) throws ServletException, IOException {
java.util.List<String> valuesList = new java.util.ArrayList<String>( );
valuesList.add("safe");
valuesList.add( param );
valuesList.add( "moresafe" );
valuesList.remove(0); // remove the 1st safe value
String bar = valuesList.get(1); // get the last 'safe' value<｜fim▁hole｜>
return bar;
}
}<｜fim▁end｜> | |
<|file_name|>Nav.js<|end_file_name|><｜fim▁begin｜>import React, { Component } from 'react';
import { Link } from 'react-router-dom'
import { CSSTransition } from 'react-transition-group';
class Nav extends Component {
constructor(props) {
super(props);
this.state = {
menuActive: false
}
this.handleClick = this.handleClick.bind(this);
}
handleClick() {
var obj = {};
obj['menuActive'] = !this.state.menuActive;
this.setState(obj);
}
render() {
return (
<div className={this.state.menuActive? 'nav active': 'nav'} >
<div className='nav__button' onClick={this.handleClick}>
<div className='nav__buttonPart' />
<div className='nav__buttonPart' />
<div className='nav__buttonPart' />
<div className="nav__buttonTitle"> {this.state.menuActive? <div>Close</div> : <div>Menu</div>} </div>
</div>
<div className='nav__menuBox'>
<ul className='nav__menu'>
<li className='nav__menuItem'> <Link to='/'> home </Link> </li>
<li className='nav__menuItem'> <Link to='/'> blog </Link> </li>
<li className='nav__menuItem'> <Link to='/About'> about </Link> </li>
</ul>
</div>
<CSSTransition
in={this.state.menuActive}
timeout={300}
classNames="nav__background"
>
<div className="nav__background"/>
</CSSTransition>
<CSSTransition
in={this.state.menuActive}
timeout={300}
classNames="nav__shadowBackground"
><｜fim▁hole｜> }
}
export default Nav;<｜fim▁end｜> | <div className="nav__shadowBackground"/>
</CSSTransition>
</div>
); |
<|file_name|>single-line-html-open.js<|end_file_name|><｜fim▁begin｜>// Copyright (C) 2016 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/*---
esid: sec-html-like-comments
description: SingleLineHTMLOpenComment
info: |
Comment ::
MultiLineComment
SingleLineComment
SingleLineHTMLOpenComment
SingleLineHTMLCloseComment
SingleLineDelimitedComment
SingleLineHTMLOpenComment ::
<!--SingleLineCommentCharsopt
negative:
phase: runtime
type: Test262Error
---*/
var counter = 0;<｜fim▁hole｜>counter += 1;
<!--the comment extends to these characters
counter += 1;
counter += 1;<!--the comment extends to these characters
counter += 1;
var x = 0;
x = -1 <!--x;
// Because this test concerns the interpretation of non-executable character
// sequences within ECMAScript source code, special care must be taken to
// ensure that executable code is evaluated as expected.
//
// Express the intended behavior by intentionally throwing an error; this
// guarantees that test runners will only consider the test "passing" if
// executable sequences are correctly interpreted as such.
if (counter === 4 && x === -1) {
throw new Test262Error();
}<｜fim▁end｜> | <!-- |
<|file_name|>models.py<|end_file_name|><｜fim▁begin｜>from __init__ import redis_db
from werkzeug.security import generate_password_hash, check_password_hash
from os import urandom
from base64 import b64encode
class User(object):
def __init__(self):
self.username = "" # required
self.password_hash = "" # required
self.phone_number = "" # required
self.emergency_contact = "" # not required
self.secret_key = b64encode(urandom(64)).decode("utf-8")
self.contacts = set() # can be empty
def set_password(self, password):
self.password_hash = generate_password_hash(password, method="pbkdf2:sha256", salt_length=32)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def write_to_db(self):
user_dict = {"password_hash": self.password_hash, "phone_number": self.phone_number,
"secret_key": self.secret_key, "emergency_contact": self.emergency_contact}
redis_db.hmset(self.username, user_dict)<｜fim▁hole｜> if len(self.contacts):
redis_db.sadd(self.username + ":contacts", *self.contacts)
def deauthenticate(self):
self.secret_key = b64encode(urandom(64)).decode("utf-8")
@classmethod
def get_from_db(cls, username):
user_dict = redis_db.hmget(username, ["password_hash", "phone_number", "secret_key", "emergency_contact"])
fetched_user = User()
fetched_user.username = username
fetched_user.password_hash = user_dict[0]
fetched_user.phone_number = user_dict[1]
fetched_user.secret_key = user_dict[2]
fetched_user.emergency_contact = user_dict[3]
if not fetched_user.password_hash or not fetched_user.phone_number or not fetched_user.secret_key:
return None
else:
fetched_user.contacts = redis_db.smembers(fetched_user.username + ":contacts")
return fetched_user<｜fim▁end｜> | redis_db.delete(self.username + ":contacts") |
<|file_name|>index.js<|end_file_name|><｜fim▁begin｜>'use strict';
import React from 'react';
import ReactDOM from 'react-dom';
import UIDropdownComponent from './component';
let uiDropdown = function (element) {
ReactDOM.render(
React.createElement(
UIDropdownComponent,
{'message': element.getAttribute('data-message')}
),
element
);
};
<｜fim▁hole｜><｜fim▁end｜> | export default uiDropdown; |
<|file_name|>IconTheme.py<|end_file_name|><｜fim▁begin｜># encoding: utf-8
# module gtk._gtk
# from /usr/lib/python2.7/dist-packages/gtk-2.0/gtk/_gtk.so
# by generator 1.135
# no doc
# imports
import atk as __atk
import gio as __gio
import gobject as __gobject
import gobject._gobject as __gobject__gobject
class IconTheme(__gobject__gobject.GObject):
"""
Object GtkIconTheme
Signals from GtkIconTheme:
changed ()
Signals from GObject:
notify (GParam)
"""
def append_search_path(self, *args, **kwargs): # real signature unknown
pass
def choose_icon(self, *args, **kwargs): # real signature unknown
pass
@classmethod
def do_changed(cls, *args, **kwargs): # real signature unknown
pass
def get_example_icon_name(self, *args, **kwargs): # real signature unknown
pass
def get_icon_sizes(self, *args, **kwargs): # real signature unknown
pass
def get_search_path(self, *args, **kwargs): # real signature unknown
pass
def has_icon(self, *args, **kwargs): # real signature unknown
pass
def list_contexts(self, *args, **kwargs): # real signature unknown<｜fim▁hole｜>
def load_icon(self, *args, **kwargs): # real signature unknown
pass
def lookup_by_gicon(self, *args, **kwargs): # real signature unknown
pass
def lookup_icon(self, *args, **kwargs): # real signature unknown
pass
def prepend_search_path(self, *args, **kwargs): # real signature unknown
pass
def rescan_if_needed(self, *args, **kwargs): # real signature unknown
pass
def set_custom_theme(self, *args, **kwargs): # real signature unknown
pass
def set_screen(self, *args, **kwargs): # real signature unknown
pass
def set_search_path(self, *args, **kwargs): # real signature unknown
pass
def __init__(self, *args, **kwargs): # real signature unknown
pass
__gtype__ = None # (!) real value is ''<｜fim▁end｜> | pass
def list_icons(self, *args, **kwargs): # real signature unknown
pass |
<|file_name|>Find-Unusual-Scripts.py<|end_file_name|><｜fim▁begin｜># (c) 2016 Douglas Roark
# Licensed under the MIT License. See LICENSE for the details.
from __future__ import print_function, division # Valid as of 2.6
import sys
sys.path.insert(0, '/home/droark/Projects/etotheipi-BitcoinArmory')
import binascii, hashlib, string, os
from collections import namedtuple
from math import ceil, log
from copy import deepcopy
# from armoryengine.BinaryPacker import * # Armory
from armoryengine.BinaryUnpacker import * # Armory
from armoryengine.ArmoryUtils import * # Armory
preBufZero = '\x00' * 4
# Quick-and-dirty enum.
class TxType:
p2pKey = 1
p2pHash = 2
p2sh = 3
multiSig = 4
opReturn = 5
unknownTx = 6
# Transaction opcodes. Include only the ones we care about.
OP_0 = '\x00'
OP_1 = '\x51'
OP_2 = '\x52'
OP_3 = '\x53'
OP_RETURN = '\x6a'
OP_DUP = '\x76'
OP_EQUAL = '\x87'
OP_EQUALVERIFY = '\x88'
OP_HASH160 = '\xa9'
OP_CHECKSIG = '\xac'
OP_CHECKMULTISIG = '\xae'
# OP_CHECKSIG hashtype values (https://en.bitcoin.it/wiki/OP_CHECKSIG)
NULL_BYTE = '\x00' # A few sig/pubKey combos use a null byte.
SIGHASH_ALL = '\x01'
SIGHASH_NONE = '\x02'
SIGHASH_SINGLE = '\x03'
SIGHASH_ANYONECANPAY = '\x80'
# ASN.1 encoding bytes
ASN1_INTEGER = '\x02'
ASN1_SEQUENCE = '\x30'
# A global variable 'cause I'm being a lazy bastard. :) Used when printing data
# about a weird transaction. Useful for blockchain.info, blockexplorer.com, etc.
curTxHash = '\x00'
# Get a block file name based on a given number (blkXXXXX.dat).
# Input: A number between 0-99,999.
# Output: Block file name based on the input (e.g., blk00008.dat).
def getBCBlkFilename(fileNum):
'''Create a Bitcoin block data file name based on the incoming number.'''
if(fileNum < 0 or fileNum > 99999):
print("Bad blkXXXXX.dat input number. Defaulting to blk99999.dat.")
fileNum = 99999
blkFile = os.path.join(BLKFILE_DIR, 'blk%05d.dat' % fileNum)
return blkFile
# Read block header values and get the block header 2xSHA256 hash. The block
# header values are as follows, in the given order, and also returned in the
# same order. (The block header hash is returned last.)
# 1)Block header version (4 bytes - Little endian)
# 2)Previous block header's hash (32 bytes - Big endian)
# 3)Block transactions' merkle root (32 bytes - Big endian)
# 4)Block timestamp (4 bytes - Little endian)
# 5)Block difficulty "bits" (4 bytes - Little endian)
# 6)Block nonce (4 bytes - Little endian)
# Input: Raw data pointing to a block header.
# Output: The individual block header pieces, and the block header hash.
def getBlkHdrValues(header):
'''Get the block header values & hash. Will read the data itself.'''
# Get the block hash (endian-flipped result of 2xSHA256 block header
# hash), then get the individual block pieces and return everything.
blkHdrData = header.read(80)
blkHdrHash = hash256(blkHdrData) # BE
blkHdrUnpack = BinaryUnpacker(blkHdrData)
blkVer = blkHdrUnpack.get(UINT32) # LE
prevBlkHash = blkHdrUnpack.get(BINARY_CHUNK, 32) # BE
blkMerkleRoot = blkHdrUnpack.get(BINARY_CHUNK, 32) # BE
blkTimestamp = blkHdrUnpack.get(UINT32) # LE
blkBits = blkHdrUnpack.get(UINT32) # LE
blkNonce = blkHdrUnpack.get(UINT32) # LE
return (blkVer, prevBlkHash, blkMerkleRoot, blkTimestamp, blkBits, \
blkNonce, blkHdrHash)
# Look in a BinaryUnpacker object with a transaction input item and gets the
# pieces. The transaction input includes, in the following order:
# 1)A 2xSHA256 hash of a transaction being used as an input. (32 bytes - BE)
# 2)The index of the referenced output in the referenced trans. (4 bytes - LE)
# 3)Transaction input's script length. (VAR_INT - Little endian)
# 4)Transaction input's script. (VAR_LEN - Big endian)
# 5)Sequence # (usually 0xFFFFFFFF, usually irrelevant). (4 bytes - LE)
# Input: A BinaryUnpacker object with the transaction input.
# Output: The Tx input's individual objects and the TxIn binary string.
def getTxIn(txUnpack):
'''Function that unpacks the items inside a transaction input.'''
txStartPos = txUnpack.getPosition()
# Get the individual Tx pieces.
txInPrevHash = txUnpack.get(BINARY_CHUNK, 32) # BE
txInPrevTxOutHashIdx = txUnpack.get(UINT32)
txInScrLen = txUnpack.get(VAR_INT)
txInScr = txUnpack.get(BINARY_CHUNK, txInScrLen)
txInSeqNum = txUnpack.get(UINT32)
# While we're here, let's get the Tx binary string itself.
txLen = txUnpack.getPosition() - txStartPos
txUnpack.rewind(txLen)
txInStr = txUnpack.get(BINARY_CHUNK, txLen)
return (txInPrevHash, txInPrevTxOutHashIdx, txInScrLen, txInScr, \
txInSeqNum, txInStr)
# Look in a BinaryUnpacker object with a transaction output item and gets the
# pieces. The transaction output includes, in the following order:
# 1)The amount sent in the transaction. (8 bytes - LE)
# 2)Transaction output's script length. (VAR_INT - LE)
# 3)Transaction output's script. (VAR_LEN - BE)
# Input: A BinaryUnpacker object with the transaction input.
# Output: The Tx output's individual objects and the TxOut binary string.
def getTxOut(txUnpack):
'''Function that unpacks the items inside a transaction output.'''
txStartPos = txUnpack.getPosition()
# Get the individual Tx pieces.
txOutVal = txUnpack.get(UINT64)
txOutScrLen = txUnpack.get(VAR_INT)
txOutScr = txUnpack.get(BINARY_CHUNK, txOutScrLen)
# While we're here, let's get the Tx binary string itself.
txLen = txUnpack.getPosition() - txStartPos
txUnpack.rewind(txLen)
txOutStr = txUnpack.get(BINARY_CHUNK, txLen)
return (txOutVal, txOutScrLen, txOutScr, txOutStr)
# Look in a BinaryUnpacker object with a transaction item and gets the pieces.
# The transaction includes, in the following order:
# 1)Transaction version number. (4 bytes - Little endian)
# 2)Number of transaction inputs. (VAR INT - LE)
# 3)Transaction inputs. (VAR_LEN - Big endian)
# 4)Number of transaction outputs. (VAR INT - LE)
# 5)Transaction outputs. (VAR_LEN - BE)
# 6)Transaction lock time. (4 bytes - LE)
# Input: A BinaryUnpacker object with the transaction.
# Output: The transaction's individual objects, and the 2xSHA256 hash of the
# transaction. The inputs & outputs will be returned in lists.
def getTxObj(txUnpack):
'''Function that unpacks the items inside a transaction.'''
txInList = []
txOutList = []
txInStr = b''
txOutStr = b''
unpackStartPos = txUnpack.getPosition()
# Get the Tx version and the inputs. Put the inputs in a list.
txVer = txUnpack.get(UINT32) # Item 1
numTxIn = txUnpack.get(VAR_INT) # Item 2
txInCtr = numTxIn
while(txInCtr > 0):
txInPrevHash, txInPrevTxOutHashIdx, txInScrLen, txInScr, txInSeqNum, \
txInStr = getTxIn(txUnpack) # Item 3
txInList.append(txInStr)
txInCtr -= 1
# Get the Tx outputs and put them in a list.
numTxOut = txUnpack.get(VAR_INT) # Item 4
txOutCtr = numTxOut
while(txOutCtr > 0):
txOutVal, txOutScrLen, txOutScr, txOutStr = getTxOut(txUnpack) # Item 5
txOutList.append(txOutStr)
txOutCtr -= 1
# Get the Tx lock time.
txLockTime = txUnpack.get(UINT32) # Item 6
# Because the reference Bitcoin client currently tolerates non-canonical
# VAR_INT objects, we're not allowed to recreate a hash from the individual
# Tx elements. It's a possible Tx malleability attack. Once the client
# disallows non-canonical VAR_INTs, we can hash the pieces. 'Til then, we
# must rewind and hash the entire Tx.
txLen = txUnpack.getPosition() - unpackStartPos
txUnpack.rewind(txLen)
txStr = txUnpack.get(BINARY_CHUNK, txLen)
txHash = hash256(txStr)
return (txVer, numTxIn, txInList, numTxOut, txOutList, txLockTime, txHash)
# Function that determines if a BinaryUnpacker object contains an ECDSA public
# key, as defined by X9.62. The function only determines if the format is
# correct, not if the key is actually valid. The format is:
# Compressed key - (0x02 or 0x03) + 32 bytes
# Uncompressed key - 0x04 + 64 bytes
# Input: BinaryUnpacker object pointing to a supposed ECDSA public key. The
# object will be rewound to its starting position at the end.
# Output: 0 if the key is invalid, or the key length if the key is valid.
def isPubKey(pkIn):
'''Determine if a chunk of data is an ECDSA public key (X9.62 encoding).'''
retVal = 0<｜fim▁hole｜>
# There must be at least 33 bytes left to read.
if(pkIn.getRemainingSize() >= 33):
initByte = pkIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(initByte == '\x02' or initByte == '\x03'): # Compressed key
retVal = 33
elif(initByte == '\x04'): # Uncompressed key
# The previous length check wasn't adequate for uncompressed keys.
# Make sure there's enough data before confirming the key is valid.
if(pkIn.getRemainingSize() >= 64):
retVal = 65
# Rewind and return.
pkIn.rewind(rewindVal)
return retVal
# Function that determines if a hash byte is a valid SIGHASH byte. We'll also
# accept NULL (i.e., 0x00) byte. See https://en.bitcoin.it/wiki/OP_CHECKSIG for
# more details.
# Input: A byte to check.
# Output: True if a byte's valid, False if not.
def isValidSigHashByte(inByte):
'''Determine if a byte is a valid SIGHASH byte.'''
retVal = False
# HACK ALERT: Some scriptSig objects have a NULL byte present instead of a
# proper SIGHASH byte. We'll accept it.
if(inByte == NULL_BYTE or inByte == SIGHASH_ALL or inByte == SIGHASH_NONE or
inByte == SIGHASH_SINGLE or inByte == SIGHASH_ANYONECANPAY):
retVal = True
return retVal
# Function that determines if a BinaryUnpacker object contains an ECDSA
# signature or signatures, as defined by X9.62, plus a byte used by OP_CHECKSIG
# to determine how the Tx will be hashed. The function only determines if the
# format is correct, not if the signature is actually valid.
# NB 1: For 256-bit ECDSA, r & s are 32 byte values. However, due to DER
# encoding quirks (and Satoshi quirks), the values can be 30-34 bytes.
# NB 2: This code, strictly speaking, shouldn't handle the initial size byte or
# the SIGHASH byte. A revision for a future HW problem....
# The format is:
# Length of signature (not part of the X9.62 sig - 1 byte - Must be 67-75)
# 0x30 (1 byte - "ASN.1 SEQUENCE" byte)
# Length of "r" & "s" segments (1 byte - Must be 64-70)
# 0x02 (1 byte - "ASN.1 INTEGER" byte)
# Length of "r" variable (1 byte - Must be 30-34)
# "r" variable (31-33 bytes)
# 0x02 (1 byte - "ASN.1 INTEGER" byte)
# Length of "s" variable (1 byte - Must be 30-34)
# "s" variable (31-33 bytes)
# The OP_CHECKSIG "SIGHASH" byte (not part of the X9.62 sig - 1 byte)
# Input: BinaryUnpacker object pointing to a supposed ECDSA signature. The
# object will be rewound to its starting position at the end.
# Output: 0 if the key's invalid, or the valid key's overall length (72-74).
def isSig(sigIn):
'''Determine if a data chunk is an ECDSA signature (X9.62 DER encoding).'''
retVal = 0
rewindVal = 0
sigValid = False
chunkSize = sigIn.getRemainingSize()
# Signatures can be 67-75 bytes. We need at least 1 byte to read, at which
# point the signature will help us determine if we have enough data to read.
if(chunkSize >= 1):
initByte = sigIn.get(BINARY_CHUNK, 1)
sigSize = sigIn.getRemainingSize()
rewindVal += 1
if(initByte >= '\x43' and initByte <= '\x4b' and sigSize >= binary_to_int(initByte)):
if(sigIn.getRemainingSize() >= binary_to_int(initByte)):
asn1SeqByte = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(asn1SeqByte == ASN1_SEQUENCE):
lenByte1 = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(lenByte1 >= '\x40' and lenByte1 <= '\x48'):
asn1IntByte1 = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(asn1IntByte1 == ASN1_INTEGER):
rLen = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(rLen >= '\x1e' and rLen <= '\x22'):
sigIn.advance(binary_to_int(rLen))
rewindVal += binary_to_int(rLen)
asn1IntByte2 = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(asn1IntByte2 == ASN1_INTEGER):
sLen = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(sLen >= '\x1e' and sLen <= '\x22'):
sigIn.advance(binary_to_int(sLen))
rewindVal += binary_to_int(sLen)
lastByte = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(isValidSigHashByte(lastByte) == True):
sigValid = True
# Do final cleanup. Rewind and, if necessary, set the sig size.
sigIn.rewind(rewindVal)
if(sigValid == True):
retVal = binary_to_int(initByte) + 1
return retVal
# "Shell" function that acts as a starting point for figuring out if a chunk of
# data is an ECDSA, DER-encoded signature. This can handle chunks of data that
# may actually have multiple signatures. If we get up to 3 sigs and there's
# still more data, we'll say the data's valid and assume the user will check the
# remaining data to see if it's valid for any particular purpose.
# Input: BinaryUnpacker object pointing to a supposed ECDSA signature (it'll be
# rewound to its starting position at the end) and a boolean flag
# indicating whether or not the data may be multi-sig.
# Output: 0 if there are no valid sigs, or the number of bytes (from the
# beginning) that contain actual sigs.
def isSigShell(sigIn, isMultiSig):
'''Determine if a data chunk contains a valid ECDSA signature (X9.62 DER
encoding.'''
validSigs = True
numSigs = 0
rewindVal = 0
# For now, assume valid scripts can have only up to 3 sigs.
maxNumSigs = 1
if(isMultiSig == True):
maxNumSigs = 3
# While there's data to be read, we believe there are valid sigs, and we
# haven't encountered more than 3 signatures,
while(sigIn.getRemainingSize() != 0 and numSigs < 3 and validSigs == True):
readByte = sigIn.get(BINARY_CHUNK, 1)
rewindVal += 1
if(readByte >= '\x43' and readByte <= '\x4b'):
sigIn.rewind(1)
sigAdv = isSig(sigIn)
if(sigAdv != 0):
rewindVal += sigAdv
sigIn.advance(sigAdv)
numSigs += 1
else:
validSigs = False
else:
sigIn.rewind(1)
rewindVal -= 1
validSigs = False
# Rewind to where we started and return how many bytes are part of actual
# sigs.
sigIn.rewind(rewindVal)
return rewindVal
# Process TxOut from a Tx. It basically unpacks a TxOut and allows other functs
# to perform more specific tasks. Use it as a starting point!
# Input: The TxOut object, the TxOut block's hash, the TxOut block's position,
# the TxOut Tx's index, the TxOut index, and the file where unknown
# TxOuts will go.
# Output: None
def processTxOut(txOut, blkHash, blkPos, txIdx, txOutIdx, txOutFile):
'''Function used to start processing of a TxOut object.'''
advanceVal = 0
txOutUnpack = BinaryUnpacker(txOut)
# Simple sanity check before proceeding.
txOutLen = len(txOut)
if(txOutLen > 0):
txOutVal, txOutScrLen, txOutScr, txOutStr = getTxOut(txOutUnpack)
scrType = processTxOutScr(txOutScr, blkHash, blkPos, txIdx, \
txOutIdx, txOutFile)
# Determines the type of an incoming TxOut script. If it's not any of the five
# standard types (pay-to-pub-key, pay-to-pub-hash, pay-to-script-hash (P2SH -
# BIP16), multisig (BIP11), or OP_RETURN (BC-Core v0.9+)), it's saved to a file.
# Input: The TxOut object's script, the TxOut block's hash, the TxOut block's
# position, the TxOut Tx's index, the TxOut index, and the file where
# unknown TxOuts will go.
# Output: The TxOut type, as defined by class TxType.
def processTxOutScr(txOutScr, blkHash, blkPos, txIdx, txOutIdx, txOutFile):
'''Function processing a TxOut script.'''
# Proceed only if there's data to read.
txOutScrUnpack = BinaryUnpacker(txOutScr)
retVal = TxType.unknownTx
txOutScrSize = txOutScrUnpack.getRemainingSize()
if(txOutScrSize > 0):
# Read the initial byte and determine what TxOut type it is.
initByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
# 0x21/0x41 = Pay2PubKey
if(initByte == '\x21' or initByte == '\x41'):
# Make sure it's a valid pub key before declaring it valid.
pkLen = isPubKey(txOutScrUnpack)
if(pkLen != 0):
retVal = TxType.p2pKey
# OP_DUP = Pay2PubKeyHash
elif(initByte == OP_DUP):
# HACK ALERT: Some bright bulb has created OP_* TxOuts that have
# nothing but the OP_* code. Check the remaining size upfront.
# (Checking after every read is more robust, really. I'm just lazy
# and don't want to retrofit this chunk of code. :) )
if(txOutScrUnpack.getRemainingSize() > 0):
hashByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
if(hashByte == OP_HASH160):
hashSize = txOutScrUnpack.get(BINARY_CHUNK, 1)
hashRemSize = txOutScrUnpack.getRemainingSize()
if(hashSize == '\x14' and hashRemSize >= binary_to_int(hashSize)):
txOutScrUnpack.advance(binary_to_int(hashSize))
eqVerByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
if(eqVerByte == OP_EQUALVERIFY):
checkSigByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
if(checkSigByte == OP_CHECKSIG):
retVal = TxType.p2pHash
# OP_HASH160 = Pay2ScriptHash
elif(initByte == OP_HASH160):
hashSize = txOutScrUnpack.get(BINARY_CHUNK, 1)
hashRemSize = txOutScrUnpack.getRemainingSize()
if(hashSize == '\x14' and hashRemSize >= binary_to_int(hashSize)):
txOutScrUnpack.advance(binary_to_int(hashSize))
eqByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
if(eqByte == OP_EQUAL):
retVal = TxType.p2sh
# OP_1/2/3 = MultiSig
elif(initByte == OP_1 or initByte == OP_2 or initByte == OP_3):
validKeys = True
readByte = 0
numKeys = 0
# HACK ALERT 1: Some scripts are weird and initially appear to be
# multi-sig but really aren't. We should compensate. One particular
# way is to require at least 36 bytes (assume 1-of-1 w/ compressed
# key) beyond the initial byte.
#
# HACK ALERT 2: There are some multisig TxOuts that, for unknown
# reasons have things like compressed keys that where the first byte
# is 0x00, not 0x02 or 0x03. For now, we just mark them as unknown
# Tx and move on.
if(txOutScrUnpack.getRemainingSize() >= 36):
readByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
while((readByte == '\x21' or readByte == '\x41') and numKeys < 3
and validKeys == True):
pkLen = isPubKey(txOutScrUnpack)
if(pkLen != 0):
txOutScrUnpack.advance(pkLen)
numKeys += 1
readByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
else:
validKeys = False
else:
validKeys = False
if(validKeys == True):
if((readByte == OP_1 or readByte == OP_2 or readByte == OP_3) \
and binary_to_int(initByte) <= binary_to_int(readByte)):
cmsByte = txOutScrUnpack.get(BINARY_CHUNK, 1)
if(cmsByte == OP_CHECKMULTISIG):
retVal = TxType.multiSig
# OP_RETURN = Arbitrary data attached to a Tx.
# Official as of BC-Core 0.9. https://bitcoinfoundation.org/blog/?p=290
# and https://github.com/bitcoin/bitcoin/pull/2738 have the details of
# the initial commit, with https://github.com/bitcoin/bitcoin/pull/3737
# having the revision down to 40 bytes.
elif(initByte == OP_RETURN):
# If the 1st byte is OP_RETURN, as of BC-Core v0.9, there can be
# arbitrary data placed afterwards. This makes the TxOut immediately
# prunable, meaning it can never be used as a TxIn. (It can still be
# spent, mind you.) The final BC-Core 0.9 only accepts <=40 bytes,
# but preview versions accepted <=80. In theory, any amount of data
# is valid, but miners won't accept non-standard amounts by default.
#
# Anyway, since it's arbitrary, we don't care what's present and
# just assume it's valid.
retVal = TxType.opReturn
# Everything else is weird and should be reported.
else:
print("DEBUG: Block {0} - Tx Hash {1}: 1st BYTE (TxOut) IS " \
"TOTALLY UNKNOWN!!! BYTE={2}".format(blkPos, \
binary_to_hex(curTxHash, endOut=BIGENDIAN), \
binary_to_hex(initByte)))
# Write the script to the file if necessary.
if(retVal == TxType.unknownTx):
print("TxOut: {0}".format(binary_to_hex(txOutScr)), \
file=txOutFile)
print("Block Number: {0}".format(blkPos), file=txOutFile)
print("Block Hash: {0}".format(binary_to_hex(blkHash)), \
file=txOutFile)
print("Tx Hash: {0}", binary_to_hex(curTxHash, endOut=BIGENDIAN), \
file=txOutFile)
print("Tx Index: {0}", txIdx, file=txOutFile)
print("TxOut Index: {0}", txOutIdx, file=txOutFile)
print("---------------------------------------", file=txOutFile)
return retVal
# Process TxIn from a Tx. It basically unpacks a TxIn and allows other functs to
# perform more specific tasks. Coinbase TxIns are ignored. Use this function as
# a starting point!
# Input: The TxIn object, the TxIn block's hash, the TxIn block's position, the
# TxIn Tx's index, the TxIn index, and the file where unknown TxIns will
# go.
# Output: None
def processTxIn(txIn, blkHash, blkPos, txIdx, txInIdx, txInFile):
'''Function used to start processing of a TxIn object.'''
advanceVal = 0
txInUnpack = BinaryUnpacker(txIn)
# Simple sanity check before proceeding.
txInLen = len(txIn)
if(txInLen > 0):
txInPrevHash, txInPrevTxOutHashIdx, txInScrLen, txInScr, txInSeqNum, \
txInStr = getTxIn(txInUnpack)
# Proceed only if there's a script and if this isn't a coinbase TxIn.
# For now, assume it's coinbase if the hash of the referenced TxOut
# is a 32-byte NULL object.
if(txInScrLen != 0 and txInPrevHash != ('\x00' * 32)):
scrType = processTxInScr(txInScr, blkHash, blkPos, txIdx, \
txInIdx, txInFile)
# Process TxIn from a Tx. Determines which TxIn type it is. If it's not any of
# the four standard types (pay-to-pub-key, pay-to-pub-hash, pay-to-script-hash
# (P2SH - BIP16), multisig (BIP11)), or if it's a P2SH script, it's saved to a
# file. (The OP_RETURN script type has no use for TxIns.) P2SH TxIn scripts are
# saved because the scripts inside the TxIn, as of Apr. 2014, are never
# standard TxOut scripts.
# Input: TxIn length, TxIn, the TxIn block's hash, the TxIn block's position,
# the TxIn Tx's index, the TxIn index, and the file where unknown TxIns will go.
# Output: The TxIn type, as defined by class TxType.
def processTxInScr(txInScr, blkHash, blkPos, txIdx, txInIdx, txInFile):
'''Function processing a TxIn script.'''
# Proceed only if there's data to read.
txInScrUnpack = BinaryUnpacker(txInScr)
retVal = TxType.unknownTx
txInScrSize = txInScrUnpack.getRemainingSize()
if(txInScrSize > 0):
# Read the initial byte and determine what TxOut type it is.
initByte = txInScrUnpack.get(BINARY_CHUNK, 1)
# Except for multisig and possibly OP_RETURN, all should start with a
# sig.
if(initByte >= '\x43' and initByte <= '\x4b'):
# Make sure it's a valid pub key before declaring it valid.
# CATCH: We'll rewind because the first byte of the sig isn't
# repeated, meaning the stack uses the first byte of the sig to push
# the rest of the sig onto the stack. The rewind isn't necessary but
# I'd like to keep the sig verification whole.
txInScrUnpack.rewind(1)
sigLen = isSigShell(txInScrUnpack, False)
if(sigLen != 0):
txInScrUnpack.advance(sigLen)
if(txInScrUnpack.getRemainingSize() == 0):
retVal = TxType.p2pKey
else:
readByte = txInScrUnpack.get(BINARY_CHUNK, 1)
if(readByte == '\x21' or readByte == '\x41'):
pkLen = isPubKey(txInScrUnpack)
if(pkLen != 0):
retVal = TxType.p2pHash
# OP_0 = P2SH or MultiSig
elif(initByte == OP_0):
numBytesAdv = isSigShell(txInScrUnpack, True)
# Proceed only if there was at least 1 valid sig.
if(numBytesAdv != 0):
txInScrUnpack.advance(numBytesAdv)
numBytesRem = txInScrUnpack.getRemainingSize()
if(numBytesRem != 0):
# Confirm that the remaining bytes are a standard script
# before marking this as a P2SH script. (There are P2SH
# scripts that aren't standard, so we'll mark the entire
# script as unknown and save it.) In a fully robust system,
# we'd Hash160 and compare against the Hash160 in the
# ref'd TxOut to confirm that this is valid.
# NB: In the real world, it looks like all scripts don't
# match the normal TxOut types! Just mark this as P2SH and
# write it out anyway.
# p2shScript = txInScrUnpack.get(BINARY_CHUNK, numBytesRem)
# if(processTxOutScr(p2shScript, blkHash, blkPos, txIdx, \
# txOutIdx, txOutFile) != TxType.unknownTx):
# retVal = TxType.p2sh
# print("HEY, WE GOT A GOOD SCRIPT! {0}".format(binary_to_hex(p2shScript)))
# else:
# print("OH NO, WE HAVE A BAD SCRIPT! {0}".format(binary_to_hex(p2shScript)))
retVal = TxType.p2sh
else:
# We have multi-sig.
retVal = TxType.multiSig
# We have an unknown script type. We'll report it. There's a chance it
# refers to an OP_RETURN TxOut script but we'll ignore that possibility
# for now in order to keep things simple.
else:
print("DEBUG: Block {0}: 1st BYTE (TxIn) IS TOTALLY UNKNOWN!!! " \
"BYTE={1}".format(blkPos, binary_to_hex(initByte)))
# If a script is unknown or is P2SH, write it out here.
# NB: After running this code several times, it appears that the multisig
# code uses keys with invalid first bytes. I'm not sure what's going on. The
# scripts seem valid otherwise.
# if(retVal == TxType.unknownTx or retVal == TxType.p2sh):
# if(retVal == TxType.p2sh):
# print("P2SH script")
# else:
# print("Unknown TxIn script")
if retVal == TxType.unknownTx:
print("TxIn: {0}".format(binary_to_hex(txInScr)), \
file=txInFile)
print("Block Number: {0}".format(blkPos), file=txInFile)
print("Block Hash: {0}".format(binary_to_hex(blkHash)), \
file=txInFile)
print("Tx Hash: {0}", binary_to_hex(curTxHash, endOut=BIGENDIAN), \
file=txInFile)
print("Tx Index: {0}", txIdx, file=txInFile)
print("TxIn Index: {0}", txInIdx, file=txInFile)
print("---------------------------------------", file=txInFile)
return retVal
if __name__ == '__main__':
# Variables
# curBlkFile = 138 ################################################################## ONLY IN SPECIAL CIRCUMSTANCES
curBlkFile = 0
numBlks = 0
fileName = getBCBlkFilename(curBlkFile)
# Open a file which will receive the TxOut materials.
txInFilename = "prob3TxIn.txt"
txInFile = open(txInFilename, "wt")
txOutFilename = "prob3TxOut.txt"
txOutFile = open(txOutFilename, "wt")
# Write the starts of the TxOut/TxIn files.
print("Unknown TxOuts", file=txOutFile)
print("---------------------------------------", file=txOutFile)
print("Unknown/P2SH TxIns", file=txInFile)
print("---------------------------------------", file=txInFile)
# Iterate through each block by going through each file. Note that the code
# assumes blocks are in order. In the future, this may not be case.
while(os.path.isfile(fileName) is True):
# if(os.path.isfile(fileName) == True): # SPECIAL DEBUG: ONLY 1 FILE PARSED
print("DEBUG: File blk%05d.dat exists." % curBlkFile)
# While reading the files, read data only as needed, and not all at
# once. More I/O but it keeps memory usage down.
with open(fileName, "rb") as rawData:
try:
# Read the magic bytes (4 bytes) & block size (4 bytes). Proceed
# only if there's data to read.
readData = rawData.read(8)
while(readData != ""):
# If the magic bytes are legit, proceed.
readUnpack = BinaryUnpacker(readData)
read_magic = readUnpack.get(BINARY_CHUNK, 4)
if(read_magic == MAGIC_BYTES):
# Get the block header data.
blockLen = readUnpack.get(UINT32)
blockVer, prevBlkHash, merkRoot, timestamp, bits, \
nonce, blkHdrHash = getBlkHdrValues(rawData)
# Get the transaction data and process it.
rawTxData = rawData.read(blockLen - 80)
txUnpack = BinaryUnpacker(rawTxData)
txVarInt = txUnpack.get(VAR_INT)
txIdx = 0
# Process all Tx objects.
while(txVarInt > 0):
txVer, numTxIn, txInList, numTxOut, txOutList, \
txLockTime, txHash = getTxObj(txUnpack)
curTxHash = txHash # Global hack 'cause I'm lazy.
# Process every TxOut & TxIn in a Tx.
txOutIdx = 0
txInIdx = 0
for txOutObj in txOutList:
processTxOut(txOutObj, blkHdrHash, numBlks, \
txIdx, txOutIdx, txOutFile)
txOutIdx += 1
for txInObj in txInList:
processTxIn(txInObj, blkHdrHash, numBlks, \
txIdx, txInIdx, txInFile)
txInIdx += 1
txIdx += 1
txVarInt -= 1
# Increment the # of blocks we've processed.
numBlks += 1
# If magic bytes aren't magic, assume we've hit the
# end. In theory, Bitcoin-Qt pre-buffers w/ 0s, but
# in practice, the pre-buffering seems to be anything.
else:
break
# Before looping back, try reading data again.
readData = rawData.read(8)
# Always close a file once it's done.
finally:
rawData.close()
# Get ready to read the next file.
curBlkFile += 1
fileName = getBCBlkFilename(curBlkFile)
txInFile.close()
txOutFile.close()<｜fim▁end｜> | rewindVal = 0 # Here only so that future changes are made obvious. |
<|file_name|>data_manipulation.py<|end_file_name|><｜fim▁begin｜>import pandas
import numpy
import operator
from sklearn.preprocessing import OneHotEncoder
from typing import Mapping
def one_hot_encode(vector, dtype='float32', categories=None, index=None):
if isinstance(vector, pandas.Series):
index = vector.index
vector = vector.values
encoder = OneHotEncoder(
categories='auto' if categories is None else [categories,],
sparse=False,
dtype=dtype,
).fit(vector.reshape(-1,1))
return pandas.DataFrame(
data = encoder.transform(vector.reshape(-1,1)),
columns=encoder.categories_,
index=index
)
def periodize(
values,
mapping=None,
default=None,
right=True,
left=True,
**kwargs,
):
"""
Label sections of a continuous variable.
This function contrasts with `pandas.cut` in that
there can be multiple non-contiguous sections of the
underlying continuous interval that obtain the same
categorical value.
Parameters
----------
values : array-like
The values to label. If given as a pandas.Series,
the returned values will also be a Series,
with a categorical dtype.
mapping : Collection or Mapping
A mapping, or a collection of 2-tuples giving
key-value pairs (not necessarily unique keys).
The keys (or first values) will be the new values,
and the values (or second values) are 2-tuples
giving upper and lower bounds.
default : any, default None
Keys not inside any labeled interval will get
this value instead.
right : bool, default True
Whether to include the upper bound[s] in the
intervals for labeling.
left : bool, default True
Whether to include the lower bound[s] in the
intervals for labeling.
**kwargs :
Are added to `mapping`.
Returns
-------
array-like
Example
-------
>>> import pandas
>>> h = pandas.Series(range(1,24))<｜fim▁hole｜> 0 OP
1 OP
2 OP
3 OP
4 OP
5 OP
6 AM
7 AM
8 AM
9 OP
10 OP
11 OP
12 OP
13 OP
14 OP
15 PM
16 PM
17 PM
18 PM
19 OP
20 OP
21 OP
22 OP
dtype: category
Categories (3, object): ['AM', 'OP', 'PM']
"""
if mapping is None:
mapping = []
if isinstance(mapping, Mapping):
mapping = list(mapping.items())
mapping.extend(kwargs.items())
if isinstance(values, pandas.Series):
x = pandas.Series(index=values.index, data=default)
else:
x = numpy.full(values.shape, default)
if right:
rop = operator.le
else:
rop = operator.lt
if left:
lop = operator.ge
else:
lop = operator.gt
for k,(lowerbound,upperbound) in mapping:
if lowerbound is None:
lowerbound = -numpy.inf
if upperbound is None:
upperbound = numpy.inf
x[lop(values,lowerbound) & rop(values,upperbound)] = k
if isinstance(x, pandas.Series):
x = x.astype('category')
return x<｜fim▁end｜> | >>> periodize(h, default='OP', AM=(6.5, 9), PM=(16, 19)) |
<|file_name|>main.cc<|end_file_name|><｜fim▁begin｜>#include <fstream>
#include <iostream>
#include <vector>
<｜fim▁hole｜> std::vector<std::string> args(argv, argv + argc);
std::ofstream tty;
tty.open("/dev/tty");
if (args.size() <= 1 || (args.size() & 2) == 1) {
std::cerr << "usage: maplabel [devlocal remote]... remotedir\n";
return 1;
}
std::string curdir = args[args.size() - 1];
for (size_t i = 1; i + 1 < args.size(); i += 2) {
if (curdir.find(args[i + 1]) == 0) {
if ((curdir.size() > args[i + 1].size() &&
curdir[args[i + 1].size()] == '/') ||
curdir.size() == args[i + 1].size()) {
tty << "\033];" << args[i] + curdir.substr(args[i + 1].size())
<< "\007\n";
return 0;
}
}
}
tty << "\033];" << curdir << "\007\n";
return 0;
}<｜fim▁end｜> | int main(int argc, char **argv) { |
<|file_name|>package_integrity_test.py<|end_file_name|><｜fim▁begin｜>import os
import unittest<｜fim▁hole｜>from conans.test.utils.conanfile import TestConanFile
from conans.test.utils.tools import TestClient, TestServer,\
NO_SETTINGS_PACKAGE_ID
from conans.util.files import set_dirty
class PackageIngrityTest(unittest.TestCase):
def remove_locks_test(self):
client = TestClient()
client.save({"conanfile.py": str(TestConanFile())})
client.run("create . lasote/testing")
self.assertNotIn('does not contain a number!', client.out)
ref = ConanFileReference.loads("Hello/0.1@lasote/testing")
conan_folder = client.cache.package_layout(ref).base_folder()
self.assertIn("locks", os.listdir(conan_folder))
self.assertTrue(os.path.exists(conan_folder + ".count"))
self.assertTrue(os.path.exists(conan_folder + ".count.lock"))
client.run("remove * --locks", assert_error=True)
self.assertIn("ERROR: Specifying a pattern is not supported", client.out)
client.run("remove", assert_error=True)
self.assertIn('ERROR: Please specify a pattern to be removed ("*" for all)', client.out)
client.run("remove --locks")
self.assertNotIn("locks", os.listdir(conan_folder))
self.assertFalse(os.path.exists(conan_folder + ".count"))
self.assertFalse(os.path.exists(conan_folder + ".count.lock"))
def upload_dirty_test(self):
test_server = TestServer([], users={"lasote": "mypass"})
client = TestClient(servers={"default": test_server},
users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": str(TestConanFile())})
client.run("create . lasote/testing")
ref = ConanFileReference.loads("Hello/0.1@lasote/testing")
pref = PackageReference(ref, NO_SETTINGS_PACKAGE_ID)
package_folder = client.cache.package_layout(pref.ref).package(pref)
set_dirty(package_folder)
client.run("upload * --all --confirm", assert_error=True)
self.assertIn("ERROR: Package %s is corrupted, aborting upload" % str(pref),
client.out)
self.assertIn("Remove it with 'conan remove Hello/0.1@lasote/testing -p=%s'"
% NO_SETTINGS_PACKAGE_ID, client.out)
client.run("remove Hello/0.1@lasote/testing -p=%s -f" % NO_SETTINGS_PACKAGE_ID)
client.run("upload * --all --confirm")<｜fim▁end｜> |
from conans.model.ref import ConanFileReference, PackageReference |
<|file_name|>transaction_queue.rs<|end_file_name|><｜fim▁begin｜>// Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! Transaction Queue
//!
//! `TransactionQueue` keeps track of all transactions seen by the node (received from other peers) and own transactions
//! and orders them by priority. Top priority transactions are those with low nonce height (difference between
//! transaction's nonce and next nonce expected from this sender). If nonces are equal transaction's gas price is used
//! for comparison (higher gas price = higher priority).
//!
//! # Usage Example
//!
//! ```rust
//! extern crate ethcore_util as util;
//! extern crate ethcore;
//! extern crate ethkey;
//! extern crate rustc_serialize;
//!
//! use util::{Uint, U256, Address};
//! use ethkey::{Random, Generator};
//! use ethcore::miner::{TransactionQueue, TransactionQueueDetailsProvider, AccountDetails, TransactionOrigin};
//! use ethcore::transaction::*;
//! use rustc_serialize::hex::FromHex;
//!
//! #[derive(Default)]
//! struct DummyTransactionDetailsProvider;
//!
//! impl TransactionQueueDetailsProvider for DummyTransactionDetailsProvider {
//! fn fetch_account(&self, _address: &Address) -> AccountDetails {
//! AccountDetails {
//! nonce: U256::from(10),
//! balance: U256::from(1_000_000)
//! }
//! }
//!
//! fn estimate_gas_required(&self, _tx: &SignedTransaction) -> U256 {
//! 2.into()
//! }
//!
//! fn is_service_transaction_acceptable(&self, _tx: &SignedTransaction) -> Result<bool, String> {
//! Ok(true)
//! }
//! }
//!
//! fn main() {
//! let key = Random.generate().unwrap();
//! let t1 = Transaction { action: Action::Create, value: U256::from(100), data: "3331600055".from_hex().unwrap(),
//! gas: U256::from(100_000), gas_price: U256::one(), nonce: U256::from(10) };
//! let t2 = Transaction { action: Action::Create, value: U256::from(100), data: "3331600055".from_hex().unwrap(),
//! gas: U256::from(100_000), gas_price: U256::one(), nonce: U256::from(11) };
//!
//! let st1 = t1.sign(&key.secret(), None);
//! let st2 = t2.sign(&key.secret(), None);
//! let details_provider = DummyTransactionDetailsProvider::default();
//!
//! let mut txq = TransactionQueue::default();
//! txq.add(st2.clone(), TransactionOrigin::External, 0, None, &details_provider).unwrap();
//! txq.add(st1.clone(), TransactionOrigin::External, 0, None, &details_provider).unwrap();
//!
//! // Check status
//! assert_eq!(txq.status().pending, 2);
//! // Check top transactions
//! let top = txq.top_transactions();
//! assert_eq!(top.len(), 2);
//! assert_eq!(top[0], st1);
//! assert_eq!(top[1], st2);
//!
//! // And when transaction is removed (but nonce haven't changed)
//! // it will move subsequent transactions to future
//! txq.remove_invalid(&st1.hash(), &|_| 10.into());
//! assert_eq!(txq.status().pending, 0);
//! assert_eq!(txq.status().future, 1);
//! assert_eq!(txq.top_transactions().len(), 0);
//! }
//! ```
//!
//! # Maintaing valid state
//!
//! 1. Whenever transaction is imported to queue (to queue) all other transactions from this sender are revalidated in current. It means that they are moved to future and back again (height recalculation & gap filling).
//! 2. Whenever invalid transaction is removed:
//! - When it's removed from `future` - all `future` transactions heights are recalculated and then
//! we check if the transactions should go to `current` (comparing state nonce)
//! - When it's removed from `current` - all transactions from this sender (`current` & `future`) are recalculated.
//! 3. `cull` is used to inform the queue about client (state) nonce changes.
//! - It removes all transactions (either from `current` or `future`) with nonce < client nonce
//! - It moves matching `future` transactions to `current`
//! 4. `remove_old` is used as convenient method to update the state nonce for all senders in the queue.
//! - Invokes `cull` with latest state nonce for all senders.
use std::ops::Deref;
use std::cmp::Ordering;
use std::cmp;
use std::collections::{HashSet, HashMap, BTreeSet, BTreeMap};
use linked_hash_map::LinkedHashMap;
use util::{Address, H256, Uint, U256};
use util::table::Table;
use transaction::*;
use error::{Error, TransactionError};
use client::TransactionImportResult;
use header::BlockNumber;
use miner::local_transactions::{LocalTransactionsList, Status as LocalTransactionStatus};
/// Transaction origin
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransactionOrigin {
/// Transaction coming from local RPC
Local,
/// External transaction received from network
External,
/// Transactions from retracted blocks
RetractedBlock,
}
impl PartialOrd for TransactionOrigin {
fn partial_cmp(&self, other: &TransactionOrigin) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for TransactionOrigin {
#[cfg_attr(feature="dev", allow(match_same_arms))]
fn cmp(&self, other: &TransactionOrigin) -> Ordering {
if *other == *self {
return Ordering::Equal;
}
match (*self, *other) {
(TransactionOrigin::RetractedBlock, _) => Ordering::Less,
(_, TransactionOrigin::RetractedBlock) => Ordering::Greater,
(TransactionOrigin::Local, _) => Ordering::Less,
_ => Ordering::Greater,
}
}
}
impl TransactionOrigin {
fn is_local(&self) -> bool {
*self == TransactionOrigin::Local
}
}
#[derive(Clone, Debug)]
/// Light structure used to identify transaction and its order
struct TransactionOrder {
/// Primary ordering factory. Difference between transaction nonce and expected nonce in state
/// (e.g. Tx(nonce:5), State(nonce:0) -> height: 5)
/// High nonce_height = Low priority (processed later)
nonce_height: U256,
/// Gas Price of the transaction.
/// Low gas price = Low priority (processed later)
gas_price: U256,
/// Gas usage priority factor. Usage depends on strategy.
/// Represents the linear increment in required gas price for heavy transactions.
///
/// High gas limit + Low gas price = Low priority
/// High gas limit + High gas price = High priority
gas_factor: U256,
/// Gas (limit) of the transaction. Usage depends on strategy.
/// Low gas limit = High priority (processed earlier)
gas: U256,
/// Transaction ordering strategy
strategy: PrioritizationStrategy,
/// Hash to identify associated transaction
hash: H256,
/// Origin of the transaction
origin: TransactionOrigin,
/// Penalties
penalties: usize,
}
impl TransactionOrder {
fn for_transaction(tx: &VerifiedTransaction, base_nonce: U256, min_gas_price: U256, strategy: PrioritizationStrategy) -> Self {
let factor = (tx.transaction.gas >> 15) * min_gas_price;
TransactionOrder {
nonce_height: tx.nonce() - base_nonce,
gas_price: tx.transaction.gas_price,
gas: tx.transaction.gas,
gas_factor: factor,
strategy: strategy,
hash: tx.hash(),
origin: tx.origin,
penalties: 0,
}
}
fn update_height(mut self, nonce: U256, base_nonce: U256) -> Self {
self.nonce_height = nonce - base_nonce;
self
}
fn penalize(mut self) -> Self {
self.penalties = self.penalties.saturating_add(1);
self
}
}
impl Eq for TransactionOrder {}
impl PartialEq for TransactionOrder {
fn eq(&self, other: &TransactionOrder) -> bool {
self.cmp(other) == Ordering::Equal
}
}
impl PartialOrd for TransactionOrder {
fn partial_cmp(&self, other: &TransactionOrder) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for TransactionOrder {
fn cmp(&self, b: &TransactionOrder) -> Ordering {
// First check number of penalties
if self.penalties != b.penalties {
return self.penalties.cmp(&b.penalties);
}
// Local transactions should always have priority
if self.origin != b.origin {
return self.origin.cmp(&b.origin);
}
// Check nonce_height
if self.nonce_height != b.nonce_height {
return self.nonce_height.cmp(&b.nonce_height);
}
match self.strategy {
PrioritizationStrategy::GasAndGasPrice => {
if self.gas != b.gas {
return self.gas.cmp(&b.gas);
}
},
PrioritizationStrategy::GasFactorAndGasPrice => {
// avoiding overflows
// (gp1 - g1) > (gp2 - g2) <=>
// (gp1 + g2) > (gp2 + g1)
let f_a = self.gas_price + b.gas_factor;
let f_b = b.gas_price + self.gas_factor;
if f_a != f_b {
return f_b.cmp(&f_a);
}
},
PrioritizationStrategy::GasPriceOnly => {},
}
// Then compare gas_prices
if self.gas_price != b.gas_price {
return b.gas_price.cmp(&self.gas_price);
}
// Compare hashes
self.hash.cmp(&b.hash)
}
}
/// Verified transaction
#[derive(Debug)]
struct VerifiedTransaction {
/// Transaction.
transaction: SignedTransaction,
/// Transaction origin.
origin: TransactionOrigin,
/// Insertion time
insertion_time: QueuingInstant,
/// Delay until specified condition is met.
condition: Option<Condition>,
}
impl VerifiedTransaction {
fn new(transaction: SignedTransaction, origin: TransactionOrigin, time: QueuingInstant, condition: Option<Condition>) -> Self {
VerifiedTransaction {
transaction: transaction,
origin: origin,
insertion_time: time,
condition: condition,
}
}
fn hash(&self) -> H256 {
self.transaction.hash()
}
fn nonce(&self) -> U256 {
self.transaction.nonce
}
fn sender(&self) -> Address {
self.transaction.sender()
}
fn cost(&self) -> U256 {
self.transaction.value + self.transaction.gas_price * self.transaction.gas
}
}
#[derive(Debug, Default)]
struct GasPriceQueue {
backing: BTreeMap<U256, HashSet<H256>>,
}
impl GasPriceQueue {
/// Insert an item into a BTreeMap/HashSet "multimap".
pub fn insert(&mut self, gas_price: U256, hash: H256) -> bool {
self.backing.entry(gas_price).or_insert_with(Default::default).insert(hash)
}
/// Remove an item from a BTreeMap/HashSet "multimap".
/// Returns true if the item was removed successfully.
pub fn remove(&mut self, gas_price: &U256, hash: &H256) -> bool {
if let Some(mut hashes) = self.backing.get_mut(gas_price) {
let only_one_left = hashes.len() == 1;
if !only_one_left {
// Operation may be ok: only if hash is in gas-price's Set.
return hashes.remove(hash);
}
if hash != hashes.iter().next().expect("We know there is only one element in collection, tested above; qed") {
// Operation failed: hash not the single item in gas-price's Set.
return false;
}
} else {
// Operation failed: gas-price not found in Map.
return false;
}
// Operation maybe ok: only if hash not found in gas-price Set.
self.backing.remove(gas_price).is_some()
}
}
impl Deref for GasPriceQueue {
type Target=BTreeMap<U256, HashSet<H256>>;
fn deref(&self) -> &Self::Target {
&self.backing
}
}
/// Holds transactions accessible by (address, nonce) and by priority
///
/// `TransactionSet` keeps number of entries below limit, but it doesn't
/// automatically happen during `insert/remove` operations.
/// You have to call `enforce_limit` to remove lowest priority transactions from set.
struct TransactionSet {
by_priority: BTreeSet<TransactionOrder>,
by_address: Table<Address, U256, TransactionOrder>,
by_gas_price: GasPriceQueue,
limit: usize,
gas_limit: U256,
}
impl TransactionSet {
/// Inserts `TransactionOrder` to this set. Transaction does not need to be unique -
/// the same transaction may be validly inserted twice. Any previous transaction that
/// it replaces (i.e. with the same `sender` and `nonce`) should be returned.
fn insert(&mut self, sender: Address, nonce: U256, order: TransactionOrder) -> Option<TransactionOrder> {
if !self.by_priority.insert(order.clone()) {
return Some(order.clone());
}
let order_hash = order.hash.clone();
let order_gas_price = order.gas_price.clone();
let by_address_replaced = self.by_address.insert(sender, nonce, order);
// If transaction was replaced remove it from priority queue
if let Some(ref old_order) = by_address_replaced {
assert!(self.by_priority.remove(old_order), "hash is in `by_address`; all transactions in `by_address` must be in `by_priority`; qed");
assert!(self.by_gas_price.remove(&old_order.gas_price, &old_order.hash),
"hash is in `by_address`; all transactions' gas_prices in `by_address` must be in `by_gas_limit`; qed");
}
self.by_gas_price.insert(order_gas_price, order_hash);
assert_eq!(self.by_priority.len(), self.by_address.len());
assert_eq!(self.by_gas_price.values().map(|v| v.len()).fold(0, |a, b| a + b), self.by_address.len());
by_address_replaced
}
/// Remove low priority transactions if there is more than specified by given `limit`.
///
/// It drops transactions from this set but also removes associated `VerifiedTransaction`.
/// Returns addresses and lowest nonces of transactions removed because of limit.
fn enforce_limit(&mut self, by_hash: &mut HashMap<H256, VerifiedTransaction>, local: &mut LocalTransactionsList) -> Option<HashMap<Address, U256>> {
let mut count = 0;
let mut gas: U256 = 0.into();
let to_drop : Vec<(Address, U256)> = {
self.by_priority
.iter()
.filter(|order| {
count = count + 1;
let r = gas.overflowing_add(order.gas);
if r.1 { return false }
gas = r.0;
// Own and retracted transactions are allowed to go above all limits.
order.origin != TransactionOrigin::Local && order.origin != TransactionOrigin::RetractedBlock &&
(gas > self.gas_limit || count > self.limit)
})
.map(|order| by_hash.get(&order.hash)
.expect("All transactions in `self.by_priority` and `self.by_address` are kept in sync with `by_hash`."))
.map(|tx| (tx.sender(), tx.nonce()))
.collect()
};
Some(to_drop.into_iter()
.fold(HashMap::new(), |mut removed, (sender, nonce)| {
let order = self.drop(&sender, &nonce)
.expect("Transaction has just been found in `by_priority`; so it is in `by_address` also.");
trace!(target: "txqueue", "Dropped out of limit transaction: {:?}", order.hash);
let order = by_hash.remove(&order.hash)
.expect("hash is in `by_priorty`; all hashes in `by_priority` must be in `by_hash`; qed");
if order.origin.is_local() {
local.mark_dropped(order.transaction);
}
let min = removed.get(&sender).map_or(nonce, |val| cmp::min(*val, nonce));
removed.insert(sender, min);
removed
}))
}
/// Drop transaction from this set (remove from `by_priority` and `by_address`)
fn drop(&mut self, sender: &Address, nonce: &U256) -> Option<TransactionOrder> {
if let Some(tx_order) = self.by_address.remove(sender, nonce) {
assert!(self.by_gas_price.remove(&tx_order.gas_price, &tx_order.hash),
"hash is in `by_address`; all transactions' gas_prices in `by_address` must be in `by_gas_limit`; qed");
assert!(self.by_priority.remove(&tx_order),
"hash is in `by_address`; all transactions' gas_prices in `by_address` must be in `by_priority`; qed");
assert_eq!(self.by_priority.len(), self.by_address.len());
assert_eq!(self.by_gas_price.values().map(|v| v.len()).fold(0, |a, b| a + b), self.by_address.len());
return Some(tx_order);
}
assert_eq!(self.by_priority.len(), self.by_address.len());
assert_eq!(self.by_gas_price.values().map(|v| v.len()).fold(0, |a, b| a + b), self.by_address.len());
None
}
/// Drop all transactions.
fn clear(&mut self) {
self.by_priority.clear();
self.by_address.clear();
self.by_gas_price.backing.clear();
}
/// Sets new limit for number of transactions in this `TransactionSet`.
/// Note the limit is not applied (no transactions are removed) by calling this method.
fn set_limit(&mut self, limit: usize) {
self.limit = limit;
}
/// Get the minimum gas price that we can accept into this queue that wouldn't cause the transaction to
/// immediately be dropped. 0 if the queue isn't at capacity; 1 plus the lowest if it is.
fn gas_price_entry_limit(&self) -> U256 {
match self.by_gas_price.keys().next() {
Some(k) if self.by_priority.len() >= self.limit => *k + 1.into(),
_ => U256::default(),
}
}
}
#[derive(Debug)]
/// Current status of the queue
pub struct TransactionQueueStatus {
/// Number of pending transactions (ready to go to block)
pub pending: usize,
/// Number of future transactions (waiting for transactions with lower nonces first)
pub future: usize,
}
/// Details of account
pub struct AccountDetails {
/// Most recent account nonce
pub nonce: U256,
/// Current account balance
pub balance: U256,
}
/// Transactions with `gas > (gas_limit + gas_limit * Factor(in percents))` are not imported to the queue.
const GAS_LIMIT_HYSTERESIS: usize = 10; // (100/GAS_LIMIT_HYSTERESIS) %
/// Describes the strategy used to prioritize transactions in the queue.
#[cfg_attr(feature="dev", allow(enum_variant_names))]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum PrioritizationStrategy {
/// Use only gas price. Disregards the actual computation cost of the transaction.
/// i.e. Higher gas price = Higher priority
GasPriceOnly,
/// Use gas limit and then gas price.
/// i.e. Higher gas limit = Lower priority
GasAndGasPrice,
/// Calculate and use priority based on gas and gas price.
/// PRIORITY = GAS_PRICE - GAS/2^15 * MIN_GAS_PRICE
///
/// Rationale:
/// Heavy transactions are paying linear cost (GAS * GAS_PRICE)
/// while the computation might be more expensive.
///
/// i.e.
/// 1M gas tx with `gas_price=30*min` has the same priority
/// as 32k gas tx with `gas_price=min`
GasFactorAndGasPrice,
}
/// Point in time when transaction was inserted.
pub type QueuingInstant = BlockNumber;
const DEFAULT_QUEUING_PERIOD: BlockNumber = 128;
/// `TransactionQueue` transaction details provider.
pub trait TransactionDetailsProvider {
/// Fetch transaction-related account details.
fn fetch_account(&self, address: &Address) -> AccountDetails;
/// Estimate gas required for transaction.
fn estimate_gas_required(&self, tx: &SignedTransaction) -> U256;
/// Check if this service transaction can be accepted by `TransactionQueue`.
fn is_service_transaction_acceptable(&self, tx: &SignedTransaction) -> Result<bool, String>;
}
/// `TransactionQueue` implementation
pub struct TransactionQueue {
/// Prioritization strategy for this queue
strategy: PrioritizationStrategy,
/// Gas Price threshold for transactions that can be imported to this queue (defaults to 0)
minimal_gas_price: U256,
/// The maximum amount of gas any individual transaction may use.
tx_gas_limit: U256,
/// Current gas limit (block gas limit * factor). Transactions above the limit will not be accepted (default to !0)
gas_limit: U256,
/// Maximal time transaction may occupy the queue.
/// When we reach `max_time_in_queue / 2^3` we re-validate
/// account balance.
max_time_in_queue: QueuingInstant,
/// Priority queue for transactions that can go to block
current: TransactionSet,
/// Priority queue for transactions that has been received but are not yet valid to go to block
future: TransactionSet,
/// All transactions managed by queue indexed by hash
by_hash: HashMap<H256, VerifiedTransaction>,
/// Last nonce of transaction in current (to quickly check next expected transaction)
last_nonces: HashMap<Address, U256>,
/// List of local transactions and their statuses.
local_transactions: LocalTransactionsList,
}
impl Default for TransactionQueue {
fn default() -> Self {
TransactionQueue::new(PrioritizationStrategy::GasPriceOnly)
}
}
impl TransactionQueue {
/// Creates new instance of this Queue
pub fn new(strategy: PrioritizationStrategy) -> Self {
Self::with_limits(strategy, 1024, !U256::zero(), !U256::zero())
}
/// Create new instance of this Queue with specified limits
pub fn with_limits(strategy: PrioritizationStrategy, limit: usize, gas_limit: U256, tx_gas_limit: U256) -> Self {
let current = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: limit,
gas_limit: gas_limit,
};
let future = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: limit,
gas_limit: gas_limit,
};
TransactionQueue {
strategy: strategy,
minimal_gas_price: U256::zero(),
tx_gas_limit: tx_gas_limit,
gas_limit: !U256::zero(),
max_time_in_queue: DEFAULT_QUEUING_PERIOD,
current: current,
future: future,
by_hash: HashMap::new(),
last_nonces: HashMap::new(),
local_transactions: LocalTransactionsList::default(),
}
}
/// Set the new limit for `current` and `future` queue.
pub fn set_limit(&mut self, limit: usize) {
self.current.set_limit(limit);
self.future.set_limit(limit);
// And ensure the limits
self.current.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
self.future.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
}
/// Returns current limit of transactions in the queue.
pub fn limit(&self) -> usize {
self.current.limit
}
/// Get the minimal gas price.
pub fn minimal_gas_price(&self) -> &U256 {
&self.minimal_gas_price
}
/// Sets new gas price threshold for incoming transactions.
/// Any transaction already imported to the queue is not affected.
pub fn set_minimal_gas_price(&mut self, min_gas_price: U256) {
self.minimal_gas_price = min_gas_price;
}
/// Get one more than the lowest gas price in the queue iff the pool is
/// full, otherwise 0.
pub fn effective_minimum_gas_price(&self) -> U256 {
self.current.gas_price_entry_limit()
}
/// Sets new gas limit. Transactions with gas slightly (`GAS_LIMIT_HYSTERESIS`) above the limit won't be imported.
/// Any transaction already imported to the queue is not affected.
pub fn set_gas_limit(&mut self, gas_limit: U256) {
let extra = gas_limit / U256::from(GAS_LIMIT_HYSTERESIS);
self.gas_limit = match gas_limit.overflowing_add(extra) {
(_, true) => !U256::zero(),
(val, false) => val,
};
}
/// Sets new total gas limit.
pub fn set_total_gas_limit(&mut self, gas_limit: U256) {
self.future.gas_limit = gas_limit;
self.current.gas_limit = gas_limit;
self.future.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
}
/// Set the new limit for the amount of gas any individual transaction may have.
/// Any transaction already imported to the queue is not affected.
pub fn set_tx_gas_limit(&mut self, limit: U256) {
self.tx_gas_limit = limit;
}
/// Returns current status for this queue
pub fn status(&self) -> TransactionQueueStatus {
TransactionQueueStatus {
pending: self.current.by_priority.len(),
future: self.future.by_priority.len(),
}
}
/// Add signed transaction to queue to be verified and imported.
///
/// NOTE details_provider methods should be cheap to compute
/// otherwise it might open up an attack vector.
pub fn add(
&mut self,
tx: SignedTransaction,
origin: TransactionOrigin,
time: QueuingInstant,
condition: Option<Condition>,
details_provider: &TransactionDetailsProvider,
) -> Result<TransactionImportResult, Error> {
if origin == TransactionOrigin::Local {
let hash = tx.hash();
let cloned_tx = tx.clone();
let result = self.add_internal(tx, origin, time, condition, details_provider);
match result {
Ok(TransactionImportResult::Current) => {
self.local_transactions.mark_pending(hash);
},
Ok(TransactionImportResult::Future) => {
self.local_transactions.mark_future(hash);
},
Err(Error::Transaction(ref err)) => {
// Sometimes transactions are re-imported, so
// don't overwrite transactions if they are already on the list
if !self.local_transactions.contains(&hash) {
self.local_transactions.mark_rejected(cloned_tx, err.clone());
}
},
Err(_) => {
self.local_transactions.mark_invalid(cloned_tx);
},
}
result
} else {
self.add_internal(tx, origin, time, condition, details_provider)
}
}
/// Adds signed transaction to the queue.
fn add_internal(
&mut self,
tx: SignedTransaction,
origin: TransactionOrigin,
time: QueuingInstant,
condition: Option<Condition>,
details_provider: &TransactionDetailsProvider,
) -> Result<TransactionImportResult, Error> {
if origin != TransactionOrigin::Local && tx.gas_price < self.minimal_gas_price {
// if it is non-service-transaction => drop
let is_service_transaction = tx.gas_price.is_zero();
if !is_service_transaction {
trace!(target: "txqueue",
"Dropping transaction below minimal gas price threshold: {:?} (gp: {} < {})",
tx.hash(),
tx.gas_price,
self.minimal_gas_price
);
return Err(Error::Transaction(TransactionError::InsufficientGasPrice {
minimal: self.minimal_gas_price,
got: tx.gas_price,
}));
}
let is_service_transaction_accepted = match details_provider.is_service_transaction_acceptable(&tx) {
Ok(true) => true,
Ok(false) => {
trace!(target: "txqueue",
"Dropping service transaction as sender is not certified to send service transactions: {:?} (sender: {:?})",
tx.hash(),
tx.sender(),
);
false
},
Err(contract_err) => {
trace!(target: "txqueue",
"Dropping service transaction as service contract returned error: {:?} (error: {:?})",
tx.hash(),
contract_err,
);
false
},
};
if !is_service_transaction_accepted {
return Err(Error::Transaction(TransactionError::InsufficientGasPrice {
minimal: self.minimal_gas_price,
got: tx.gas_price,
}));
}
}
let full_queues_lowest = self.effective_minimum_gas_price();
if tx.gas_price < full_queues_lowest && origin != TransactionOrigin::Local {
trace!(target: "txqueue",
"Dropping transaction below lowest gas price in a full queue: {:?} (gp: {} < {})",
tx.hash(),
tx.gas_price,
full_queues_lowest
);
return Err(Error::Transaction(TransactionError::InsufficientGasPrice {
minimal: full_queues_lowest,
got: tx.gas_price,
}));
}
if tx.gas > self.gas_limit || tx.gas > self.tx_gas_limit {
trace!(target: "txqueue",
"Dropping transaction above gas limit: {:?} ({} > min({}, {}))",
tx.hash(),
tx.gas,
self.gas_limit,
self.tx_gas_limit
);
return Err(Error::Transaction(TransactionError::GasLimitExceeded {
limit: self.gas_limit,
got: tx.gas,
}));
}
let minimal_gas = details_provider.estimate_gas_required(&tx);
if tx.gas < minimal_gas {
trace!(target: "txqueue",
"Dropping transaction with insufficient gas: {:?} ({} > {})",
tx.hash(),
tx.gas,
minimal_gas,
);
return Err(Error::Transaction(TransactionError::InsufficientGas {
minimal: minimal_gas,
got: tx.gas,
}));
}
let client_account = details_provider.fetch_account(&tx.sender());
let cost = tx.value + tx.gas_price * tx.gas;
if client_account.balance < cost {
trace!(target: "txqueue",
"Dropping transaction without sufficient balance: {:?} ({} < {})",
tx.hash(),
client_account.balance,
cost
);
return Err(Error::Transaction(TransactionError::InsufficientBalance {
cost: cost,
balance: client_account.balance
}));
}
tx.check_low_s()?;
// No invalid transactions beyond this point.
let vtx = VerifiedTransaction::new(tx, origin, time, condition);
let r = self.import_tx(vtx, client_account.nonce).map_err(Error::Transaction);
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
r
}
/// Removes all transactions from particular sender up to (excluding) given client (state) nonce.
/// Client (State) Nonce = next valid nonce for this sender.
pub fn cull(&mut self, sender: Address, client_nonce: U256) {
// Check if there is anything in current...
let should_check_in_current = self.current.by_address.row(&sender)
// If nonce == client_nonce nothing is changed
.and_then(|by_nonce| by_nonce.keys().find(|nonce| *nonce < &client_nonce))
.map(|_| ());
// ... or future
let should_check_in_future = self.future.by_address.row(&sender)
// if nonce == client_nonce we need to promote to current
.and_then(|by_nonce| by_nonce.keys().find(|nonce| *nonce <= &client_nonce))
.map(|_| ());
if should_check_in_current.or(should_check_in_future).is_none() {
return;
}
self.cull_internal(sender, client_nonce);
}
/// Always updates future and moves transactions from current to future.
fn cull_internal(&mut self, sender: Address, client_nonce: U256) {
// We will either move transaction to future or remove it completely
// so there will be no transactions from this sender in current
self.last_nonces.remove(&sender);
// First update height of transactions in future to avoid collisions
self.update_future(&sender, client_nonce);
// This should move all current transactions to future and remove old transactions
self.move_all_to_future(&sender, client_nonce);
// And now lets check if there is some batch of transactions in future
// that should be placed in current. It should also update last_nonces.
self.move_matching_future_to_current(sender, client_nonce, client_nonce);
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
}
/// Checks the current nonce for all transactions' senders in the queue and removes the old transactions.
pub fn remove_old<F>(&mut self, fetch_account: &F, current_time: QueuingInstant) where
F: Fn(&Address) -> AccountDetails,
{
let senders = self.current.by_address.keys()
.chain(self.future.by_address.keys())
.map(|sender| (*sender, fetch_account(sender)))
.collect::<HashMap<_, _>>();
for (sender, details) in senders.iter() {
self.cull(*sender, details.nonce);
}
let max_time = self.max_time_in_queue;
let balance_check = max_time >> 3;
// Clear transactions occupying the queue too long
let invalid = self.by_hash.iter()
.filter(|&(_, ref tx)| !tx.origin.is_local())
.map(|(hash, tx)| (hash, tx, current_time.saturating_sub(tx.insertion_time)))
.filter_map(|(hash, tx, time_diff)| {
if time_diff > max_time {
return Some(*hash);
}
if time_diff > balance_check {
return match senders.get(&tx.sender()) {
Some(details) if tx.cost() > details.balance => {
Some(*hash)
},
_ => None,
};
}
None
})
.collect::<Vec<_>>();
let fetch_nonce = |a: &Address| senders.get(a)
.expect("We fetch details for all senders from both current and future")
.nonce;
for hash in invalid {
self.remove_invalid(&hash, &fetch_nonce);
}
}
/// Penalize transactions from sender of transaction with given hash.
/// I.e. it should change the priority of the transaction in the queue.
///
/// NOTE: We need to penalize all transactions from particular sender
/// to avoid breaking invariants in queue (ordered by nonces).
/// Consecutive transactions from this sender would fail otherwise (because of invalid nonce).
pub fn penalize(&mut self, transaction_hash: &H256) {
let transaction = match self.by_hash.get(transaction_hash) {
None => return,
Some(t) => t,
};
// Never penalize local transactions
if transaction.origin.is_local() {
return;
}
let sender = transaction.sender();
// Penalize all transactions from this sender
let nonces_from_sender = match self.current.by_address.row(&sender) {
Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
None => vec![],
};
for k in nonces_from_sender {
let order = self.current.drop(&sender, &k).expect("transaction known to be in self.current; qed");
self.current.insert(sender, k, order.penalize());
}
// Same thing for future
let nonces_from_sender = match self.future.by_address.row(&sender) {
Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
None => vec![],
};
for k in nonces_from_sender {
let order = self.future.drop(&sender, &k).expect("transaction known to be in self.future; qed");
self.future.insert(sender, k, order.penalize());
}
}
/// Removes invalid transaction identified by hash from queue.
/// Assumption is that this transaction nonce is not related to client nonce,
/// so transactions left in queue are processed according to client nonce.
///
/// If gap is introduced marks subsequent transactions as future
pub fn remove_invalid<F>(&mut self, transaction_hash: &H256, fetch_nonce: &F)
where F: Fn(&Address) -> U256 {
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
let transaction = self.by_hash.remove(transaction_hash);
if transaction.is_none() {
// We don't know this transaction
return;
}
let transaction = transaction.expect("None is tested in early-exit condition above; qed");
let sender = transaction.sender();
let nonce = transaction.nonce();
let current_nonce = fetch_nonce(&sender);
trace!(target: "txqueue", "Removing invalid transaction: {:?}", transaction.hash());
// Mark in locals
if self.local_transactions.contains(transaction_hash) {
self.local_transactions.mark_invalid(transaction.transaction.into());
}
// Remove from future
let order = self.future.drop(&sender, &nonce);
if order.is_some() {
self.update_future(&sender, current_nonce);
// And now lets check if there is some chain of transactions in future
// that should be placed in current
self.move_matching_future_to_current(sender, current_nonce, current_nonce);
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
return;
}
// Remove from current
let order = self.current.drop(&sender, &nonce);
if order.is_some() {
// This will keep consistency in queue
// Moves all to future and then promotes a batch from current:
self.cull_internal(sender, current_nonce);
assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
return;
}
}
/// Marks all transactions from particular sender as local transactions
fn mark_transactions_local(&mut self, sender: &Address) {
fn mark_local<F: FnMut(H256)>(sender: &Address, set: &mut TransactionSet, mut mark: F) {
// Mark all transactions from this sender as local
let nonces_from_sender = set.by_address.row(sender)
.map(|row_map| {
row_map.iter().filter_map(|(nonce, order)| if order.origin.is_local() {
None
} else {
Some(*nonce)
}).collect::<Vec<U256>>()
})
.unwrap_or_else(Vec::new);
for k in nonces_from_sender {
let mut order = set.drop(sender, &k).expect("transaction known to be in self.current/self.future; qed");
order.origin = TransactionOrigin::Local;
mark(order.hash);
set.insert(*sender, k, order);
}
}
let local = &mut self.local_transactions;
mark_local(sender, &mut self.current, |hash| local.mark_pending(hash));
mark_local(sender, &mut self.future, |hash| local.mark_future(hash));
}
/// Update height of all transactions in future transactions set.
fn update_future(&mut self, sender: &Address, current_nonce: U256) {
// We need to drain all transactions for current sender from future and reinsert them with updated height
let all_nonces_from_sender = match self.future.by_address.row(sender) {
Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
None => vec![],
};
for k in all_nonces_from_sender {
let order = self.future.drop(sender, &k).expect("iterating over a collection that has been retrieved above; qed");
if k >= current_nonce {
self.future.insert(*sender, k, order.update_height(k, current_nonce));
} else {
trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
// Remove the transaction completely
self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
}
}
}
/// Drop all transactions from given sender from `current`.
/// Either moves them to `future` or removes them from queue completely.
fn move_all_to_future(&mut self, sender: &Address, current_nonce: U256) {
let all_nonces_from_sender = match self.current.by_address.row(sender) {
Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
None => vec![],
};
for k in all_nonces_from_sender {
// Goes to future or is removed
let order = self.current.drop(sender, &k).expect("iterating over a collection that has been retrieved above;
qed");
if k >= current_nonce {
let order = order.update_height(k, current_nonce);
if order.origin.is_local() {
self.local_transactions.mark_future(order.hash);
}
if let Some(old) = self.future.insert(*sender, k, order.clone()) {
Self::replace_orders(*sender, k, old, order, &mut self.future, &mut self.by_hash, &mut self.local_transactions);
}
} else {
trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
let tx = self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
if tx.origin.is_local() {
self.local_transactions.mark_mined(tx.transaction);
}
}
}
self.future.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
}
/// Returns top transactions from the queue ordered by priority.
pub fn top_transactions(&self) -> Vec<SignedTransaction> {
self.top_transactions_at(BlockNumber::max_value(), u64::max_value())
}
fn filter_pending_transaction<F>(&self, best_block: BlockNumber, best_timestamp: u64, mut f: F)
where F: FnMut(&VerifiedTransaction) {
let mut delayed = HashSet::new();
for t in self.current.by_priority.iter() {
let tx = self.by_hash.get(&t.hash).expect("All transactions in `current` and `future` are always included in `by_hash`");
let sender = tx.sender();
if delayed.contains(&sender) {
continue;
}
let delay = match tx.condition {
Some(Condition::Number(n)) => n > best_block,
Some(Condition::Timestamp(t)) => t > best_timestamp,
None => false,
};
if delay {
delayed.insert(sender);
continue;
}
f(&tx);
}
}
/// Returns top transactions from the queue ordered by priority.
pub fn top_transactions_at(&self, best_block: BlockNumber, best_timestamp: u64) -> Vec<SignedTransaction> {
let mut r = Vec::new();
self.filter_pending_transaction(best_block, best_timestamp, |tx| r.push(tx.transaction.clone()));
r
}
/// Return all ready transactions.
pub fn pending_transactions(&self, best_block: BlockNumber, best_timestamp: u64) -> Vec<PendingTransaction> {
let mut r = Vec::new();
self.filter_pending_transaction(best_block, best_timestamp, |tx| r.push(PendingTransaction::new(tx.transaction.clone(), tx.condition.clone())));
r
}
/// Return all future transactions.
pub fn future_transactions(&self) -> Vec<PendingTransaction> {
self.future.by_priority
.iter()
.map(|t| self.by_hash.get(&t.hash).expect("All transactions in `current` and `future` are always included in `by_hash`"))
.map(|t| PendingTransaction { transaction: t.transaction.clone(), condition: t.condition.clone() })
.collect()
}
/// Returns local transactions (some of them might not be part of the queue anymore).
pub fn local_transactions(&self) -> &LinkedHashMap<H256, LocalTransactionStatus> {
self.local_transactions.all_transactions()
}
/// Returns hashes of all transactions from current, ordered by priority.
pub fn pending_hashes(&self) -> Vec<H256> {
self.current.by_priority
.iter()
.map(|t| t.hash)
.collect()
}
/// Returns true if there is at least one local transaction pending
pub fn has_local_pending_transactions(&self) -> bool {
self.current.by_priority.iter().any(|tx| tx.origin == TransactionOrigin::Local)
}
/// Finds transaction in the queue by hash (if any)
pub fn find(&self, hash: &H256) -> Option<PendingTransaction> {
self.by_hash.get(hash).map(|tx| PendingTransaction { transaction: tx.transaction.clone(), condition: tx.condition.clone() })
}
/// Removes all elements (in any state) from the queue
pub fn clear(&mut self) {
self.current.clear();
self.future.clear();
self.by_hash.clear();
self.last_nonces.clear();
}
/// Returns highest transaction nonce for given address.
pub fn last_nonce(&self, address: &Address) -> Option<U256> {
self.last_nonces.get(address).cloned()
}
/// Checks if there are any transactions in `future` that should actually be promoted to `current`
/// (because nonce matches).
fn move_matching_future_to_current(&mut self, address: Address, mut current_nonce: U256, first_nonce: U256) {
let mut update_last_nonce_to = None;
{
let by_nonce = self.future.by_address.row_mut(&address);
if by_nonce.is_none() {
return;
}
let mut by_nonce = by_nonce.expect("None is tested in early-exit condition above; qed");
while let Some(order) = by_nonce.remove(¤t_nonce) {
// remove also from priority and gas_price
self.future.by_priority.remove(&order);
self.future.by_gas_price.remove(&order.gas_price, &order.hash);
// Put to current
let order = order.update_height(current_nonce, first_nonce);
if order.origin.is_local() {
self.local_transactions.mark_pending(order.hash);
}
if let Some(old) = self.current.insert(address, current_nonce, order.clone()) {
Self::replace_orders(address, current_nonce, old, order, &mut self.current, &mut self.by_hash, &mut self.local_transactions);
}
update_last_nonce_to = Some(current_nonce);
current_nonce = current_nonce + U256::one();
}
}
self.future.by_address.clear_if_empty(&address);
if let Some(x) = update_last_nonce_to {
// Update last inserted nonce
self.last_nonces.insert(address, x);
}
}
/// Adds VerifiedTransaction to this queue.
///
/// Determines if it should be placed in current or future. When transaction is
/// imported to `current` also checks if there are any `future` transactions that should be promoted because of
/// this.
///
/// It ignores transactions that has already been imported (same `hash`) and replaces the transaction
/// iff `(address, nonce)` is the same but `gas_price` is higher.
///
/// Returns `true` when transaction was imported successfuly
fn import_tx(&mut self, tx: VerifiedTransaction, state_nonce: U256) -> Result<TransactionImportResult, TransactionError> {
if self.by_hash.get(&tx.hash()).is_some() {
// Transaction is already imported.
trace!(target: "txqueue", "Dropping already imported transaction: {:?}", tx.hash());
return Err(TransactionError::AlreadyImported);
}
let min_gas_price = (self.minimal_gas_price, self.strategy);
let address = tx.sender();
let nonce = tx.nonce();
let hash = tx.hash();
// The transaction might be old, let's check that.
// This has to be the first test, otherwise calculating
// nonce height would result in overflow.
if nonce < state_nonce {
// Droping transaction
trace!(target: "txqueue", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, state_nonce);
return Err(TransactionError::Old);
}
// Update nonces of transactions in future (remove old transactions)
self.update_future(&address, state_nonce);
// State nonce could be updated. Maybe there are some more items waiting in future?
self.move_matching_future_to_current(address, state_nonce, state_nonce);
// Check the next expected nonce (might be updated by move above)
let next_nonce = self.last_nonces
.get(&address)
.cloned()
.map_or(state_nonce, |n| n + U256::one());
if tx.origin.is_local() {
self.mark_transactions_local(&address);
}
// Future transaction
if nonce > next_nonce {
// We have a gap - put to future.
// Insert transaction (or replace old one with lower gas price)
check_too_cheap(
Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.future, &mut self.by_hash, &mut self.local_transactions)
)?;
// Enforce limit in Future
let removed = self.future.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
// Return an error if this transaction was not imported because of limit.
check_if_removed(&address, &nonce, removed)?;
debug!(target: "txqueue", "Importing transaction to future: {:?}", hash);
debug!(target: "txqueue", "status: {:?}", self.status());
return Ok(TransactionImportResult::Future);
}
// We might have filled a gap - move some more transactions from future
self.move_matching_future_to_current(address, nonce, state_nonce);
self.move_matching_future_to_current(address, nonce + U256::one(), state_nonce);
// Replace transaction if any
check_too_cheap(
Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.current, &mut self.by_hash, &mut self.local_transactions)
)?;
// Keep track of highest nonce stored in current
let new_max = self.last_nonces.get(&address).map_or(nonce, |n| cmp::max(nonce, *n));
self.last_nonces.insert(address, new_max);
// Also enforce the limit
let removed = self.current.enforce_limit(&mut self.by_hash, &mut self.local_transactions);
// If some transaction were removed because of limit we need to update last_nonces also.
self.update_last_nonces(&removed);
// Trigger error if the transaction we are importing was removed.
check_if_removed(&address, &nonce, removed)?;
debug!(target: "txqueue", "Imported transaction to current: {:?}", hash);
debug!(target: "txqueue", "status: {:?}", self.status());
Ok(TransactionImportResult::Current)
}
/// Updates
fn update_last_nonces(&mut self, removed_min_nonces: &Option<HashMap<Address, U256>>) {
if let Some(ref min_nonces) = *removed_min_nonces {
for (sender, nonce) in min_nonces.iter() {
if *nonce == U256::zero() {
self.last_nonces.remove(sender);
} else {
self.last_nonces.insert(*sender, *nonce - U256::one());
}
}
}
}
/// Replaces transaction in given set (could be `future` or `current`).
///
/// If there is already transaction with same `(sender, nonce)` it will be replaced iff `gas_price` is higher.
/// One of the transactions is dropped from set and also removed from queue entirely (from `by_hash`).
///
/// Returns `true` if transaction actually got to the queue (`false` if there was already a transaction with higher
/// gas_price)
fn replace_transaction(
tx: VerifiedTransaction,
base_nonce: U256,
min_gas_price: (U256, PrioritizationStrategy),
set: &mut TransactionSet,
by_hash: &mut HashMap<H256, VerifiedTransaction>,
local: &mut LocalTransactionsList,
) -> bool {
let order = TransactionOrder::for_transaction(&tx, base_nonce, min_gas_price.0, min_gas_price.1);
let hash = tx.hash();
let address = tx.sender();
let nonce = tx.nonce();
let old_hash = by_hash.insert(hash, tx);
assert!(old_hash.is_none(), "Each hash has to be inserted exactly once.");
trace!(target: "txqueue", "Inserting: {:?}", order);
if let Some(old) = set.insert(address, nonce, order.clone()) {
Self::replace_orders(address, nonce, old, order, set, by_hash, local)
} else {
true
}
}
fn replace_orders(
address: Address,
nonce: U256,
old: TransactionOrder,
order: TransactionOrder,
set: &mut TransactionSet,
by_hash: &mut HashMap<H256, VerifiedTransaction>,
local: &mut LocalTransactionsList,
) -> bool {
// There was already transaction in queue. Let's check which one should stay
let old_hash = old.hash;
let new_hash = order.hash;
let old_fee = old.gas_price;
let new_fee = order.gas_price;
if old_fee.cmp(&new_fee) == Ordering::Greater {
trace!(target: "txqueue", "Didn't insert transaction because gas price was too low: {:?} ({:?} stays in the queue)", order.hash, old.hash);
// Put back old transaction since it has greater priority (higher gas_price)
set.insert(address, nonce, old);
// and remove new one
let order = by_hash.remove(&order.hash).expect("The hash has been just inserted and no other line is altering `by_hash`.");
if order.origin.is_local() {
local.mark_replaced(order.transaction, old_fee, old_hash);
}
false
} else {
trace!(target: "txqueue", "Replaced transaction: {:?} with transaction with higher gas price: {:?}", old.hash, order.hash);
// Make sure we remove old transaction entirely
let old = by_hash.remove(&old.hash).expect("The hash is coming from `future` so it has to be in `by_hash`.");
if old.origin.is_local() {
local.mark_replaced(old.transaction, new_fee, new_hash);
}
true
}
}
}
fn check_too_cheap(is_in: bool) -> Result<(), TransactionError> {
if is_in {
Ok(())
} else {
Err(TransactionError::TooCheapToReplace)
}
}
fn check_if_removed(sender: &Address, nonce: &U256, dropped: Option<HashMap<Address, U256>>) -> Result<(), TransactionError> {
match dropped {
Some(ref dropped) => match dropped.get(sender) {
Some(min) if nonce >= min => {
Err(TransactionError::LimitReached)
},
_ => Ok(()),
},
_ => Ok(()),
}
}
#[cfg(test)]
pub mod test {
extern crate rustc_serialize;
use util::table::*;
use util::*;
use ethkey::{Random, Generator};
use error::{Error, TransactionError};
use super::*;
use super::{TransactionSet, TransactionOrder, VerifiedTransaction};
use miner::local_transactions::LocalTransactionsList;
use client::TransactionImportResult;
use transaction::{SignedTransaction, Transaction, Action, Condition};
pub struct DummyTransactionDetailsProvider {
account_details: AccountDetails,
gas_required: U256,
service_transactions_check_result: Result<bool, String>,
}
impl Default for DummyTransactionDetailsProvider {
fn default() -> Self {
DummyTransactionDetailsProvider {
account_details: default_account_details(),
gas_required: U256::zero(),
service_transactions_check_result: Ok(false),
}
}
}
impl DummyTransactionDetailsProvider {
pub fn with_account(mut self, account_details: AccountDetails) -> Self {
self.account_details = account_details;
self
}
pub fn with_account_nonce(mut self, nonce: U256) -> Self {
self.account_details.nonce = nonce;
self
}
pub fn with_tx_gas_required(mut self, gas_required: U256) -> Self {
self.gas_required = gas_required;
self
}
pub fn service_transaction_checker_returns_error(mut self, error: &str) -> Self {
self.service_transactions_check_result = Err(error.to_owned());
self
}
pub fn service_transaction_checker_accepts(mut self, accepts: bool) -> Self {
self.service_transactions_check_result = Ok(accepts);
self
}
}
impl TransactionDetailsProvider for DummyTransactionDetailsProvider {
fn fetch_account(&self, _address: &Address) -> AccountDetails {
AccountDetails {
nonce: self.account_details.nonce,
balance: self.account_details.balance,
}
}
fn estimate_gas_required(&self, _tx: &SignedTransaction) -> U256 {
self.gas_required
}
fn is_service_transaction_acceptable(&self, _tx: &SignedTransaction) -> Result<bool, String> {
self.service_transactions_check_result.clone()
}
}
fn unwrap_tx_err(err: Result<TransactionImportResult, Error>) -> TransactionError {
match err.unwrap_err() {
Error::Transaction(e) => e,
_ => panic!("Expected transaction error!"),
}
}
fn default_nonce() -> U256 { 123.into() }
fn default_gas_val() -> U256 { 100_000.into() }
fn default_gas_price() -> U256 { 1.into() }
fn new_unsigned_tx(nonce: U256, gas: U256, gas_price: U256) -> Transaction {
Transaction {
action: Action::Create,
value: U256::from(100),
data: "3331600055".from_hex().unwrap(),
gas: gas,
gas_price: gas_price,
nonce: nonce
}
}
fn new_tx(nonce: U256, gas_price: U256) -> SignedTransaction {
let keypair = Random.generate().unwrap();
new_unsigned_tx(nonce, default_gas_val(), gas_price).sign(keypair.secret(), None)
}
fn new_tx_with_gas(gas: U256, gas_price: U256) -> SignedTransaction {
let keypair = Random.generate().unwrap();
new_unsigned_tx(default_nonce(), gas, gas_price).sign(keypair.secret(), None)
}
fn new_tx_default() -> SignedTransaction {
new_tx(default_nonce(), default_gas_price())
}
fn default_account_details() -> AccountDetails {
AccountDetails {
nonce: default_nonce(),
balance: !U256::zero()
}
}
fn default_account_details_for_addr(_a: &Address) -> AccountDetails {
default_account_details()
}
fn default_tx_provider() -> DummyTransactionDetailsProvider {
DummyTransactionDetailsProvider::default()
}
fn new_tx_pair(nonce: U256, gas_price: U256, nonce_increment: U256, gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
let tx1 = new_unsigned_tx(nonce, default_gas_val(), gas_price);
let tx2 = new_unsigned_tx(nonce + nonce_increment, default_gas_val(), gas_price + gas_price_increment);
let keypair = Random.generate().unwrap();
let secret = &keypair.secret();
(tx1.sign(secret, None).into(), tx2.sign(secret, None).into())
}
/// Returns two consecutive transactions, both with increased gas price
fn new_tx_pair_with_gas_price_increment(gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
let gas = default_gas_price() + gas_price_increment;
let tx1 = new_unsigned_tx(default_nonce(), default_gas_val(), gas);
let tx2 = new_unsigned_tx(default_nonce() + 1.into(), default_gas_val(), gas);
let keypair = Random.generate().unwrap();
let secret = &keypair.secret();
(tx1.sign(secret, None).into(), tx2.sign(secret, None).into())
}
fn new_tx_pair_default(nonce_increment: U256, gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
new_tx_pair(default_nonce(), default_gas_price(), nonce_increment, gas_price_increment)
}
/// Returns two transactions with identical (sender, nonce) but different gas price/hash.
fn new_similar_tx_pair() -> (SignedTransaction, SignedTransaction) {
new_tx_pair_default(0.into(), 1.into())
}
#[test]
fn test_ordering() {
assert_eq!(TransactionOrigin::Local.cmp(&TransactionOrigin::External), Ordering::Less);
assert_eq!(TransactionOrigin::RetractedBlock.cmp(&TransactionOrigin::Local), Ordering::Less);
assert_eq!(TransactionOrigin::RetractedBlock.cmp(&TransactionOrigin::External), Ordering::Less);
assert_eq!(TransactionOrigin::External.cmp(&TransactionOrigin::Local), Ordering::Greater);
assert_eq!(TransactionOrigin::Local.cmp(&TransactionOrigin::RetractedBlock), Ordering::Greater);
assert_eq!(TransactionOrigin::External.cmp(&TransactionOrigin::RetractedBlock), Ordering::Greater);
}
fn transaction_order(tx: &VerifiedTransaction, nonce: U256) -> TransactionOrder {
TransactionOrder::for_transaction(tx, nonce, 0.into(), PrioritizationStrategy::GasPriceOnly)
}
#[test]
fn should_return_correct_nonces_when_dropped_because_of_limit() {
// given
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 2, !U256::zero(), !U256::zero());
let (tx1, tx2) = new_tx_pair(123.into(), 1.into(), 1.into(), 0.into());
let sender = tx1.sender();
let nonce = tx1.nonce;
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 2);
assert_eq!(txq.last_nonce(&sender), Some(nonce + 1.into()));
// when
let tx = new_tx(123.into(), 1.into());
let res = txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider());
// then
// No longer the case as we don't even consider a transaction that isn't above a full
// queue's minimum gas price.
// We may want to reconsider this in the near future so leaving this code in as a
// possible alternative.
/*
assert_eq!(res.unwrap(), TransactionImportResult::Current);
assert_eq!(txq.status().pending, 2);
assert_eq!(txq.last_nonce(&sender), Some(nonce));
*/
assert_eq!(unwrap_tx_err(res), TransactionError::InsufficientGasPrice {
minimal: 2.into(),
got: 1.into(),
});
assert_eq!(txq.status().pending, 2);
assert_eq!(txq.last_nonce(&sender), Some(tx2.nonce));
}
#[test]
fn should_create_transaction_set() {
// given
let mut local = LocalTransactionsList::default();
let mut set = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: 1,
gas_limit: !U256::zero(),
};
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let tx1 = VerifiedTransaction::new(tx1, TransactionOrigin::External, 0, None);
let tx2 = VerifiedTransaction::new(tx2, TransactionOrigin::External, 0, None);
let mut by_hash = {
let mut x = HashMap::new();
let tx1 = VerifiedTransaction::new(tx1.transaction.clone(), TransactionOrigin::External, 0, None);
let tx2 = VerifiedTransaction::new(tx2.transaction.clone(), TransactionOrigin::External, 0, None);
x.insert(tx1.hash(), tx1);
x.insert(tx2.hash(), tx2);
x
};
// Insert both transactions
let order1 = transaction_order(&tx1, U256::zero());
set.insert(tx1.sender(), tx1.nonce(), order1.clone());
let order2 = transaction_order(&tx2, U256::zero());
set.insert(tx2.sender(), tx2.nonce(), order2.clone());
assert_eq!(set.by_priority.len(), 2);
assert_eq!(set.by_address.len(), 2);
// when
set.enforce_limit(&mut by_hash, &mut local);
// then
assert_eq!(by_hash.len(), 1);
assert_eq!(set.by_priority.len(), 1);
assert_eq!(set.by_address.len(), 1);
assert_eq!(set.by_priority.iter().next().unwrap().clone(), order1);
set.clear();
assert_eq!(set.by_priority.len(), 0);
assert_eq!(set.by_address.len(), 0);
}
#[test]
fn should_replace_transaction_in_set() {
let mut set = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: 1,
gas_limit: !U256::zero(),
};
// Create two transactions with same nonce
// (same hash)
let (tx1, tx2) = new_tx_pair_default(0.into(), 0.into());
let tx1 = VerifiedTransaction::new(tx1, TransactionOrigin::External, 0, None);
let tx2 = VerifiedTransaction::new(tx2, TransactionOrigin::External, 0, None);
let by_hash = {
let mut x = HashMap::new();
let tx1 = VerifiedTransaction::new(tx1.transaction.clone(), TransactionOrigin::External, 0, None);
let tx2 = VerifiedTransaction::new(tx2.transaction.clone(), TransactionOrigin::External, 0, None);
x.insert(tx1.hash(), tx1);
x.insert(tx2.hash(), tx2);
x
};
// Insert both transactions
let order1 = transaction_order(&tx1, U256::zero());
set.insert(tx1.sender(), tx1.nonce(), order1.clone());
assert_eq!(set.by_priority.len(), 1);
assert_eq!(set.by_address.len(), 1);
assert_eq!(set.by_gas_price.len(), 1);
assert_eq!(*set.by_gas_price.iter().next().unwrap().0, 1.into());
assert_eq!(set.by_gas_price.iter().next().unwrap().1.len(), 1);
// Two different orders (imagine nonce changed in the meantime)
let order2 = transaction_order(&tx2, U256::one());
set.insert(tx2.sender(), tx2.nonce(), order2.clone());
assert_eq!(set.by_priority.len(), 1);
assert_eq!(set.by_address.len(), 1);
assert_eq!(set.by_gas_price.len(), 1);
assert_eq!(*set.by_gas_price.iter().next().unwrap().0, 1.into());
assert_eq!(set.by_gas_price.iter().next().unwrap().1.len(), 1);
// then
assert_eq!(by_hash.len(), 1);
assert_eq!(set.by_priority.len(), 1);
assert_eq!(set.by_address.len(), 1);
assert_eq!(set.by_gas_price.len(), 1);
assert_eq!(*set.by_gas_price.iter().next().unwrap().0, 1.into());
assert_eq!(set.by_gas_price.iter().next().unwrap().1.len(), 1);
assert_eq!(set.by_priority.iter().next().unwrap().clone(), order2);
}
#[test]
fn should_not_insert_same_transaction_twice_into_set() {
let mut set = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: 2,
gas_limit: !U256::zero(),
};
let tx = new_tx_default();
let tx1 = VerifiedTransaction::new(tx.clone(), TransactionOrigin::External, 0, None);
let order1 = TransactionOrder::for_transaction(&tx1, 0.into(), 1.into(), PrioritizationStrategy::GasPriceOnly);
assert!(set.insert(tx1.sender(), tx1.nonce(), order1).is_none());
let tx2 = VerifiedTransaction::new(tx, TransactionOrigin::External, 0, None);
let order2 = TransactionOrder::for_transaction(&tx2, 0.into(), 1.into(), PrioritizationStrategy::GasPriceOnly);
assert!(set.insert(tx2.sender(), tx2.nonce(), order2).is_some());
}
#[test]
fn should_give_correct_gas_price_entry_limit() {
let mut set = TransactionSet {
by_priority: BTreeSet::new(),
by_address: Table::new(),
by_gas_price: Default::default(),
limit: 1,
gas_limit: !U256::zero(),
};
assert_eq!(set.gas_price_entry_limit(), 0.into());
let tx = new_tx_default();
let tx1 = VerifiedTransaction::new(tx.clone(), TransactionOrigin::External, 0, None);
let order1 = TransactionOrder::for_transaction(&tx1, 0.into(), 1.into(), PrioritizationStrategy::GasPriceOnly);
assert!(set.insert(tx1.sender(), tx1.nonce(), order1.clone()).is_none());
assert_eq!(set.gas_price_entry_limit(), 2.into());
}
#[test]
fn should_handle_same_transaction_imported_twice_with_different_state_nonces() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_similar_tx_pair();
let prev_nonce = default_account_details().nonce - U256::one();
// First insert one transaction to future
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce));
assert_eq!(res.unwrap(), TransactionImportResult::Future);
assert_eq!(txq.status().future, 1);
// now import second transaction to current
let res = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider());
// and then there should be only one transaction in current (the one with higher gas_price)
assert_eq!(res.unwrap(), TransactionImportResult::Current);
assert_eq!(txq.status().pending, 1);
assert_eq!(txq.status().future, 0);
assert_eq!(txq.current.by_priority.len(), 1);
assert_eq!(txq.current.by_address.len(), 1);
let top = txq.top_transactions();
assert_eq!(top[0], tx2);
}
#[test]
fn should_move_all_transactions_from_future() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 1.into());
let prev_nonce = default_account_details().nonce - U256::one();
// First insert one transaction to future
let res = txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce));
assert_eq!(res.unwrap(), TransactionImportResult::Future);
assert_eq!(txq.status().future, 1);
// now import second transaction to current
let res = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(res.unwrap(), TransactionImportResult::Current);
assert_eq!(txq.status().pending, 2);
assert_eq!(txq.status().future, 0);
assert_eq!(txq.current.by_priority.len(), 2);
assert_eq!(txq.current.by_address.len(), 2);
let top = txq.top_transactions();
assert_eq!(top[0], tx);
assert_eq!(top[1], tx2);
}
#[test]
fn should_import_tx() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
// when
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(res.unwrap(), TransactionImportResult::Current);
let stats = txq.status();
assert_eq!(stats.pending, 1);
}
#[test]
fn should_order_by_gas() {
// given
let mut txq = TransactionQueue::new(PrioritizationStrategy::GasAndGasPrice);
let tx1 = new_tx_with_gas(50000.into(), 40.into());
let tx2 = new_tx_with_gas(40000.into(), 30.into());
let tx3 = new_tx_with_gas(30000.into(), 10.into());
let tx4 = new_tx_with_gas(50000.into(), 20.into());
txq.set_minimal_gas_price(15.into());
// when
let res1 = txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider());
let res2 = txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider());
let res3 = txq.add(tx3, TransactionOrigin::External, 0, None, &default_tx_provider());
let res4 = txq.add(tx4, TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(res1.unwrap(), TransactionImportResult::Current);
assert_eq!(res2.unwrap(), TransactionImportResult::Current);
assert_eq!(unwrap_tx_err(res3), TransactionError::InsufficientGasPrice {
minimal: U256::from(15),
got: U256::from(10),
});
assert_eq!(res4.unwrap(), TransactionImportResult::Current);
let stats = txq.status();
assert_eq!(stats.pending, 3);
assert_eq!(txq.top_transactions()[0].gas, 40000.into());
assert_eq!(txq.top_transactions()[1].gas, 50000.into());
assert_eq!(txq.top_transactions()[2].gas, 50000.into());
assert_eq!(txq.top_transactions()[1].gas_price, 40.into());
assert_eq!(txq.top_transactions()[2].gas_price, 20.into());
}
#[test]
fn should_order_by_gas_factor() {
// given
let mut txq = TransactionQueue::new(PrioritizationStrategy::GasFactorAndGasPrice);
let tx1 = new_tx_with_gas(150_000.into(), 40.into());
let tx2 = new_tx_with_gas(40_000.into(), 16.into());
let tx3 = new_tx_with_gas(30_000.into(), 15.into());
let tx4 = new_tx_with_gas(150_000.into(), 62.into());
txq.set_minimal_gas_price(15.into());
// when
let res1 = txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider());
let res2 = txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider());
let res3 = txq.add(tx3, TransactionOrigin::External, 0, None, &default_tx_provider());
let res4 = txq.add(tx4, TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(res1.unwrap(), TransactionImportResult::Current);
assert_eq!(res2.unwrap(), TransactionImportResult::Current);
assert_eq!(res3.unwrap(), TransactionImportResult::Current);
assert_eq!(res4.unwrap(), TransactionImportResult::Current);
let stats = txq.status();
assert_eq!(stats.pending, 4);
assert_eq!(txq.top_transactions()[0].gas, 30_000.into());
assert_eq!(txq.top_transactions()[1].gas, 150_000.into());
assert_eq!(txq.top_transactions()[2].gas, 40_000.into());
assert_eq!(txq.top_transactions()[3].gas, 150_000.into());
assert_eq!(txq.top_transactions()[0].gas_price, 15.into());
assert_eq!(txq.top_transactions()[1].gas_price, 62.into());
assert_eq!(txq.top_transactions()[2].gas_price, 16.into());
assert_eq!(txq.top_transactions()[3].gas_price, 40.into());
}
#[test]
fn gas_limit_should_never_overflow() {
// given
let mut txq = TransactionQueue::default();
txq.set_gas_limit(U256::zero());
assert_eq!(txq.gas_limit, U256::zero());
// when
txq.set_gas_limit(!U256::zero());
// then
assert_eq!(txq.gas_limit, !U256::zero());
}
#[test]
fn should_not_import_transaction_above_gas_limit() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
let gas = tx.gas;
let limit = gas / U256::from(2);
txq.set_gas_limit(limit);
// when
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(unwrap_tx_err(res), TransactionError::GasLimitExceeded {
limit: U256::from(55_000), // Should be 110% of set_gas_limit
got: gas,
});
let stats = txq.status();
assert_eq!(stats.pending, 0);
assert_eq!(stats.future, 0);
}
#[test]
fn should_drop_transactions_from_senders_without_balance() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
let account = AccountDetails {
nonce: default_account_details().nonce,
balance: U256::one()
};
// when
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider().with_account(account));
// then
assert_eq!(unwrap_tx_err(res), TransactionError::InsufficientBalance {
balance: U256::from(1),
cost: U256::from(100_100),
});
let stats = txq.status();
assert_eq!(stats.pending, 0);
assert_eq!(stats.future, 0);
}
#[test]
fn should_not_import_transaction_below_min_gas_price_threshold_if_external() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
txq.set_minimal_gas_price(tx.gas_price + U256::one());
// when
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider());
// then
assert_eq!(unwrap_tx_err(res), TransactionError::InsufficientGasPrice {
minimal: U256::from(2),
got: U256::from(1),
});
let stats = txq.status();
assert_eq!(stats.pending, 0);
assert_eq!(stats.future, 0);
}
#[test]
fn should_import_transaction_below_min_gas_price_threshold_if_local() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
txq.set_minimal_gas_price(tx.gas_price + U256::one());
// when
let res = txq.add(tx, TransactionOrigin::Local, 0, None, &default_tx_provider());
// then
assert_eq!(res.unwrap(), TransactionImportResult::Current);
let stats = txq.status();
assert_eq!(stats.pending, 1);
assert_eq!(stats.future, 0);
}
#[test]
fn should_import_txs_from_same_sender() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
// when
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let top = txq.top_transactions();
assert_eq!(top[0], tx);
assert_eq!(top[1], tx2);
assert_eq!(top.len(), 2);
}
#[test]
fn should_prioritize_local_transactions_within_same_nonce_height() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
// the second one has same nonce but higher `gas_price`
let (_, tx2) = new_similar_tx_pair();
// when
// first insert the one with higher gas price
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then the one with lower gas price, but local
txq.add(tx.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// then
let top = txq.top_transactions();
assert_eq!(top[0], tx); // local should be first
assert_eq!(top[1], tx2);
assert_eq!(top.len(), 2);
}
#[test]
fn when_importing_local_should_mark_others_from_the_same_sender_as_local() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
// the second one has same nonce but higher `gas_price`
let (_, tx0) = new_similar_tx_pair();
txq.add(tx0.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// the one with higher gas price is first
let top = txq.top_transactions();
assert_eq!(top[0], tx0);
assert_eq!(top[1], tx1);
// when
// insert second as local
txq.add(tx2.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// then
// the order should be updated
let top = txq.top_transactions();
assert_eq!(top[0], tx1);
assert_eq!(top[1], tx2);
assert_eq!(top[2], tx0);
}
#[test]
fn should_prioritize_reimported_transactions_within_same_nonce_height() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
// the second one has same nonce but higher `gas_price`
let (_, tx2) = new_similar_tx_pair();
// when
// first insert local one with higher gas price
txq.add(tx2.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// then the one with lower gas price, but from retracted block
txq.add(tx.clone(), TransactionOrigin::RetractedBlock, 0, None, &default_tx_provider()).unwrap();
// then
let top = txq.top_transactions();
assert_eq!(top[0], tx); // retracted should be first
assert_eq!(top[1], tx2);
assert_eq!(top.len(), 2);
}
#[test]
fn should_not_prioritize_local_transactions_with_different_nonce_height() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
// when
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// then
let top = txq.top_transactions();
assert_eq!(top[0], tx);
assert_eq!(top[1], tx2);
assert_eq!(top.len(), 2);
}
#[test]
fn should_penalize_transactions_from_sender_in_future() {
// given
let prev_nonce = default_account_details().nonce - U256::one();
let mut txq = TransactionQueue::default();
// txa, txb - slightly bigger gas price to have consistent ordering
let (txa, txb) = new_tx_pair_default(1.into(), 0.into());
let (tx1, tx2) = new_tx_pair_with_gas_price_increment(3.into());
// insert everything
txq.add(txa.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
txq.add(txb.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
assert_eq!(txq.status().future, 4);
// when
txq.penalize(&tx1.hash());
// then
let top: Vec<_> = txq.future_transactions().into_iter().map(|tx| tx.transaction).collect();
assert_eq!(top[0], txa);
assert_eq!(top[1], txb);
assert_eq!(top[2], tx1);
assert_eq!(top[3], tx2);
assert_eq!(top.len(), 4);
}
#[test]
fn should_not_penalize_local_transactions() {
// given
let mut txq = TransactionQueue::default();
// txa, txb - slightly bigger gas price to have consistent ordering
let (txa, txb) = new_tx_pair_default(1.into(), 0.into());
let (tx1, tx2) = new_tx_pair_with_gas_price_increment(3.into());
// insert everything
txq.add(txa.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(txb.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx1.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
let top = txq.top_transactions();
assert_eq!(top[0], tx1);
assert_eq!(top[1], txa);
assert_eq!(top[2], tx2);
assert_eq!(top[3], txb);
assert_eq!(top.len(), 4);
// when
txq.penalize(&tx1.hash());
// then (order is the same)
let top = txq.top_transactions();
assert_eq!(top[0], tx1);
assert_eq!(top[1], txa);
assert_eq!(top[2], tx2);
assert_eq!(top[3], txb);
assert_eq!(top.len(), 4);
}
#[test]
fn should_penalize_transactions_from_sender() {
// given
let mut txq = TransactionQueue::default();
// txa, txb - slightly bigger gas price to have consistent ordering
let (txa, txb) = new_tx_pair_default(1.into(), 0.into());
let (tx1, tx2) = new_tx_pair_with_gas_price_increment(3.into());
// insert everything
txq.add(txa.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(txb.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
let top = txq.top_transactions();
assert_eq!(top[0], tx1);
assert_eq!(top[1], txa);
assert_eq!(top[2], tx2);
assert_eq!(top[3], txb);
assert_eq!(top.len(), 4);
// when
txq.penalize(&tx1.hash());
// then
let top = txq.top_transactions();
assert_eq!(top[0], txa);
assert_eq!(top[1], txb);
assert_eq!(top[2], tx1);
assert_eq!(top[3], tx2);
assert_eq!(top.len(), 4);
}
#[test]
fn should_return_pending_hashes() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
// when
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let top = txq.pending_hashes();
assert_eq!(top[0], tx.hash());
assert_eq!(top[1], tx2.hash());
assert_eq!(top.len(), 2);
}
#[test]
fn should_put_transaction_to_futures_if_gap_detected() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(2.into(), 0.into());
// when
let res1 = txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
let res2 = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
assert_eq!(res1, TransactionImportResult::Current);
assert_eq!(res2, TransactionImportResult::Future);
let stats = txq.status();
assert_eq!(stats.pending, 1);
assert_eq!(stats.future, 1);
let top = txq.top_transactions();
assert_eq!(top.len(), 1);
assert_eq!(top[0], tx);
}
#[test]
fn should_handle_min_block() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
// when
let res1 = txq.add(tx.clone(), TransactionOrigin::External, 0, Some(Condition::Number(1)), &default_tx_provider()).unwrap();
let res2 = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
assert_eq!(res1, TransactionImportResult::Current);
assert_eq!(res2, TransactionImportResult::Current);
let top = txq.top_transactions_at(0, 0);
assert_eq!(top.len(), 0);
let top = txq.top_transactions_at(1, 0);
assert_eq!(top.len(), 2);
}
#[test]
fn should_correctly_update_futures_when_removing() {
// given
let prev_nonce = default_account_details().nonce - U256::one();
let next2_nonce = default_nonce() + U256::from(3);
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap();
assert_eq!(txq.status().future, 2);
// when
txq.cull(tx.sender(), next2_nonce);
// should remove both transactions since they are not valid
// then
assert_eq!(txq.status().pending, 0);
assert_eq!(txq.status().future, 0);
}
#[test]
fn should_move_transactions_if_gap_filled() {
// given
let mut txq = TransactionQueue::default();
let kp = Random.generate().unwrap();
let secret = kp.secret();
let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(secret, None).into();
let tx1 = new_unsigned_tx(124.into(), default_gas_val(), 1.into()).sign(secret, None).into();
let tx2 = new_unsigned_tx(125.into(), default_gas_val(), 1.into()).sign(secret, None).into();
txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 1);
txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
// when
txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let stats = txq.status();
assert_eq!(stats.pending, 3);
assert_eq!(stats.future, 0);
assert_eq!(txq.future.by_priority.len(), 0);
assert_eq!(txq.future.by_address.len(), 0);
assert_eq!(txq.future.by_gas_price.len(), 0);
}
#[test]
fn should_remove_transaction() {
// given
let mut txq2 = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(3.into(), 0.into());
txq2.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq2.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq2.status().pending, 1);
assert_eq!(txq2.status().future, 1);
// when
txq2.cull(tx.sender(), tx.nonce + U256::one());
txq2.cull(tx2.sender(), tx2.nonce + U256::one());
// then
let stats = txq2.status();
assert_eq!(stats.pending, 0);
assert_eq!(stats.future, 0);
}
#[test]
fn should_move_transactions_to_future_if_gap_introduced() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
let tx3 = new_tx_default();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
txq.add(tx3.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 3);
// when
txq.remove_invalid(&tx.hash(), &|_| default_nonce());
// then
let stats = txq.status();
assert_eq!(stats.future, 1);
assert_eq!(stats.pending, 1);
}
#[test]
fn should_clear_queue() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
// add
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
let stats = txq.status();
assert_eq!(stats.pending, 2);
// when
txq.clear();
// then
let stats = txq.status();
assert_eq!(stats.pending, 0);
}
#[test]
fn should_drop_old_transactions_when_hitting_the_limit() {
// given
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
let sender = tx.sender();
let nonce = tx.nonce;
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 1);
// when
let res = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider());
// then
let t = txq.top_transactions();
assert_eq!(unwrap_tx_err(res), TransactionError::InsufficientGasPrice { minimal: 2.into(), got: 1.into() });
assert_eq!(txq.status().pending, 1);
assert_eq!(t.len(), 1);
assert_eq!(t[0], tx);
assert_eq!(txq.last_nonce(&sender), Some(nonce));
}
#[test]
fn should_limit_future_transactions() {
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
txq.current.set_limit(10);
let (tx1, tx2) = new_tx_pair_default(4.into(), 1.into());
let (tx3, tx4) = new_tx_pair_default(4.into(), 2.into());
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx3.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 2);
// when
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
txq.add(tx4.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
assert_eq!(txq.status().future, 1);
}
#[test]
fn should_limit_by_gas() {
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
let (tx1, tx2) = new_tx_pair_default(U256::from(1), U256::from(1));
let (tx3, tx4) = new_tx_pair_default(U256::from(1), U256::from(2));
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx3.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// limited by gas
txq.add(tx4.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap_err();
assert_eq!(txq.status().pending, 2);
}
#[test]
fn should_keep_own_transactions_above_gas_limit() {
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
let (tx1, tx2) = new_tx_pair_default(U256::from(1), U256::from(1));
let (tx3, tx4) = new_tx_pair_default(U256::from(1), U256::from(2));
let (tx5, _) = new_tx_pair_default(U256::from(1), U256::from(2));
txq.add(tx1.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// Not accepted because of limit
txq.add(tx5.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap_err();
txq.add(tx3.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx4.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 4);
}
#[test]
fn should_drop_transactions_with_old_nonces() {
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
let last_nonce = tx.nonce + U256::one();
// when
let res = txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(last_nonce));
// then
assert_eq!(unwrap_tx_err(res), TransactionError::Old);
let stats = txq.status();
assert_eq!(stats.pending, 0);
assert_eq!(stats.future, 0);
}
#[test]
fn should_not_insert_same_transaction_twice() {
// given
let nonce = default_account_details().nonce + U256::one();
let mut txq = TransactionQueue::default();
let (_tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
assert_eq!(txq.status().pending, 0);
// when
let res = txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(nonce));
// then
assert_eq!(unwrap_tx_err(res), TransactionError::AlreadyImported);
let stats = txq.status();
assert_eq!(stats.future, 1);
assert_eq!(stats.pending, 0);
}
#[test]
fn should_accept_same_transaction_twice_if_removed() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 2);
// when
txq.remove_invalid(&tx1.hash(), &|_| default_nonce());
assert_eq!(txq.status().pending, 0);
assert_eq!(txq.status().future, 1);
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let stats = txq.status();
assert_eq!(stats.future, 0);
assert_eq!(stats.pending, 2);
}
#[test]
fn should_not_move_to_future_if_state_nonce_is_higher() {
// given
let mut txq = TransactionQueue::default();
let (tx, tx2) = new_tx_pair_default(1.into(), 0.into());
let tx3 = new_tx_default();
txq.add(tx2.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
txq.add(tx3.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx.clone(), TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().pending, 3);
// when
txq.cull(tx.sender(), default_nonce() + U256::one());
// then
let stats = txq.status();
assert_eq!(stats.future, 0);
assert_eq!(stats.pending, 2);
}
#[test]
fn should_replace_same_transaction_when_has_higher_fee() {
init_log();
// given
let mut txq = TransactionQueue::default();
let keypair = Random.generate().unwrap();
let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret(), None);
let tx2 = {
let mut tx2 = (**tx).clone();
tx2.gas_price = U256::from(200);
tx2.sign(keypair.secret(), None)
};
// when
txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let stats = txq.status();
assert_eq!(stats.pending, 1);
assert_eq!(stats.future, 0);
assert_eq!(txq.top_transactions()[0].gas_price, U256::from(200));
}
#[test]
fn should_replace_same_transaction_when_importing_to_futures() {
// given
let mut txq = TransactionQueue::default();
let keypair = Random.generate().unwrap();
let tx0 = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret(), None);
let tx1 = {
let mut tx1 = (**tx0).clone();
tx1.nonce = U256::from(124);
tx1.sign(keypair.secret(), None)
};
let tx2 = {
let mut tx2 = (**tx1).clone();
tx2.gas_price = U256::from(200);
tx2.sign(keypair.secret(), None)
};
// when
txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.status().future, 1);
txq.add(tx0, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
// then
let stats = txq.status();
assert_eq!(stats.future, 0);
assert_eq!(stats.pending, 2);
assert_eq!(txq.top_transactions()[1].gas_price, U256::from(200));
}
#[test]
fn should_recalculate_height_when_removing_from_future() {
// given
let previous_nonce = default_account_details().nonce - U256::one();
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(previous_nonce)).unwrap();
txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(previous_nonce)).unwrap();
assert_eq!(txq.status().future, 2);<｜fim▁hole｜> // then
let stats = txq.status();
assert_eq!(stats.future, 0);
assert_eq!(stats.pending, 1);
}
#[test]
fn should_return_none_when_transaction_from_given_address_does_not_exist() {
// given
let txq = TransactionQueue::default();
// then
assert_eq!(txq.last_nonce(&Address::default()), None);
}
#[test]
fn should_return_correct_nonce_when_transactions_from_given_address_exist() {
// given
let mut txq = TransactionQueue::default();
let tx = new_tx_default();
let from = tx.sender();
let nonce = tx.nonce;
// when
txq.add(tx, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(nonce)).unwrap();
// then
assert_eq!(txq.last_nonce(&from), Some(nonce));
}
#[test]
fn should_remove_old_transaction_even_if_newer_transaction_was_not_known() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let (nonce1, nonce2) = (tx1.nonce, tx2.nonce);
// Insert first transaction
txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(nonce1)).unwrap();
// when
txq.cull(tx2.sender(), nonce2 + U256::one());
// then
assert!(txq.top_transactions().is_empty());
}
#[test]
fn should_return_valid_last_nonce_after_cull() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(4.into(), 0.into());
let sender = tx1.sender();
let (nonce1, nonce2) = (tx1.nonce, tx2.nonce);
// when
// Insert first transaction
assert_eq!(txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(nonce1)).unwrap(), TransactionImportResult::Current);
// Second should go to future
assert_eq!(txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(nonce1)).unwrap(), TransactionImportResult::Future);
// Now block is imported
txq.cull(sender, nonce2 - U256::from(1));
// tx2 should be not be promoted to current
assert_eq!(txq.status().pending, 0);
assert_eq!(txq.status().future, 1);
// then
assert_eq!(txq.last_nonce(&sender), None);
}
#[test]
fn should_return_true_if_there_is_local_transaction_pending() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
assert_eq!(txq.has_local_pending_transactions(), false);
// when
assert_eq!(txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap(), TransactionImportResult::Current);
assert_eq!(txq.has_local_pending_transactions(), false);
assert_eq!(txq.add(tx2, TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap(), TransactionImportResult::Current);
// then
assert_eq!(txq.has_local_pending_transactions(), true);
}
#[test]
fn should_keep_right_order_in_future() {
// given
let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let prev_nonce = default_account_details().nonce - U256::one();
// when
assert_eq!(txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap(), TransactionImportResult::Future);
assert_eq!(txq.add(tx1.clone(), TransactionOrigin::External, 0, None, &default_tx_provider().with_account_nonce(prev_nonce)).unwrap(), TransactionImportResult::Future);
// then
assert_eq!(txq.future.by_priority.len(), 1);
assert_eq!(txq.future.by_priority.iter().next().unwrap().hash, tx1.hash());
}
#[test]
fn should_return_correct_last_nonce() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2, tx2_2, tx3) = {
let keypair = Random.generate().unwrap();
let secret = &keypair.secret();
let nonce = 123.into();
let gas = default_gas_val();
let tx = new_unsigned_tx(nonce, gas, 1.into());
let tx2 = new_unsigned_tx(nonce + 1.into(), gas, 1.into());
let tx2_2 = new_unsigned_tx(nonce + 1.into(), gas, 5.into());
let tx3 = new_unsigned_tx(nonce + 2.into(), gas, 1.into());
(tx.sign(secret, None), tx2.sign(secret, None), tx2_2.sign(secret, None), tx3.sign(secret, None))
};
let sender = tx1.sender();
txq.add(tx1, TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2, TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx3, TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.future.by_priority.len(), 0);
assert_eq!(txq.current.by_priority.len(), 3);
// when
let res = txq.add(tx2_2, TransactionOrigin::Local, 0, None, &default_tx_provider());
// then
assert_eq!(txq.last_nonce(&sender).unwrap(), 125.into());
assert_eq!(res.unwrap(), TransactionImportResult::Current);
assert_eq!(txq.current.by_priority.len(), 3);
}
#[test]
fn should_reject_transactions_below_base_gas() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let high_gas = 100_001.into();
// when
let res1 = txq.add(tx1, TransactionOrigin::Local, 0, None, &default_tx_provider());
let res2 = txq.add(tx2, TransactionOrigin::Local, 0, None, &default_tx_provider().with_tx_gas_required(high_gas));
// then
assert_eq!(res1.unwrap(), TransactionImportResult::Current);
assert_eq!(unwrap_tx_err(res2), TransactionError::InsufficientGas {
minimal: 100_001.into(),
got: 100_000.into(),
});
}
#[test]
fn should_clear_all_old_transactions() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let (tx3, tx4) = new_tx_pair_default(1.into(), 0.into());
let next_nonce = |_: &Address|
AccountDetails { nonce: default_nonce() + U256::one(), balance: !U256::zero() };
// Insert all transactions
txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx3, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
txq.add(tx4, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.top_transactions().len(), 4);
// when
txq.remove_old(&next_nonce, 0);
// then
assert_eq!(txq.top_transactions().len(), 2);
}
#[test]
fn should_remove_out_of_date_transactions_occupying_queue() {
// given
let mut txq = TransactionQueue::default();
let (tx1, tx2) = new_tx_pair_default(1.into(), 0.into());
let (tx3, tx4) = new_tx_pair_default(2.into(), 0.into());
// Insert all transactions
txq.add(tx1.clone(), TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
txq.add(tx2, TransactionOrigin::External, 5, None, &default_tx_provider()).unwrap();
txq.add(tx3.clone(), TransactionOrigin::External, 10, None, &default_tx_provider()).unwrap();
txq.add(tx4, TransactionOrigin::External, 0, None, &default_tx_provider()).unwrap();
assert_eq!(txq.top_transactions().len(), 3);
assert_eq!(txq.future_transactions().len(), 1);
// when
txq.remove_old(&default_account_details_for_addr, 9 + super::DEFAULT_QUEUING_PERIOD);
// then
assert_eq!(txq.top_transactions().len(), 2);
assert_eq!(txq.future_transactions().len(), 0);
assert_eq!(txq.top_transactions(), vec![tx1, tx3]);
}
#[test]
fn should_accept_local_service_transaction() {
// given
let tx = new_tx(123.into(), 0.into());
let mut txq = TransactionQueue::default();
txq.set_minimal_gas_price(100.into());
// when
txq.add(tx, TransactionOrigin::Local, 0, None, &default_tx_provider()).unwrap();
// then
assert_eq!(txq.top_transactions().len(), 1);
}
#[test]
fn should_not_accept_external_service_transaction_if_sender_not_certified() {
// given
let tx1 = new_tx(123.into(), 0.into());
let tx2 = new_tx(456.into(), 0.into());
let mut txq = TransactionQueue::default();
txq.set_minimal_gas_price(100.into());
// when
assert_eq!(unwrap_tx_err(txq.add(tx1, TransactionOrigin::External, 0, None, &default_tx_provider())),
TransactionError::InsufficientGasPrice {
minimal: 100.into(),
got: 0.into(),
});
assert_eq!(unwrap_tx_err(txq.add(tx2, TransactionOrigin::RetractedBlock, 0, None, &default_tx_provider())),
TransactionError::InsufficientGasPrice {
minimal: 100.into(),
got: 0.into(),
});
// then
assert_eq!(txq.top_transactions().len(), 0);
}
#[test]
fn should_not_accept_external_service_transaction_if_contract_returns_error() {
// given
let tx = new_tx(123.into(), 0.into());
let mut txq = TransactionQueue::default();
txq.set_minimal_gas_price(100.into());
// when
let details_provider = default_tx_provider().service_transaction_checker_returns_error("Contract error");
assert_eq!(unwrap_tx_err(txq.add(tx, TransactionOrigin::External, 0, None, &details_provider)),
TransactionError::InsufficientGasPrice {
minimal: 100.into(),
got: 0.into(),
});
// then
assert_eq!(txq.top_transactions().len(), 0);
}
#[test]
fn should_accept_external_service_transaction_if_sender_is_certified() {
// given
let tx = new_tx(123.into(), 0.into());
let mut txq = TransactionQueue::default();
txq.set_minimal_gas_price(100.into());
// when
let details_provider = default_tx_provider().service_transaction_checker_accepts(true);
txq.add(tx, TransactionOrigin::External, 0, None, &details_provider).unwrap();
// then
assert_eq!(txq.top_transactions().len(), 1);
}
}<｜fim▁end｜> |
// when
txq.remove_invalid(&tx1.hash(), &|_| default_nonce() + 1.into());
|
<|file_name|>HarvesterProfileSettings.java<|end_file_name|><｜fim▁begin｜>/*
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
* The Apereo Foundation licenses this file to you 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 com.tle.common.harvester;
import com.tle.beans.entity.LanguageBundle;
import java.util.Map;
public abstract class HarvesterProfileSettings {
private LanguageBundle name;
private Map<String, String> attributes;
public HarvesterProfileSettings() {
super();
}
public HarvesterProfileSettings(HarvesterProfile gateway) {
this();
load(gateway);
}
public void load(HarvesterProfile gateway1) {
this.attributes = gateway1.getAttributes();
this.name = gateway1.getName();
_load();
}
public void save(HarvesterProfile gateway1) {
gateway1.setType(getType());
this.attributes = gateway1.getAttributes();
gateway1.setName(name);
_save();
for (Map.Entry<String, String> entry : attributes.entrySet()) {
gateway1.setAttribute(entry.getKey(), entry.getValue());
}
}
public String get(String key, String defaultValue) {
String value = attributes.get(key);
if (value == null) {
value = defaultValue;
}
return value;
}
public boolean get(String key, boolean defaultValue) {
String value = attributes.get(key);
boolean v;
if (value == null) {
v = defaultValue;
} else {
v = Boolean.valueOf(value);
}
return v;<｜fim▁hole｜> public int get(String key, int defaultValue) {
String value = attributes.get(key);
int v;
if (value != null) {
try {
v = Integer.parseInt(value);
} catch (Exception e) {
v = defaultValue;
}
} else {
v = defaultValue;
}
return v;
}
public void put(String key, Object value) {
attributes.put(key, value.toString());
}
public void put(String key, String value) {
attributes.put(key, value);
}
protected abstract String getType();
protected abstract void _load();
protected abstract void _save();
public LanguageBundle getName() {
return name;
}
public void setName(LanguageBundle name) {
this.name = name;
}
}<｜fim▁end｜> | }
|
<|file_name|>renren.d.ts<|end_file_name|><｜fim▁begin｜>import * as React from 'react';
import { IconBaseProps } from 'react-icon-base';<｜fim▁hole｜><｜fim▁end｜> | declare class FaRenren extends React.Component<IconBaseProps> { }
export = FaRenren; |
<|file_name|>HttpClient.test.ts<|end_file_name|><｜fim▁begin｜>// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
import { HttpRequest } from "../src/HttpClient";
import { TestHttpClient } from "./TestHttpClient";
import { registerUnhandledRejectionHandler } from "./Utils";
registerUnhandledRejectionHandler();
describe("HttpClient", () => {
describe("get", () => {
it("sets the method and URL appropriately", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.get("http://localhost");
expect(request.method).toEqual("GET");
expect(request.url).toEqual("http://localhost");
});
it("overrides method and url in options", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.get("http://localhost", {
method: "OPTIONS",
url: "http://wrong",
});
expect(request.method).toEqual("GET");
expect(request.url).toEqual("http://localhost");
});
it("copies other options", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.get("http://localhost", {
headers: { "X-HEADER": "VALUE"},
timeout: 42,
});
expect(request.timeout).toEqual(42);
expect(request.headers).toEqual({ "X-HEADER": "VALUE"});
});
});
describe("post", () => {
it("sets the method and URL appropriately", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.post("http://localhost");
expect(request.method).toEqual("POST");
expect(request.url).toEqual("http://localhost");
});
it("overrides method and url in options", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.post("http://localhost", {
method: "OPTIONS",
url: "http://wrong",
});
expect(request.method).toEqual("POST");
expect(request.url).toEqual("http://localhost");
});
it("copies other options", async () => {
let request!: HttpRequest;
const testClient = new TestHttpClient().on((r) => {
request = r;
return "";
});
await testClient.post("http://localhost", {
headers: { "X-HEADER": "VALUE"},
timeout: 42,
});
expect(request.timeout).toEqual(42);<｜fim▁hole｜>});<｜fim▁end｜> | expect(request.headers).toEqual({ "X-HEADER": "VALUE"});
});
}); |
<|file_name|>ping_.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
#Master-Thesis dot parsing framework (PING MODULE)
#Date: 14.01.2014
#Author: Bruno-Johannes Schuetze
#uses python 2.7.6
#uses the djikstra algorithm implemented by David Eppstein
#Module does calculations to behave similar to ping, uses delay label defined in the dot file
from libraries.dijkstra import *
def getSingleValue(src, dst, edgeCostHash):
return edgeCostHash[(src*100000)+dst]<｜fim▁hole｜>def getPathTotal(start, end, edgeCostHash, networkDict):
#get shortest path between start and end
shortPathList = shortestPath(networkDict, start, end)
print "WE PINGING SHAWTY", shortPathList<｜fim▁end｜> | |
<|file_name|>icons_rc.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Resource object code
#
# Created: Sat May 11 12:28:54 2013
# by: The Resource Compiler for PyQt (Qt v4.8.4)
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore
qt_resource_data = b"\
\x00\x00\x04\x58\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x1f\x49\x44\x41\x54\x78\xda\xa5\x55\xcf\x4f\x54\x67\
\x14\x3d\xef\xbd\x6f\xde\x30\x3f\x5b\xc6\x81\x86\x0a\x08\x84\xa8\
\x11\x5c\xd8\x11\xc5\xc4\x1a\xd4\x88\xd1\xc4\x85\x89\x2b\x16\x06\
\x97\x2e\x5c\x91\x2e\x5d\x55\x77\x25\x51\x17\x2e\xdc\x9a\xd0\x3f\
\x40\x25\xda\x8d\x89\x71\xa5\xa8\x55\xab\x9a\x4a\x81\x02\x05\x40\
\x1c\x98\x61\x7e\x31\x30\xef\xf5\xdc\x8f\x37\x93\x57\x16\xdd\x78\
\x92\x3b\xf7\xcd\x8f\xef\x7c\xe7\x9e\xef\xde\x6f\x8c\x9f\x80\xe6\
\x80\x65\xfd\xdc\x91\x4c\x0e\x28\xcb\xb2\xf1\x15\xd8\xac\x54\xca\
\x13\xcb\xcb\x23\x1b\x95\xca\x55\x25\xa4\x43\xfd\xfd\x83\xc5\x62\
\x11\xcb\x6b\x6b\x80\xeb\xc2\x0f\xd3\x30\x60\x9a\xa6\xce\x96\x97\
\xcd\xed\xd9\x7b\x8e\xd4\xd5\xd9\x9b\xc0\xe0\x2f\x8f\x1e\x41\xb5\
\x53\x69\xbe\x50\xc0\xfc\xee\xdd\x48\xa4\x52\xf0\xc3\xf0\x16\x69\
\xd2\x60\x50\xbf\x37\x36\x37\x61\x4a\xf6\xc2\xff\x9c\x7f\xf7\x0e\
\x91\xd7\xaf\x21\x9c\x4a\x99\xa6\x2d\x4a\x63\x9d\x9d\x70\xb8\xc8\
\xaf\x34\xd2\xde\x0e\x9b\x11\x6c\x68\x40\x38\x91\x80\x20\xff\xe5\
\x0b\xf2\x8b\x8b\x28\x7c\xfa\x84\xe8\xea\x2a\xe0\x23\x0e\xb6\xb5\
\xa1\x3c\x36\x06\xe1\x54\x2e\xa4\x7a\x17\x1b\xd9\x2c\x9c\x8d\x0d\
\x08\x54\x28\x84\x1d\xa7\x4e\xa1\x7e\xff\x7e\x6c\x47\x34\x99\xd4\
\x81\xae\x2e\xfc\xfd\xec\x19\x2c\x12\x85\xc4\x3e\x5a\x61\xac\xaf\
\xeb\x0d\x84\x53\x89\xa7\x12\xe5\x4c\x06\x16\xbf\xb0\xc3\x61\xec\
\xba\x7c\x19\x75\x9e\xc2\x3f\x1e\x3f\xc6\xe7\x37\x6f\x50\xa1\xca\
\x38\xed\x50\x4d\x4d\x48\x70\xc3\xb6\x23\x47\xb0\xeb\xd0\x21\xac\
\x75\x74\x60\xee\xce\x1d\x34\x28\x05\x50\x98\x01\x68\x3e\xe5\xf0\
\x45\x22\xfd\xfc\x39\x12\xdd\xdd\xf8\xee\xc2\x05\x4d\x5a\xe0\x46\
\xbf\x0d\x0f\xa3\x71\x6e\x0e\xcd\xd1\xe8\x96\xd7\xdc\xd8\xa4\x6d\
\xe6\xf8\x38\x26\xe9\x65\xd3\xc0\x00\x62\x54\x6f\x1d\x3d\x8a\x8d\
\x87\x0f\x61\x93\x87\x32\x35\x9f\x29\x36\x68\x2b\xe6\xe7\x11\x88\
\x44\x90\x3c\x7c\x18\x82\xd1\xeb\xd7\xd1\x36\x31\x81\xfa\x4a\x05\
\x6e\x2e\x87\x6f\xfa\xfb\x61\xf5\xf5\xa1\xc4\x0d\xc1\xf7\xf6\xdb\
\xb7\xc8\xdc\xbd\x0b\x41\xe7\xb1\x63\x98\xad\xaf\x07\xd8\x04\x86\
\x08\xd6\xc4\xd8\x82\x65\x59\x68\x38\x7d\x1a\x82\xdf\xef\xdd\x43\
\x9c\x8a\x14\x5b\xd0\xa5\xc2\x10\x0f\x25\x79\xe6\x0c\x5a\xcf\x9d\
\xdb\x22\xe0\x67\x42\xee\xd2\xdf\xf4\x93\x27\x10\xc4\x0f\x1e\x44\
\x81\x76\x91\x4f\x42\x2b\xd6\x65\x2a\x12\xc7\x79\x20\x82\x89\xfb\
\xf7\xb1\x43\x0e\x93\x21\xc4\x26\xbf\xab\xc2\x09\x04\x84\x54\x93\
\x1b\xcc\x72\x78\x82\x46\x76\x55\x7a\x61\xa1\xa6\x58\xb9\x9e\x2f\
\xc1\x78\x1c\x91\xd6\x56\x08\x8a\x1f\x3f\xc2\x28\x95\xe0\x96\xcb\
\x70\x85\x88\xde\xd6\xc0\xcf\x84\x58\x6f\xc6\xb5\x9b\xac\x4c\x2b\
\x6e\x6e\x46\xc6\xb6\xb1\xb3\x4a\x2c\x46\x1b\x9e\xe2\x2a\x42\x7c\
\x96\x29\xd3\x21\x65\x39\x0e\xaa\x30\xf5\x22\x47\xb2\x4c\x9b\xce\
\x55\xac\xcb\xb3\xff\xf0\x20\xe4\x34\x3e\x37\x33\x03\x41\x78\xdf\
\x3e\x21\xd5\xbe\x2b\x6f\x6c\xfd\x83\xe3\x1f\x67\x7b\xcf\x1e\x08\
\xb2\xb3\xb3\xf8\x96\x03\xe6\x72\x53\x72\xd6\x3c\xd6\x24\x85\x0f\
\x1f\x20\x68\x3e\x79\x52\x37\xbc\xf2\x54\xfb\x15\x73\xa1\x26\xb5\
\xbc\xbb\x43\xf5\xf6\x42\xb0\xcc\xb5\x8d\xec\x73\x6f\xe0\xb8\xc6\
\xf3\x58\x7e\x94\x63\x2f\x0a\xba\xcf\x9f\xc7\x6a\x2a\x55\xb3\xa3\
\xfc\xea\x15\x72\xd3\xd3\x58\x99\x9a\x42\xf1\xc5\x0b\x58\x9e\x62\
\xbb\xa7\x07\x41\x8a\x10\x4c\x73\x6d\xd2\x23\x76\xaa\xc4\xf0\x88\
\x4b\x4f\x9f\x62\x61\x74\x14\x82\x1f\xae\x5d\x43\x91\x2d\xa4\x15\
\xb3\xed\xb2\x97\x2e\x61\xe6\xe2\x45\xf4\xf0\x30\x35\x29\xfb\xdd\
\x1e\x1a\x82\x60\x9c\x6b\xbe\x67\x5f\xb3\x42\x5d\x91\x53\xed\x0a\
\x71\x50\x79\x9e\xe6\x6f\xde\x44\xfe\xc0\x01\x44\x38\xba\x5d\x37\
\x6e\x60\xfa\xc1\x03\x04\x78\x27\xa8\xc9\x49\x48\xcf\x04\xf6\xee\
\x85\xc1\x71\x0e\x1f\x3f\x0e\x41\x8e\x83\x35\x7d\xeb\x16\x7e\x8c\
\x46\x75\x13\x88\x69\x9a\x73\x38\x1a\x75\xfb\xd8\x83\x61\x96\x51\
\x2d\x1d\xb1\x18\x02\x57\xae\xa0\xe5\xec\x59\xfc\x1f\xfe\x64\xbf\
\x2f\xde\xbe\x8d\x14\xab\xb0\x29\x4a\x88\x97\x56\x56\xf0\x2b\xaf\
\x07\xe5\xf7\xb8\x16\x2c\xdd\xe2\x3d\xf1\x17\xa7\xca\x3c\x71\x02\
\x09\xaa\x8c\xb7\xb4\x40\x90\x65\xe7\xc8\x41\xfd\x43\x4f\x77\xbe\
\x7f\x8f\xde\x70\x58\x08\x6b\xe1\x78\x1e\xab\x8a\xe3\x94\x8b\xa5\
\x92\x5d\x1f\x89\x54\x5b\xac\xf6\x4f\x11\x7f\xf9\x12\x16\x0f\xae\
\x04\x60\x89\x15\xe5\xd9\x4e\x31\x46\x03\x07\xa1\x45\x29\x18\x3e\
\x52\xd3\xcb\x9f\x79\x47\x0b\xa7\x5a\x29\x95\x46\x16\x32\x99\x41\
\x07\x74\x20\x14\xfa\xef\xbf\xc3\xb6\x1c\x61\xb8\xb2\x49\xf5\x37\
\x20\xbc\x2c\xef\x97\x79\x05\x4c\x2d\x2d\x41\x38\xc5\x8a\xab\x63\
\x9c\xf1\x78\x3a\x3d\x40\x02\x1b\x5f\x01\x72\x95\xb3\xe5\xf2\x88\
\x70\xfe\x0b\x44\xcb\xf0\x2c\x1e\xa0\xc6\x2d\x00\x00\x00\x00\x49\
\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x05\xf7\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\
\x01\x42\x28\x9b\x78\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x05\x74\x49\x44\
\x41\x54\x58\x85\xcd\x97\xcf\x6f\x1b\x45\x14\xc7\xdf\x9b\xd9\x1f\
\xde\xb5\xd7\x89\xd3\x24\x35\x89\xc3\x8f\x42\x53\x08\x87\x22\x37\
\x97\x56\x42\xa9\xc4\xc1\x7f\x40\x2b\x11\x11\x89\x14\xba\x51\xc4\
\x81\x63\x11\x3d\x35\x39\x15\xc1\x91\x03\x8a\xb2\x15\xcd\xa1\x10\
\x89\xe6\x0f\xc8\x01\xa9\xbd\xa4\x17\x17\x29\xa8\x0a\xa1\xa0\x40\
\x89\x95\x5a\x69\xf3\xc3\xbb\xf6\xae\xf7\xd7\x0c\x07\x77\x93\x3a\
\xb1\x13\x03\xaa\xc2\x93\x56\x5a\xcd\xce\xcc\xe7\xbb\x6f\xde\x9b\
\x79\x83\xba\xae\xc3\x51\x1a\x39\x52\xfa\xff\x41\x80\xf0\x4f\x3a\
\x8f\x18\x86\x20\x0b\x30\x24\x0a\x64\x14\x00\xfb\x08\x42\x1c\x00\
\x80\x71\xa8\x00\xf0\x55\x3f\x60\x33\x6e\x00\x77\x6f\xe9\x7a\xd0\
\xea\x9c\xd8\x4a\x0c\x4c\x1b\x06\xc9\x4b\xe4\xba\x20\xe1\x45\x29\
\x2e\xa4\xe5\xb8\xa8\x12\x8a\x75\x7d\x58\xc8\xc1\xad\xf8\xb6\x57\
\x09\x8a\x81\xc7\x6f\x0f\x7a\xec\xea\x98\xae\xb3\xff\x2c\x60\xcc\
\x30\xfa\xa9\x42\x66\xe3\xc7\xe4\x01\x39\x2e\xc8\x87\xaa\x05\x00\
\xb7\x12\xb8\x95\x0d\x77\x29\x74\xd8\xf0\xb4\xae\x3f\xfc\x57\x02\
\xa6\x0d\x03\xf3\x12\xb9\x26\xa9\xe4\x72\x22\xad\x64\x90\xd4\xff\
\x31\x70\x00\xdf\x0d\x01\x38\x00\x95\x08\xec\xf5\x08\x67\x1c\xca\
\x45\xa7\xe0\xd9\xec\xc6\xa0\xc7\x26\xc7\x74\x9d\x37\xe2\x34\x8d\
\x81\xbc\x44\xae\xc5\xbb\xe5\x2b\xb1\x76\x49\x8d\xda\x58\xc8\xa1\
\xbc\xee\xae\x31\x37\x2c\x32\xc6\xd7\xc0\xe3\x77\x38\xa2\x85\x94\
\x9f\x45\xc4\x7e\x51\x15\x4e\x28\x5d\x52\x9a\x0a\x04\x90\x20\x68\
\x99\x78\xa6\xba\xed\x5d\xc9\xaf\xbb\x00\x00\x13\x2d\x7b\x60\xcc\
\x30\xfa\x63\x1d\xd2\x8f\xc9\x8c\x9a\x89\xda\xaa\x25\xcf\xb6\xd7\
\xdd\x45\xcf\x09\x3f\xb8\xa1\xeb\x7f\x36\x9a\x6c\xdc\x30\x4e\x31\
\x01\x17\x3a\x4f\x6a\x1d\x44\xdc\x4d\x30\xb3\x60\x17\xaa\x9b\xde\
\x7b\x8d\x96\x63\x5f\x1a\x4e\x1b\x06\xa1\x2a\x99\xd5\x7a\x95\x0c\
\x90\x5a\x0f\x6b\xcd\x29\x94\x1f\x57\x27\xbf\x19\xf9\xe8\x5c\x33\
\xf8\xb4\x61\x10\x50\xe8\x17\xed\x2f\xab\x0a\x91\x09\x44\x63\x81\
\x00\x68\xbd\x4a\x86\xaa\x64\x76\xda\x30\xf6\xf1\xf6\x35\xe4\x65\
\x72\x3d\xd1\xab\x0e\xa0\x44\x00\x28\x42\xd5\xf4\x6d\xd7\xf4\xbf\
\x9e\xfa\xf0\xe3\x2f\x1b\x81\x23\x78\x5e\xa1\x73\xc9\xde\x58\x4e\
\x4a\x49\x0a\x50\x04\xa0\x08\x2c\xe4\x00\x14\x01\x25\x02\x89\x5e\
\x75\x20\x2f\x93\xeb\x07\x0a\x18\x31\x0c\x41\x50\xe8\x45\xb9\x5d\
\x92\x81\x20\x30\x06\x60\x17\xdd\xc5\x96\xe0\x7d\x4a\x4e\x4a\xc9\
\x0a\x10\x04\x20\x08\x9e\xe5\x3b\x4f\x97\xcd\xcd\x30\xe4\x00\x04\
\x41\x6e\x97\x64\x41\xa1\x17\x47\x0c\xa3\x2e\xee\xea\x04\xc8\x02\
\x0c\x49\x29\x29\x1d\x4d\x62\xad\x39\x6b\x9e\x1d\x7c\x70\x38\x5c\
\xad\x87\x97\x7c\xc7\x5c\x75\xe6\x89\xcf\xcf\xd9\xc5\x6a\x31\x6a\
\x97\x52\x52\x5a\x16\x60\xa8\xa9\x00\x51\xa6\xa3\x4a\xa7\xac\x22\
\x45\x40\x8a\xc0\xdc\xb0\x78\xd0\x9a\xdf\x57\xe9\x5c\xf2\x95\x44\
\x4e\xee\x94\x95\x68\x8c\x57\x0a\x1c\xab\x60\xcf\x0f\x3a\xe1\x85\
\x29\x5d\xff\xd5\x2f\x07\x2b\xd1\x37\xa5\x53\x56\x45\x99\x8e\x36\
\x15\x80\x88\x7d\x3b\x01\x84\x00\x3c\xe4\x6b\x07\xc1\xb5\xd7\x12\
\x39\xb9\x53\x54\xa2\x60\x73\x4b\xbe\x63\xfd\x55\x9e\x3f\x63\x87\
\x17\xa2\x5d\x90\x73\xfe\x90\x31\x0e\x40\x00\x88\x4c\x00\x11\xfb\
\x9a\x0b\xa0\x10\x8f\xdc\xe5\x3b\x21\xf0\x80\xdd\x69\x0a\x3f\x91\
\xc8\xc9\xc7\xa4\x1d\xb7\xbb\xdb\xbe\x63\xfd\x51\x0f\x07\x00\xe0\
\x21\xdc\x0b\x5d\x06\x51\x3f\xa4\xb5\xf3\x23\xb2\x3d\x1b\x51\x2d\
\x7a\xa3\x57\xce\xd1\x6a\x08\x7f\x43\xab\xc1\x9f\x99\xbb\xe1\x39\
\xd6\xca\x7e\x78\xcd\xab\x5c\x8b\xb2\x62\x67\xe2\x66\x1e\xe0\x8c\
\x57\x22\xa5\x34\x21\x00\x8a\x70\xb6\x0e\x9e\xa0\x73\x5a\x7f\x32\
\x27\x77\xed\x06\x9c\xbb\xe5\x3b\xd6\x8a\xd5\x10\x0e\x00\x80\x22\
\x39\x2f\x6a\xc2\x8e\x07\x38\xe3\x95\xe6\x02\x90\xaf\xb2\x80\xd5\
\xd6\x4b\x22\x80\x88\xfd\x75\xf0\x93\xc9\x9c\xdc\x25\xed\xae\xf9\
\xa6\xe7\x58\xbf\x9b\xf3\x67\xca\x8d\xe1\xcf\x04\xf4\x80\x80\x00\
\x04\x80\x05\x0c\x38\xf2\xd5\xe6\x02\xec\x70\xc6\xdd\xf0\xec\x28\
\x6a\xa5\x94\x74\x62\xdc\x30\x4e\xdd\x4f\xd0\xb9\xe4\x9b\x6d\xb9\
\xd8\xf1\xe7\xa2\x7d\xcb\x77\xac\xdf\x0e\x86\x5f\x36\x8c\x57\x69\
\x5c\x48\x47\x63\xdc\x0d\xcf\xe6\x76\x38\xd3\x54\x40\x25\x80\xbb\
\xd5\xf5\xdd\xbc\x8d\xbf\x9e\x48\x33\x89\x2c\x24\xdf\x6a\xcb\xc9\
\xdd\xcf\xb9\x7d\xc3\x73\xcc\xe5\xd2\x81\x70\x00\x00\x29\x29\x7e\
\x97\x3c\xa5\xf5\x44\xe3\xaa\xeb\xd5\x62\x25\x80\xbb\x4d\x05\xdc\
\xd2\xf5\x80\x55\xc2\xdb\xd5\x4d\xcf\x05\x82\x40\x55\x01\xba\xdf\
\xed\xea\x90\x8f\xc7\x76\xe1\x4f\x3d\xc7\xfc\xe5\x70\xf8\xf8\xf7\
\x37\x3f\x8b\xf7\x6b\xa7\x89\x4c\x6b\xf0\x4d\xcf\x65\x95\xf0\xf6\
\xde\x6a\x69\xdf\x59\x90\xad\x04\x57\xad\x65\x73\x89\x47\xb9\x1b\
\xa7\x3b\x87\x8a\xfb\xc4\x75\xcc\xa5\xed\x96\xe0\xb1\x6e\xe9\x53\
\xa5\x27\xa6\x02\xa9\xd5\x06\xd6\xb2\xb9\x94\xad\x04\x57\xf7\xf6\
\xdd\x27\x60\x4c\xd7\x59\xb8\xed\x0f\x9b\x0f\x4a\x85\x9d\xf4\xa1\
\x08\xcc\x65\xb0\xb5\xb8\xe5\xf0\x72\xf8\xf9\x41\x6b\xfe\xc9\x0f\
\x33\x0b\xda\xdb\xc9\x6b\xc9\x77\x52\x99\x68\xac\xf9\xa0\x54\x08\
\xb7\xfd\xe1\x86\x59\xd2\xac\x22\x1a\x9f\xbd\x39\xa1\x0d\x24\xaf\
\xa8\x7d\xea\x4e\x41\x12\x56\x43\x28\x2f\x9b\x45\x6f\xd3\x5b\x01\
\x0e\x0f\x99\xc7\xee\x21\xa2\x86\x12\x39\x8f\x22\xf6\x50\x4d\x48\
\xb7\x0d\xb4\xf5\x10\x69\xf7\xbf\xec\x55\xdb\xb6\x96\xcc\xaf\xa6\
\x86\x2f\x4d\x34\xe2\x34\xad\x88\x06\xcb\xc1\x64\x7e\xc9\x04\xef\
\x49\xf5\x72\xdb\xe9\x54\x06\x45\x02\x54\x15\xa0\x2d\xdb\x91\x06\
\x80\x34\xf3\xd8\xb9\xa0\x1c\x5c\x42\x04\x10\xdb\xc4\x5a\x9e\x3f\
\x67\xdc\x67\x50\x5a\xdc\x2a\xb8\x4f\xbc\x1b\x83\xe5\x60\x72\xaa\
\x09\xa7\xb5\xa2\x34\x25\xce\x26\x4f\xa7\x06\x62\xe9\x58\x4b\x45\
\x69\xb5\x58\x75\xcd\xc5\xad\xa5\x70\xcb\x3f\xb4\x28\xa5\xd9\x6c\
\xf6\xc0\xc9\x7e\xca\x66\x37\xc6\x17\xf2\xd3\x8f\x36\xdc\x44\xf5\
\xb1\xf3\x12\x67\x5c\x16\xe2\x54\x44\x91\xd4\x76\xd5\x67\x0f\x73\
\x43\xb0\x1f\xd9\xb6\xf5\xf3\xf6\xaa\xfb\xa8\xf2\xed\x99\x52\xf0\
\xfe\x84\xae\x3f\x3d\x4c\x6c\x4b\xf7\x82\xc8\x46\x0c\x43\x88\x0b\
\x30\x84\x9a\x38\x8a\x00\x7d\x44\xc0\xda\xc5\x24\xe0\x15\x0e\xb0\
\xca\x2d\x7f\xa6\xf2\x22\x2e\x26\x2f\xd2\x8e\xfc\x6e\x78\xe4\x02\
\xfe\x06\x88\x39\xad\x57\x92\xe3\xa1\x6d\x00\x00\x00\x00\x49\x45\
\x4e\x44\xae\x42\x60\x82\
\x00\x00\x04\x66\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x2d\x49\x44\x41\x54\x78\xda\x7d\x55\xd9\x4b\xa3\x57\
\x14\x3f\xd1\xb8\xaf\x55\x27\x6a\x5c\x12\xf7\xa9\x5b\xa2\x03\x63\
\x8a\xce\x44\xd0\xd2\x97\x56\xda\xbe\x39\x4f\xa5\x21\x54\x2c\xe0\
\x02\xf8\x6f\xf8\xa4\x55\xe8\x93\xd0\x06\x04\x4b\x09\x56\x2d\x75\
\x04\xb1\x08\x51\x23\x06\xa3\x8e\xa8\xe0\x02\xa2\xc1\x7d\x8f\x71\
\xe9\xf9\x1d\x9a\x8f\xaf\x69\x98\x0b\x87\xfb\xe5\xe6\xdc\xdf\x39\
\xe7\x77\x96\xab\x79\x7e\x7e\xa6\x70\xab\xbb\xbb\x3b\xf1\xf1\xf1\
\xf1\x8b\xe4\xe4\xe4\x37\x39\x39\x39\x6f\xd3\xd2\xd2\xca\xa2\xa3\
\xa3\x35\xc7\xc7\xc7\x9b\x3e\x9f\xcf\xb5\xb1\xb1\xf1\xd7\xd5\xd5\
\xd5\xd8\xf0\xf0\xf0\x55\xb8\xfb\x61\x81\x3b\x3b\x3b\x5b\x0b\x0a\
\x0a\x7e\xaa\xab\xab\x4b\x31\x18\x0c\xe4\xf7\xfb\xff\x23\x77\x77\
\x77\x74\x72\x72\x42\xf3\xf3\xf3\xe7\x6b\x6b\x6b\x3f\x8e\x8c\x8c\
\xfc\xf2\x51\xe0\xae\xae\x2e\x1d\x7b\xf5\x73\x53\x53\xd3\x57\x3a\
\x9d\x8e\x4e\x4f\x4f\x69\x73\x73\x93\x0e\x0f\x0f\x89\xbd\x14\xd0\
\x84\x84\x04\x8a\x8d\x8d\xa5\x98\x98\x18\x88\xe8\x30\xb8\x93\xbd\
\xb7\x4f\x4d\x4d\xf9\xfe\x07\xdc\xd1\xd1\xa1\xe3\xd0\xe7\x1a\x1b\
\x1b\x0d\x91\x91\x91\xe4\xf5\x7a\x69\x65\x65\x85\x2e\x2f\x2f\x29\
\x10\x08\x10\xff\x47\x4f\x4f\x4f\x04\x7d\x00\x42\x27\x22\x22\x42\
\xf6\x9b\x9b\x1b\x44\xb1\xc3\x3a\xaf\x67\x67\x67\x05\x5c\xcb\x82\
\x85\xcb\x03\xfc\x87\x61\x69\x69\x49\xf1\x10\x21\x97\x94\x94\x50\
\x65\x65\x25\x55\x55\x55\x41\x4d\x8c\x41\x87\x39\x16\x63\x0f\x0f\
\x0f\xb2\xe3\x2e\xcb\x00\xab\x7c\xab\x78\xdc\xd6\xd6\xd6\xca\x87\
\xbf\x42\x01\x72\x7e\x7e\x4e\x1a\x8d\x86\xda\xdb\xdb\xa9\xb9\xb9\
\x99\x42\x17\xee\x70\xd8\xd4\xdb\xdb\x0b\xae\x71\x47\x2d\xef\x96\
\x97\x97\x1d\x1a\xbb\xdd\x8e\xec\x6f\xb3\xa4\xb3\xd0\xfd\xfd\xbd\
\x78\xd1\xdf\xdf\x4f\xe0\x79\x7c\x7c\x9c\x46\x47\x47\x29\x2e\x2e\
\x0e\xa1\x83\x0e\x31\xc6\x94\xd1\xc1\xc1\x01\xd9\x6c\x36\xf0\xac\
\x06\x3e\x66\x31\x46\x56\x57\x57\x7f\xc9\x40\xdf\xb1\x00\x10\xe1\
\x83\x6f\xaa\xa8\xa8\xa0\x9e\x9e\x1e\x72\xb9\x5c\x54\x53\x53\x43\
\x16\x8b\x85\x6a\x6b\x6b\x29\x33\x33\x93\xa6\xa7\xa7\x69\x66\x66\
\x86\x3e\x67\x03\xba\x17\x2f\x68\xf2\xfd\x7b\xdc\x0d\x4a\x3c\x8b\
\x3b\x82\xb9\x7d\xc5\x42\x10\x78\x0b\x40\xab\xd5\x4a\x0e\x87\x83\
\x9c\x4e\x27\x25\x26\x26\x52\x6a\x6a\x2a\xa5\xa7\xa7\x53\x56\x56\
\x16\x65\x64\x64\x08\xef\x93\x93\x93\xf4\xc7\xd8\x18\xd5\x37\x34\
\x50\x79\x79\x39\xa9\x30\x20\xaf\xb4\x00\x56\x27\xa1\xb8\xb8\x98\
\x9e\x78\x1f\x1a\x1a\xa2\xb3\xb3\x33\x24\x11\x89\x92\x4b\xf1\xf1\
\xf1\x74\x71\x71\x41\xeb\xeb\xeb\x48\x30\x0c\x0b\x25\xa5\xa5\xa5\
\x12\x99\x0a\x47\x80\x4d\x41\x50\x48\x5e\x5e\x1e\xdd\xf9\xfd\x00\
\x94\x04\x72\x22\xc0\x25\xf8\x06\xc7\xc2\xe7\xd1\xd1\x91\x94\x19\
\x77\x21\x05\xd8\x43\xa3\xd1\x08\x2f\xd5\x3c\x9b\xb4\x21\x07\x0a\
\x57\x68\x02\xd0\x80\xa4\xe1\x1c\xd9\x07\x30\xbe\xe1\x39\x16\xf6\
\x00\xeb\x06\x69\x50\xe3\xc0\x63\x0f\x7f\x64\x05\x0f\xd6\x3f\x7c\
\xa0\xcf\x2c\x16\xf1\xe2\xfa\xfa\x1a\xe0\xe8\x36\x18\x80\x97\x4a\
\x82\x61\x24\x3f\x3f\x9f\x1e\xf9\xf7\xea\xea\x6a\x28\xb0\x07\xc0\
\x6e\x0c\x9b\xe0\xe1\xb2\xd7\x2b\x5e\xb4\xb4\xb4\xd0\xde\xde\x9e\
\x00\x26\x25\x25\x09\x78\x54\x54\x94\x00\x70\xfb\xca\x79\x43\x7d\
\xbd\x18\xf2\x78\x3c\xa1\xc0\x6e\x01\x56\x87\xb0\xb8\xb8\x48\x53\
\x5c\x3e\x6f\x38\xdb\xbb\xbb\xbb\x48\x0a\x5a\x18\x9e\x23\x74\x89\
\x42\xab\xd5\x52\x8d\xd9\x8c\x8e\x94\x52\x9b\x9b\x9b\x53\xee\xff\
\x3b\x22\xdc\x1a\x9e\x60\xea\x06\x81\x07\x02\xd0\xd7\xd7\x87\xd2\
\x42\x0b\xc3\x23\x84\x0f\x03\xe2\xe9\xa7\x2f\x5f\x82\x2a\x49\xea\
\xf7\x36\x1b\x8c\x21\x0a\x19\x52\xbc\x8e\x59\x8c\xd2\xd2\x66\xb3\
\xb9\x95\x01\x95\x96\x06\x00\x92\x87\xae\x6a\xb4\x5a\x95\xe1\xa3\
\x5e\x63\x5c\xc3\x03\x83\x83\xa2\x7b\x7b\x7b\x0b\x70\x8c\x02\x54\
\xc7\x3b\xd6\x75\x28\xd3\xad\xac\xac\xec\x37\x06\xfd\x86\xc7\xa6\
\x78\xcc\xc3\x1d\x97\x24\x82\x7c\x2e\xc1\x12\xae\xd5\x67\x36\x80\
\x44\xa1\xae\xb3\xf5\x7a\xe2\xe1\x8f\x99\x0c\x6f\x01\x8a\x9c\xfc\
\x0e\x8c\xd0\xe9\xd6\xc6\x9e\xd5\x72\xa8\x06\x24\x09\x61\x99\x4c\
\x26\x44\x43\x30\x06\x2a\x10\x45\x9d\xc5\x02\x8e\xc5\xc0\xc4\xc4\
\x04\xf1\x0b\x23\x11\x6d\x6f\x6f\xef\xf1\xfe\x43\xd8\x41\xaf\xd7\
\xeb\x75\xbc\x0d\x66\x67\x67\x7f\x8d\x99\x80\x84\x81\xe7\xc2\xc2\
\x42\xe2\x33\xa5\xf3\xf6\xf7\xf7\x21\x12\xfe\xd6\xd6\x16\xb9\xdd\
\x6e\x27\x7f\xdb\x19\xcb\xf7\xd1\xa7\x29\x25\x25\xa5\x95\x81\xfa\
\x8a\x8a\x8a\x3e\xc9\xcd\xcd\x45\xb9\xc1\x08\x3c\x46\xfd\x4a\x34\
\x3b\x3b\x3b\xb4\xb0\xb0\x70\xc6\x89\x6d\x07\xa7\x61\x9f\xa6\x30\
\x0b\xe1\xcb\x63\xca\x4d\xf1\x9a\xdf\xbd\x7a\x8e\xa6\x9a\x29\x42\
\xab\x7b\xf9\xb9\xfa\x9b\x13\xe6\x62\xb5\x3f\xf9\x7e\xd8\xc7\xf4\
\x1f\x85\x93\x46\x73\x71\x93\x58\x29\x00\x00\x00\x00\x49\x45\x4e\
\x44\xae\x42\x60\x82\
\x00\x00\x07\x39\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x06\xcb\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x1a\x70\x07\x00\x04\x10\x0b\x32\x87\x91\x67\
\x22\x76\x55\x7f\xff\x43\xf0\x3f\x20\xfb\x1f\x90\xfe\xcf\x20\xc3\
\xc0\xf0\x3b\x1d\xc8\x0b\x02\xea\x62\x03\x0a\x6e\x67\x60\x60\x9d\
\x01\x64\x5f\x63\x60\x62\x64\x60\x00\x79\x8b\x05\x4a\x33\x83\x68\
\x46\x14\xe3\xfe\x7f\xc8\x83\xb3\x01\x02\x88\x85\x64\x27\xff\xff\
\xe7\x0c\xb4\x7c\xa2\xb3\xb3\xb2\x76\x6c\xac\x36\x03\x3b\x3b\x0b\
\xc3\xba\x75\x37\x73\x57\xaf\xbe\x16\x00\xb4\xad\x12\x68\xf3\x52\
\x52\x8c\x03\x08\x20\xd2\x1c\xf0\xf7\x4f\x14\x33\x0b\xe3\xf4\xda\
\x5a\x07\xbe\xb2\x52\x53\x06\x4e\x4e\x88\xf6\x90\x10\x55\x06\x27\
\x27\x79\xd9\xd2\xb2\x03\x0b\xbf\x7c\xfe\x29\xc5\xc0\xc4\xda\x4d\
\xac\x91\x00\x01\x44\x7c\x1a\xf8\xf3\x37\x86\x83\x83\x71\xee\xb4\
\xe9\xee\x7c\xf5\x75\x96\x60\xcb\x6f\xbc\xfe\xcb\x70\xf6\xe9\x1f\
\x06\x16\xe6\xbf\x0c\x19\x19\xfa\x0c\xab\x56\xf9\x32\x8b\x8a\x71\
\x75\x31\xfc\xf9\x53\x49\xac\xb1\x00\x01\x44\x9c\x03\x7e\xff\x75\
\x63\xf8\xff\x7f\x56\xef\x04\x37\x8e\xb4\x14\x5d\x50\x42\x60\xd8\
\x7f\xff\x1f\x43\xeb\x51\x66\x86\xb6\xe3\x2c\x0c\x2b\x2f\xfd\x67\
\xf8\xfb\xe3\x3b\x83\xa7\x87\x12\xc3\xbc\xf9\x5e\x0c\x7c\xfc\x6c\
\x2d\x0c\x3f\xfe\x24\x31\x30\x32\x12\x34\x1a\x20\x80\x50\x1d\xf0\
\x1f\x09\x23\x12\xa0\x0a\x90\x98\xd1\xda\x6e\xc7\x99\x95\xae\x07\
\x96\xdc\x71\x87\x91\x61\xd2\x19\x26\x86\xaf\xbf\x81\x4e\xf9\xf3\
\x87\x61\xce\xd9\x7f\x40\xfc\x87\xe1\xdb\x97\xaf\x0c\x3e\x5e\x8a\
\x0c\xd3\x67\xb8\x32\x71\x72\x32\xf5\x31\xfc\xfe\xe7\x40\xc8\x01\
\x00\x01\x84\xea\x00\x0e\x46\x08\x66\x67\x84\xa4\x62\x66\x46\x6e\
\x86\x1f\x3f\x66\xc7\xc4\xe9\x29\x56\x94\x99\x81\x7d\x7e\xe4\xd1\
\x3f\x86\x99\xe7\x19\xc1\x89\x9b\x85\xe1\x2f\x03\x23\xd0\x01\x6c\
\xff\x7f\x33\x2c\x39\xfb\x9b\x61\xf5\x85\x5f\x0c\x7f\xbe\x7e\x61\
\x88\x8a\x50\x67\x28\x2a\x33\xe3\x67\xf8\xf5\x6b\x0e\x50\x93\x34\
\x3e\x07\x00\x04\x10\xaa\x03\x58\x18\x11\x98\x99\x81\x91\xe1\xcb\
\xaf\x76\x03\x63\x29\x87\xde\x4e\x7b\x06\x26\x60\x56\xba\xf1\xe6\
\x3f\xc3\xec\xf3\x4c\x0c\xa0\x80\x65\xfe\xf7\x97\xe1\xf7\xcf\xdf\
\x0c\xbf\x7f\xfd\x02\x86\xc2\x6f\x06\x16\xa0\x23\xe6\x1c\xfb\xca\
\xb0\xed\xea\x0f\x86\x5f\x5f\xbf\x31\x54\x94\x1a\x31\x78\xfb\xab\
\x2a\x33\x7c\xfe\x35\x0d\xa8\x81\x03\xac\x09\x86\x91\x00\x40\x00\
\x61\x8f\x02\x10\xf8\xfe\x37\x8a\x5f\x88\x23\x7b\xda\x74\x37\x06\
\x31\x51\x4e\x86\x37\x5f\xff\x30\x4c\x3d\xcb\xc4\xf0\xe1\x27\x23\
\x03\x2b\xd0\xe7\x3f\x7f\x81\x2c\x87\xe0\x3f\x40\x0c\xcc\x21\x0c\
\x3f\x80\x0e\xea\xd9\xfd\x81\xe1\xcc\xbd\x6f\x0c\x5c\x2c\xff\x18\
\x26\xf4\xdb\x33\x28\x6a\x08\xf9\x31\x7c\xfb\x5d\xc2\xc0\x8a\xe4\
\x39\x24\x00\x10\x40\xa8\x0e\x80\xb9\xf0\xff\x7f\x25\x86\x7f\xff\
\xda\xda\x3b\xec\x98\x2c\x4d\x25\x18\x7e\xff\xfe\xc3\x30\xe3\x1c\
\x33\xc3\xfd\xf7\x8c\xc0\xd8\xf9\xcb\xf0\x0b\x68\xd1\x5f\xa8\xc5\
\x7f\x60\x0e\x01\x8a\xb1\xfe\xff\xc3\xf0\xe6\xe3\x4f\x86\xb6\x2d\
\x6f\x18\xee\x3c\xf9\xca\xa0\x28\xcd\xc1\x30\x79\xa2\x3d\x03\x1b\
\x37\x6b\x05\x30\x3d\x58\x63\x0b\x01\x80\x00\x42\x75\x00\x28\x62\
\x19\x81\x25\xdb\xc7\x5f\x13\xa2\x63\xb5\xe5\x32\x93\x81\x89\xee\
\xff\x5f\x86\x15\xd7\x18\x19\xf6\x3d\x00\xca\xfd\xfd\xcb\xf0\xe9\
\xeb\x4f\xa0\x03\x80\x71\xfd\x1b\xe6\x80\x3f\x60\x0c\x8a\x8a\x8f\
\x5f\x7e\x02\x1d\xf6\x87\xe1\xd8\xcd\xcf\x0c\x5d\x5b\x5f\x31\x3c\
\x7f\xf1\x85\xc1\xc3\x51\x8a\xa1\xa4\xc0\x90\x1b\x98\x62\x27\x03\
\x4b\x44\x41\x06\x36\x54\x17\x00\x04\x10\x66\x36\x04\x66\x1f\x29\
\x65\x01\xdf\xfa\x4a\x0b\x70\x7c\xbc\xfe\xfc\x9f\xe1\xf1\x27\x46\
\x06\x4b\xc9\x3f\x0c\x06\xa2\xbf\x19\xf4\x45\xfe\x32\xb0\x31\xfc\
\x61\xf8\x09\x0a\x05\x90\x23\x80\xf8\x17\x28\x0a\x80\x89\x51\x5f\
\x8a\x99\xc1\x4c\x9e\x95\xc1\x59\x83\x83\xe1\xcd\x87\x9f\x0c\x37\
\x9e\x7e\x63\x78\xfb\xe6\x0b\x43\x66\xb2\x16\x83\xa1\x95\xa4\x21\
\xd0\x11\x35\xe8\xd6\x01\x04\x10\x23\x72\x7b\x80\x51\x66\x8a\x36\
\xe3\xd7\xdf\xbb\x17\xce\xf6\x92\x8c\x0d\x51\x07\x1a\x0e\xf4\x19\
\xb0\x0e\x60\x04\x3a\x84\x11\x18\x12\xff\x81\xf5\xc0\x1f\x20\xbf\
\x64\xf3\x57\x86\x0b\x8f\x7f\x02\x13\xde\x1f\x70\x28\x7c\xff\xfe\
\x9b\x81\x87\xf5\x2f\xc3\xcc\x58\x31\x06\x49\x7e\x66\x60\x5a\xf8\
\xc7\xf0\x07\x68\xee\xaf\xdf\x40\x3d\x7f\xff\x31\x08\x09\x72\x30\
\x5c\x06\x86\x8a\x77\xf8\xb6\x1f\xdf\xff\xff\xf7\xfe\xff\x3c\x77\
\x1f\xcc\x4e\x80\x00\x42\x0d\x81\xef\x7f\xaa\xfc\x83\xd5\xc1\x96\
\xff\x05\x6a\x04\x39\x8d\x19\x18\x2d\xe0\xf2\x84\x89\x19\x14\x3d\
\x0c\x7f\xfe\x01\x0d\xff\xf3\x17\x98\xe6\xfe\x80\x1d\x08\xc1\xbf\
\x21\xf4\x9f\x7f\x40\xf5\x4c\x0c\x5c\xbc\x1c\x0c\xdc\x3c\x1c\x0c\
\x02\x7c\x9c\x0c\xfc\x02\x5c\x40\x4f\x30\x32\xd8\x5b\x4a\x30\xa4\
\xa5\xe8\x70\x30\xfc\xfa\x87\x12\x0a\x00\x01\x84\x5a\x17\x70\xb1\
\x70\x5c\xba\xfd\xee\xbf\xb9\xff\xea\xff\xbf\x7e\xfd\x85\x25\xcc\
\x7f\xdf\xbf\xfe\x61\xd2\xd5\x14\x61\x5a\xd8\xeb\x00\x16\x00\xc5\
\x33\x28\xd1\xfd\x87\x86\x00\x18\x03\x7d\xfc\x0f\x88\x39\x38\xd8\
\x18\xaa\xfa\xce\x33\x6c\xd9\xf3\xf0\x1f\x17\x37\xeb\x3f\x98\x27\
\x81\xee\x62\xf8\xf6\xe3\x0f\x13\x23\x2f\x0b\x8a\x9d\x00\x01\x84\
\xea\x00\x56\xa6\xdc\x7b\xf7\x3e\xac\xb8\xf7\xeb\xef\x3f\xa4\x0c\
\xf9\x97\xe1\xdb\x1f\x27\x4e\x46\xc6\xbc\x3f\xff\x21\xf9\xf4\xcf\
\x1f\x88\xc5\x0c\x20\x07\x00\x1d\x02\xc2\x7f\x81\x72\xa0\x28\x02\
\xc9\xdf\x79\xf0\x91\xe1\xf6\xb9\x97\xcb\x18\xb8\x59\x57\xa3\xd8\
\xc1\xcc\xc4\xca\xc0\xc1\x7c\x0e\xd9\x4a\x80\x00\x42\xaf\x0d\x9f\
\x01\x73\xc2\x6a\x06\x36\x66\x44\xb9\xc0\xca\x04\xca\xbb\x1c\xac\
\xdc\xcc\x79\x20\x81\x7f\x40\xb7\x81\x82\xfc\x2f\xd4\x01\xbf\x81\
\x6c\x30\x66\xfc\x0f\x8e\x36\x50\x28\xb0\x70\x00\xf5\xf3\xb0\x9e\
\x67\xe0\x60\xd9\x04\x0c\x1a\x44\xd6\xc3\x52\x37\x00\x04\x10\xee\
\xea\x18\x66\x39\xa8\x58\xfe\x0d\x2c\xc9\xa0\xe0\x1f\x28\x21\x82\
\x12\x27\xd0\x01\xff\x90\xa3\x00\x24\x07\x4a\x37\xff\xa1\x16\x32\
\x31\xb0\x83\x0b\x1f\x70\x4d\xfa\x1f\x23\xff\xc3\x00\x40\x00\xb1\
\xe0\xb4\x1c\x94\x5f\x39\x99\x20\x6c\x66\x46\x08\x06\x85\x00\x30\
\x11\xfe\xfd\x0d\x4d\x03\x0c\x7f\x10\x65\x01\x54\x0e\x14\x0d\xff\
\x19\x19\x11\x7a\x40\x25\x1f\x30\x57\x30\xfc\xc2\xee\x08\x80\x00\
\xc2\x74\x00\x28\xf6\xd9\x81\x16\x73\x33\x21\x52\x01\x33\x14\x43\
\xe3\xf9\xf3\x97\x5f\x0c\xef\x3f\xfd\x00\x96\x7c\x7f\xc1\x05\xd0\
\xb7\x6f\xc0\x02\x08\x58\x89\xfd\x85\x25\x1d\x26\x24\x3d\xe0\xc4\
\xcd\x04\x11\xff\x8d\xd9\x05\x00\x08\x20\x16\x0c\xcb\x41\x3e\xe7\
\x66\x46\x2b\x2d\x20\x65\x28\x28\xf8\x41\x96\xb8\x68\x71\x33\xa8\
\x88\x30\x31\x30\xff\xff\x07\x4e\x90\xa0\x82\x88\x1d\xe8\x5b\x76\
\x60\x90\xff\x02\x66\x45\x48\x91\xcb\x88\x88\x73\x10\xc5\x0d\x24\
\xbe\xfd\x83\xd8\x81\x04\x00\x02\x08\xd5\x01\x20\xcb\x79\xb0\xb4\
\x51\x80\xee\x61\x06\x1a\xce\xc9\xc6\xc2\xc0\x08\x6c\x09\x65\x79\
\x88\x83\x0b\xa7\xbf\xa0\xe0\x06\x06\x3b\xd8\x61\x40\x83\xbf\xff\
\xf8\xcd\xc0\x06\x4c\x37\xac\x6c\x4c\x90\xb4\x8f\x1e\xbe\xbc\xa0\
\xbc\x88\x1a\x0a\x00\x01\x84\xaa\x84\x8f\x19\x7b\x4a\x61\x65\x62\
\xfa\x04\x8c\xf3\x23\x57\xde\x00\x33\x08\x30\x0d\x80\x7c\x09\x72\
\xc2\x7f\x50\xa2\x63\x80\x60\x06\x08\x83\xe3\xfd\x1f\x86\x57\x1f\
\x7e\x00\x2d\x67\x66\x45\x6f\x0d\x83\x01\x0f\xaa\x18\x40\x00\x11\
\xd7\x28\xe5\x64\x39\x7f\xf3\xf9\x97\xbb\xa1\xf9\xbb\x44\x81\xa1\
\xfa\x1b\x9e\x36\x18\x91\x12\x2d\x2c\xaa\xfe\xff\x67\xfe\xfc\xfb\
\xdf\x0f\x06\x6e\x96\x53\xc4\x18\x0d\x10\x40\x8c\x03\xdd\x37\x04\
\x08\xa0\x01\xef\x19\x01\x04\xd0\x80\x3b\x00\x20\x80\x06\xdc\x01\
\x00\x01\x06\x00\xd1\x67\xef\xf0\x4b\xda\xdd\x32\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x09\x2e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x08\xab\x49\x44\
\x41\x54\x58\x85\x9d\x96\x7f\x50\x93\xf7\x1d\xc7\xdf\xdf\x3c\x4f\
\x1e\x12\xe0\x49\x48\x94\x90\x88\x41\x08\x04\x70\x80\x08\x45\xa6\
\xb4\xa0\x52\x7b\xae\x3a\x9d\xba\xea\xec\xd4\x93\x43\xab\x67\x67\
\xdd\xe9\x79\xb5\xf6\xd4\xbb\xc2\xd9\x96\x9e\xd6\xcd\x9e\xd5\xae\
\x76\x70\x95\xc1\xb9\xd3\x93\xde\xa0\xca\xbc\x95\xcd\x75\xd6\x41\
\xaa\xa2\x41\x6a\x02\x92\x75\x44\x12\x13\x92\x10\x7e\xc4\xe4\x79\
\xf2\x3c\xfb\xc7\x78\xc8\x8f\x41\xfb\xbd\xfb\xde\xe5\xc7\xe7\xfb\
\xbc\x5e\xdf\xcf\xe7\xfb\xc9\x37\x10\x45\x11\xa2\x28\x02\x80\x34\
\x23\x23\x83\x8d\xbc\xff\xb1\x13\x80\x14\x00\x35\x6f\xde\x3c\x0d\
\x00\x7a\xaa\x78\x22\x8a\x22\xb4\x5a\x6d\x4c\x73\x73\xb3\x89\xa2\
\xa8\x99\xf5\xf5\xf5\x05\x47\x8f\x1e\xfd\x0f\x7e\xc4\xd8\xb4\x69\
\x93\xca\x68\x34\x1e\xd7\xeb\xf5\x6b\x04\x41\x88\x1e\x1c\x1c\xb4\
\x9b\x4c\xa6\x43\x75\x75\x75\xf5\x93\xad\x21\x00\xa8\xf6\xf6\xf6\
\x8e\x39\x73\xe6\x64\x00\xc0\xe0\xe0\x60\xb8\xb1\xb1\x71\xd7\xae\
\x5d\xbb\xaa\x45\x51\xe4\xa7\x0b\xdf\xb6\x6d\x5b\x5e\x69\x69\x69\
\xa3\x4a\xa5\x9a\xc5\x71\x1c\x78\x9e\x07\xc7\x71\x70\xbb\xdd\xdf\
\x9d\x39\x73\xe6\x79\xb3\xd9\xec\x99\x68\x1d\x9d\x95\x95\xa5\xa4\
\x69\x5a\x15\xf9\x80\x65\x59\x6a\xf9\xf2\xe5\x7f\xf8\xe4\x93\x4f\
\xb2\x01\xfc\x76\x3a\xf0\x13\x27\x4e\x2c\xd8\xb8\x71\xe3\xd5\xe8\
\xe8\x68\x25\xc7\x71\x88\x08\x38\x1c\x0e\x7b\x67\x67\xe7\x8b\x1d\
\x1d\x1d\xde\xc9\xd6\x4a\xcc\x66\xb3\xe7\xf8\xf1\xe3\x2b\x86\x86\
\x86\x78\x00\x18\x18\x18\xc0\xc0\xc0\x00\x52\x52\x52\xde\xd8\xb1\
\x63\x47\xc1\x54\x70\xa3\xd1\xa8\x30\x18\x0c\xf5\x6a\xb5\x5a\xc9\
\x30\x0c\xe4\x72\x39\x62\x62\x62\x30\x32\x32\xd2\xdb\xd2\xd2\x52\
\x7a\xea\xd4\xa9\x87\xe2\x93\xc3\x31\xa1\x00\x00\x7c\xf6\xd9\x67\
\xdf\xd6\xd7\xd7\x1f\xf4\x78\x3c\xf0\x78\x3c\xe8\xef\xef\x87\xd7\
\xeb\x25\x0b\x17\x2e\xfc\xaa\xac\xac\x6c\xd1\x64\x8b\x09\x21\x64\
\xcf\x9e\x3d\x9b\x0c\x06\x43\x2a\x4d\xd3\x88\x4c\x9f\xcf\xf7\xdf\
\xb6\xb6\xb6\x82\xcf\x3f\xff\xdc\x32\xd5\x06\x24\x91\x17\xfb\xf7\
\xef\x3f\xd6\xd4\xd4\x74\xd6\xed\x76\x8b\x1e\x8f\x07\x6a\xb5\x1a\
\x3a\x9d\x8e\x2d\x2e\x2e\x6e\xde\xb3\x67\xcf\xbc\x89\x16\xa7\xa5\
\xa5\x31\xb3\x67\xcf\x5e\x3b\x1a\xde\xdf\xdf\xff\xb0\xb1\xb1\xb1\
\xf4\xfd\xf7\xdf\x77\x4e\x06\xcd\xcd\xcd\xd5\x8c\x13\x00\x80\xdd\
\xbb\x77\xbf\x76\xfa\xf4\xe9\x15\x84\x10\xb7\x46\xa3\x81\x46\xa3\
\x41\x7c\x7c\x3c\x9b\x9b\x9b\xfb\xaf\x49\x32\x11\xa5\x50\x28\x12\
\xc7\xec\xde\x7c\xf9\xf2\xe5\xde\xc9\xe0\x85\x85\x85\xfa\xb7\xde\
\x7a\xab\x7e\xdf\xbe\x7d\x3f\x1f\x27\x00\x00\x17\x2f\x5e\xbc\x52\
\x5b\x5b\xfb\x6b\xab\xd5\xfa\x48\x2a\x95\x42\xaf\xd7\x63\xd6\xac\
\x59\xb1\xc5\xc5\xc5\xcd\xaf\xbf\xfe\xfa\xfc\xd1\xb1\x14\x45\x89\
\xb1\xb1\xb1\x33\x22\x70\xa9\x54\x8a\xc4\xc4\xc4\xbc\xb8\xb8\x38\
\xd9\x44\xf0\xa5\x4b\x97\x26\x1f\x38\x70\xa0\xc1\x60\x30\x94\x16\
\x15\x15\xfd\xce\x68\x34\x2a\xc6\x09\x00\x40\x43\x43\xc3\xd5\xda\
\xda\xda\x57\xac\x56\xab\x8b\xa2\x28\xe8\x74\x3a\x68\x34\x1a\x36\
\x3f\x3f\xff\xda\xce\x9d\x3b\x0b\x23\x71\x1c\xc7\x49\xe4\x72\xb9\
\x2c\x02\xa7\x69\x1a\x5a\xad\x36\x7e\xf1\xe2\xc5\x99\x63\x9f\x59\
\x52\x52\xa2\xdb\xbb\x77\xef\x05\x83\xc1\x90\x4f\xd3\x34\xd4\x6a\
\xb5\x56\x22\x91\x30\x13\x0a\x00\xc0\xa5\x4b\x97\xfe\x59\x53\x53\
\xb3\xc5\x62\xb1\xb8\x24\x12\x09\x74\x3a\x1d\x74\x3a\x1d\xbb\x60\
\xc1\x82\xbf\x6d\xdf\xbe\x7d\x01\x00\xcc\x98\x31\x43\xce\xb2\xac\
\x2c\x02\x8f\x88\x2c\x59\xb2\x64\xef\xd6\xad\x5b\x73\x08\x21\x14\
\x21\x84\xbc\xf4\xd2\x4b\x49\x6f\xbf\xfd\xf6\x17\xa9\xa9\xa9\xcf\
\x45\xe2\x44\x51\x0c\x08\x82\x30\x48\xfe\x4f\x87\x00\x00\xd6\xac\
\x59\x53\xb2\x65\xcb\x96\x3f\x1b\x8d\xc6\x04\x00\xe8\xed\xed\x85\
\xdd\x6e\x1f\x34\x99\x4c\xc5\xc5\xc5\xc5\xf9\x2b\x56\xac\xf8\xa3\
\x20\x08\x18\x3b\x39\x8e\x13\x1c\x0e\xc7\x43\xbb\xdd\x7e\x53\xa9\
\x54\xa6\x24\x27\x27\xe7\x8c\xfe\xbe\xad\xad\xed\xe3\xa3\x47\x8f\
\xee\x9b\x52\x00\x00\x56\xad\x5a\xb5\x6c\xeb\xd6\xad\x75\xe9\xe9\
\xe9\xf1\xc1\x60\x10\x0e\x87\x03\x7d\x7d\x7d\x23\x49\x49\x49\x43\
\x1c\xc7\x69\x16\x2d\x5a\x04\xbb\xdd\x0e\x96\x65\x11\x1b\x1b\xfb\
\x14\x22\x8a\xe2\x38\x31\x41\x10\xe0\x72\xb9\xfa\xdf\x79\xe7\x9d\
\x82\xe6\xe6\x66\xdb\xb4\x04\x00\x60\xe5\xca\x95\xa5\xe5\xe5\xe5\
\x75\x46\xa3\x31\x41\x10\x04\x38\x1c\x0e\xf4\xf6\xf6\x82\xe3\x38\
\xb4\xb6\xb6\xc2\x66\xb3\x81\xe7\x79\x9c\x3c\x79\x12\x49\x49\x49\
\x13\x82\x05\x41\xc0\xd0\xd0\x50\xa0\xba\xba\x7a\xfd\xb1\x63\xc7\
\x9a\x80\x09\xba\x60\xb2\xd1\xd4\xd4\xf4\x55\x4d\x4d\xcd\x86\xfb\
\xf7\xef\xfb\x24\x12\x49\xa4\x45\x61\xfa\xe6\x1a\xf2\x5c\x4d\x58\
\x0d\x2b\xe4\x81\x00\xce\x9d\x3b\x07\x9e\xe7\x31\xba\x35\x23\xd3\
\xe9\x74\xda\xaf\x5e\xbd\x5a\x16\x81\x03\x00\x3d\x5d\x01\x00\xc8\
\xc9\xc9\x91\x07\x02\x01\x99\xd5\x6a\x85\xd1\x68\xc4\xed\xdb\xb7\
\xd1\xd3\x7a\x05\x9f\xbe\x4a\x70\xcf\x1e\xc6\xc3\xae\x61\x58\x1f\
\x3c\xc0\xd9\xb3\x67\xb9\xc2\xc2\xc2\xc1\x99\x33\x67\x7a\x87\x87\
\x87\x5d\x7e\xbf\xbf\x77\x70\x70\xf0\x72\x65\x65\xe5\x97\x66\xb3\
\xd9\x31\xfa\x99\xd3\x2e\xc1\xe1\xc3\x87\xd7\x96\x96\x96\xd6\xfa\
\xfd\xfe\x68\xbf\xdf\x8f\xbb\x77\xef\xa2\xba\xba\x1a\x00\x50\x9e\
\xcd\xa1\x50\x47\x70\xd6\x32\x03\xac\x21\x1f\x1e\x8f\x07\x1d\x1d\
\x1d\xfd\x2c\xcb\xae\x0b\x04\x02\x6d\x32\x99\x4c\xe8\xea\xea\x0a\
\x4d\x74\x27\x4c\x4b\xe0\xd0\xa1\x43\xaf\x95\x94\x94\x9c\x0a\x87\
\xc3\xd2\xe8\xe8\x68\xd4\xd5\xd5\xc1\xeb\xf5\xa2\xbb\xbb\x1b\xdf\
\x7f\xff\xfd\x33\xb1\xeb\x32\xe5\x98\x4d\x11\x7c\xed\x8d\x43\xbb\
\xd3\xe9\x8e\x89\x89\x59\xd5\xdd\xdd\x7d\x63\xb2\x67\x4f\x59\x82\
\x8a\x8a\x8a\xdf\x14\x15\x15\xfd\x9e\xa6\x69\x8a\x65\x59\xd8\x6c\
\x36\xb4\xb4\xb4\x20\x3e\x3e\x1e\xa9\xa9\xa9\x00\xf0\x8c\xc4\x1b\
\xf3\xfd\x40\x90\x82\xde\x16\x02\x90\x30\xb3\xdd\xe9\x6c\x34\x1a\
\x8d\x2f\x5b\xad\xd6\xb6\x1f\x24\x40\x08\xa1\x0e\x1f\x3e\x7c\xa4\
\xa0\xa0\xe0\x50\x5c\x5c\x9c\x84\x61\x18\x08\x82\x00\xbd\x5e\x0f\
\x95\x4a\x05\x97\xcb\x05\x00\xe3\x24\xbe\xb0\x00\x07\x8b\x44\x00\
\x21\x00\x8f\x00\x24\xcc\x68\x77\x3a\x9b\xd2\xd2\xd2\x56\x75\x75\
\x75\xfd\x7b\x1c\x67\xa2\x12\xa4\xa4\xa4\xc8\xca\xca\xca\x2a\xb2\
\xb3\xb3\xf7\xcf\x99\x33\x87\x44\xe0\x82\x20\x80\xe7\x79\x38\x9d\
\x4e\x9c\x3f\x7f\x1e\x9d\x9d\x9d\x90\xc9\x64\x48\x4c\x4c\x7c\x5a\
\x0e\x02\x60\x5f\x01\x8f\x37\x17\x12\xdc\xb3\x13\x98\x6c\x0c\xea\
\x9d\x1a\xdc\x79\xf4\xc8\xab\x50\x28\x56\xde\xbf\x7f\xff\x9b\xd1\
\xac\x71\x6d\xa8\xd5\x6a\x63\x36\x6f\xde\xfc\x51\x66\x66\xe6\x7e\
\xbd\x5e\x4f\xa2\xa2\xa2\x40\x08\x01\x45\x51\xa0\x28\x0a\x52\xa9\
\x14\x2a\x95\x0a\x1b\x36\x6c\x08\x33\x0c\xf3\xa5\xcb\xe5\x82\xdd\
\x6e\x47\x6a\x6a\x2a\x92\x92\x92\x20\x02\xf8\xd0\x44\xe3\x83\x1b\
\x22\x7e\x92\x28\xa2\x20\x39\x84\x57\x13\x1e\x61\x9e\x46\xa3\x1a\
\x18\x18\xf8\xcb\xdc\xb9\x73\x0b\x47\xf3\x9e\x29\x41\x76\x76\xb6\
\x7a\xc7\x8e\x1d\x1f\x1b\x0c\x86\x5f\xa9\xd5\x6a\x84\x42\x21\x10\
\x42\x10\x91\x90\x48\x24\x08\x85\x42\x70\xbb\xdd\xc2\xf5\xeb\xd7\
\x2b\xfb\xfb\xfb\xcf\xf9\xfd\xfe\xe7\x00\x24\x8c\x2d\xc7\x87\x26\
\x1a\x00\x8f\x37\x17\x62\x6c\x39\x2e\xcf\x9d\x3b\xf7\x17\x9d\x9d\
\x9d\x5f\x3f\x53\x82\x9c\x9c\x9c\x84\xb5\x6b\xd7\xd6\x24\x26\x26\
\xfe\x4c\xa5\x52\x41\x2e\x97\x83\x61\x18\x44\x45\x45\x21\x2a\x2a\
\x0a\x0c\xc3\x00\x00\x7a\x7a\x7a\xc4\x9b\x37\x6f\x56\xbd\xfb\xee\
\xbb\x07\x09\x21\x92\xe4\xe4\xe4\xac\x40\x20\xf0\x57\x85\x42\xa1\
\x8d\x8f\x8f\x9f\x56\x39\xda\x9d\x4e\xaf\x5a\xad\x5e\x7e\xef\xde\
\xbd\x36\xfa\x09\x5c\xbf\x7e\xfd\xfa\x3a\x95\x4a\xf5\x02\x00\x04\
\x02\x81\xc8\x85\x02\x9e\xe7\xc1\xf3\x3c\x82\xc1\x20\xec\x76\x3b\
\xee\xdc\xb9\xf3\x69\x55\x55\xd5\x41\x00\x10\x45\x51\x20\x84\x98\
\x8d\x46\xe3\x2f\xfd\x7e\xff\x25\x00\x9a\xe9\x64\x82\x10\xad\xaa\
\xdd\xe9\xbc\x98\x91\x91\x91\x4f\x13\x42\xe8\x23\x47\x8e\x9c\x8b\
\x8d\x8d\x7d\x61\x78\x78\x18\xe1\x70\x18\xe1\x70\xf8\x29\x38\xf2\
\xf7\xda\xeb\xf5\xc2\x62\xb1\xfc\xa9\xaa\xaa\x6a\xe7\xe8\xb2\x89\
\xa2\x28\x12\x42\x6e\xe8\xf5\xfa\x97\xfd\x7e\x7f\x13\x00\xed\x54\
\x12\x66\x3e\x88\xa0\x2a\xb3\xaf\xa5\xa5\xc5\x4d\x67\x65\x65\x29\
\x94\x4a\x65\xbe\xd7\xeb\x8d\xd4\xf9\xae\x44\x22\x49\xe7\x79\x3e\
\x8a\xe7\x79\x84\x42\x21\x70\x1c\x07\x9b\xcd\xd6\x74\xe1\xc2\x85\
\x6d\xef\xbd\xf7\xde\xb8\xae\x79\x92\x89\x5b\x69\x69\x69\xab\x9f\
\x48\xc4\x4f\x24\xf1\x98\xe7\xa0\x57\x10\xfc\xdd\x8d\x07\x4c\x6c\
\x70\xdd\xd3\x33\x50\x51\x51\x71\x93\x65\xd9\x3c\x87\xc3\x01\x93\
\xc9\x94\xba\x6c\xd9\xb2\xb3\x00\x96\x32\x0c\x03\xa9\x54\x0a\xb7\
\xdb\xfd\x8f\xca\xca\xca\x17\x45\x51\x0c\x8f\xa3\x8f\x1a\x84\x10\
\x49\x7a\x7a\xfa\x4f\x7d\x3e\xdf\x25\xa5\x52\x99\x30\xf6\x4c\x00\
\x80\x54\x2a\xed\x1c\x19\x19\x79\xde\xe7\xf3\x79\x9f\x76\x81\xcd\
\x66\xdb\x3f\x7f\xfe\xfc\x46\xa5\x52\x29\x2f\x28\x28\xe8\x1e\x18\
\x18\x00\x4d\xd3\xa0\x28\x0a\x43\x43\x43\xdf\x36\x37\x37\xaf\x9e\
\x0a\x3e\x2a\x13\x37\x0c\x06\xc3\x0a\xbf\xdf\x7f\x65\x6c\x26\xfa\
\xfa\xfa\x2c\xa2\x28\x2e\x8e\xc0\x9f\x0a\xf4\xf4\xf4\x5c\x93\xcb\
\xe5\x6b\x32\x33\x33\x1b\x18\x86\x91\xfb\x7c\x3e\xb0\x2c\x0b\x9e\
\xe7\x3b\x1a\x1a\x1a\x96\xdd\xba\x75\xcb\x3f\x15\x7c\x94\x84\x48\
\x08\xb9\x9d\x9e\x9e\xfe\x8a\xcf\xe7\xbb\x10\x91\xd0\xeb\xf5\xdf\
\x05\x83\xc1\xa5\x66\xb3\xd9\xf5\x4c\xd6\x22\x6d\x48\x08\x91\x94\
\x97\x97\x97\x26\x27\x27\x7f\xa4\x54\x2a\x93\x7d\x3e\x9f\xa5\xb5\
\xb5\x75\x79\x63\x63\xa3\x63\x3c\x66\xea\x41\x08\x91\x18\x0c\x86\
\xdc\x91\x91\x91\x8b\x71\x71\x71\x9e\x70\x38\x5c\x6a\xb1\x58\xc6\
\x6d\xe4\x99\x9f\x62\x42\x08\x49\x4b\x4b\x63\x64\x32\x99\xe6\xf1\
\xe3\xc7\x8f\x26\xbb\x42\x7f\x80\x04\xc9\xcb\xcb\x9b\x19\x0e\x87\
\x47\xda\xdb\xdb\x87\x27\x8a\xf9\x1f\x27\xb8\x88\xcb\x85\x50\xc5\
\x5d\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x04\x42\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x03\xbf\x49\x44\
\x41\x54\x58\x85\xc5\x97\xcf\x4f\x22\x67\x18\xc7\xbf\xcc\x0f\x7e\
\x65\x58\x4a\x56\x60\x41\x70\x91\xd6\x6d\x4c\x34\x2a\x49\x25\xde\
\x09\x89\x37\x13\x23\xc9\x9e\xd6\x26\x5c\x76\xbd\x35\xfd\x13\x3c\
\xf6\xb4\x47\x9b\x18\xec\xc1\x34\xc1\x18\x2e\xbd\xd4\xcb\x96\x78\
\xa9\xf4\x60\x6b\xb2\x6e\x4d\x4a\x24\xc8\x10\xc8\xa4\x40\x18\xf0\
\x1d\x66\x06\x7a\xa8\x4e\x19\x14\xdd\x1d\xdc\xee\x37\x99\xc3\xbc\
\xcf\xf7\x7d\xde\xcf\xcc\x33\xef\x8f\x31\xf5\x7a\x3d\x7c\x4a\x31\
\xf7\x19\x8e\x8f\x8f\x73\x1e\x8f\xe7\x73\x23\xc9\xab\xd5\xea\x5f\
\xf3\xf3\xf3\x5f\x8d\x04\xe0\x74\x3a\xfd\x7e\xbf\xdf\x65\x04\x40\
\x92\x24\xff\x7d\x1e\xca\x48\xe2\x87\xd4\x50\x80\x44\x22\x41\x27\
\x93\xc9\x17\x92\x24\x71\x46\x93\x4b\x92\xc4\x25\x93\xc9\x17\x89\
\x44\x82\x1e\xe6\x19\x5a\x02\x97\xcb\xe5\x51\x55\xf5\x35\x21\xe4\
\x91\xaa\xaa\x86\x00\x08\x21\x8f\x00\xbc\x76\xb9\x5c\x3f\x03\x28\
\x7f\x10\xc0\xb5\x14\x45\x81\x2c\xcb\x86\x00\x14\x45\xb9\xd7\x73\
\x27\x80\xa2\x28\x23\x03\x28\x8a\x02\x9a\x1e\x5a\x81\xbb\x01\x3a\
\x9d\x0e\x64\x59\x36\x0c\x20\xcb\x32\x3a\x9d\x0e\x2c\x16\xcb\x68\
\x00\x9d\x4e\x67\x24\x80\xbb\xa4\x01\xa4\x52\xa9\xe7\x00\xbc\xd7\
\xf7\x81\x40\x60\xbc\x5a\xad\xd2\xa3\x96\x40\x55\x55\x3a\x10\x08\
\x7c\x93\x4a\xa5\x4a\x7d\xa1\xea\xfa\xfa\xfa\xae\x06\x90\x4e\xa7\
\x6d\x66\xb3\x79\xb7\xdb\xed\x6a\x0e\x9e\xe7\x41\x08\x91\x47\x2d\
\x41\xbb\xdd\x36\xf3\x3c\xff\xed\xe4\xe4\xa4\xd6\x4e\x51\x14\xd2\
\xe9\xf4\x4f\x6b\x6b\x6b\x0d\x06\x00\x38\x8e\x9b\x6c\xb5\x5a\xe8\
\x9f\x6e\x34\x4d\x83\xe7\x79\xe6\xf0\xf0\x10\xf9\x7c\xde\x10\x00\
\xcf\xf3\x28\x97\xcb\xcc\xd4\xd4\x14\x58\x96\xd5\xe5\x76\x38\x1c\
\x21\x00\xbf\x33\x00\xe0\x70\x38\xc2\x92\x24\x81\xa2\x28\x9d\x89\
\x65\x59\xd3\xc1\xc1\x81\xa1\xc1\xaf\x65\x36\x9b\x4d\x57\xb9\xb4\
\x36\x8a\xa2\xc0\x71\xdc\x53\x0d\xc0\x6e\xb7\x3f\xa3\x69\x5a\x37\
\x5d\xee\x9a\x3a\x1f\xaa\x41\x00\x00\xb0\xd9\x6c\x5f\x00\x57\xdf\
\x80\xd3\xe9\x7c\x1a\x0a\x85\x74\x06\xbb\xdd\x8e\x8d\x8d\x8d\x07\
\x01\x38\x3f\x3f\xc7\xc2\xc2\x82\xae\xad\x5e\xaf\x87\x34\x00\x51\
\x14\xdd\x26\x93\xe9\x46\xa7\x6c\x36\xfb\x20\x00\x13\x13\x13\xe8\
\xff\x08\x01\xa0\xd9\x6c\x7a\x34\x00\x42\xc8\x63\x8e\xbb\xb9\xe7\
\x9c\x9c\x9c\x3c\x18\xc0\xe0\xc1\x87\x10\xf2\x58\x03\xc8\xe5\x72\
\x5f\x0a\x82\xa0\x33\x88\xa2\x78\xa3\x93\x51\x9d\x9e\x9e\xa2\x58\
\x2c\xea\xda\xdc\x6e\xf7\xb3\x68\x34\xfa\x2f\xc0\xf4\xf4\xb4\x3c\
\xf8\x8a\x3e\xb6\x0a\x85\x82\x0c\xfc\x57\x02\xdb\xff\x71\x36\x6c\
\xb7\xdb\x68\x36\x9b\xf0\x7a\xbd\x20\x84\xd8\x80\xab\x03\x49\xb7\
\xdb\x6d\x7f\xf4\xd1\x01\xb0\x2c\x0b\xab\xd5\x8a\xfe\x31\x19\x00\
\xf0\x78\x3c\xf5\x5a\xad\xa6\x33\xb7\x5a\xad\x5e\x26\x93\x31\xb9\
\xdd\x6e\xd8\xed\x76\x43\x03\xd6\xeb\x75\x10\x42\xb0\xb2\xb2\xd2\
\x63\x18\xc6\x74\xbd\xd4\xd7\x6a\x35\x8c\x8d\x8d\x35\x34\x80\x4a\
\xa5\x52\x1b\xdc\x32\x37\x37\x37\x1b\x56\xab\xe5\xb3\x37\x6f\x7e\
\x81\xcf\xe7\x33\x04\x20\x08\x02\x16\x17\x17\x61\xb5\x5a\xab\x4b\
\x4b\x4b\xde\xfe\x98\x24\x49\x7f\x6b\x00\xc5\x62\x51\xb0\xd9\x6c\
\xba\xce\x7e\xbf\x8f\x79\xf2\xc4\x8b\x77\xef\xfe\xc4\xea\xea\xaa\
\x21\x80\xbd\xbd\x3d\xc4\xe3\x31\xd4\xeb\x0d\xba\x54\x2a\xe9\x62\
\x97\x97\x97\x82\x06\x50\x2e\x97\xab\x83\x4b\x6f\x3c\x1e\x37\x67\
\x32\x19\xc4\x62\x31\xc4\xe3\x71\x43\x00\x8d\x46\x03\xc5\xe2\x05\
\x22\x91\x88\xa5\x50\x28\xe8\x62\xaa\xaa\x56\x34\x00\x9e\xe7\xbf\
\x67\x18\xe6\xd7\x7e\x43\x2c\x16\xfb\xe1\xe2\xa2\x84\x97\x2f\x5f\
\x21\x1a\x8d\x1a\x02\xe8\xf5\x7a\xd8\xd9\xd9\xc1\xf8\xf8\x78\x27\
\x97\xfb\xed\x79\x7f\x4c\x51\x94\x3f\x34\x80\xed\xed\xed\xb7\x00\
\xde\xf6\x1b\xb2\xd9\xec\xee\xcc\xcc\x0c\xc2\xe1\x30\x18\xe6\xde\
\xb3\xeb\xad\x0a\x87\xc3\xf0\xf9\x7c\x10\xc5\x16\xbb\xb5\xb5\xf5\
\xe3\x6d\x9e\xa1\x99\x45\x51\xc4\xf2\xf2\x32\x82\xc1\x20\x06\xf7\
\x89\xf7\x55\x30\x18\xc4\xec\xec\x2c\x06\x57\xd9\x7e\x0d\xfd\x31\
\xd9\xdf\xdf\xef\x9e\x9d\x9d\x75\x59\x96\x05\xc3\x30\x86\x2e\x96\
\x65\x91\xcf\xe7\x7b\x47\x47\x47\x43\xcf\xe7\x43\xdf\x00\x45\x51\
\xd3\x73\x73\x73\xaf\x2a\x95\xca\xd7\xef\xfd\xc8\xb7\x28\x12\x89\
\xec\x08\x82\xf0\xdd\xb0\xb8\xe9\x53\xff\x9e\xff\x03\xea\x33\x99\
\x79\xb2\xbf\xb1\x29\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x04\xbb\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x82\x49\x44\x41\x54\x78\x5e\x95\x54\x5d\x68\x54\x47\
\x18\x3d\x73\xef\x64\xff\xf3\x5b\x4d\xba\x69\xe2\x86\x6a\x52\xba\
\xda\xb0\x94\xb0\x58\x35\x21\x60\x50\x20\x0a\x6a\xc9\x53\xe8\x53\
\x81\xd6\x97\x58\x28\x02\x05\x03\xd2\x97\xbe\xd9\x00\x2d\x22\x16\
\xc1\x50\x28\x56\x51\xa8\x88\x5a\x05\xb5\xd0\xa8\x11\xc4\xaa\x52\
\x89\xec\xa6\x36\x92\xe8\x6e\x8c\xc9\x26\xee\xde\xbd\xb9\x77\x6f\
\xcf\x0c\x4b\x34\x52\x4a\xf3\xc1\xe1\x63\x98\xef\x9e\xef\xcc\x99\
\xf9\xae\xf4\x3c\x0f\x2b\x8d\x1f\x92\xc9\xcf\x6b\x9a\x9b\xbf\x08\
\xad\x5a\xd5\xe4\x01\x32\x9f\xcb\x65\x27\xd2\xe9\x8b\x37\x46\x47\
\x3f\xfb\xd9\xf3\x5c\x30\x24\x56\x10\x5f\x0b\x61\xb6\x6e\xdf\x7e\
\x6d\xd3\xc0\xc0\xe6\xd8\xd6\xad\x78\x2d\x9a\xa6\xef\xdd\xfb\xb4\
\xee\xc8\x91\x9d\x5f\x25\x12\xdb\xbe\xb9\x73\xe7\x8f\x15\x11\x37\
\x25\x93\x3f\xb6\xf7\xf7\x6f\x7e\xa7\xbb\x1b\x2f\xe7\xe6\xb0\x98\
\xcd\x42\x85\xa8\xac\x44\xa4\xad\x0d\x5d\x03\x03\xf5\xb3\x83\x83\
\xe7\x3b\x85\x68\xfa\xdf\xc4\xdf\xc7\xe3\x89\xb0\xcf\xd7\x17\x69\
\x69\x41\x75\x53\x13\x94\x85\xa9\xa7\x4f\x61\xe7\x72\x58\xd7\xd1\
\x01\x5f\x30\x88\xfc\xfc\x3c\x1a\x4d\x33\xda\x95\x4c\x7e\x27\x85\
\x10\x06\x80\xd5\x84\xc0\x7f\xc4\xb7\x89\xc4\x97\x56\x2a\x65\x66\
\xee\xde\x45\x7d\x22\x81\x20\x55\xbe\xdb\xd9\x09\xdb\xb2\x34\x69\
\xa9\x54\xc2\xe4\x83\x07\xb0\xa7\xa6\x10\x08\x85\xb6\xc9\x78\x3c\
\x7e\xaf\xa7\xa7\xa7\x4d\x4a\xe9\x39\x8e\xe3\xd9\xb6\x0d\x42\xd8\
\xc5\xa2\x51\x2c\x16\x61\x15\x0a\xb0\x98\xa9\xc6\x30\xa9\x28\x75\
\xec\x18\x66\xa8\xb4\x6b\xff\x7e\x04\xab\xaa\x10\x08\x87\x35\xe9\
\x6f\x87\x0f\xc3\x39\x73\x06\xe2\xd1\x23\x38\x2d\x2d\x2d\x32\x16\
\x8b\xb5\x0d\x0d\x0d\x2d\xb3\xa4\x48\x15\xb9\x74\x1a\x15\x15\x15\
\x98\x4b\xa5\xf0\xec\xe6\x4d\xfc\x79\xe5\x0a\xe6\x01\x64\x6f\xdf\
\xc6\x02\x09\xad\xbd\x7b\x35\xb1\x0a\x67\x71\x11\x8f\xaf\x5d\x43\
\x94\x35\xd5\x6c\x22\x4b\x25\x53\x59\x81\x37\xa3\xe4\xba\x30\xa4\
\x44\x8e\xa4\x7f\x5f\xb8\x80\x85\x27\x4f\x50\x5c\x58\x80\xc1\x46\
\x88\xc7\xb1\xf3\xe8\x51\xd4\x36\x36\x42\x05\x4f\x06\x9f\xdf\x8f\
\x3e\x9e\x64\x98\x36\x6c\x18\x1d\x85\x15\x0e\x7b\xff\xfa\x8e\x67\
\x67\x66\xf0\xf8\xf4\x69\x3c\x1b\x1e\xc6\xf3\x87\x0f\x91\x07\xb0\
\xc8\x8f\x83\xbc\xb8\xb7\x36\x6d\x42\xc3\xba\x75\x50\x71\x92\xaa\
\x55\xf3\x4f\xce\x9e\x45\x28\x12\x41\xf3\x8e\x1d\x08\x4f\x4c\xe0\
\xae\x65\xb9\xd2\x75\x5d\xed\xa5\x6a\x90\xcf\xe7\x91\xc9\x64\x90\
\x61\xe7\x17\x54\x9d\xa3\x2a\x87\x3e\xba\xf4\xd0\xe6\xda\xae\xaf\
\x47\x25\xf7\xce\x1f\x3a\x84\xe7\xf7\xef\xe3\xed\xe3\xc7\xb1\x9e\
\x7b\x27\xfb\xfa\xd0\xb8\x67\x0f\xfc\xe3\xe3\xb8\x15\x8b\xe1\xd7\
\xeb\xd7\x4b\x8a\x18\x7e\xaa\x61\xe8\x5c\x53\x53\x03\x76\x83\xc9\
\x0b\xf2\x8f\x8c\xc0\xa2\xdf\x2f\xd5\x29\x08\xbb\xbf\x1f\xb6\x94\
\xb0\xcf\x9d\xc3\x7b\x7c\x09\xfe\xf6\x76\x04\x67\x67\xd1\xcb\x66\
\xe2\xc4\x09\x5c\xa4\xb8\x0f\x0e\x1c\x80\xd7\xdb\x0b\xb9\x48\xe3\
\x19\x5a\x31\x6f\x57\x67\x0d\xbe\xcf\x80\x6d\x43\x00\x70\x08\x3f\
\x61\x71\xff\xe3\xa1\x21\xdc\x3a\x75\x0a\x0f\x2f\x5d\x82\xc1\xc1\
\x50\x62\xdc\xba\x3a\x78\xf4\x7e\xf3\xbe\x7d\x70\xca\x7c\x9a\x98\
\x44\xcb\x88\x4b\x84\xe0\x64\x85\xb8\x36\x94\x52\xc2\x47\x38\xae\
\xab\xf7\x3e\xdc\xbd\x1b\xde\xae\x5d\x28\x95\xc5\x8c\xf0\x64\x1f\
\x6d\xdc\xa8\xd7\x76\xd9\x56\xa9\xde\xed\xe4\xe4\x24\x54\x9e\xce\
\x66\xf5\xc7\x19\xae\x73\xa6\x09\xdf\xfa\xf5\x28\x72\x3d\x4f\xe4\
\x48\x90\xa1\x88\xcb\x97\x2f\x43\xd9\xe7\x3a\x8e\xce\x0e\x31\x36\
\x36\x86\x67\xb4\x4e\xad\x0b\xb4\x4e\x08\xe1\xc9\x42\xa1\x50\x6a\
\x68\x68\x30\x54\xe7\x68\x34\x0a\x95\xc7\x03\x01\xfd\x7e\x1b\x38\
\x49\x0b\x00\x66\x88\x69\x62\x91\x8d\xba\xf9\x9f\xd0\x56\xbd\x76\
\xba\x20\xfd\xee\xdc\xb2\x05\x2a\xc8\x87\x83\x07\x0f\x96\x24\x2f\
\x47\x93\xb1\xdb\xd2\x07\xaa\xd8\xa4\xc7\x41\x45\x46\x54\x10\xb2\
\x3c\x08\xe5\xfd\xa5\x5a\xaa\x43\x80\x42\x0c\x9e\x90\x04\x7a\xa8\
\x6a\x6b\x6b\x85\x9c\x9b\x9b\xf3\x78\xac\x57\xc5\x65\x72\x76\xd4\
\xc4\x79\xc2\x24\x0c\x82\xcd\x5f\x5d\x30\xa0\xc9\x04\xa0\x15\x9b\
\x24\x56\x21\xb9\x47\x62\xc8\x79\xfe\x03\x6e\x70\x64\x49\xae\xfd\
\x72\xcb\x1e\x5b\x1b\x36\x20\xc5\x41\xc8\x97\x3d\x5e\xa0\xb2\xc7\
\x54\xfc\x0b\x87\x41\xa9\xf2\xfb\x7c\x7a\xe2\x7c\xcc\xd3\xd3\xd3\
\x9a\xd8\x30\x0c\xdd\xb8\xaa\xaa\x4a\xea\xc9\xeb\xe8\xe8\x58\xe6\
\xd9\x5f\xbc\x8c\xe2\xe0\x20\xde\xcf\x64\xb4\xb7\x59\x92\xbc\x5c\
\xbb\x16\xb3\x7c\x56\xbd\x7c\xa3\x86\x10\x9a\x44\x83\x84\xe9\x74\
\x1a\xad\xad\xad\xca\x16\x2d\x4c\xcf\x02\x80\x57\xc7\x2b\x67\x97\
\x79\x8a\x39\x54\xb6\xa2\xb0\x7a\x35\xc4\x9a\x35\xf0\xa4\x84\x0e\
\x21\x34\x84\x22\x66\x56\x56\xc8\xb2\x62\xa5\x5c\x13\x93\x48\xf0\
\x52\x54\xd1\x12\x39\x2b\x30\xc1\xc7\x5f\xe4\x88\x5b\x4a\x85\xf2\
\xd0\xb6\x91\xa7\x72\x16\x69\x78\x84\xbe\x1b\xd6\x56\x48\xa9\x95\
\x9b\x84\x64\x7d\x25\xbf\x95\xd5\xd5\xd5\x63\xd1\xc6\xc6\x56\xbc\
\x11\xaa\xe1\xd2\x62\x7c\x5c\x41\x2b\xfa\xa9\xbd\x5d\x44\x22\x11\
\x8f\x40\x28\x14\x42\x38\x1c\x56\x59\x10\x9e\x9a\x42\x29\xa5\xb8\
\x7a\xf5\xea\xef\xff\x00\x1e\xa4\xa9\x5c\x40\x6e\xf1\x36\x00\x00\
\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0b\x29\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x0a\xbb\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x2c\x30\x86\xa7\xa7\x27\x03\x23\x23\x42\x02\x18\x30\xc6\x9c\x9c\
\x3c\x91\xc2\xc2\xe2\xd6\x3c\x3c\x3c\xb2\xbf\x7f\xfd\xfe\xf1\xe6\
\xed\xeb\x6b\x0f\x1e\xdc\xd9\x7b\xf9\xf2\x85\xcd\xdf\xbe\x7d\xbf\
\x87\xcb\x50\x3b\x3b\x3b\x06\x45\x45\x45\x86\xdf\xbf\x7f\x33\x80\
\x42\x98\x89\x09\xe2\x4f\x76\x76\x76\x86\xc7\x8f\x1f\x33\xec\xde\
\xbd\x1b\x6a\xc7\x7f\x06\x80\x00\x62\x41\xd6\xf8\xe7\xcf\x1f\xb0\
\xe0\xdf\xbf\x7f\x18\xd4\xd5\x0d\xe6\xc7\xc6\xa6\xe9\xca\xca\x8a\
\x33\x70\x70\xb0\x03\xc5\xfe\x32\xbc\x7d\xfb\x41\xf9\xda\xb5\xeb\
\xbe\xbb\x76\x6d\x29\xdc\xbb\x77\x5b\xcb\xfd\xfb\xf7\xe7\x01\xb5\
\xfd\x23\xc6\xa7\x20\xfd\x40\x07\xf1\xfe\xfb\xf7\x97\x19\xc8\xfd\
\x00\x13\x07\x08\x20\xb8\x03\x18\xa1\xde\x7f\xfe\xfc\x05\xc3\xd5\
\xab\x57\x19\x7e\xfd\xfa\x77\xf8\xc9\x93\x87\xba\x3a\x3a\x2a\x0c\
\xbc\xbc\x6c\x40\x03\xfe\x31\x88\x8a\xf2\x31\xa8\xa9\xc9\x31\x18\
\x1a\x1a\xc8\x2b\x28\xa8\xcc\x9e\x3f\x7f\x8a\xcc\xdd\xbb\x77\xdb\
\x81\xda\x7e\xe2\xb2\x18\xe4\xa1\x1f\x3f\x7e\xf0\x08\x08\xf0\xbb\
\x1a\x18\x18\x37\xde\xbf\xf7\xe0\xdf\xb9\x73\xe7\xd3\xde\xbf\x7f\
\x7f\x0a\x24\x0f\x10\x40\x48\x21\x00\xf6\xb9\x04\x30\x14\xbe\x00\
\x39\x5f\x8e\x1d\x3b\x5c\xf9\xfd\xfb\x37\x91\xaf\xdf\xbe\x85\xf9\
\xfa\x78\x32\xf0\xf0\xb0\x30\xfc\xfb\xf7\x1f\xec\x50\x59\x59\x61\
\x86\xe8\xe8\x58\x86\x77\xef\xde\x54\xcc\x9d\x3b\xf9\xd1\xc7\x8f\
\x9f\xe6\xe1\xb2\x9c\x99\x99\xd9\xd4\xcc\xcc\xac\xdf\xc1\xc1\xd5\
\x9a\x9b\x5b\x8c\x61\xe3\xa6\x8d\x0c\xac\xac\xac\x09\x40\xe9\xbb\
\x40\xfc\x16\x20\x80\xe0\x89\xf0\xd7\xaf\x5f\xc6\x7a\x7a\x66\x97\
\x35\x34\xb4\xd7\xb3\xb3\xb3\xa9\x02\xf5\x7e\x3a\x77\xee\x6c\x5a\
\x7f\x5f\xd3\xd2\xf5\x1b\xb6\x00\x2d\xfb\x06\x36\xf0\xd7\xaf\x3f\
\x40\xfc\x9b\x41\x4c\x8c\x8f\x21\x20\x20\x94\xdd\xd8\xd8\xa2\x00\
\xa8\x5d\x1f\x39\x24\xd9\xd9\x39\x40\x69\x08\x18\xe4\x7f\x18\x74\
\x74\x74\x9a\x0a\x0a\x0a\xad\xe5\xe5\x95\x18\x1e\x3f\x79\xc6\xb0\
\x75\xeb\x9a\x97\xaf\x5e\xbd\x7a\x00\x52\x0a\x52\x0f\x10\x40\xf0\
\x10\xe0\xe0\xe0\x8e\x8e\x8e\x4e\x14\x01\xc6\x93\xcb\xf7\xef\x3f\
\x56\x1c\x3c\xb8\x27\xf6\xe7\xcf\x5f\xd7\x2e\x5f\xbe\x94\x3d\x79\
\x62\xcb\xff\x1f\x3f\xbe\xc7\xf8\xfb\x79\x01\xa3\x83\x13\x98\x56\
\xfe\x33\xb0\xb0\xfc\x07\x26\x34\x59\x06\x53\x33\x1b\xdd\xa3\x47\
\x0f\x38\x03\xd5\x5e\x07\xf9\x43\x5e\x5e\x9e\x41\x4a\x4a\x92\xe1\
\xfb\xf7\xef\x40\x87\xfe\xe4\x02\xf2\xb5\x3e\x7c\xf8\xc5\xf0\xf4\
\xd9\x07\x86\xa3\x47\x0f\x32\x9c\x3b\x7b\xfc\x2c\x50\xdd\x31\x20\
\x7e\x07\xb2\x17\x20\x80\xe0\x0e\x90\x90\x90\xb1\xe4\xe6\xe6\x61\
\x50\x50\x90\x64\x28\x2f\x6f\x30\x02\x0a\x2d\xda\xbf\x7f\x77\x02\
\xd0\x41\x57\x2e\x5f\xb9\x9c\x3e\x7b\x56\x3f\x9b\x8c\xb4\x4c\x98\
\xad\xad\x19\x30\x2a\xfe\x00\x31\xc8\xa7\xac\x0c\x6a\xaa\x9a\x0c\
\x42\x42\x22\x06\xcf\x9f\x3f\xe3\x07\xea\x79\x0d\x49\x6c\xbf\x40\
\x0e\xe0\xd0\xd0\xd0\x98\x28\x23\xa3\x2e\x37\x6d\xda\x9c\xff\xf7\
\x1f\xdc\xfb\x7f\xfc\xf8\xce\x3b\x9f\x3f\x7f\xde\x03\x54\x77\x15\
\x96\x78\x01\x02\x08\xee\x00\x1e\x1e\x3e\x09\x50\x76\xf9\xf4\xe9\
\x13\x83\xae\xae\x06\x43\x51\x51\x8d\x31\x0b\x0b\xeb\xe2\xbd\x7b\
\xb7\x27\x02\x43\xeb\x02\x37\x0f\xf7\xd3\x5f\xc0\x6c\xf5\xe7\xcf\
\x5f\xa0\xe5\x7f\xc1\x41\x0c\xca\x5d\x3c\x3c\xbc\x0c\x9c\x9c\x9c\
\x22\x40\x23\xf8\x40\x0e\x90\x91\x91\x06\x59\xce\xa5\xab\xab\x37\
\xcf\xcf\x2f\x2a\x7c\xc9\x92\x85\x5f\x16\x2e\x9c\x76\xe4\xdb\xb7\
\x6f\x17\x80\x09\x19\x14\x4a\xc7\x91\x73\x01\x40\x00\xc1\x1d\x00\
\x0c\xe2\x8f\xc0\x60\x64\xf8\xf9\x93\x05\x68\xf8\x4f\x06\x2d\x2d\
\x35\x86\x8c\x8c\x22\x03\xa0\xe1\x4b\xde\xbf\x7f\x7b\xc1\xd3\x2b\
\x38\x40\x5b\x4b\x0b\x94\xa2\xc1\x69\x01\x14\xd7\xa0\x8c\xf3\xf1\
\xe3\x7b\x86\xaf\x5f\xbf\xfe\x00\xc5\x29\x2f\x2f\x2f\x83\xa4\xa4\
\x24\xa7\x8e\x8e\xee\x3c\x0f\x8f\xb0\xf0\x65\xcb\x16\xff\x98\x3d\
\x7b\xc2\x6e\xa0\xb9\x8b\x81\xf2\x47\x80\xf8\x23\x28\x9a\x90\x13\
\x2a\x40\x00\xc1\x1d\xf0\xe2\xc5\xe3\x0b\xaf\x5f\xbf\xd6\xe7\xe1\
\x91\x03\x97\x07\x4c\x4c\x7f\x18\xd4\xd4\x95\x19\xf2\x0b\xaa\xb5\
\x7f\xfe\xf8\xae\x2d\x2e\x2e\x06\x4c\x27\xcc\x40\x07\xfe\x41\xca\
\xb6\xff\xc0\x21\x21\x28\x28\x28\xf6\xf2\xe5\x0b\x60\xc8\xe9\x70\
\xe8\xeb\x1b\x2e\x71\x75\x0d\x0a\x9a\x3f\x7f\xd6\xe7\x85\x0b\xa7\
\xef\x04\x26\xd8\x45\x40\x85\xfb\x41\x39\x0b\x5b\x4e\x01\x08\x20\
\xb8\x03\xee\xdd\xbb\xb3\xed\xc6\x8d\xeb\xf1\x32\x32\x32\xe0\xd4\
\x0b\xf1\x25\x03\x83\x88\x30\x3f\x90\x16\x00\x17\x24\xdf\xbf\xff\
\x42\xc9\x62\xac\xac\xcc\x0c\xce\xce\x0e\x0c\xdf\x7f\x7c\xb3\x9e\
\x33\xbb\xbf\xc4\xd2\xd2\x4a\xc4\xc3\x23\x34\x68\xd6\xac\xa9\x20\
\xcb\xb7\x02\xa3\x6b\x29\x50\xe9\x5e\x20\xfe\x8e\xab\x9c\x00\x08\
\x20\xb8\x03\x80\x96\x6f\xde\xb5\x6b\xe3\x5e\x65\x15\x0d\x67\x19\
\x69\x71\x70\x31\x0a\x2a\x1b\x80\xe5\x23\xbc\x9c\x80\x78\x9d\x81\
\x81\x99\x85\x15\xc8\x63\x04\x87\x82\xb0\x30\x1f\x83\xbb\x9b\x13\
\x03\x13\xe3\xef\x74\x1d\x1d\x23\x86\x29\x53\xfa\xde\x2d\x5f\x3e\
\x0f\x64\xf9\x32\xa0\xea\x43\xf8\x2c\x07\x01\x80\x00\x82\x97\x03\
\x40\x5f\x7f\x3f\x7c\x78\x5f\xe5\xea\xd5\x0b\x9e\x3c\x7b\xfe\x8a\
\x81\x85\x95\x1d\x68\x01\x33\x38\x88\x41\x05\xd0\xbf\x7f\x20\x5f\
\x33\x02\x2d\x66\x66\x78\x76\xfb\x0e\xc3\xdb\x27\x8f\x18\xf8\x85\
\x85\x19\x3e\x7e\xf8\xc0\x70\xeb\xe6\x25\x06\x55\x35\x6d\x86\x3d\
\x7b\xf7\x30\x9c\x3a\x79\xe8\x39\xd0\xf2\xf5\x50\x9f\x7f\x23\x54\
\x44\x03\x04\x10\x23\xac\x3a\x86\x15\xc5\xc0\x22\xd3\xc9\xd6\xd6\
\x69\x82\x8f\x4f\x98\xae\x8a\xaa\x3a\x03\x37\x37\x37\x03\x0b\x33\
\x33\xd8\xff\xff\x80\xbe\xbe\xbc\x6c\x0e\xc3\xaf\xc3\x3b\x18\x7e\
\x32\xb2\x30\xa8\x97\xd5\x32\xfc\xe4\x00\x16\xd3\xc0\x82\xf8\xc9\
\x93\xfb\x0c\xce\x4e\x4e\x0c\x87\x0f\x9f\x66\x98\x3d\xbb\x6f\xc9\
\xe5\xcb\x17\xf3\x81\x0e\x79\x87\xcf\x72\x90\xdd\x00\x01\x84\xe1\
\x00\x10\x60\x66\x66\xd2\x91\x95\x95\x4b\xd1\xd1\x31\xf4\x95\x93\
\x53\x90\x12\x14\x14\x61\xff\xfa\xed\xcb\xbf\xef\x4c\xcc\x7f\x04\
\x4e\x1c\x61\x4b\x0b\xf1\x62\x64\x02\x46\xc3\x82\xde\x3e\x06\xa9\
\xe2\x46\x86\x5f\x6c\x2c\x0c\x7e\x1e\x8e\x0c\x72\x72\x32\x0c\xaf\
\xdf\x7c\x61\x58\xb1\x62\x2d\xc3\x82\x79\x53\x96\x5e\xbc\x74\xbe\
\x00\x98\x76\xde\xe0\x73\x00\x40\x00\x81\x09\x1c\x8d\x12\x1e\x20\
\x36\x63\x62\x62\x4c\x60\x65\x65\xa9\x04\xb2\x0b\xc4\x38\x39\xbb\
\xab\x14\xe5\xbf\xbd\x5e\xb5\xf4\xff\xbb\xed\x5b\xfe\x1f\x76\xb6\
\xfb\x5f\x2e\x21\xf1\x7f\xdb\xfa\xcd\xff\x7f\xfc\xfa\xff\xff\xe3\
\xc7\x2f\xff\x81\x39\xe8\xff\xdb\x37\x5f\xff\x4f\x9c\xb4\xe0\xbf\
\x85\x85\xd5\x5a\xa0\x5e\x31\x7c\x0e\x00\x08\x20\x16\x3c\x21\x04\
\xca\x36\xa7\x80\xf1\x7f\x06\x58\xf2\xfd\xd3\x66\x64\xb2\x09\x10\
\xe2\x8b\x8e\x4e\x4d\xe2\x64\x60\x66\x65\x78\xb1\x7f\x2f\x03\x0b\
\x30\x6d\x58\xbc\x7d\xc5\x70\xae\xbc\x98\x41\x54\x42\x92\x41\x55\
\x47\x87\xe1\xdb\xd7\x9f\xc0\x68\xe4\x64\x88\x8c\x08\x06\x55\x3a\
\x41\x40\x4b\xfe\x9d\x3f\x7f\x26\x17\x98\x1d\x5f\x60\xb3\x04\x20\
\x80\x30\x1c\xc0\x06\xc4\xe2\xc0\xb8\xfe\x01\x8c\x11\x4d\x60\x03\
\x42\x9b\x93\xfb\xdf\xcf\xef\x5f\x13\x6c\xf4\xb5\x7b\x03\x4a\x8a\
\x84\x18\xd9\x38\x18\x5e\x1e\x39\xc4\xf0\xe1\xe0\x7e\x86\x37\x57\
\xae\x31\x7c\xfb\xfd\x8f\xe1\xcf\xdb\xb7\x0c\x3f\x80\xe5\xc3\xcf\
\x9f\xbf\x19\x98\xfe\xff\x05\xe7\x14\x21\x21\x2e\xa0\x23\x02\x41\
\x51\x1b\xc2\xc2\x3a\x83\xfd\xf4\xa9\xe3\x99\x40\x47\x3c\x45\xb7\
\x0f\x20\x80\xe0\x0e\x70\x07\xa6\x81\x9f\xff\x21\xe5\xa9\x16\x30\
\xd1\xfd\x61\x61\x61\xf8\xc1\xc4\xcc\xc1\xfc\xed\x53\x6b\x60\x58\
\x50\x91\x5d\x4e\x2e\xc3\xb7\x17\x2f\x18\xde\x1e\x3b\xcc\xf0\xe5\
\xf0\x01\x86\xa7\x57\xaf\x31\x1c\x91\x55\xfa\x27\x68\x6a\xcb\xa4\
\xa8\xa1\xc9\x20\x2c\x26\xc5\xf0\xf9\xc3\x17\x60\xfd\x80\xf0\x13\
\x2f\x2f\x07\x43\x48\x88\x2f\x28\xf7\xf8\x02\xdd\xc4\x78\xfa\xf4\
\xf1\x34\xa0\x23\x9f\x23\x3b\x00\x20\x80\xe0\xaa\x2d\x41\xbe\x06\
\xb5\x09\x80\xec\xaf\xa0\xf2\xf2\xf7\x6f\x11\x61\xa6\xff\xf3\x22\
\xaa\x4a\x7d\x75\x63\xe2\x18\x3e\x5c\x3c\xcf\xf0\xf1\xf8\x31\x86\
\x6f\xa7\x4f\x30\x7c\xb8\x79\x83\x61\x0b\x27\xdf\xbb\xe5\x4f\x9f\
\xed\x74\xd7\xff\x69\xa4\xa7\x6f\xae\x0e\x6c\x78\x01\x8b\xe9\x9f\
\x40\xcb\xfe\x81\x0b\x0b\x58\x9a\x16\x11\xe6\x61\x08\x0f\xf3\x03\
\xf1\x7d\x98\x98\x98\x67\x9f\x3a\x79\x34\xf3\xc7\xcf\x5f\x8f\x61\
\xf6\x02\x04\x10\xa2\x2e\x80\x62\x50\x72\xfc\xfd\xf7\x8f\xac\x1c\
\x1f\xd7\xf2\xb8\xfe\x6e\x6b\x19\x57\x4f\x86\xf7\x47\x0f\x31\x7c\
\xb9\x74\x9e\xe1\xeb\xc5\x33\x0c\x3f\xae\x5e\x61\x38\xc4\xc6\xfb\
\x67\xf3\xe7\x6f\x47\x7e\x7d\xfb\x36\x73\xd7\xc6\x55\x5f\x19\x7e\
\x7c\x9b\x19\x13\x93\x69\xa4\xa3\xad\x0e\x6e\x2b\x40\x72\xd5\x7f\
\x70\xf9\xf1\xf5\xeb\x77\x60\x51\xcd\xcb\x10\x12\xec\x03\x2c\xe2\
\xff\x79\xb3\xb0\xb0\xcc\x3e\x7e\xfc\x70\x3a\xb0\xca\x7f\x08\x52\
\x07\x10\x40\x18\x69\x00\xe8\x07\x19\x65\x41\x9e\x75\x89\xf3\x66\
\x99\x08\x9b\x59\x31\x7c\x3c\xb0\x97\xe1\xfb\xc5\x73\x0c\xdf\x80\
\x0e\xf8\x73\xf5\x22\xc3\x59\x66\x0e\x86\xc5\x5f\x7f\x9d\x7e\xf7\
\xed\xdb\x6a\xa0\xf2\xb3\xc0\x8a\xe6\xcb\x8e\xed\x9b\x62\x81\xec\
\x25\x11\x91\xa9\x86\x06\xfa\x3a\xe0\xb4\x00\xca\xd6\x7f\x81\xa5\
\xd7\xf3\xe7\x6f\x19\x2e\x5c\xbc\xc3\xe0\x60\x6f\xc8\x10\x16\xea\
\x0b\x2c\x45\x59\xdc\xdf\xbf\x7f\xd7\x7c\xfe\xfc\xd9\x5c\x50\xe5\
\x04\x10\x40\x28\x0e\x00\xb6\x61\x45\x94\x79\x39\x57\x24\xcd\x99\
\x69\x22\x64\x6a\xc5\xf0\xe9\xe0\x1e\x86\x1f\x57\x2e\x30\x7c\xbb\
\x7c\x8e\xe1\xff\xf5\x2b\x0c\x37\xff\x30\x33\xcc\xfa\xf1\xef\xea\
\xfd\xcf\x9f\x96\x03\x95\xef\x81\x55\x30\xc0\x52\xf4\xda\xae\x9d\
\x5b\xa2\xff\xfd\xfb\xb7\xf0\xff\xff\x34\x53\x90\x23\x40\x21\x01\
\xcc\xc2\x0c\xac\xc0\xb4\x04\xaa\x2c\xbf\x7c\xf9\xc1\xf0\xee\xfd\
\x17\x86\xcf\x9f\x3f\x32\x7c\xfb\xf6\x55\x1e\xa8\x0d\x84\x2f\x01\
\x04\x10\xdc\x01\x7f\xff\xff\x67\x02\x66\xd8\x89\xd1\x7d\x5d\xd6\
\x42\x96\x36\x0c\x5f\x0e\xec\x62\xf8\x75\xf9\x3c\xc3\x0f\x60\xdc\
\x33\xdc\xb8\xcc\xf0\x10\x58\xda\x4d\xfb\xc9\x72\xef\xfc\xc7\x8f\
\x2b\x81\xca\x37\x81\x2a\x50\x94\x90\x03\xb6\x88\x80\x8e\x88\x05\
\x86\xfb\xc2\x7f\x7f\xd3\xcc\x8d\x0c\x0d\x80\x95\xd4\x4f\x70\x5a\
\xd0\xd5\x51\x06\x36\xc7\xde\x32\x6c\xde\xbc\x99\x61\xf5\xaa\x39\
\xb7\x6e\xde\xbc\xb1\x13\xa8\xe5\x3d\x48\x1f\x40\x00\xb1\x20\x9a\
\xa4\xff\x23\x7c\x32\xe3\xa3\x24\xdd\xdc\x19\xbe\x1f\xde\xc3\xf0\
\xfb\xca\x39\x86\x9f\x97\x2f\x30\x30\xde\xba\xca\xf0\xf8\xc7\x3f\
\x86\xc9\x3f\xd9\x9e\x1d\xfc\xf8\x09\x18\xec\xff\xd7\x02\x95\x3f\
\xc4\x96\xa7\x81\x21\x71\x73\xf7\x9e\xed\xb1\xc0\x8a\x0a\x18\x12\
\x29\x96\x46\x86\x7a\xc0\x9c\xc0\x0d\x6c\xce\x7f\x61\xd8\xb5\x67\
\x17\xc3\xaa\x55\xb3\x6f\x5c\xbd\x72\x05\x54\x43\xae\x02\xe2\x27\
\x20\x3d\x00\x01\x04\x77\x80\x82\x20\x57\xa6\x9e\xa7\x1b\xc3\x1f\
\xa0\xaf\x7f\x5f\x01\x62\x20\xcd\x72\xe7\x1a\xc3\x9d\x6f\x7f\x19\
\x7a\xbf\xb1\x3e\xdb\xf1\x09\x68\xf9\xff\x7f\x20\xdf\xdf\xc0\x57\
\xbe\x03\x83\xfe\xf6\xee\xdd\x5b\xe3\x81\xb9\x61\xc1\xdf\x7f\x49\
\x56\xca\x4a\xea\x0c\x07\x0f\xed\x61\x58\xb9\x7c\xe6\x4d\x60\x73\
\x1f\xd4\x30\x01\xa5\x9d\x3b\x30\xf5\x00\x01\x04\x77\x00\xcb\xef\
\xdf\xfc\x8c\xc0\x4a\xe6\xaf\x00\xb0\x75\x75\xe9\x14\xd0\xf2\xeb\
\x0c\xa7\x3e\xfe\x65\xe8\xfe\xc4\x78\x7f\xdf\xb7\x4f\x2b\x80\xf9\
\x0b\xa4\xf1\x12\x31\x1d\x11\x60\x48\xdc\xde\xbb\x67\x47\x1c\x30\
\x1f\x4c\xd7\xd2\x36\x72\xdd\xbd\x6b\x13\xd0\xee\xab\x20\x9f\xaf\
\x00\xe2\xfb\xc8\x6a\x01\x02\x08\x5e\x17\x58\x33\x30\x44\xaf\x15\
\x61\xff\xfe\xcd\x5c\xea\xff\x7d\x55\xde\xff\x53\x84\xb9\xfe\x6a\
\xb3\xb1\x9d\x01\xaa\xa9\x06\x62\x4d\x72\xfa\x91\x6c\x6c\x6c\x72\
\xc0\x66\x5a\x3e\x30\x47\xa4\x00\xb9\x2a\xd8\xea\x02\x80\x00\x82\
\xd7\x86\x4c\x8c\x8c\x4c\x40\x5b\x52\x74\x58\x19\x93\x80\xad\x01\
\x96\xf3\x7f\xfe\x5d\xf9\xf8\xff\xef\x2e\x68\xa3\xe2\x09\x05\xfd\
\x4f\x56\x28\xfe\x8e\x68\xd5\x20\x1c\x00\x10\x40\xe8\xd5\x31\xa8\
\xdf\xa6\x00\x2a\xc0\xa0\x0d\xc8\xc7\xd0\x82\x91\x26\x00\x64\x37\
\x40\x80\x01\x00\x1b\xec\xcf\x8a\xf9\x42\x05\x71\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x12\x17\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x40\x00\x00\x00\x40\x08\x06\x00\x00\x00\xaa\x69\x71\xde\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x1b\xaf\x00\x00\
\x1b\xaf\x01\x5e\x1a\x91\x1c\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x40\x00\x00\x00\x40\x00\xea\xf3\xf8\x60\x00\x00\x0f\xf4\
\x49\x44\x41\x54\x78\xda\xed\x9b\x59\x90\x5c\xd5\x79\xc7\x7f\xe7\
\x6e\xbd\xcd\xf4\x6c\x2d\x89\x11\x8b\x85\x62\x20\xc8\x82\x8a\x5d\
\x85\x52\x94\x13\x9c\xe0\xe2\xc1\x7e\x81\x0a\x89\xed\xe4\x89\xaa\
\xe4\x25\x7e\xc8\x43\x2a\x09\x95\xed\x21\x15\xdb\xe5\x8a\x1d\x3f\
\x04\x17\x4b\x05\x84\x02\x18\x83\x59\x44\x28\xa5\x02\xa9\x12\x65\
\x09\x04\x48\x01\x44\x0d\xa0\x20\x66\x46\xa3\x85\xd1\x8c\x46\x9a\
\xad\xa7\xbb\xef\x72\xee\x39\x27\x0f\xf7\xf6\x4c\x6b\xd4\x33\x7d\
\x7b\x24\x95\xf3\x90\xaf\xea\x56\xdf\xe5\xdc\x73\xcf\xff\xff\x7d\
\xe7\x5b\xce\xbd\x2d\xf8\xbf\x2c\x4f\x01\x53\x40\x9e\x3c\x82\x5f\
\xc7\xe1\x2e\x1c\xee\xc2\x66\x27\x16\xd7\x20\x28\xa5\x2d\x1b\x28\
\xa6\xd0\x7c\x42\xcc\x01\x14\x07\x51\x7c\xca\x3c\x01\x3b\x80\x6f\
\xad\xfd\x08\xd1\x61\x08\x9d\xae\x5f\x3d\x31\x18\x7e\x40\x9e\x1c\
\xbf\x89\xe0\xdb\x38\x7c\x1d\x87\xeb\x71\x29\x38\x9e\x43\xce\xcb\
\x91\xb3\x73\x00\x84\x2a\x24\x8c\x42\x62\x19\x83\xc4\x47\x72\x86\
\x98\xfd\x28\x9e\x43\x72\x04\x8b\x80\xbf\x6e\xff\x18\x67\x9d\x21\
\xe4\x80\x7e\xc0\xfd\x95\x10\xf0\x6d\xb6\xf2\x1b\xfc\x11\x82\x3f\
\xc0\x65\xab\x9d\xb7\xb9\xb6\xff\x5a\x76\x56\x76\xb2\x63\x60\x07\
\xc3\xc5\x61\x7a\xdc\x1e\x00\x6a\xb2\xc6\x54\x63\x8a\x63\xf3\xc7\
\xf8\x78\xf6\xe3\xc2\xe4\xc2\xe4\xcd\xca\x57\x37\x03\xf7\xa2\x79\
\x1e\x9f\x47\x80\x51\xfe\x1c\xf8\xc9\xc5\x8f\x59\x4b\xc3\x02\xd8\
\xdc\xdf\xdf\xbf\x6b\xd7\xae\x5d\xbf\x56\x28\x14\xec\xab\x8d\xd7\
\x18\x83\x10\x02\xa5\x94\x79\xdb\x7d\x7b\xd3\xdc\xed\x73\xdf\xa0\
\x9f\x9d\x14\xb0\x87\x07\x87\xf9\xfa\xf5\x5f\xe7\xab\x5b\xbe\xca\
\xd6\xe2\x56\x3c\xdb\x43\x20\x30\x98\x74\xb0\xc9\x7e\xa4\x22\xce\
\x36\xce\x72\xe8\xdc\x21\xf6\x9f\xd9\xcf\xd4\xdc\x14\xf8\x28\x24\
\x87\x30\xfc\x3d\x1e\x6f\x22\x31\xfc\x55\x36\x02\xae\xbb\xe7\x9e\
\x7b\xee\x7f\xf8\xe1\x87\xff\xac\xbf\xbf\xbf\x5f\x6b\x6d\x56\xae\
\x8a\x75\x6f\x6e\xdf\xa3\xb8\xa8\xf3\xb5\x64\xdf\xf8\x3e\x1e\x7c\
\xf7\xc1\xfc\x8c\x98\x29\x5a\xbd\x16\xb7\x0f\xdf\xce\x7d\xdb\xee\
\xe3\xa6\xbe\x9b\xb0\x84\x85\x46\xa3\x54\x8c\xd2\x0a\x4c\x4a\x80\
\x10\x58\x96\x8d\x6d\x3b\x49\x1b\xad\x19\x5d\x1c\xe5\x95\x93\xaf\
\x30\x32\x35\x82\xae\x69\x08\x39\x86\xe6\x2f\xd0\xbc\x86\x85\xe1\
\xc1\xe4\x79\xeb\x4d\x01\x8a\xc5\xa2\xdd\xdf\xdf\xdf\x67\x3b\xce\
\x80\x96\x12\x81\x00\x91\x3c\xb0\xc9\x7c\x13\xcd\xf2\xb9\x56\x72\
\x5a\x41\xb7\x23\xa0\xa5\xad\x40\xf0\xd6\xd4\x21\x7e\x74\xec\x47\
\xcc\xd8\x33\x58\x65\x8b\x2f\x6f\xfd\x32\xf7\x6d\xbb\x8f\x4a\xbe\
\xc2\xa2\x5e\xc0\x12\xa0\xe3\x18\xbf\xde\x20\x6f\xf2\x58\x22\x31\
\x4c\x6d\x14\xa1\x08\xc8\x97\x8a\x58\x8e\x83\x31\xb0\xa5\x67\x0b\
\xf7\x7f\xf1\x7e\x6c\xc7\xe6\xe8\xd9\xa3\xe8\xaa\xde\x41\xc0\x8f\
\x31\x34\x18\xe0\x00\xdf\x03\xfe\xae\x03\x01\x00\x5a\x6b\xb4\x94\
\xc4\x71\x9c\x0c\x53\x24\x03\x17\xed\x40\xaf\xfa\x5d\x97\x90\x96\
\x63\x0b\xc1\x89\xc5\x13\x7c\xef\xf0\x3f\x72\x6c\xe9\x18\xf4\xc1\
\xf6\x2d\xdb\xb9\xfb\xba\xbb\x71\x1d\x87\x45\x3d\x8f\x23\xc0\x16\
\x10\x85\x3e\x26\x80\x7b\x6f\xfc\x3d\x06\x0b\x43\x00\xcc\xf9\xb3\
\xbc\x38\xf1\x0c\xd2\x6d\x90\xb3\x0a\x28\x03\xb1\x01\xd7\x71\xb8\
\xfb\xba\xbb\x59\x54\x8b\x8c\x99\x31\x30\xec\x20\xe0\x1f\x98\xe1\
\x8f\xa9\x30\x8e\x9b\x81\x80\x15\x10\x02\x21\x32\x12\xb0\x86\xf6\
\xd7\x22\xc1\x97\x01\x4f\x1c\x7b\x82\x77\xe6\xde\x81\x5e\x28\x0f\
\x94\xb9\x63\xcb\x1d\xd8\x8e\x45\x55\xcf\xe3\x01\xae\x00\x47\x40\
\x10\xd7\x31\x81\x43\xd9\x2d\x33\x90\x4b\x08\x88\x63\x49\x10\x54\
\x11\xf9\x18\xe1\x95\x88\x01\xa9\x21\xd2\x60\xbb\x16\x77\x5c\x73\
\x07\x33\xe1\x0c\x55\x55\x05\xc5\x6f\x63\xf8\x2e\xc7\xf9\x5b\xbe\
\x4f\xb0\x1e\x01\xcd\x09\x76\x11\xf8\x15\x32\x56\xc0\x75\xd2\x78\
\x27\xed\x1f\x99\x3e\xc2\x4b\x13\x2f\xa1\xf3\x1a\xd1\x23\xb8\x71\
\xe0\x46\x7a\x72\x3d\x2c\xa5\xe0\x35\x60\xac\x64\x40\x91\xaa\x11\
\x87\x2e\xda\xa8\x15\x2b\x35\x0a\x3f\x5c\xc0\x55\x12\x17\x49\xa4\
\x21\x32\x10\x1a\x08\x35\xf4\xe6\x7a\xb8\x71\xe0\x46\x46\x82\x11\
\x8c\x34\x16\x8a\xef\x30\xc8\x7f\xf0\x97\xbc\xd1\xd1\x02\x52\x85\
\x5f\x02\x3e\xab\xb9\x37\xf7\xdb\x92\x80\xa0\x1e\x35\x78\x69\xfc\
\x45\xa6\xe3\x69\xe8\x81\x42\xa9\xc0\xe6\xd2\x66\x1a\xba\x8a\x12\
\x06\x23\x40\x18\xb0\x00\x0b\x43\xac\xea\x84\x61\x1e\xad\xf5\x0a\
\x01\x5a\x13\x86\x4b\x08\x1d\xa0\x8c\x44\x21\x90\x29\xf8\x40\x43\
\xa0\x05\x9b\x4b\x9b\x29\x94\x0a\x34\x82\x06\x84\x6c\x45\xf2\x87\
\x7c\x87\x23\x99\xa7\x40\xab\xa6\xb3\x98\xfe\x45\xfb\x6b\x68\x5f\
\x18\xc1\xe8\xfc\x28\x07\xcf\x1d\x4c\xb2\x8e\x02\xf4\xe6\x7b\x41\
\x18\xea\x66\x01\x63\xc0\x32\xe0\x18\xd0\x06\x8c\x30\x28\x5d\x27\
\x0a\x63\x8c\x59\x21\xc0\x18\x4d\x14\xd6\xf0\x74\x1d\x23\x62\x94\
\x11\xc4\x86\x65\x12\x7c\x0d\x96\x65\xe8\x2d\xf4\xd2\x28\x34\xc0\
\x07\x24\xbf\xcb\x76\x6e\xcb\x44\x40\x3b\x32\x2e\xd1\x7a\x17\xd3\
\xa0\xd9\x52\x6b\xc5\x91\x99\x23\x4c\x46\x93\xd0\x0b\x78\x10\xdb\
\x31\x4b\x6a\x1e\xcb\x72\xb0\x01\x07\x83\x27\x52\x02\x00\xa3\x7c\
\xa2\x10\x4c\x4b\x54\x36\xda\x20\xc3\x3a\x46\x55\xc1\x48\x74\xea\
\x04\x23\x0d\xa1\x16\xf8\x1a\x96\x54\x8c\xb2\x62\xf0\x48\xc8\x0e\
\xb9\x96\x22\xbf\xd3\xb5\x05\xac\x07\xbe\x9d\xd6\xdb\x01\x6f\x1e\
\x37\x22\x9f\xa3\x73\x1f\x20\x2d\x99\xe4\x9b\x0e\x2c\xc8\x39\x26\
\x66\x23\x36\xeb\x5e\xfa\x6c\x87\x92\x0d\x35\x1b\x4a\x36\x14\x6d\
\x68\xcc\x45\x44\x55\x0b\xdd\x62\x01\xda\x68\x96\xaa\x35\xa2\xe9\
\xf3\xd4\x43\x8f\x86\x86\xba\x4a\xb6\x5a\x0c\x55\x1d\x73\xce\x5a\
\x62\x41\xd4\x12\xb7\x9f\x03\x5c\xf2\xe4\xf9\xad\xcc\x16\x70\xd1\
\x14\x68\x07\x34\xe3\x34\x68\x92\x60\x0c\x2c\x06\x8b\x4c\xd4\x4f\
\x26\x83\x72\x00\x0b\x8c\x6f\xa8\x9f\x0e\xd0\x72\x88\xd8\x29\x10\
\x58\x02\x6d\x09\x02\x21\xa8\x0a\xd0\x52\x31\xe8\x6e\xc6\x16\x2b\
\x43\xb7\x85\x43\x4e\x6d\x66\x7e\x22\x62\x71\xd2\x46\x6a\x90\xc6\
\x10\x69\x83\xd4\x86\x58\xf9\x34\x9c\x00\x6e\x30\xcb\x44\xa7\x44\
\xdc\x9a\x3d\x0c\xae\x4e\x78\xd6\xd1\xf6\x9a\x4e\xb0\x65\xdf\x68\
\xcd\x62\xb0\xc8\xac\xba\x70\x31\x01\x0d\xd8\x52\x1f\xe6\xa7\xf7\
\xee\x66\x5b\xe5\x0b\x18\xb3\x92\xee\x26\x37\x1a\x5c\xdb\x65\x73\
\x79\x78\x79\x7c\x9b\xcb\xc3\x7c\xff\xf7\x1f\x47\x2a\xb9\xfc\x5c\
\xd3\x92\x25\x9e\xba\x70\x8a\x3f\xf9\xf7\x07\xa8\xf9\xa7\x13\xed\
\xdb\xcb\x24\x6c\xce\x46\x40\x3a\x80\xae\x2d\x60\x9d\x69\x60\x8c\
\x21\x90\x3e\x81\x09\x96\xc1\x03\xa0\xc0\x89\x5d\x6e\x18\xf8\x02\
\xdb\x2a\xdb\x33\x59\xa7\x63\xbb\x5c\x3b\x78\xc3\x9a\xd7\x75\xda\
\xa7\x50\xe9\x00\xac\x94\x04\x97\x7c\x67\x02\x56\x62\x60\x5b\x2d\
\x77\xb4\x84\x35\xac\xc2\x18\x43\xac\x14\xc6\x32\xad\x2c\x5f\xbd\
\xfa\xbb\xb5\xe3\x26\x01\x76\xe7\x4c\xd0\xb4\xde\xbf\x16\xf8\x4e\
\x71\xff\x12\x42\xd2\x8e\x6d\x2c\x3c\xdb\x4b\x0e\x9a\x16\x60\x43\
\xec\x48\xce\xcc\x9f\xc2\xb2\xc5\x72\xb8\x13\xcb\xcc\x81\x6b\xbb\
\x6c\xe9\x1b\xc6\xb1\x93\x4a\x3d\x56\x92\x73\x8b\x53\xe9\x14\x48\
\xda\x34\x07\x2e\x84\xc5\x99\xf9\x53\xc4\xb6\x4c\x40\x37\x81\xd8\
\x80\x45\x98\x3d\x0a\x64\x01\x9f\xc1\x02\x5a\x49\xc8\x8b\x02\xfd\
\x4e\x3f\xa8\x96\x67\x15\x61\xa6\x38\xc5\x77\xff\xf3\x01\x8a\xb6\
\x8b\x2b\xc0\xb3\xd2\x4d\x80\x96\x9a\x8a\xb7\x8d\x1f\x7e\x6b\x0f\
\x5b\x07\x12\xb3\x9f\xa9\x4e\xf1\x37\x2f\x3c\xc0\x6c\x74\x12\xe1\
\x59\x44\x3a\x4d\x85\xd3\x50\xd8\x50\x92\x0b\xa5\x29\x28\xb6\xa8\
\xd4\x02\x34\x73\x99\x32\xc1\xb6\x20\xb2\x80\x6f\x01\xbc\x1c\x3e\
\x5b\xda\xf7\xd8\x25\x86\x9d\xe1\x24\xd7\x4d\x37\x93\x03\xbd\x4d\
\x72\x41\x9e\xa6\xc7\x86\xb2\x03\x8e\x03\xae\x93\x84\x42\xb9\x08\
\xb5\x19\x41\xac\xe5\xf2\x18\x95\x96\xd4\xad\x53\xe4\x6f\x98\xc0\
\xeb\x87\x9a\x82\x28\x86\x20\x86\xa5\x18\x96\x34\x68\x07\x8c\xbb\
\xf2\x1c\x04\xe0\x73\x32\xb3\x13\xec\x44\x42\xc7\x36\xab\xf6\x2d\
\xcb\xa2\xe0\x15\xb8\xc5\xbd\x85\xd7\xe4\x6b\xc4\x3a\x86\x18\xb4\
\x0d\xca\x03\x51\x02\xc7\x05\xd7\x85\x9c\x0b\x05\x07\x8a\x0e\x48\
\x07\x54\x43\x20\xac\x96\x01\x5a\x90\xeb\x11\x38\x15\xf0\x06\x40\
\x29\x90\x12\x42\x09\xb6\x04\x11\x83\x92\xa0\x63\x12\x6b\x33\x80\
\x21\x62\x9a\x91\x6c\x79\x40\x6b\x02\xd4\xa5\x0f\x68\x67\x01\x02\
\xb0\x6d\x8b\x9c\x97\xe3\x4b\xde\x97\xa8\x04\x15\xa6\xc5\x74\x5a\
\xf5\x80\xb4\x20\x20\x89\x58\x9e\x01\xd7\x80\x9d\x0c\x1a\xa5\xc0\
\x6b\xce\xe5\x95\xe1\xa1\x6c\x08\x14\x38\x32\x49\x7e\xea\x12\x1a\
\x31\x04\x29\x11\x91\x04\xa3\x5b\xa6\x80\xe4\x02\xc7\x38\xda\x55\
\x2a\x2c\x56\x81\xcd\x04\x7e\x0d\x12\x2c\xcb\xc2\xcb\x7b\x6c\x2f\
\x6e\xe7\xb6\xa5\xdb\x98\xb6\xa6\x93\x6b\x1a\x54\x5a\xc4\xb8\x1a\
\x6c\x9d\xd4\x03\xe8\x24\x9c\x99\x18\xca\xab\x08\x30\x02\x62\x3b\
\x01\x6e\x05\x2b\x19\x60\x5d\x42\x43\x82\x1f\x43\xac\x5a\xee\xb1\
\x80\x59\x46\x38\xc8\x67\x16\x19\x44\xd0\x7e\x0e\xaf\x06\xbf\xae\
\xb3\x5c\x45\x9a\x65\x59\xe4\x72\x39\x2a\xe5\x0a\x5f\xb3\xbf\x46\
\xbf\xe8\x5f\xf1\xd2\x3a\xd1\x58\x23\x84\x7a\x08\xb5\x00\x96\x42\
\xa8\x06\xb0\x24\x21\x6a\x13\x2b\x23\x91\x5c\x5b\x6c\xb6\x4b\xef\
\xad\x87\x10\x46\xa9\xf6\x21\x79\x46\xcc\x02\xef\xf1\x4b\xce\x73\
\x3e\x13\x01\xab\x93\x98\xd6\x7a\xa0\x55\xf3\xab\x89\x69\x67\x01\
\xcb\x44\x09\x81\xe7\x79\xf4\xf6\xf5\xf2\x95\xe2\x57\xb8\x53\xde\
\x89\x70\x44\x12\x98\x45\x32\xe0\x40\xa6\xe0\x03\xa8\xfa\xb0\xe8\
\x43\x35\x82\xb0\xd5\x0a\xd3\xfd\x00\xa8\x86\x69\x9b\x00\x96\xfc\
\xe4\xbe\x20\x4a\x2c\x0a\x41\x33\xfb\x33\x9c\xe4\x6d\xf6\xf1\x01\
\x50\xcd\x5e\x0b\xac\x06\xd3\x06\x64\x47\x3f\xd1\xd2\x46\x08\x81\
\x6d\xdb\xf4\xf4\xf4\x30\x3c\x34\xcc\x37\x17\xbe\xc9\x98\x1c\x63\
\xb4\x30\x9a\xda\x35\xe8\x28\xf1\xe4\x5a\x82\xb4\x21\x72\xc0\x8e\
\xa1\x8a\xe4\x4c\xed\x14\x26\xed\xeb\xf3\xda\x29\x96\xb4\xa4\x1a\
\x26\x3e\x22\x54\xe0\xab\x64\x41\x44\x09\x92\xfc\xbf\x59\x05\xce\
\x30\xca\xcb\xec\x63\x9e\xb3\x40\x2d\x7b\x14\xc8\x98\x0b\x64\x05\
\x4f\x3a\x0d\xf2\xf9\x3c\x83\x95\x41\x76\xcc\xef\xe0\xfe\x73\xf7\
\xb3\xc7\xdb\xc3\x74\x71\x7a\xd9\xdc\x74\x98\x00\x8a\xe3\x64\x5a\
\xb8\x06\x26\xd4\x14\x7f\x7a\xf0\x01\xbc\x34\x11\x92\x5a\x32\x1d\
\x4e\x11\x3a\x89\xf7\x8f\x0c\xc4\x80\x71\x52\xe0\x79\xa0\x00\x2c\
\x31\xcd\xab\xbc\xc0\x21\x3e\x01\xe6\x00\x3f\x73\x14\x58\x17\x5c\
\x86\xf0\xd8\x6e\xdd\x00\xc0\x71\x1c\xca\xe5\x32\xc3\x5b\x87\xb9\
\xb3\x7e\x27\x8d\xf3\x0d\x9e\xbf\xe6\x79\xce\xf5\x9c\x4b\x4c\xd6\
\x06\x13\x40\x2c\x41\xc5\x89\x56\x1b\x5a\xb2\xd0\x38\xbd\x52\x57\
\x90\x38\x42\x6d\x40\x0b\x30\x76\xaa\xf5\x26\xf0\x26\xf8\xbd\x3c\
\xcf\x2f\x78\x87\xe4\x85\x5b\x95\x24\xaa\x66\xb3\x80\x2c\xa9\x70\
\xb7\xe0\x9b\xe7\x0a\x85\x02\x9b\x36\x6d\x22\x0c\x42\xee\x1a\xbf\
\x0b\xfb\x73\x9b\x57\x87\x5f\x65\xa2\x3c\x81\xf6\x74\xa2\xc5\x00\
\x4c\x98\x90\xa0\x14\x49\xc8\x6c\xa2\x6f\x2d\x70\x9a\xf5\x7e\x9e\
\x24\xf3\xf3\x30\x4c\x71\x92\xe7\x78\x99\x17\x39\x84\xe6\x34\x70\
\x3e\xe9\x31\x31\x92\x6c\xd2\xce\xf1\x75\x22\x25\x03\x78\x00\xdb\
\xb6\x29\x95\x4a\x0c\x6f\x1d\x4e\x5e\x78\x4c\xc0\xc0\xe9\x01\xf6\
\x0f\xed\xe7\xe8\x96\xa3\x54\xf3\xd5\xc4\xf3\x05\x24\xbf\x92\x24\
\xa1\x69\x92\xb0\x52\xdd\x25\x64\x15\x40\xe4\x05\xf9\x30\xaf\xe5\
\x01\x79\x3c\x7e\x2e\x7e\x95\x0f\x39\x0c\x4c\x00\x67\x81\x7a\xda\
\x43\xb6\x65\xf1\x4c\xe9\x2f\x6c\x08\x7c\x53\x5c\xd7\xa5\x5c\x2e\
\x73\xdd\x75\xd7\x61\xdb\x36\xb9\xd3\x39\x2a\x33\x15\x76\xce\xed\
\xe4\xbd\x4d\xef\x31\x3a\x30\xca\x62\xef\x22\xaa\xa8\xd6\x25\xc0\
\xb6\x6d\xfa\xe2\x3e\x6e\x9e\xb9\x99\x9b\xc6\x6f\x0a\xde\xf8\xd7\
\x37\x3e\x9a\x1c\x9f\x3c\x06\x8c\x03\x93\xa4\xa6\xdf\x7c\x6e\x57\
\x16\xb0\x2e\x09\x6b\x84\xca\x2c\xe0\x9b\xe7\x5c\xd7\xa5\xaf\xaf\
\x0f\xc7\x71\x28\x14\x0a\x94\x7a\x4b\x0c\x4c\x0d\x70\xcb\xe4\x2d\
\x9c\x39\x7b\x86\x89\xe2\x04\xa7\x8b\xa7\x99\xf5\x66\xa9\xdb\x75\
\xa4\x48\xaa\x3f\x37\x76\x29\xa9\x12\x95\xb0\xc2\xf5\x8d\xeb\xd9\
\xde\xd8\xce\x0d\xd6\x0d\x38\x9e\xa3\xde\xf7\xde\x9f\x99\x64\x72\
\x02\x38\x03\x2c\x91\xf8\xc7\x65\xe9\xae\x16\x80\x35\x3d\x7f\x5b\
\x32\xba\x00\xdf\x4a\x42\x6f\x6f\x2f\x9e\xe7\x51\x2a\x95\x18\x1c\
\x1c\x64\xd3\xf9\x4d\x0c\xcf\x0d\x73\xeb\xd2\xad\xd4\xce\xd5\xa8\
\xa9\x1a\x3e\x3e\x71\x8a\xc5\xc1\xa1\x20\x0a\xf4\x58\x3d\xf4\xe4\
\x7b\xe8\x1d\xec\x65\xb0\x32\x88\x65\x59\x6a\x70\x68\xf0\x02\x70\
\xae\x1d\xf8\xae\x2c\xe0\x22\xc0\x5d\x58\x44\x56\xf0\xad\x62\xdb\
\x36\xc5\x62\x31\x49\x94\x7a\x7b\xa9\x54\x2a\x54\xab\x55\xaa\xd5\
\x2a\xb5\xa5\x1a\xbe\xef\x23\x23\x89\x52\x6a\xb9\xbd\x9b\x73\x29\
\x14\x0a\xf4\xf4\xf4\x50\x2e\x97\xe9\xeb\xeb\x23\x8a\x22\x5d\x2e\
\x97\x1b\x24\xde\x43\xd1\x46\xb2\xaf\x08\x71\xe9\x1c\x5f\x7d\xee\
\x4a\x80\x6f\x3d\xef\xba\x2e\x8e\xe3\x90\xcf\xe7\x9b\x80\x08\xc3\
\x90\x28\x8a\x90\x52\x2e\xbf\x1c\xb1\x2c\x0b\xd7\x75\xf1\x3c\x8f\
\x5c\x2e\x47\x2e\x97\xc3\xf3\x3c\x16\x17\x17\x71\x1c\xa7\xb5\x04\
\xda\x00\x01\xab\xb4\x2f\xd6\x39\xb7\x36\x87\x1b\x27\xa4\x39\x2d\
\x5c\x37\xd1\xb0\xd6\x1a\x63\xcc\xf2\x6f\xb3\x8d\x65\x59\x58\x96\
\xb5\x9c\x66\x37\x8f\x3b\x49\xe6\x05\x91\xb5\xbc\x7f\xa7\x79\x7f\
\xa5\xac\xa1\x15\xe8\x95\x94\xae\x32\x41\xd1\xe6\xdc\x45\xd7\x45\
\x27\x5b\xb8\x7c\x42\xae\xb4\x74\x9d\x08\xb5\xd5\x7e\x46\xb0\x57\
\x0a\x7c\xd3\xf4\x57\xef\xb7\x8a\x65\x59\x68\x63\xd6\x9e\xfc\xdd\
\x10\xd0\xba\xa4\x75\xc9\x00\x33\x9a\xfe\x95\x00\x6f\x8c\x59\x06\
\xdc\xba\xdf\xb6\x2d\xa0\xb5\x59\xfe\x8c\xe6\xb2\x08\xb8\x88\x84\
\xd5\xc0\xb3\x76\x70\x19\xe0\x9b\x60\x57\x6f\xad\x8e\x70\x75\x3f\
\x96\x65\x11\x2b\x8d\xee\x60\x02\xdd\x2d\x89\xad\x01\x7c\x23\xda\
\xef\x06\x7c\x13\xa8\x31\x06\xa5\x54\xf2\xd9\x4e\x9b\x68\xd0\xec\
\xa7\xf9\xd1\x94\x8c\xe3\x75\xad\xa4\x6b\x02\x3a\x01\xcf\xdc\x47\
\x06\x82\x56\x6b\x5a\x6b\x8d\x52\xaa\xcd\xa6\xd3\x7c\xa0\x19\x12\
\x2d\x6c\xdb\xc2\x76\x3d\x1a\x61\x14\x07\x41\x18\xb3\x52\x35\x6c\
\x90\x80\x96\x64\x68\xf9\x78\x83\xe0\xba\x05\xdf\x04\x1a\xc7\x31\
\x4a\x29\xa4\x94\x48\x29\xd3\x64\x28\x4e\x2d\x42\xa5\x9a\x4e\xb4\
\xef\xe6\xf3\x58\xae\x52\x47\x0e\xbf\xfb\xe1\xc8\xc8\x87\x13\x24\
\x9f\x44\xb4\x35\x85\x0d\xa5\xc2\x57\xc2\x0a\xd6\x93\x56\xf0\x71\
\x1c\x13\xc7\x31\x32\x8e\x09\x83\x90\x30\x0c\x08\x82\x24\x1b\x8c\
\xa4\x44\xa5\xc4\x18\x4c\xba\xb6\x50\x44\xdb\xb6\xf9\xe8\xfd\xf7\
\xfe\xfb\xc7\x3f\xfc\xc1\x33\x17\xce\x9f\x1f\x21\xa9\x03\xda\x4a\
\xe6\x28\xb0\x9a\xbe\x8d\xcc\xeb\x6e\xb4\xdf\x0a\x3e\x8a\x22\x7c\
\xdf\xa7\xe1\xfb\xf8\xbe\x4f\xe0\x07\x49\x4a\x2c\x25\xb1\x94\x68\
\x63\xc8\x79\x1e\xfd\xfd\x7d\xe4\x72\x1e\x9f\xfd\xcf\x27\x9f\x3c\
\xf2\xd0\xbf\x3c\xfe\xf1\x47\x1f\xbd\x49\x52\x02\xcb\xb5\xc6\xb8\
\x61\x27\x98\x05\x70\xb7\xb2\x7a\xbe\x37\xc1\x37\x1a\x0d\x6a\xb5\
\x3a\x8b\xd5\x45\xea\xb5\x3a\x41\x10\x10\x45\x11\xda\x18\x0a\xf9\
\x3c\x95\x4a\x85\xca\xa6\x0a\x02\xc3\xf1\xcf\x8e\x4f\xfc\xec\x67\
\xcf\x3c\xf6\xd6\x5b\x87\xf6\x77\x02\xdf\x35\x01\x97\x03\x78\x23\
\xda\x97\x52\xe2\xfb\x3e\xf5\x7a\x9d\x85\x85\x05\x2e\xcc\x5e\xc0\
\xb6\x6c\xbc\x9c\xc7\xe0\xe0\x00\x43\x43\x43\x0c\x0e\x0e\xe2\xba\
\x2e\xd5\x6a\x95\xe3\xc7\x3f\x9d\xde\xbb\x77\xef\xa3\x2f\xbf\xb4\
\x77\x5f\x16\xf0\x1b\x22\xa0\x93\x15\x6c\x84\x9c\x56\xf0\xad\x16\
\x10\x86\x21\x8d\x86\x4f\xbd\xde\x60\x69\x69\x09\x21\x04\xbb\x76\
\xdd\x41\xb9\x5c\xc6\xb6\x93\xcf\x64\x83\x20\x60\x76\x6e\x96\xb1\
\xb1\xd1\xb9\xd7\x5e\x7f\xed\xb1\x3d\x4f\xee\xf9\x45\x56\xf0\xb0\
\xf2\x56\x3e\x03\xf2\xd6\x77\x51\xed\x93\x8f\xec\x5d\xad\xad\xfd\
\x26\x78\x29\x25\x41\x10\xa6\x73\xbf\x41\xc3\x6f\xe0\x3a\xc9\x62\
\x49\x2e\x97\x03\x0c\xbe\xef\x33\x3b\x3b\xcb\xf8\xf8\xd8\xd2\x81\
\x03\xbf\xdc\xbd\xfb\x89\xdd\x4f\xc5\xb1\xca\x0c\xbe\x3b\x02\x36\
\x08\x36\x4b\xfb\xd6\xf4\xb6\x49\x40\x14\x45\x04\x61\x40\x10\x04\
\x89\xe3\x0b\x42\x4a\xa5\x12\x8e\xe3\x10\xc7\x12\xdf\x0f\x98\x9b\
\x9b\x63\xfc\xc4\x58\xfd\xd0\xa1\xb7\xf6\x3c\xb9\x7b\xcf\xa3\x8b\
\x8b\xd5\xd3\xdd\x80\xef\x8a\x80\xab\x5d\x9b\xb5\xb3\x80\x28\x4c\
\x16\x40\x82\x20\x44\x2b\xcd\xd0\xd0\x20\x40\x2b\x78\xff\xf0\xe1\
\x77\x9f\x79\xfa\xa9\x67\x1e\x9a\x9c\x3c\x7b\x8a\x36\x4b\x5e\x9d\
\xa4\x3b\x1f\xb0\xaa\x36\xbf\xd2\x04\x34\xe7\x7f\x1c\xc7\x44\xcd\
\x84\x27\x4d\x7a\xf2\xf9\x1c\x43\x43\x43\x04\xc1\x8a\xe6\x0f\x1f\
\x7e\xf7\x99\x9f\x3f\xfb\xdc\x4f\xc6\xc6\xc6\x27\x36\x02\xbe\x7b\
\x02\x8c\xc9\xe4\x00\x37\x02\xbe\xf9\xbb\x6c\x05\x71\x9a\x07\xa4\
\xd9\xde\x96\xe1\x61\x72\xb9\x1c\xb3\x73\xb3\x8c\x9f\x18\x5b\x3a\
\xf4\xf6\xa1\x27\x9f\x7e\xea\xe9\x87\xc6\x46\xc7\x4f\x6e\x14\x7c\
\xd7\x04\x64\x85\x7e\x39\xd6\xb1\x62\x09\x69\xae\xaf\x15\x39\xcf\
\x63\xcb\x35\x5b\xa8\x56\xab\x8c\x8d\x8d\xce\x1d\x38\x78\xe0\x89\
\x3d\x4f\xfe\xdb\xa3\x9f\x9f\xf9\xfc\xf4\xe5\x80\xef\x9a\x00\xb3\
\x6a\x41\x74\x23\xb2\x9a\x9c\x76\xf5\x7d\x42\x42\x7a\x6c\x60\x70\
\x68\x08\xc7\xb6\x38\xfe\xd9\xa7\x53\xff\xf5\xfa\xeb\x8f\xee\x7e\
\x72\xcf\x53\xf3\x73\xf3\x9f\x5f\x2e\xf8\x4e\x04\xa4\x1f\xa5\xb4\
\x0c\xfe\x72\x9f\xb6\x06\x21\xed\x6b\xfa\xe4\xb7\x50\x2a\xd1\xd7\
\xdf\xc7\xe8\xe8\xe8\x89\xbd\xaf\xec\x7d\xf8\xc9\xdd\x7b\x5e\x88\
\xe3\xf8\xec\x95\x00\xdf\x89\x80\x4b\x19\x49\xff\xd9\xb5\x7a\x7f\
\xbd\x76\x59\xaf\xad\xfe\x1c\x3f\xa9\xea\x0a\xe4\x5c\xd7\x4c\x4c\
\x9c\xf8\xf8\xe7\xcf\x3e\xfb\xc8\x8b\x2f\xbc\xb8\x8f\xe4\xcd\xee\
\x15\x01\xdf\x91\x00\x91\x08\xb6\x6d\x27\x35\x77\x86\xf5\xff\x76\
\xe7\xb3\x1c\x0b\x21\x10\x96\x85\x65\xdb\xd8\x8e\x8b\x9b\x2f\x92\
\xb3\x3c\x75\x6c\xe4\xe8\x91\xc7\x1f\x7d\xf8\xb1\x03\x07\x0e\xbe\
\x71\xa5\xc1\x77\x24\xa0\xd1\x68\xc4\x73\x73\x73\x0b\x80\x30\x9d\
\x96\x56\xd6\x27\x72\xcd\x6b\xc6\x18\xb4\x01\xa5\x35\xb1\x52\x44\
\x52\x11\x4a\x49\x2d\x88\xe2\xa3\x1f\xbc\xff\xc1\x4f\xff\xf9\x9f\
\x9e\xfa\x68\x64\xe4\x4d\x60\xfa\x4a\x83\x87\x75\x16\x74\x81\x4d\
\xe9\x1f\x27\xbf\x58\x28\x14\xec\xcb\xc0\xdf\x51\x4c\xba\x7a\xab\
\x97\xc3\x20\x04\x61\x20\x3f\x3d\x76\x6c\xec\xdc\xf4\xd4\xc8\xd5\
\x02\xbf\x1e\x01\x90\x7c\x66\xd0\x47\xf2\xc6\xfd\x57\x21\x1a\x68\
\x00\xb5\xab\x05\xbe\x13\x01\x59\xae\x5f\x6d\xb9\x7a\x66\xf7\xff\
\x92\xc8\xff\x02\x85\xd4\x27\x29\xf9\x96\x51\xb8\x00\x00\x00\x25\
\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\x74\x65\x00\
\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x33\x3a\x30\x32\
\x3a\x31\x31\x2d\x30\x37\x3a\x30\x30\x4b\xf9\xc3\xed\x00\x00\x00\
\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\
\x00\x32\x30\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\x33\x3a\x32\
\x36\x3a\x31\x35\x2d\x30\x37\x3a\x30\x30\x06\x3b\x5c\x81\x00\x00\
\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\
\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\x30\x39\x3a\
\x33\x32\x3a\x31\x31\x2d\x30\x37\x3a\x30\x30\xce\xd9\x51\xa3\x00\
\x00\x00\x67\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\
\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\
\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\
\x65\x73\x2f\x62\x79\x2d\x73\x61\x2f\x33\x2e\x30\x2f\x20\x6f\x72\
\x20\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\
\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\
\x6e\x73\x65\x73\x2f\x4c\x47\x50\x4c\x2f\x32\x2e\x31\x2f\x5b\x8f\
\x3c\x63\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\x79\
\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\
\x54\x31\x33\x3a\x30\x32\x3a\x31\x31\x2d\x30\x37\x3a\x30\x30\x14\
\x48\xb5\xd9\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\x13\x74\x45\x58\x74\
\x53\x6f\x75\x72\x63\x65\x00\x4f\x78\x79\x67\x65\x6e\x20\x49\x63\
\x6f\x6e\x73\xec\x18\xae\xe8\x00\x00\x00\x27\x74\x45\x58\x74\x53\
\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\x2f\
\x2f\x77\x77\x77\x2e\x6f\x78\x79\x67\x65\x6e\x2d\x69\x63\x6f\x6e\
\x73\x2e\x6f\x72\x67\x2f\xef\x37\xaa\xcb\x00\x00\x00\x00\x49\x45\
\x4e\x44\xae\x42\x60\x82\
\x00\x00\x02\xd4\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x02\x9b\x49\x44\x41\x54\x78\x5e\xed\xd4\x01\x48\x93\x61\
\x10\x06\x60\xe1\xe6\xbf\xe1\x92\x24\x13\xd1\x32\x8c\xb0\x96\x65\
\x53\x44\xd3\x52\xdd\x66\xd5\xb0\x0d\x20\x47\x5a\x11\x26\x61\x53\
\x75\x45\xaa\x2b\xcd\xb2\xe1\x54\x02\xcb\x11\x40\x41\x09\xe8\x14\
\x62\xa5\x96\x26\x05\x60\x22\x2d\x93\x14\x2c\x43\xdd\x44\x4a\x43\
\xca\x54\x29\x0a\xd4\x6d\xff\x7f\xd7\x50\x12\x22\x45\xad\x02\x90\
\x3e\x78\xe1\xe0\x83\x87\x83\x83\xd7\x85\x88\xfe\x49\x56\x11\x0c\
\xca\x41\x21\x28\xac\x47\xfc\x92\x07\x1a\x0f\x15\x0d\xbd\x8a\xc9\
\x1b\xec\x14\x67\xf4\x9b\x05\xca\x4e\x1d\x1c\x7c\x21\x5a\x31\x0c\
\x0a\x8b\x70\xfd\x31\x8b\xa9\xc8\x38\xca\x75\x0d\x4e\xa1\x83\x45\
\x42\x44\xfa\xf1\x46\x3f\xdb\xa9\xdc\x34\xcc\x86\xa8\x3b\x86\x21\
\xee\x71\xf4\xb2\x60\x88\x7f\x2d\x0a\x4a\xef\xff\xd4\xf0\xf2\x2b\
\x59\xc6\x38\x1a\x98\x40\xb2\x8c\x73\x64\x1d\x9f\x9b\xe7\x33\x8e\
\xf4\x66\xc4\x46\xea\xeb\xdd\x76\xfe\xbe\xfa\x0a\x88\xbd\xcb\x2c\
\x0a\x83\xbc\x53\x21\x4e\xef\x71\xd4\xb4\x7f\x23\x53\xd7\x14\x95\
\xd4\x8d\x62\x9a\xc1\xc2\x25\x5c\xee\x26\x59\x76\x07\x9d\x36\xf4\
\x72\x46\xf3\x17\x6a\xec\x47\x7a\xd0\x37\x97\xfa\x1e\x3b\xe5\x57\
\xf6\x3a\xf8\xd2\x6a\xe3\x82\x30\x1c\x30\xfb\xba\x2b\xcd\x33\x67\
\xaa\x3e\x52\xe2\x55\x2b\x6e\x48\x6a\x9b\x04\x59\x73\x2e\xc8\x9a\
\x44\xb3\xff\x92\x3a\x80\x58\x93\xdc\xe7\x70\xd3\x58\xd6\x9d\xb7\
\xa4\x7f\x8a\xa4\x6f\x41\x2a\x76\x46\xf7\xc4\x46\x7b\xd3\x1b\x6d\
\x10\x79\xe3\xe8\x2f\x30\x3f\xbe\xb5\xcd\x2f\xb1\x95\xbc\x13\x5a\
\xa6\x79\xb2\xa6\x4c\x90\x36\xf0\x16\x3c\x68\x54\xe5\x46\x6f\x45\
\x0d\xaa\xaa\x6c\xa4\x32\xe2\x6c\x12\xaa\x91\x14\x86\x0f\xe4\x16\
\x53\x31\xf9\x13\x0c\xb2\x47\x27\x40\xfa\x90\x04\xf2\xe6\x6e\x90\
\xdc\xf3\x5a\xea\xda\x8c\xf4\xf6\x3b\xdf\xb3\x56\xda\x52\x86\xb4\
\xb9\x14\xc9\xbf\x04\x69\x53\x31\x47\xae\x11\x7a\x16\x42\x0b\x03\
\xe6\x61\x9e\xe4\xfe\x08\xb3\xbf\xce\x00\x31\xb5\xb0\x18\x06\x11\
\x06\x7f\x88\xac\xb0\x43\x44\x39\x07\xe1\x65\xe8\x71\xb2\x83\x7c\
\x74\x48\xde\x57\x90\xbc\x8a\x90\x3c\x2f\x21\xf1\xe3\x8d\x08\x21\
\x39\x1c\x84\x9c\xe3\x20\x2c\xbf\xcf\x05\xa2\xab\x84\x4b\x6d\x09\
\xe1\xa5\x7c\xde\x9e\xf2\x76\x46\x76\x0b\x3d\x73\x27\x9c\x10\x4b\
\xeb\x0a\x91\x3c\x2e\x22\xad\x2d\x40\x72\xcf\x47\x12\x6a\x1d\x24\
\x38\xd5\x4b\x10\x9c\xc5\xc1\xae\x34\xcd\xb2\x3b\x00\x42\x0b\xf8\
\xbc\xdd\xba\xe7\x4c\xdc\x4d\x74\xd7\xce\xd0\x9a\x0b\x4e\xec\x3c\
\x92\x9b\x16\x49\x90\x87\xc4\xa8\xdf\x3b\xd1\x4c\x16\x82\x52\x34\
\x2b\xee\x0a\x10\x6b\xf8\x10\x9a\x67\xe6\x49\xae\x21\x93\x3d\x4d\
\x4c\x2e\x92\x6b\x0e\x12\xa4\x0e\x13\x88\x53\x59\xd8\x71\x5c\xf3\
\xdb\x5d\x01\x3b\x53\x18\x08\xce\x30\x43\x94\x1e\x21\x6b\x9a\x20\
\x65\x88\x20\x28\x99\x85\xed\x2a\xcd\x1f\x97\x10\x88\x54\x8c\x13\
\x7b\x06\x61\x5a\x84\xc0\x24\x16\xb6\x29\x35\x7f\xad\xdd\x20\x40\
\xce\x40\x60\x62\x2d\x6c\x95\xab\x57\x59\x1f\xff\x87\xbf\x03\xea\
\x01\x27\x6b\xe4\x0e\xa9\xe9\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x02\xb6\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x01\x73\x52\x47\x42\x00\xae\xce\x1c\xe9\x00\x00\x00\
\x06\x62\x4b\x47\x44\x00\xff\x00\xff\x00\xff\xa0\xbd\xa7\x93\x00\
\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0b\x13\x00\x00\x0b\x13\x01\
\x00\x9a\x9c\x18\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xd8\x07\x13\
\x10\x02\x36\x23\x9f\x44\xe8\x00\x00\x02\x36\x49\x44\x41\x54\x58\
\xc3\xe5\x57\x3d\x6f\xd3\x40\x18\x7e\xee\x6a\x13\x29\x60\x20\x42\
\xb8\x8d\xda\x14\x09\x09\x2c\xa4\x4a\x48\x08\xc4\xc2\x84\xc4\xc0\
\xc4\xc2\x1f\x60\x46\x4c\x4c\x4c\xa8\x12\x42\xb0\xc0\x2f\xe0\xf7\
\x20\x31\x31\xb0\x14\xf1\x35\x90\x96\x34\x6d\x21\x29\xcd\xc7\xd9\
\x7e\x5f\x06\x37\xca\xc5\x39\x17\x3b\xbe\xa8\x43\x6f\xb0\xcf\x96\
\xec\xe7\xe3\x7d\xde\x3b\x5b\x30\x33\x8e\x73\x48\x1c\xf3\x70\xf4\
\x0b\x71\xfd\x51\x50\x5b\x5a\x7d\xeb\x2f\xaf\xdc\x04\x73\x64\x13\
\x48\xc8\x05\x67\xb7\xb5\xb5\xd1\xfe\xf9\xfd\x29\x7f\x7c\xf7\xc1\
\x48\xe0\x74\xcd\x7f\xf1\xfa\xf9\xe3\xfb\x0f\x6e\xf9\x50\x21\x90\
\xbb\x38\x22\x39\x31\x25\xf3\x51\x55\xe9\xf0\xc0\x00\x4e\xb9\xc0\
\xfb\xaf\xbd\x8b\x4f\x9e\xbd\x79\x05\xe0\xae\x91\xc0\x79\x7f\x31\
\xb8\x13\xf8\xf0\x5d\x00\xae\x3d\xf5\x7c\xc8\xf1\xf6\xe5\x2a\xea\
\x2b\xab\x8d\xcc\x12\x30\x71\xac\x62\x1e\x4b\xca\x0b\xc0\x09\x08\
\x69\xca\x99\xb4\x39\x03\x15\x07\x18\x28\x80\x88\xc8\x6a\x08\x47\
\xe0\xac\xa9\x1d\x81\x33\xb4\x72\xf0\x78\x9e\xe9\xc0\xac\xe0\x64\
\x00\x21\x00\x55\x77\xec\xe4\x20\x62\x63\xa6\x64\x69\x70\x18\xd4\
\xc2\xac\x56\x88\xe9\xe2\x66\x3a\x20\x84\xd0\xc0\x38\x97\x72\xd6\
\x88\xb0\x81\xb0\x8a\x80\x61\x5c\xd2\x81\xa3\x94\x4f\x80\xa7\x18\
\xa8\x18\xf8\xf6\x07\x68\x76\x67\xc8\x80\xee\x46\x4c\xfc\x7f\xe5\
\x0c\x44\x29\x02\x21\x59\x0a\xe1\x51\xca\x47\x17\xc3\x18\x50\x34\
\xbd\x16\xd8\xe9\x02\x9e\x56\xae\xa7\x7d\xe7\x80\x8d\x6a\x89\xc6\
\x99\x29\x97\x81\x94\x72\x32\x58\x4d\x00\xe2\xd4\xfd\xc5\x33\x02\
\x0f\x03\x51\xde\x01\xe6\xa4\x9d\x58\x00\x14\x03\x6e\xea\x0d\x75\
\x4f\xe4\xd9\x36\x66\x27\x50\x71\x26\xdb\xb3\xec\xd7\x84\x63\xb2\
\x38\xef\x88\x00\x84\xb6\x3f\x48\x8a\x6c\x43\x61\x46\xb2\x4b\x11\
\x20\x2e\x96\x07\x62\x8b\x25\x10\x00\x6e\x2c\xc9\x42\x6b\x02\xd9\
\x2c\xc1\x6e\xbf\xe0\xa2\xc4\x49\x7f\x5b\x23\x30\x8c\x8a\x13\xb0\
\xda\x05\xa2\x60\x17\xd4\x1c\x01\xd8\xee\x82\x13\xf7\x5f\x20\x67\
\x5d\x03\xe6\xe3\x80\x94\x0b\xf3\x06\x14\x52\xca\x4c\x02\xf1\x7e\
\xfb\xc7\xbc\x09\x0c\x7e\xff\xda\xce\xde\x0b\xfe\x6e\xae\xbb\xf7\
\x5e\xfa\xb5\x4b\x6b\x57\x7a\xad\xcf\x91\x74\x2a\xa8\x5e\x68\x20\
\xec\x75\xd0\xdf\x6b\xc2\xab\x5f\x05\xa4\xc4\xb0\xd3\x82\xea\x75\
\xe0\xd5\x83\xe4\xb1\xad\x0d\xb8\xd5\x73\xa8\x9c\xf5\x01\x08\xa8\
\x83\x3d\xa8\x6e\x1b\xde\xf2\x35\x0c\x3a\xdb\x50\xfb\x3b\xf0\x1a\
\x6b\x4e\x77\xf3\x4b\xb3\xdf\xfc\xb4\x3e\xe1\xc8\x89\xff\x3b\xfe\
\x07\x5d\x3e\x25\xc2\x5e\x8a\xcf\x86\x00\x00\x00\x00\x49\x45\x4e\
\x44\xae\x42\x60\x82\
\x00\x00\x14\x21\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x49\xd2\x00\x00\
\x49\xd2\x01\xa8\x45\x8a\xf8\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x12\x34\
\x49\x44\x41\x54\x68\xde\xbd\x9a\x69\x8c\x65\x47\x75\xc7\xff\xa7\
\xea\xee\xef\xbe\xb5\xfb\xbd\x5e\x66\xba\xa7\x67\x1f\xcf\xe0\x0d\
\xdb\x80\x50\x14\x08\x18\x8c\xb1\x1d\x93\x08\x88\x51\x04\x28\x9f\
\x22\x21\x22\x81\x22\x12\x65\x43\x11\xf0\x25\x8a\x94\x40\x50\x40\
\x91\xb2\x01\x01\x44\xb0\xc1\x01\x6c\x8f\xd7\xe0\x84\xc4\x1e\x63\
\x33\xb6\xc7\x1e\x33\x3d\x63\xcf\x4c\x77\x4f\xf7\xeb\xfd\xdd\xb7\
\xdc\xb5\xaa\x4e\x3e\xf4\x8c\x69\x06\xdb\xd3\x03\x84\xf7\x74\x74\
\xee\xad\x5b\xb7\xde\xf9\xdd\x73\xaa\x4e\x55\xdd\x47\xf8\x05\x3f\
\xf7\x3f\x74\x0f\x98\xf9\x35\xeb\x10\x11\x6e\xba\xf1\x96\x5f\xf4\
\xa7\x5e\xb9\xed\xcb\xbd\xe1\x81\x87\xef\x85\x31\x06\x00\xe0\xba\
\x2e\xba\xbd\xae\xb0\x2d\xdb\x23\xa2\x0a\x80\x10\x80\x7b\xbe\x6a\
\x06\xa0\xcf\xcc\x5d\xa5\x54\x5a\x0e\xcb\x26\xcd\xd2\x97\xdb\xb9\
\xf9\x9d\xb7\xfd\xea\x01\x0e\x3f\x78\x0f\x00\x83\x34\xcd\x84\xb4\
\x64\x43\x0a\x79\x50\x4a\x79\xad\x94\xf2\xa0\x94\xd6\xa4\x94\xa2\
\x26\x48\xb8\x00\x60\x8c\xc9\xb4\xd6\x1d\x6d\xf4\x8c\xd6\xfa\xb8\
\x31\xe6\xa8\xd6\xea\xb8\xd6\x66\x4d\x4a\x69\x88\x08\xb7\xbc\xeb\
\xf6\x5f\x1d\xc0\xe1\x07\xbf\x07\x22\x21\xb4\x2e\xa6\x84\x90\x6f\
\x73\x1d\xf7\x16\xdf\x0f\xae\x2b\x05\xa5\x61\xcf\xf7\x5d\xc7\x76\
\x84\x94\x12\x44\x04\x80\x61\x8c\x81\x52\x1a\x79\x9e\x99\x24\x4d\
\xb2\x38\x8e\x57\x92\x34\x7e\x2a\xcf\xf3\x7b\x94\x52\x8f\x48\x29\
\xcf\x18\x63\xcc\xad\x37\xbf\xe7\xff\x17\xe0\xf0\x83\xdf\x83\x10\
\x02\x5a\xeb\x06\x11\xbd\xcb\xf3\xbc\x0f\x55\x2b\xb5\x37\xd6\xaa\
\xf5\x9a\xef\xfb\x60\x30\xb2\x3c\x43\x9a\xc4\x48\xb3\x0c\x4a\x29\
\x00\x80\x65\x59\x70\x5d\x17\x9e\xeb\xc1\xb6\x6d\xb0\x61\xc4\x49\
\x8c\x28\x8a\x3a\xdd\x6e\x74\x24\xcd\xb2\x2f\x33\x9b\xc3\x00\xd6\
\xb4\xd6\x78\xcf\x6d\xef\xfd\xe5\x03\xdc\xf7\xc0\x77\x61\xb9\x0e\
\x8a\x34\xdb\x63\xdb\xf6\x47\xaa\x95\xda\xef\xb4\x5a\x23\xe3\x41\
\x10\x20\x4d\x13\xac\xae\xae\x60\x69\x79\x19\x6b\xeb\x1d\xd3\x1f\
\x24\x2a\xcd\xb5\xd2\x1a\x06\x00\x2c\x49\xc2\x75\xa4\x55\x2e\xf9\
\xd6\xd0\x50\x4d\x0c\x0f\x37\x51\xaf\xd5\x60\x49\x07\xfd\x7e\x0f\
\xcb\x2b\xcb\xf3\xdd\x5e\xf4\x8d\xa2\x28\xbe\x90\xab\xe2\x94\x6d\
\x59\xf8\xad\xdb\xde\xf7\xcb\x03\xb8\xff\xa1\x7b\x40\x44\x42\x29\
\x75\xad\xe7\x79\x7f\xd1\x6a\x8e\xde\xd4\x6a\x8d\x78\x79\x91\x61\
\x7e\x7e\x0e\x33\x33\x73\x3c\xbf\xd8\x89\xd7\x63\x8a\x06\x3a\x88\
\x32\x94\xfa\x8a\xdd\xcc\x40\x6a\x00\x10\x50\xd2\x42\xe6\xba\x14\
\x87\xa1\x15\x57\x1b\x25\xaa\x6e\x1b\xad\x07\x13\x13\xdb\xa9\x35\
\xdc\x02\x03\x58\x5a\x5a\x4c\x57\x56\x96\xef\x4f\xb3\xf4\xd3\x52\
\xca\xa3\xac\x94\xb9\xfd\xf6\xf7\xff\xe2\x00\x77\x7f\xf7\x4e\x04\
\x41\x40\x4a\xa9\xeb\x3d\xcf\xff\xd4\xf6\xf1\xed\x37\x36\x1a\xc3\
\xd6\x5a\x67\x05\xd3\x27\xa7\x71\x66\x66\x29\x6e\x77\xad\xc5\x1e\
\x86\x17\x0b\x59\xef\x43\xba\x9a\x48\x30\x01\xc4\x00\x33\x33\x0c\
\x83\x8d\x61\x30\x1b\x90\xc9\x2d\x0f\x51\xb9\x26\x56\x47\xc6\x6b\
\x66\x64\xd7\x8e\xd1\x60\xe7\xd4\x4e\xf8\x9e\x8f\xe5\xe5\x65\xb5\
\xd0\x9e\x7f\x28\xcd\xd2\x4f\x5a\xa0\x27\x07\x59\xca\x1f\x78\xff\
\x07\xb7\x0c\x60\xbd\x52\xa1\x94\x12\x59\x96\xed\xf1\x3d\xff\x4f\
\xc6\xc7\xb6\xdf\x38\x34\xd4\xb4\xe6\xdb\x73\x78\xfe\xf8\x71\xf3\
\xd2\x5c\x6f\x65\x45\x8f\xcc\x14\xce\xc8\xba\xb4\x7d\x13\x48\x90\
\x20\x08\x00\x64\x98\xc1\x0c\x18\xc3\xcc\xcc\x6c\x0c\xb1\x66\x62\
\xad\xfd\x22\x65\x7f\x6d\x89\x1b\xdd\x41\x67\x65\xa5\x97\x2e\xec\
\x88\xe3\x64\x78\xff\xbe\x7d\xa2\x35\x32\x62\x19\x36\x37\x9e\x9b\
\x3f\x97\xa4\x69\xfa\xc7\x82\xc4\xc9\xcb\xf1\x80\xbc\xb8\xe0\x3f\
\xbe\x77\x17\x98\xb9\x6a\xdb\xf6\x27\xc6\x46\xc7\x3f\x30\x3a\x32\
\xea\xcc\xb7\xe7\xf0\xf4\x33\xcf\xe9\xe3\x67\xe3\x95\x99\x6c\x62\
\x26\x95\x43\xa9\x10\xd2\x01\x6b\x57\x6b\xed\x28\xad\x1d\x30\x5b\
\x8e\x25\xd9\x92\x82\x84\x20\x02\x43\x66\x85\x72\xb3\x5c\x39\x85\
\x52\x4e\xa1\x94\x9d\x29\x96\x7d\xe5\x15\xeb\xa9\x3b\x48\xfb\x6b\
\x36\x54\xd7\xaf\x55\x2b\x62\xa8\x31\x24\x94\x52\x3b\xe3\x78\x40\
\x4a\xa9\xc7\xdf\xfb\xde\xdf\xce\xee\xba\xf3\xdb\x3f\xb7\x07\x24\
\x11\xdd\x5c\xab\xd6\xee\x18\x69\x8d\x7a\x6b\xeb\xab\x38\x7e\xfc\
\xc7\x7a\xfa\x5c\xb6\xf2\x52\x7f\x64\x50\x2a\xfb\x23\xbe\xad\x04\
\x09\x45\x00\x81\x00\xe4\x85\xa1\xb5\x41\x91\x6d\x6b\xd5\xdb\x81\
\xe7\xa6\x86\x99\xf2\xa2\x70\xd6\xa2\x68\xb4\xe2\x5b\xae\x6b\x4b\
\x63\x36\x62\x0b\x00\x90\x15\x2e\xff\x78\xbd\x3e\x10\xa2\xcb\xae\
\xf3\x62\xf3\xd0\xc1\x2b\xe4\xd8\xe8\x98\x37\x18\x0c\xee\x58\x2d\
\x56\x8e\x18\x6d\xbe\x09\x40\x5f\x36\xc0\x5d\x77\x7f\x03\xcc\x3c\
\xe9\xb9\xfe\x87\x47\x46\xc6\x46\x94\x56\x38\x75\xea\x24\x4e\x2f\
\xf4\xd7\x96\xf4\xc4\xac\xe3\xdb\x23\xbf\xf9\xe6\xa9\x52\xb3\xe6\
\x83\x68\xa3\x03\x11\x11\x96\x3a\x31\x7d\xe7\x7f\xce\x90\x10\x24\
\x1d\x5b\x0a\xc3\x60\x21\x84\x2c\x79\xd2\xbf\xf5\xcd\x53\x6e\xb3\
\x16\x80\x0d\x33\x63\x23\xc4\x96\xd6\x63\xdc\xf5\xdf\x2f\xc5\x73\
\x89\x37\x5b\x99\x5f\x16\xd5\xca\x5c\x6b\xf7\xae\x3d\x18\x1d\x19\
\x1d\xe9\xf5\xbb\x1f\x4e\x92\xe4\xc8\x97\xbf\xfa\x2f\xa7\x3f\xf4\
\xbb\xbf\x77\x49\x00\xb1\xf9\x84\x88\x24\x80\x77\xd4\x6a\xb5\x37\
\x85\x61\x48\xf3\x0b\x73\x38\x33\xb7\x94\xac\x9b\xb1\xb3\xe4\xd6\
\x52\xcf\x95\x62\xa4\xee\xa3\x56\x92\xd0\x2a\x47\x92\xa6\x94\x64\
\x29\x65\x59\x0e\x00\x70\x6c\x4b\x38\x8e\x25\x1c\x5b\x0a\xc7\x96\
\x82\x40\xc8\xf3\x9c\xb2\x34\x43\x9a\x65\xc4\x46\xa3\x1e\x5a\xdc\
\x08\x6d\xb6\xa5\x40\x8a\x30\x5e\x48\x86\xce\x9e\x99\x5b\x4c\x3a\
\xd1\x3a\xea\xf5\x06\xd5\xaa\xf5\x37\x01\xf4\x0e\x6c\xd8\xb2\x75\
\x0f\xfc\xf3\x97\xfe\x09\x5a\xab\xa6\xe7\x86\x37\x0d\x0d\x0d\xd7\
\x92\x24\xc6\xdc\xb9\x79\x5e\x89\xdd\x45\xe3\x8e\x46\x3e\x23\x48\
\x53\x22\x10\x61\xad\x9b\xe2\x9e\xc7\x67\xd0\x4b\x75\x6e\x49\xc1\
\x85\x32\x30\xa0\xc2\x73\x2d\x6c\x78\x80\xd9\x73\x6d\x68\xa6\xfc\
\xa1\x1f\xb5\x61\x49\xe2\x42\x19\x6a\x54\x1c\xfb\x3d\xbf\xb6\x9b\
\x68\xa3\x19\x12\x52\xd0\x00\x43\x9d\x76\xb7\xbf\xd8\x6e\x2f\xee\
\xa8\xd5\xea\x34\x3c\x34\x5c\x5b\x5d\x5d\xb9\x29\xcf\xb2\xef\x7c\
\xfe\x0b\x9f\x6d\xff\xc1\x47\x3e\xb6\x35\x00\xad\x24\x98\xb1\x3f\
\x08\x4a\xd7\x04\x41\x09\x8b\x4b\xf3\x58\x5e\xeb\x27\x03\x1a\x5d\
\xf6\x7c\x1f\x79\x9e\x8b\x9c\x08\x44\x44\xca\x30\xba\xb1\x2a\x6a\
\xb5\xea\x4a\xb9\xe4\x17\x00\x43\x0a\x61\x7c\xcf\x51\x82\x48\x68\
\x03\xae\x94\x7c\xb5\x7b\x72\x74\x29\xcb\x15\x94\x61\xee\xf5\x53\
\x3b\x8a\xd3\x51\xc3\x70\x84\x10\x20\x22\x58\x52\x10\x49\x47\xaf\
\xab\xfa\xd2\xe2\x5a\xd4\x9a\x1c\xf4\x83\x4a\xa5\x8a\x20\x08\xae\
\xe9\xf5\x7b\xfb\x0d\xa8\xbd\x65\x0f\x58\xb6\x92\x42\x78\xd7\x84\
\x61\x38\x0e\x30\xd6\xd6\xd6\x10\xa5\xb2\xcb\x6e\x23\x76\x1d\x4b\
\x68\xa3\x48\x08\x22\x29\x08\x96\x20\x72\x6c\x0b\x43\xd5\x52\x51\
\xaf\x94\xf2\xf3\xb1\xcd\x86\x99\x98\x01\x61\x18\x52\x0a\xd8\xb6\
\x2c\xb4\x61\x56\x9a\x8d\x14\x82\x7b\xbd\x02\x52\x08\x62\x29\x58\
\x08\x01\x69\x09\x58\x96\xa4\x4c\x57\xfa\x6b\xfd\x28\x8a\xba\xdd\
\x60\xdb\x78\x05\x61\x58\x1e\x5f\x5e\x59\xb9\x46\xc0\xfc\xe0\x52\
\x9d\xf9\x65\x00\x22\xb8\x96\xb4\x0e\xfa\x7e\xe0\x16\x45\x8e\xa8\
\xdb\xd7\x19\x97\xba\x96\xe3\x6b\x4b\x0a\x29\x85\x20\x65\x18\x4b\
\x9d\x84\xd2\x34\x43\x61\x0c\x48\x9c\x1f\x32\x41\x60\x80\xc4\x06\
\x07\x19\x03\x63\x0c\x03\xc4\x02\xc4\x86\xc1\x24\xa5\x20\xa5\x0d\
\x96\x3a\x09\x8a\xa2\x20\xad\x37\xca\x2c\x4b\x90\x82\xab\x06\xda\
\xef\x76\x7b\xfd\xd6\x76\x40\x96\x82\xd0\xb5\xa4\x75\x90\x88\x5c\
\x00\xf1\x16\x01\xa8\x24\xa5\x35\xe9\x38\x0e\x65\x59\x8a\x38\xcd\
\x95\x96\x43\xb1\x6d\xdb\x90\x52\x90\x6d\x4b\xce\x15\x17\x87\x9f\
\x98\x11\xcc\x4c\x85\xa6\xc2\xb1\x25\x4b\x29\x80\x8d\x0c\x0c\x00\
\x1b\x89\x8c\x58\x68\x01\x03\xc3\x44\xda\x10\x88\xc9\x71\x2c\xc4\
\xa9\xc9\xef\x3d\x32\x03\x6d\x0c\x72\x8d\xdc\xb1\x2d\x30\x88\x93\
\x82\x54\xcf\x38\xbd\x7e\x9c\x29\x6d\xb4\xf4\x3d\x8f\xa4\x94\x93\
\x44\xa2\xb4\x65\x00\x00\x81\x10\xa2\x21\xa5\x44\x9c\x24\x28\x14\
\x2b\x96\x41\x2e\x85\x24\x21\x88\x2a\xa1\xaf\x0e\xec\x1c\x5f\x02\
\x20\xa4\x24\x72\x1d\x89\x30\xf0\x34\x09\x22\x02\x5d\x98\x94\x10\
\x33\x40\xc4\x00\x43\x10\xb1\x39\x0f\x47\x61\xe0\x15\xbb\xa7\xc6\
\xdb\xb9\x52\xd0\x8a\x39\x2c\x4c\xbe\x1e\x9b\xde\xe9\x76\xb7\x7f\
\x6e\x25\x4d\xf7\x36\x52\x1c\x6c\xe9\x7d\xc6\x18\xd7\x76\x1c\x48\
\x21\x1a\x00\x82\x2d\xf7\x01\x66\x76\x00\xf8\x04\x82\xd6\x1a\x86\
\x89\x85\xb4\x0d\x09\x42\x52\x18\xc5\x05\x15\xa1\xe7\xaa\x92\x2f\
\x2d\xc7\x96\xd2\x12\xb4\x11\x41\x62\x63\x44\xd9\x58\x07\x6c\x78\
\x80\x04\x83\x0c\xa0\xc1\xc4\x20\x66\x30\xd9\x6c\x71\xe0\x8b\x34\
\x8f\x8b\x7c\xa9\x9b\x25\x2f\x2e\xa4\x83\x33\x8b\x83\xb4\xd3\xcf\
\x55\x96\x1b\xae\x58\x26\xc9\x15\x0a\x66\x86\x10\x02\x20\xf2\xcf\
\xdb\xb4\x35\x00\x63\x98\x0c\x9b\x97\xb3\xa5\x10\x02\x24\x04\x56\
\x7a\x2a\x39\xb9\x10\xf7\x93\x82\x75\xb5\xe4\x58\xa3\x75\xd7\x6d\
\x55\x1d\xaf\x1e\xda\x6e\xc9\x93\xb6\x6b\x91\xb4\x2d\x12\x72\xc3\
\x11\x44\x00\x83\x89\x35\xb3\xce\x34\x9b\x41\xc6\x45\x14\xab\x7c\
\xb9\x9b\x27\xe7\x56\xf3\xe4\xdc\x5a\x9a\x2e\x47\x79\xde\x4f\x0a\
\x63\x34\x93\x90\x12\xd2\x22\x48\x29\x20\x04\x93\x10\x17\x1e\x04\
\x83\x8d\xb9\xe4\x7a\x65\x13\x80\xce\xb4\xd2\x89\x31\x06\x52\x4a\
\xd8\x96\x10\x45\xa2\x70\x6c\x66\x10\xcd\xad\x66\xa9\x65\x09\xb9\
\xd6\x4b\xe5\xcc\x32\x29\xd7\x96\x83\xd0\x77\xe2\x4a\x39\x50\x25\
\xdf\x12\x25\x57\x4a\x5b\x0a\x21\x25\x11\x33\x38\x55\xac\x93\xcc\
\xe8\x6e\xa2\xd5\x5a\xbf\xc8\x3b\xb1\x52\x83\xa4\x30\x45\x96\xb8\
\xaa\x50\x36\x98\x6d\x57\x82\x15\x89\x44\x1b\x32\xc2\x00\x81\x2b\
\x2c\xcf\x25\x29\x85\x84\xd6\x29\x94\x52\x89\xd6\x3a\xdb\x32\x80\
\x52\x3a\x2e\x8a\x62\xad\x28\x72\xd8\x96\x0d\xcf\x91\x56\x9c\xc4\
\x3c\xdf\x11\xa9\x81\x30\xc4\x3a\x70\x4d\x77\xf7\x78\xcd\x2d\x01\
\x84\xe5\x28\x4a\xba\x79\x6b\x5a\xd8\x7e\x1f\xa4\x01\x10\x0c\xc0\
\x86\x01\x65\xc0\x5a\x33\x2b\xcd\xac\xb4\x61\xa5\xc9\xc0\xe8\x60\
\x48\x76\x0f\x8c\x34\xec\x40\x6b\x83\x85\x4e\x36\x58\x2f\xca\xd3\
\x06\x56\x5f\x4a\x60\x28\x84\x5f\x0e\x1c\xdb\xb2\x6c\xe4\x59\x86\
\xa2\x28\xd6\x94\xd6\xf1\xd6\x01\x8a\x7c\x90\xe7\xd9\x6c\x92\x24\
\xa8\x37\x6a\x08\x7c\xc7\x62\x35\x70\xd2\x22\x30\x42\x5a\x6c\x58\
\x51\x3d\x94\xa5\xf7\xbf\x65\x57\x99\x19\xf8\xc6\xa3\x2f\x89\x85\
\x02\x82\x84\x64\x10\x01\x20\x80\x01\x26\x30\x6d\x28\x26\x30\x0b\
\x10\x4b\x62\xb0\x26\x31\x5a\xb3\xc3\x3b\xde\xba\x2b\x34\xc6\xe0\
\x4b\x0f\x9e\x42\xd4\x21\x21\x48\xc2\x21\x16\xdb\xaa\x5c\xad\x57\
\x4a\x8e\x90\x12\x83\x78\x80\x2c\xcf\x66\x8b\xa2\x18\x6c\x19\x40\
\x6b\x9d\x65\x59\xf6\x5c\xaf\xd7\x4d\x87\x86\x87\xbd\x4a\x39\x14\
\x0d\x6f\xa5\xe6\x5b\x85\x3d\x30\x4e\x6a\x43\xb0\x25\xa5\x69\xd5\
\x4b\xa6\x50\x1a\x52\x0a\xa3\x0b\xa9\x89\x2c\x43\xe7\x01\xcc\xc6\
\x7a\x1e\x2c\x98\x19\x60\x00\x86\xc8\x40\x1a\x66\xa3\x24\x3b\x8e\
\xc5\x63\x43\x21\x33\x1b\x38\xb6\x64\x12\x02\x60\xc9\x0d\xaf\x70\
\x77\x36\xa9\xd9\xa8\x55\x2d\x63\x0c\xa2\x28\x4a\xb3\x2c\x7b\x4e\
\xab\xe2\x92\x21\xf4\xf2\x64\x4e\x4a\xa9\xf3\xa2\x78\xa6\x13\x45\
\xf3\x4a\x29\x54\x2a\x15\x4c\x0e\xc9\xe6\x54\x35\xab\x1b\x26\xd6\
\x1b\x03\x0c\x33\x33\xb4\x31\xac\x35\x93\x2e\xd2\x40\x67\x83\x50\
\x65\x83\xd0\x14\x69\xc0\x20\x62\x61\x19\x08\xcb\x10\x91\x10\x3a\
\x0d\x85\x8a\x2b\x42\x0f\x2a\xc2\x64\x21\x33\x84\x01\x98\x41\x1b\
\x5f\x21\x20\x84\xc0\x9e\xe1\xa2\xbe\x67\xd4\x6f\x56\x2a\x15\xc4\
\x83\x18\xeb\x9d\xf5\xf9\x3c\xcf\x9f\x21\xcb\xbe\xe4\x94\xfa\x65\
\x80\x8f\x7e\xe4\xe3\x30\xc6\x9c\x88\xa2\xe8\xe9\xa8\x13\x21\x0c\
\xcb\x18\x1b\x2e\x85\xd7\x8e\x25\x53\xbe\x6d\x2c\x03\xc1\xbc\x91\
\x71\xe1\x58\x16\x86\x2b\x8e\xbb\x3d\x18\xec\xdb\x66\xaf\x5d\xd9\
\xa2\xe5\xab\xe4\x60\x7e\x2f\xeb\xdc\x65\x69\x31\x49\x8b\x05\x17\
\x9e\x9f\x2e\xec\x9b\xb0\x57\xae\xde\xe5\xaf\x5f\xbd\xb3\x9c\x1c\
\x68\x56\x1d\xd7\xb6\xe4\xf9\x79\x38\x40\x24\x10\xba\x6c\xbf\x61\
\xa2\x98\x9a\x1c\xad\x87\xae\xeb\x63\x79\x65\x19\x9d\x4e\xe7\x69\
\xad\xf5\x89\x3f\xfb\xa3\x3f\xbf\x94\xfd\x3f\xbd\x1e\x10\x24\x97\
\x93\x24\x3e\xbc\xb0\x30\xff\x1b\x8d\xa1\x46\xbd\x39\x3c\x24\xae\
\xdc\x76\x6e\xea\x64\xd4\x9f\x7d\x6a\xc1\x8f\x00\x00\x44\x68\xd5\
\x03\x7c\xe8\xa6\x83\x42\x69\x53\x22\x21\xb0\xb4\x3e\xc0\x57\x1e\
\x3e\xcd\x6d\x40\x08\x69\x31\x00\x70\x01\x31\x1c\xca\xd2\x07\xdf\
\xbe\xab\xdc\xaa\x07\x60\xc3\xb0\x2d\xc1\xf5\xd0\x45\x7b\xbd\x0f\
\x22\x02\x09\xc2\x0d\xdb\x92\xb1\xeb\x76\x7a\x53\xa3\xcd\x96\xc8\
\xd2\x14\xb3\xb3\x33\xeb\x83\x78\x70\xd8\x12\x62\xf9\x92\xd6\x5f\
\x0c\xa0\x59\x69\x18\x3c\xbc\xbc\xb2\xfc\xc4\xca\xf2\xca\x3b\x9b\
\xcd\x61\x9a\x1c\x1d\x84\x6f\x19\x74\x5f\xb7\x1a\x8b\xe7\x0b\xcd\
\x68\xaf\xc5\x50\x9a\x69\x83\x85\x40\xcc\x50\x9a\xc1\x04\x08\x69\
\x41\x5a\x16\x40\x80\xc9\x2d\xc0\x10\x94\x66\x28\x6d\x60\x0c\x23\
\xd7\x9a\x06\x69\x8e\xc5\xb5\x01\x72\xc5\xd8\x5d\xcf\x6b\x37\xee\
\x2d\x0e\xed\x9b\xdc\x16\x7a\x9e\x8f\xe9\x93\xd3\xdc\x5e\x6c\x3f\
\xa1\x95\x7e\xd8\x18\xde\xd2\x8a\xec\x67\x12\xc5\xdf\x7f\xf1\x73\
\x92\x19\xef\x1b\x1d\x1d\xfb\xec\xd5\x57\x5d\x3d\x42\x12\x98\x99\
\x9d\xd3\x4f\xbc\x94\xce\x3c\x32\x6d\x75\x2d\xdb\xb3\x1d\xeb\xe5\
\xf4\x0b\x12\x84\x42\x19\x5a\x4b\xd0\x37\x8d\xdd\x27\x84\x5f\xeb\
\x83\x00\x13\x77\x42\xb1\xf6\xe2\xfe\x86\x4f\xa1\x6d\x11\xb3\xe1\
\x8d\xe4\xc4\x8c\x2c\xd7\xcc\x26\x2f\x6e\xbe\x52\x56\xde\x76\x65\
\x73\x72\x6a\x62\x52\xae\xae\xae\xe2\xb1\x23\x8f\x2d\xce\xcd\xcd\
\x7e\x8c\x88\xbf\xf9\x89\x3f\xfc\xd3\x2d\x01\xfc\xcc\xaa\xe7\x96\
\x5b\x6f\xe6\xa2\xc8\x67\xf3\x3c\x1b\x66\xe6\x6b\x5a\xad\x11\x2b\
\x08\x7c\x51\xb6\xb2\x72\xc9\xd6\xd9\xc9\x6e\x65\xfa\x74\x5c\x3b\
\xb3\x6e\xca\x0b\x11\xca\x0b\x5d\x54\x16\x06\xb2\xbe\x40\x61\x6b\
\xd9\xf2\xc3\x54\x5a\x36\x84\x10\x44\xd2\xd6\xc6\x2e\xaf\x77\x11\
\xb6\xd7\x55\xb8\xb0\xae\x4a\x0b\xab\x45\xb0\xb0\x9a\xfb\x0b\xd5\
\x00\xc9\xad\x07\xf5\xc4\xaf\x5f\xd1\x98\xd8\x39\x39\x61\x25\x49\
\x82\x67\x8f\x3d\x13\xcf\xce\xcc\xfc\xb3\x36\xfa\x1f\xa7\xa7\x4f\
\xa6\x53\x3b\xa7\xf0\xc2\xf1\x1f\x5f\x3e\xc0\xbd\xf7\x1c\xc6\xad\
\xb7\xdd\x92\x15\x45\x71\x3a\x8e\xe3\x29\x22\xb1\x67\xa4\x35\x22\
\x4b\x81\x27\xaa\x5e\x51\x19\xf5\xe3\x80\x2c\x7b\xd0\xe1\x6a\x47\
\xcb\x30\x95\xae\x9f\x4b\xd7\xcf\xa5\xe3\x15\xc2\xb2\x21\x5e\xde\
\x1f\x25\x66\x61\x17\x90\x4e\x0e\xe9\xe4\x46\xd8\x79\xc9\x25\xbe\
\x7e\xac\x3f\x72\xeb\xfe\xc1\xeb\xde\xb4\xaf\x31\x31\xb9\x6d\xbb\
\x95\xe7\x05\x7e\x74\xf4\x47\x78\xf2\xa9\x27\x4f\xbf\x70\xe2\xc4\
\xd7\x8f\x1d\x3b\xd6\x1e\x0c\x62\xad\x94\x52\xaf\xbb\xf2\x10\x5e\
\x7f\xdd\xb5\x38\xf6\xec\x73\x5b\x07\x00\x80\xfb\xee\x3d\x8c\x5b\
\x6e\xb9\x75\x2d\xcd\x92\x17\x7b\xfd\xde\x2e\x02\x76\x36\x9b\x4d\
\xaa\x94\x43\x51\xf3\x75\x65\xdc\xef\x8d\x8c\xb8\xfd\x12\xc0\x2a\
\x35\x76\xa1\xd8\x62\x43\x92\x81\x8d\xf4\x65\x36\xf6\x86\x60\xb4\
\x01\xb1\x16\x25\x91\x3a\xfb\xcb\xeb\xad\xb7\x6f\x5b\x3a\xf4\xd6\
\xa9\xfc\xca\xab\x76\xb5\x9a\x63\x23\xa3\x22\x4b\x33\x1c\x7d\xfa\
\x28\x9e\x7c\xea\x49\xb4\xdb\x6d\x2f\x49\xd3\x6b\x3c\xdf\x7f\x9b\
\x6d\x59\x37\x08\x21\x60\x8c\x39\x63\x8c\xd1\xaf\xe5\x89\x57\x9d\
\x2c\x7d\xee\xf3\x7f\x8b\x34\xcd\x49\x08\xbe\x26\x08\x82\x4f\xee\
\xd8\xb1\xe3\x5d\xfb\xf6\xee\xf3\x82\x52\x09\x71\xd2\x47\x27\xea\
\x9a\x95\x28\x1b\x2c\xf4\xad\xa5\x73\x71\xb0\xb4\x94\x05\x51\x5f\
\x7b\x49\xc1\x52\x03\x04\x9b\x0a\x59\x96\x99\xdf\xf2\xe2\xea\xb6\
\x52\xda\xda\x5e\xe5\xd6\x78\x23\x2c\x35\x87\x86\x85\xeb\x7a\x58\
\x5d\x5d\xc5\xf1\x17\x9e\x8f\x7f\xf8\xe4\x93\x33\x67\x67\x67\x77\
\x5c\x71\x60\xbf\x5f\x2e\x97\x61\xdb\x16\xe2\x24\x31\x27\x4f\x4c\
\x9f\x5a\x58\x68\x7f\x8a\x99\xef\x24\xa2\xec\x5b\x77\xde\x7d\x79\
\x00\x00\xf0\x37\x9f\xfd\x6b\x50\x41\x28\x44\xb1\xdf\xb1\x9d\xdf\
\x6f\x36\x9b\x77\xec\xde\xb5\x67\x6c\x6c\x6c\x14\x96\x6d\x21\xcd\
\x52\x24\x71\x8c\x38\xcd\x75\x9c\xe9\x3c\x55\x9c\x2b\x03\x05\x00\
\xb6\x20\xcb\x77\x84\x53\xf6\x6d\x27\x2c\x05\x32\x2c\x85\x70\x5d\
\x0f\x69\x92\x62\x66\x76\x06\x27\x4f\x4e\x2f\x2c\x2d\x2f\x7d\xed\
\xc8\x13\x4f\x1d\x89\xba\xbd\xcf\xbc\xf1\x86\xd7\xef\x1b\x1a\x1a\
\x42\xa3\xd1\x40\x63\xa8\x8e\xd5\xd5\x55\x1c\x39\xf2\xc4\x89\xf6\
\x42\xfb\xd3\xc6\x98\xbb\x98\x39\x0d\x02\x0b\x5f\xfb\xb7\x6f\x5d\
\x3a\x84\x2e\x7c\xee\x3f\xfc\x20\x6e\xb9\xf5\x66\x64\x45\xb1\xaa\
\x95\xfa\x61\xb7\xd7\x7b\x71\x65\x65\xa5\x12\x45\x9d\x61\x30\xbc\
\x52\x10\xa2\x52\xae\xa0\x5a\xa9\x88\x46\xb5\x6c\x37\x6b\x25\x6f\
\xb4\x11\x06\x63\x8d\x72\x30\x3a\x54\xf5\x9a\x43\x75\xbb\x5a\xa9\
\x0a\xd7\xf5\x90\xa6\x29\x66\xce\x9e\xc5\x73\xcf\x1f\x8b\xa6\x4f\
\x9e\xf8\xc1\xd2\xf2\xd2\x5f\x15\x45\xf1\xaf\xf7\x3d\xf0\x9f\x73\
\xbe\xe7\xdd\x58\xaf\x57\x77\x09\x21\xd0\xed\xf6\x30\xe8\x0f\x30\
\x32\xd2\x42\xb3\x39\x3c\x1c\x75\xa2\x43\xfd\x7e\x7f\x59\x29\x75\
\x82\x59\xfc\x4c\x38\x5d\x72\xef\xe5\xbe\xc3\xf7\xe3\xa1\x07\x1e\
\xc2\xea\xda\x52\xf2\xf4\xd1\xa7\x8f\x0b\x29\x1e\x8d\xa2\xe8\xc5\
\xc5\xc5\x45\xbd\xb4\xb8\xe8\x75\x3a\x91\x93\x24\xa9\xa3\x8a\x02\
\x5a\x1b\x68\x6d\xa0\x0a\x8d\x24\x49\xd1\x89\x22\x2c\xb4\x17\x70\
\xea\xd4\xc9\xf8\xf8\x0b\xc7\xcf\x4d\x9f\x9c\x7e\x74\x7e\x7e\xfe\
\x8b\xed\x85\xf6\xdf\x7d\xfd\x6b\xff\xfe\xf8\x5d\x77\x7e\x3b\x71\
\xfd\x00\x41\x29\xb8\x3e\x0c\xc3\xeb\x4a\xbe\x47\x4b\x4b\x8b\xe8\
\xf5\xfa\x28\x0a\x8d\xf1\xf1\x71\xb4\x5a\xcd\xe1\x28\x8a\xae\x8a\
\xe3\x78\x99\x99\xa7\x0f\x1e\xba\xe2\xa7\x20\xb6\xfa\x86\xe6\xa7\
\xea\xdd\x74\xd3\x3b\xe4\xf5\x37\x5c\xd7\xb4\x1d\xfb\x90\x6d\xdb\
\x57\x3b\x8e\x73\xc0\x75\xdd\xed\xb6\xed\xd4\x2c\x29\x3d\x00\x50\
\x5a\x65\x79\x96\x47\x69\x96\x9e\x8b\xe3\x78\x7a\x30\x18\x1c\x9b\
\x9b\x3b\xf7\xc2\x43\x0f\x3e\xb2\xba\xb2\xbc\xa2\x2f\xb4\xe9\xb8\
\x2e\xef\x39\x70\xc5\xbb\x5b\xad\xd6\x67\x0e\xec\xdf\xbd\x37\xf0\
\x1c\x74\xbb\x5d\x94\x4a\x65\x4c\x4c\x6c\xc7\x9e\xbd\xbb\xd1\xeb\
\xf5\xf0\xf8\x63\x8f\x9f\x68\xb7\x17\x3f\x63\x8c\xb9\x93\x99\xd3\
\x72\xb9\x8c\xaf\x7c\xe9\xab\x5b\x02\xa0\x4d\x7a\xb3\x30\x00\x4c\
\xed\x9c\x72\x6e\x78\xc3\x75\xa5\x52\x10\x54\xa4\x65\x95\xa4\x14\
\xae\x31\x4c\x59\x96\x15\xf1\x60\x90\x2c\x2e\x2d\x0f\x8e\x3d\xfb\
\x5c\x12\x75\x22\x8d\x8d\xb9\x97\xb8\xf8\x81\x84\x95\x8a\xb7\x7d\
\xc7\xce\xdb\x47\x47\x5b\x1f\x3f\x78\x60\xef\x4e\xcf\x75\x10\x45\
\x11\xc2\x30\xc4\xc4\xc4\x04\xf6\xed\xdf\x8b\x28\x8a\xf0\xf8\x63\
\x8f\x9f\x98\x9f\x5f\xf8\xb4\x52\xea\x9b\xb6\x6d\xe7\xdf\xba\xf3\
\xee\x4b\x02\xbc\x9a\xf1\xe2\x22\x8d\xd7\xb8\xbe\x59\x5e\xad\x0e\
\x5c\xdf\xf7\x27\x76\x4c\xbd\x7b\xfb\xf6\x6d\x1f\x3d\x78\xc5\xbe\
\x1d\xbe\xe7\xa0\xd3\x89\x50\x2a\x6d\x40\xec\x3f\xf0\x32\xc4\xa9\
\xf9\xf9\xf6\x5f\x12\xe1\x2e\x00\xe9\xa5\xfa\xc0\x66\xe3\xc4\x6b\
\x68\x71\xbe\x3f\x49\x6c\xcc\xaf\x36\x6b\xb9\xe9\xfa\xe6\x7a\x17\
\xea\xd8\x00\x1c\xad\x94\xec\xf7\x7a\xf3\x10\xb2\x9b\x17\x6a\x57\
\xbd\x56\xaf\x95\xc3\x12\x7a\xbd\x2e\x92\x24\x85\x52\x0a\xe3\xe3\
\xe3\x68\xb6\x9a\x8d\xf5\x4e\xe7\x50\x3c\x18\x9c\x05\x70\xea\x72\
\x00\x5e\xc9\x78\xc2\xa5\xe1\x36\x43\xbe\x9a\x87\x2c\x00\xb6\xd6\
\x9a\x06\xbd\xee\x2c\x0b\xd9\xc9\xf3\x62\x77\xa3\xd1\xa8\x96\xcb\
\x25\x74\xbb\x3f\x81\x98\xdc\x31\x09\xdb\xb1\x86\x17\xe6\xe7\xfb\
\x49\x92\x7e\xff\x72\x01\x70\xd1\xf9\x2b\x5d\xa7\x57\xb9\xff\x82\
\xe6\xf3\xf2\x4a\x6d\x09\xad\xb5\xee\xf7\xba\x67\x20\xe4\x72\x5e\
\x14\x7b\xeb\x8d\x5a\xad\x1c\x86\xe8\x76\xbb\x00\x80\x46\xa3\x8e\
\xf5\xf5\x8e\x9a\x9d\x99\xfd\x7e\x14\x45\x97\x05\xf0\x4a\xe5\x9b\
\x8f\xf9\x22\x0d\x60\xe3\x8d\xe5\x26\xa3\xcd\x26\x7d\x41\xf4\xa6\
\x72\x06\x00\xa3\xb5\x1a\xf4\xfb\xa7\x49\xca\xf5\x3c\x57\x7b\xea\
\xf5\x5a\xad\xd1\xa8\xa3\x5a\xab\x22\xea\x76\xf1\xec\x33\xc7\x8e\
\xb5\x17\x17\xff\xe1\xd1\x47\x1e\x3d\xbd\x95\x3d\xf8\xcd\xc6\xf2\
\x45\x06\x6d\x96\x8b\x0d\xbd\x60\xd8\x85\x63\x0d\x40\x5d\x24\xc5\
\xa6\x63\xbd\x49\x58\x6b\xa5\xfb\xbd\xfe\x59\x08\xd1\xcb\xf2\x62\
\x8f\xe7\xba\x95\x6e\xaf\x67\x5e\x78\xe1\xc4\x8b\x67\xce\x9c\xf9\
\xe2\x33\x47\x9f\xf9\xdf\x2c\xcb\x7f\xbe\x3c\x80\x57\x0f\x9d\xd7\
\x0a\xa3\xd7\x6a\xfb\x42\xe7\xb6\x37\x89\x05\xc0\x76\x3c\xaf\xb4\
\x7d\x72\xc7\x5b\x2a\xd5\xea\x5b\x08\xbc\xde\xed\x74\xfe\x6b\xf6\
\xec\xd9\xa3\x79\x9e\xf7\x00\xa4\x97\xfb\x67\x8f\x0b\x31\xbc\x95\
\x90\xba\xdc\x76\x37\x8f\x66\x16\x7e\x32\x42\xd9\x52\x4a\xd7\xf3\
\xfd\x50\x15\x85\xc9\xb2\xec\x82\xd7\xb2\x9f\x07\xe0\xb5\x0c\xf8\
\x65\xb4\xb1\x79\x94\xba\x30\xec\x5e\x80\xb9\x70\x7e\xe1\x21\x16\
\x00\x8a\xff\x03\x34\x60\x05\x5e\xc6\x0b\x52\x9c\x00\x00\x00\x25\
\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\x74\x65\x00\
\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\x3a\x35\x31\
\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\x82\x80\x0a\xca\x00\x00\x00\
\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\
\x00\x32\x30\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\x33\x3a\x32\
\x36\x3a\x31\x38\x2d\x30\x37\x3a\x30\x30\x67\xec\x3d\x41\x00\x00\
\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\
\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\x30\x39\x3a\
\x31\x31\x3a\x34\x31\x2d\x30\x37\x3a\x30\x30\x35\x62\x5d\x05\x00\
\x00\x00\x34\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\
\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\
\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\
\x65\x73\x2f\x47\x50\x4c\x2f\x32\x2e\x30\x2f\x6c\x6a\x06\xa8\x00\
\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\x79\x2d\x64\x61\
\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\
\x3a\x35\x31\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\xdd\x31\x7c\xfe\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\x2e\x6f\x72\
\x67\x9b\xee\x3c\x1a\x00\x00\x00\x17\x74\x45\x58\x74\x53\x6f\x75\
\x72\x63\x65\x00\x47\x4e\x4f\x4d\x45\x20\x49\x63\x6f\x6e\x20\x54\
\x68\x65\x6d\x65\xc1\xf9\x26\x69\x00\x00\x00\x20\x74\x45\x58\x74\
\x53\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\
\x2f\x2f\x61\x72\x74\x2e\x67\x6e\x6f\x6d\x65\x2e\x6f\x72\x67\x2f\
\x32\xe4\x91\x79\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\
\x00\x00\x10\xe5\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0a\x61\x00\x00\
\x0a\x61\x01\xfc\xcc\x4a\x25\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x0e\xe7\
\x49\x44\x41\x54\x68\xde\xed\x9a\x6b\x90\x5d\x55\x95\xc7\x7f\xfb\
\x71\xce\xbd\xe7\xdc\xdb\xb7\x3b\xdd\x9d\x90\x74\xa0\x09\x2f\x0d\
\x82\x56\x90\x97\x52\x8c\x58\x0a\xc5\xa4\x8a\x42\x60\x54\x90\xb2\
\x9c\x94\x02\x2a\xe0\x0b\x10\x07\x9c\x1a\x47\x1e\x23\x50\x28\x01\
\x81\x91\xf0\x18\x29\x40\xb0\xd0\x11\x70\x24\x08\x54\x80\xd1\xe1\
\x11\x03\x81\xe8\x20\x01\x92\xce\xd3\x74\x42\x77\xfa\x71\xfb\x9e\
\x7b\xef\x79\xec\x3d\x1f\xce\xb9\x27\xdd\x9d\xdb\x1d\xc5\x0f\x33\
\x1f\xe6\x54\xef\xba\x8f\x3e\xfb\xec\xff\x7f\xad\xff\x5a\x6b\xaf\
\xdd\x0d\xff\x7f\xfd\x1f\xbc\xac\xb5\x58\x6b\xcb\xd6\x5a\xf9\xbf\
\x8d\x65\x5f\x97\x98\x81\x80\x5a\x71\xc7\x8a\xc7\xde\x5c\xbf\x7e\
\x69\x14\x47\x02\x04\x22\xbb\xb3\x7f\xd1\xc1\x1c\xfd\xe1\x8f\xe0\
\x17\x5c\x94\x4c\xf9\x09\x21\xd2\x81\x00\x91\xde\x2b\x84\x44\x0a\
\x81\x90\x22\x7d\x2f\x65\x7a\x8f\x14\xd8\x74\x11\xc0\x66\x3f\xa6\
\xb5\x70\xfe\x1d\xd6\x10\x1b\xcb\x44\xbd\xc9\xf3\xcf\x3e\xc5\x96\
\x4d\x9b\xb0\xe9\x4c\xac\x05\xad\xb5\x39\xf2\xc8\x23\x1e\xd5\x6d\
\x59\x09\x91\x7c\xf9\x8b\x5f\x3a\xb5\x5a\xad\x8a\xb1\xf1\x31\x94\
\x54\xcc\x9f\xbf\x00\x80\x72\xb9\xcc\xc2\xfe\x45\x74\x78\xc5\x9c\
\xc0\xac\xd6\x11\x02\xd2\x9f\xcc\x5a\x02\x33\xfc\x0e\xc3\x2b\x6e\
\xa7\x70\xf0\xc1\xf8\x4b\x8e\xa6\x78\xc4\x11\x20\x04\x32\x9b\x94\
\x1a\x03\xe2\x24\x61\xb4\xd6\xa0\x5c\x2a\xd3\x68\x34\xa7\x3c\x3b\
\x6c\x86\xf2\x8d\x3f\xbe\xf1\x09\x3d\xd3\xe2\xd6\x1a\x35\x5e\xad\
\x12\x86\x11\x51\x1c\x30\x9f\xfd\xa6\x00\x93\x52\xec\x93\x40\x8e\
\x7f\xb2\x9f\x93\x98\xd1\x3b\x6f\xc7\x6e\xdd\xcc\xd8\xab\xaf\x30\
\xf1\xe4\x13\x54\x3e\xfa\x31\x3a\xcf\x38\x0b\xd9\xdb\x3b\x65\x8e\
\x30\x93\x27\x9a\xbd\x9e\x6d\x8c\x91\x33\x12\x30\x06\x5c\xd7\x65\
\xfe\x82\xf9\x04\x13\x35\x4c\x6b\xbe\xb5\x08\x01\x52\x08\x5e\x7d\
\xfb\x4f\xfb\x24\x30\xcd\x2c\x14\xd6\x7d\x93\x79\x83\x96\x28\x30\
\x38\xe5\x32\x8d\x17\x5e\x60\xd3\xe3\x8f\x53\x5a\xf9\x38\xe3\xe7\
\x5f\x82\x3a\xf8\x90\xdc\x5b\x4b\x0e\x5b\x80\x14\x02\x8b\xdd\xb3\
\xfe\x64\x8c\xd6\xa2\x67\x5e\xcc\x10\xc7\x31\x7f\xda\xb6\x9d\x38\
\x49\xe8\xf7\xbd\x29\x56\x55\x12\x8e\x5b\xbc\x70\x1f\xe6\x4f\x6f\
\x6e\xd9\x71\xfb\xea\x2b\xe9\xed\x5b\x45\xe1\xd3\x0b\x18\xf8\xf1\
\x5c\x2a\x03\x75\x8a\xa5\x12\xfe\xb1\xc7\xb2\xe3\x91\x47\xe8\x18\
\xdc\xc1\xe2\x87\x7f\x4e\xb1\xbf\x3f\x95\x49\x12\xa7\xcf\xb0\xed\
\x3d\x80\x35\xcc\xa8\x01\x63\x2c\xbd\x3d\x3d\xcc\x9f\x3f\x9f\xfd\
\x17\x2e\xc4\x18\x8b\x31\x16\x6b\x2d\x42\x88\x4c\x42\xe9\x6b\xbb\
\xa1\xf2\x91\x92\x1d\x59\xbf\x82\xee\xda\x8f\x28\x77\x74\xd3\x94\
\x3b\xb9\x3f\xda\xc8\xa6\x89\x09\x1a\x41\xc0\xc4\xd3\x4f\x33\xef\
\x9c\x73\x18\x7d\xf9\x65\xde\xfa\xfc\x32\x84\xb0\x48\xb9\x27\xc3\
\xa4\x1e\x68\x3f\x66\x24\x90\xa5\xd2\xbd\x46\xcb\xb0\x2d\x80\x7a\
\x86\xa1\x54\x36\xa4\x60\x7c\xdb\x4a\x9c\x6d\x57\x50\xee\xec\xa5\
\x1e\x8c\x73\xe3\x43\x92\x9f\xaf\x2b\x70\xc1\xf8\x38\xaf\x05\x01\
\x61\x10\x30\xf2\xd0\x43\x34\x7d\x9f\xe1\x67\x9f\x65\xf8\xf1\x95\
\x24\xc6\x92\x18\x72\xa3\xcd\x34\x66\x21\x60\xda\x0e\xb0\x99\x95\
\x41\x6a\x81\x54\x6d\x3c\xa0\xf6\x7c\x5f\x7b\x67\x2d\xcd\x3f\x7c\
\x9e\xce\xae\x6e\xa2\xb0\xc1\x03\x4f\xc6\x3c\xfc\x9b\x4e\xc2\x30\
\x64\xc7\xc4\x04\xe7\x8d\x8f\xb3\x5a\x0a\x02\xa5\xd8\x11\x45\xec\
\xaa\x54\xa8\x6d\x78\x3b\x23\x60\x30\xd6\x62\x8d\x6d\x8b\xc5\x18\
\xc3\xac\x41\x3c\xa3\x67\x26\x49\x9c\x69\x59\xc6\x4e\xba\xb7\x36\
\xba\x85\xea\xcb\x9f\xa4\xb7\xdb\x27\x49\x62\x56\xfd\x2e\xe4\x96\
\x47\x7a\x48\x92\x84\x5a\xad\x46\xad\x56\x23\x4a\x62\xf8\xaa\x47\
\xb4\x3e\x21\x7e\x22\x24\x90\x12\x7d\xec\x71\xc4\x89\x21\x49\x0c\
\x58\x8b\xb1\xed\x83\xd8\xee\x2b\x88\xdb\x13\x00\x6b\xd2\x87\x3f\
\xf6\xbb\xf5\xd8\x29\x90\x27\xdd\x17\x4d\x70\xf8\xe8\x32\x0e\xec\
\x31\x08\x24\xaf\xbe\xd9\xe4\x3b\xf7\xcf\x25\x4e\x22\x82\x20\x20\
\x08\x02\xc2\x30\xe4\xb2\x73\x5d\x3e\xf6\xc1\x88\xe2\x87\x24\xde\
\x3c\x9f\x0d\x47\x7c\x9f\xdf\xd4\x7d\xf4\x4b\x6f\xf2\xd1\x25\x8b\
\x52\x09\xcd\x80\xc7\x18\xfb\xee\x3c\x60\x2c\xc4\x89\xe5\x94\xa3\
\x0f\xc9\xbd\x30\x65\x6e\x1c\x32\xb2\xfa\x4c\xe6\x74\x07\x28\xa7\
\xc4\x86\xcd\x23\x5c\x7e\xd7\x5c\x26\x6a\x4d\x1a\x8d\x06\xb5\x5a\
\x8d\x7a\xbd\xce\x39\x27\x6b\xfe\xfe\x54\x43\xc1\x55\xf8\x9e\xc3\
\xc2\xaf\xde\xc4\xfe\xdd\xa7\x52\xa9\x54\xd0\x8e\x4b\x9c\x24\x18\
\x52\xad\xb7\xc7\x33\x8b\x84\x52\xbd\xb7\x23\x96\xea\x32\x36\x06\
\x91\xb4\xdb\x89\x58\x86\xd7\x5c\xcc\x5c\x35\x80\xeb\xf7\x32\xb8\
\x63\x90\xcb\xef\xea\x61\xe7\x70\x48\x14\x45\x39\xf8\x93\x96\x48\
\xae\xfc\xac\xa0\xe0\x0a\x7c\x4f\x31\xd1\x7b\x29\x4d\xff\x24\x3c\
\x21\x49\x0c\x88\xc4\x90\x24\x29\x70\x63\x4c\x5b\x3c\xb3\x7a\xa0\
\x95\x71\xf6\x9a\x64\xd3\xf4\x95\x24\x16\xd1\xc6\xad\x23\xaf\xdf\
\xc0\x5c\xfb\x5b\x8a\x95\x05\x8c\x0e\x6f\xe7\xda\x07\x7b\x79\x73\
\x73\x8d\x38\x8e\x73\xdd\x2f\xee\x87\x1b\x2f\x52\x14\x0a\xe0\x7b\
\x9a\x89\xca\x67\x18\xf3\x3f\x89\x27\x24\x42\xaa\xd4\xc3\xc6\x10\
\x1b\x93\x4a\xc8\xd8\xb6\x78\xf6\x21\xa1\x19\x08\x18\x93\x49\x68\
\x6f\xf0\xc1\x96\x9f\xd2\x53\xff\x09\x7e\xcf\x7b\x08\xc6\x07\x59\
\xf1\xeb\x45\x3c\xb3\x66\x2b\xd6\x5a\xea\xf5\x3a\x41\x10\x30\xb7\
\x2b\xe1\xd6\x4b\x14\x1d\x3e\x94\x3c\x4d\xdd\x3f\x89\x9d\xc5\x2f\
\x52\x94\x0a\xa4\x02\x21\x31\x16\x4c\x16\xc4\x86\x2c\x1b\xb5\xc1\
\x63\xac\xf9\xcb\x83\xd8\x98\x34\x33\xc4\x89\xc1\xda\x3d\xf2\x0f\
\x87\x9e\xa3\x73\x64\x39\xe5\xb9\x1f\xa0\x19\xec\xe6\xe7\x2f\xf4\
\x71\xdf\x2f\xdf\xca\xc1\xd7\x6a\x35\xb4\x68\x70\xdb\x37\x24\x0b\
\xba\xa1\xe4\x6b\xa2\xe2\xfb\x18\xd0\x97\x53\x90\x1a\x21\x24\x42\
\x28\xac\x10\xc4\x99\xe0\x13\x63\xb0\xc6\x62\xac\x61\xa6\x4a\xfc\
\xee\x82\x38\xcb\xd1\xab\xdf\xd8\x0e\x80\x6a\x6c\xe4\x38\xf9\x5d\
\x3a\x16\x1c\x41\x14\x05\x3c\xf7\xfb\x32\xcb\xef\xdb\x88\x31\x86\
\x30\x0c\xd3\x74\xd9\x0c\xb8\xfd\x52\xc5\xe2\x03\xc1\xf3\x14\xa1\
\x5e\xc0\x63\xdb\x2e\x24\xd1\x55\x0a\xc5\x08\xb7\xe8\x51\x2c\x78\
\x68\xc7\x05\x29\xc1\x5a\x8e\x3a\x74\xbf\x4c\x42\xa6\xfd\x5e\xc8\
\x30\x8b\x07\x66\x0b\x62\x2c\x49\x62\x38\xea\xd0\xfd\x88\x1b\x43\
\x94\x07\xbe\xc7\xbc\xbe\xf7\x63\x8c\xe1\xad\xed\x31\xff\x72\xcf\
\x36\x1a\x8d\x26\x71\x1c\xe7\x29\xf3\xea\xf3\x34\x27\xbc\xdf\xe2\
\x7b\x1a\xa7\xd0\xc5\x6b\xf1\x3f\xb2\xe8\x80\x83\xf0\x3c\x1f\xcf\
\xf3\x29\x7a\x1e\x9e\xef\xa3\x94\xca\x5b\x82\xc4\xd8\x3c\xe6\xda\
\xe1\xb1\xb3\x16\xb2\x99\x82\x38\xdb\x83\x44\x18\x6c\x1c\xd0\x35\
\x78\x0d\xbd\x0b\x8f\x04\xe9\xb2\x73\xb8\xca\x15\xb7\x8d\x32\x34\
\xb4\x1b\x6b\x2d\x41\x10\x50\xab\xd5\xf8\xd2\xe9\x96\x4f\x9c\x68\
\xf1\x3d\x45\xb1\x58\xe4\xa5\xfa\x25\xd4\x54\x5f\x1a\xb4\x42\x82\
\x90\x48\xe5\x60\x11\x69\x6c\xb5\x7a\x1a\x6b\x01\x91\xae\xd9\x06\
\x8f\x9d\x2d\x8d\x32\x63\x16\x4a\xd3\x28\x49\x4c\xe7\xe0\x35\xf4\
\x74\x77\x21\xdd\x0a\xbb\x87\x77\xf3\xed\x1f\x55\xd9\xb0\x71\x0b\
\xc6\x98\x5c\xf7\x4b\x8f\x8b\xb8\xf0\xcc\x34\x55\xfa\x9e\xcb\xea\
\xea\xf9\x0c\xdb\xf7\x50\xd4\xad\xa0\x55\x48\xed\x22\x94\x9a\x02\
\x3e\x05\x08\x92\x74\x1b\xc1\x5f\x9c\x85\x66\x92\x50\x6c\xb0\xd6\
\xe2\x0c\xfe\x90\xb9\x3d\x1d\xe8\x62\x37\xe3\xc3\x5b\xb8\xfe\xbe\
\x1a\x6b\x5e\x79\x1d\x6b\x6d\xae\xfb\x25\x87\x84\x5c\x7d\x9e\xc4\
\xf7\x24\x25\xcf\xe1\xb5\xea\xdf\xb1\xa5\x7e\x2c\x45\x4f\x22\xa4\
\x04\x14\xd2\x71\xd0\x8e\x8b\x31\x7b\x5a\xcb\x29\x58\x95\x4c\x0b\
\x5a\x5b\x09\xcd\x56\x07\x66\x08\xe2\x35\xab\x5f\xe0\xb0\xb9\x6f\
\x70\xda\x89\x1d\xb8\xa5\x45\x04\xe3\x3b\x78\x60\x95\xcf\xaf\x9e\
\x7c\x0e\x6b\x6d\xae\xfb\xbe\xee\x80\x9b\xbe\x62\x29\xfb\x12\xbf\
\xa8\x58\xf9\x72\x0f\xf7\xfd\xe6\x1d\x1c\x7d\x3f\xda\xd1\x68\xad\
\xd1\x8e\x4b\xb1\x58\x44\xce\xd4\xd9\x09\x41\xa1\x50\x60\xfb\xa6\
\x0d\x38\xda\x69\x23\x92\xd9\x2a\x71\xdb\x34\x2a\x38\x61\x49\x99\
\xa5\xc7\xc6\x14\x3b\x17\xd3\x6c\x8c\xf1\x1f\x2f\x3a\xdc\x71\xef\
\xca\x2c\x3b\x19\x82\x20\xc0\x77\x6b\xdc\xfa\x75\xc3\xbc\x39\x8a\
\x92\xe7\xf0\xea\xa6\x4e\x56\xac\xec\x43\xca\x2a\x89\x56\x28\x95\
\x12\x28\x14\x0a\x24\xcd\x20\x93\x8d\xcd\xa5\x6b\xf3\xcf\xe9\x77\
\x5a\xab\xb6\x78\x66\xed\xc8\x6c\x9b\xc2\xb1\xb8\x3f\xe4\x0b\xa7\
\x77\x52\xea\xfb\x38\x51\x30\xc8\xaa\xd5\x35\x7e\x78\xf7\xb3\x84\
\x61\x98\xe7\x7b\x9b\xd4\xb8\xf9\x6b\x11\x07\x2f\x4c\xc1\x6f\x19\
\xf2\xb9\xfa\xfe\x05\xc4\xc6\xa0\x55\x42\x02\x08\x04\x42\x6b\x6c\
\x56\x6d\xdf\xed\x35\x6b\x16\x9a\x5e\xba\xf7\x9b\x63\xf8\xf2\x27\
\x8b\x74\x2e\x3c\x99\x38\x9c\x60\xcd\xeb\x55\xae\xbe\xf9\x29\x76\
\xef\x1e\x01\x20\x0c\x43\x9a\x8d\x80\xeb\x2f\x68\x72\xd4\x7b\x15\
\x65\x4f\x33\x56\x2f\xf0\x0f\xf7\xf4\xd1\x88\x24\x4a\x89\xbc\xc5\
\x54\x5a\x23\x95\x9a\x71\xbb\xf2\xe7\x5e\xb3\x7a\x60\x72\xda\xaa\
\xf8\x82\xaf\x9c\xb1\x9b\xbe\xf7\x5e\x88\x15\x2e\x6f\xae\x7f\x9d\
\x2b\xaf\x5f\xc3\xc8\xc8\x28\x40\xbe\x49\xbb\xf4\xd3\x75\x4e\x3e\
\x46\x52\xf2\x14\x09\x2e\xdf\xbc\x73\x01\xbb\xab\x1a\xad\xd2\xa3\
\x12\x90\x68\xad\x73\x3d\x9b\xbf\x92\xc0\xac\x31\x40\x26\x21\xd7\
\x81\x6f\x9c\x5b\xe0\x3d\xc7\x2c\x03\x3d\x87\xed\x03\x6b\xb9\xec\
\x86\x75\x0c\xee\x1c\x9a\xa2\xfb\x73\x3f\x56\xe3\xdc\x93\xa1\xe4\
\x2b\x0a\xae\xcb\xd7\xff\x75\x2e\x9b\x06\x35\x4a\x41\x2a\x1a\x50\
\x4a\xe2\x3a\x4e\xba\xfd\x30\x7f\x1d\x78\x60\x1f\x1d\x19\x06\x29\
\x04\xe7\x2d\x1d\xe4\xfd\x1f\xbc\x00\x55\x7a\x1f\xef\x6c\x7d\x91\
\x7f\xba\x79\x0d\x03\x9b\xff\x94\xf7\xa4\xf5\x7a\x9d\x93\x3e\x50\
\xe3\x92\xb3\x2d\xbe\x9f\xea\xfe\xaa\x07\x7a\x79\x6d\x63\x19\xc7\
\xd1\xe8\x2c\x68\x5d\xd7\xa5\x5c\x2a\xa1\xb5\x9e\xdc\xad\x67\x96\
\xb4\xf9\x6b\xdb\x31\x43\xd3\xc4\xec\x5b\x09\x38\xe3\x84\x1d\x9c\
\xf4\xf1\xd3\xd1\x5d\x47\x33\xba\xfd\x19\xbe\xbb\xfc\x39\x5e\x5a\
\xf3\x56\xbe\x60\x18\x86\x1c\x7e\x40\x8d\xef\x9d\x9f\x50\xf6\x35\
\x65\x5f\xf3\xdc\x86\x0f\x51\x3a\xf0\x44\x3e\xb3\xd8\xa3\x58\x2c\
\xe2\xfb\x3e\xe5\x72\x99\xfe\x03\x0e\x60\x4e\x77\x77\x26\xa5\x76\
\x72\xb0\x6c\xd9\xbc\x99\xcb\x2e\xbd\x0c\xad\x54\x7e\xfc\x98\x06\
\xbf\xa2\x2f\x3b\x19\x9c\x2a\x92\x59\x3c\xf0\x37\x47\x8e\x72\xf6\
\x19\x27\xe2\xf6\x7c\x84\x60\xe8\x45\x6e\xb9\xf7\x0f\x3c\xf3\xfc\
\xdb\xe9\x6e\x94\x54\xf7\xf3\x2a\x35\x96\x5f\x14\xd2\xd9\xa1\x28\
\xf9\x9a\x35\x9b\x0f\xe3\x89\xdf\x1f\x8e\xe7\x05\x18\x63\x48\x92\
\x04\x80\xae\xae\x2e\xa2\x38\x66\x68\x68\x08\x60\x0a\x89\x96\x95\
\x85\x10\x74\x76\x75\xe1\x79\x45\x7c\xcf\x4f\xad\x6e\x21\x89\x13\
\xaa\xc1\x04\xc6\x24\x7b\x13\x48\x66\x20\xf0\xdf\x0f\xf5\x9c\xd1\
\x77\x60\x19\x6f\xff\x4f\x11\x4e\x6c\xe1\xb6\xbb\x56\xf2\xe0\x2f\
\xf6\x80\x37\xc6\x50\x54\x35\x6e\xb9\x38\x60\x7e\xaf\xa4\xe4\x6b\
\x36\xec\xea\xe3\xdf\xd7\x7e\x18\xd7\x75\x71\x1c\x07\xc7\x71\x70\
\x5d\x97\x9e\x9e\x1e\x7a\x7a\x7a\x10\x42\xe4\x40\x27\x5f\xad\x22\
\xd6\x22\xac\xa4\x42\x2a\x09\x36\xb5\xb0\xd4\x0a\xad\x34\x71\x1b\
\x02\xd2\xc4\x7b\x13\x78\x69\x45\xe1\x84\xf9\xf3\xba\x1f\xe8\x38\
\xf8\x3c\x9a\x63\x7f\xe4\xee\xbb\xef\xe6\xde\x47\xaa\x39\x78\x6b\
\x2d\x36\x09\xf8\xc1\xc5\x35\x0e\xeb\x4f\xc1\xef\xaa\xce\xe1\x0b\
\xd7\x09\x6a\x8d\x55\xa9\xe6\xa5\xc2\x62\x29\x14\x8a\x5c\x73\xed\
\x35\x68\xad\xf3\x13\xec\xb4\x3d\xdc\xa3\x69\x6b\x2d\x49\x92\x90\
\x24\x09\x52\x4a\x5a\x27\x4f\x56\x58\xb0\x02\xac\xc9\xe7\xed\xe5\
\x81\xb6\x41\x3c\xef\xeb\xdf\xf2\x3a\xd7\xf9\xe1\xee\x97\x78\xf4\
\x97\xbf\xe6\xb6\x87\x63\xe2\x78\x0f\xfb\x28\x6c\x72\xd5\xb2\x71\
\x8e\x39\x1c\x4a\x45\x45\xad\x59\xe2\xd6\xa7\x4e\x60\xd7\xd0\x6f\
\x91\x52\x23\x95\x44\xc9\xf4\x38\x3d\x0a\x23\x3c\xcf\xcb\xad\xdf\
\x92\x8f\x31\x26\x1f\x2d\x09\xc5\x71\x9c\x9f\x4a\x67\xa5\x38\x27\
\xd8\x02\xbb\x4f\x09\x3d\xba\xfc\x73\xe5\xce\xbe\xe3\xff\x76\x5b\
\x72\x28\x6f\x3c\x7d\x2b\xd7\xfe\xb8\x41\x1c\xef\x71\x79\x14\x45\
\x5c\x74\xfa\x18\x4b\x8f\xb7\x94\x3c\x4d\x42\x81\xe5\x4f\x1c\x4f\
\xb5\xd9\xb1\x27\xf2\xad\x45\x8a\xf4\xf4\x3a\x0c\xc3\x7c\x61\x21\
\x04\x49\x92\xe4\x52\x99\x4c\xa0\xf5\xbe\x45\xd4\x5a\x83\xcd\x36\
\x77\x36\x7b\xa6\x69\xd3\xc2\x1a\x39\x8d\x40\x79\xce\xbc\xd3\xfc\
\xca\x5c\x37\x6c\x6a\xf6\x5b\x7c\x3e\xe5\xf2\x5d\x34\x47\x6a\xb9\
\x05\xce\x3c\x61\x8c\x65\x4b\x63\x4a\x9e\x46\x69\xc5\x8d\xbf\x38\
\x92\x1d\x63\x73\x28\x16\x55\x4e\x40\x4a\x81\xeb\x16\x52\x6d\x4f\
\x02\xdd\x1a\x2d\xb9\x4c\x3f\xae\x6c\x05\xbc\xc9\x4e\xdc\xd2\xbf\
\x71\x98\x74\x4c\x22\xe0\x38\x1a\xc7\x71\x88\xe3\x18\x63\xe2\xa9\
\x47\x8b\x5d\xf3\x0f\x3c\x3d\x6c\x0c\x13\xd6\x06\x71\xc5\x28\x5f\
\x5b\xb6\x84\x39\x15\x07\x6b\x2d\x1f\x7a\xef\x38\xdf\xfa\x4c\x93\
\x92\xa7\x29\xb8\x8a\x2b\xef\x2c\xb0\x76\xa0\x33\xdd\x55\xea\x96\
\x1d\x04\xae\xe3\xa2\xb5\xce\x0e\x64\xa7\x5a\xb8\xf5\xb9\x15\xc8\
\xad\xdf\x45\x51\x44\x18\x86\x84\x61\x48\x92\x98\xb4\x89\x8f\xd3\
\xa6\x3e\x49\x4c\xd6\x95\xa5\xf3\x11\x82\x38\x23\x1b\x4f\x96\xd0\
\x2f\x7f\xf0\xb9\x82\xd4\xe2\xf4\x66\x30\x48\x33\xd8\x45\x18\xec\
\xa2\xaf\x3b\xe0\xdb\x5f\x98\xcb\x13\xff\xb9\x95\xcb\x3f\x55\xa3\
\xa3\x94\x82\xbf\xe5\x67\x9a\x87\x9f\xd1\x1c\x77\xbc\x42\xa9\x74\
\xa4\xe0\xd3\xec\x93\x6a\x3a\x21\x8e\x63\x9a\xcd\xb4\xb5\x9c\x6c\
\xf1\xc9\x84\x5a\xa3\x75\x8f\x49\x12\x92\x78\xaa\x87\x6c\x0b\x7c\
\xe6\x29\x63\x0d\x52\xc8\xa9\x41\xac\x7c\xe7\x14\xed\x8a\x52\x0b\
\x7c\xfa\xfa\x0e\x8e\xac\x71\xe6\x29\xfd\x34\xac\xa1\xe0\x8e\xf1\
\xb3\xe7\x04\x37\xfe\x54\x51\x2c\x38\x94\x4a\x25\x7a\x7b\x7b\xe9\
\xee\xee\xa6\x58\x2c\xe0\x3a\x4e\xba\x18\x36\x6f\x40\xe2\x38\xce\
\xdc\x3d\xd5\x0b\x2d\x29\xb5\xe4\x94\xe4\x56\x4d\xef\x6f\xd5\x01\
\x63\x5b\x31\x93\xa4\x1b\x41\xa5\x08\x83\x26\xae\x5b\x00\x98\x4c\
\xa0\xeb\x9c\xb8\x39\x42\x18\x0c\x11\xd6\x87\x89\x9a\xa3\x58\x13\
\xe3\x16\xbb\x71\xbd\x1e\xd6\x8f\xf4\xf3\x93\x27\xff\x8b\x07\x9f\
\x0a\xa9\x94\xd3\x2a\x7b\xcc\xd1\x47\xb3\xe8\xa0\x83\x50\x4a\x91\
\x24\x09\x13\x61\x98\x26\x10\x6b\x10\x52\xe6\xad\xe5\x74\xb0\x33\
\x79\x21\x27\x16\x27\x58\xa6\x7b\x20\x25\xd8\x6c\xd4\xf3\x8c\x95\
\x7b\xe0\xba\x6f\x9e\xe3\xde\xf3\xd8\xfa\x4f\x9f\xbd\x74\x21\xf3\
\x3a\xeb\x24\x51\x0d\x90\xe8\xe2\x1c\xaa\x41\x91\xc7\x9e\xdd\xc9\
\x8b\xaf\xee\xa2\x19\x7b\x54\x3a\xca\xb8\xae\x43\xd1\x4b\xb7\x08\
\x2d\xf0\x95\x8e\x0a\x43\xbb\x87\xf3\x73\x1c\x69\x0c\xdd\x3d\x3d\
\x44\x51\x94\x03\x6b\x05\x71\x8b\xc0\x64\x22\x2d\x2f\x25\x71\x42\
\x2c\xe3\x2c\x25\xa4\x67\x4f\x89\x49\x72\x09\x35\x1a\x0d\x7c\xbf\
\x44\x10\xd4\x51\x4a\xa6\x04\xde\xde\x3e\x76\xf6\xe6\x6d\x23\xce\
\x0d\x77\x6c\xe7\xb3\xa7\xed\xc7\x91\x87\xfa\xd8\xb8\x38\xbe\xea\
\xf9\xd1\x77\x56\xad\xde\x7a\x48\xbd\x99\x20\x84\x44\xc9\xf4\xb1\
\x49\x62\x30\x49\x5a\x1f\xa2\x28\x22\x8e\x63\xfe\xf9\xea\xab\xf2\
\x34\xd8\x02\x17\xc7\x31\xe3\xe3\xe3\x53\xac\xdb\xb2\xea\xf4\xec\
\x34\x59\xe3\x49\x12\x67\x7d\x71\xe6\x2d\x6b\xa6\xd4\x81\x89\x89\
\x6a\xf6\x4e\xa7\x04\x06\xb6\x8f\x9e\x5a\xad\x56\xa9\xd5\x6a\x7c\
\xff\xee\x5d\xc1\x05\x67\x1d\x71\xdd\xf3\xaf\x6c\xbd\xfb\xd9\x97\
\xb7\x1e\xd4\xbf\x70\xff\x7b\xb5\xd6\x87\x4c\x29\xe1\xd2\x00\x22\
\xd7\x77\x1c\xc7\x44\x51\x34\x25\x55\x4e\x2e\x58\x71\x1c\xef\xe5\
\x81\x16\xd1\xc9\x57\x8b\x58\x9c\xc4\xd3\x2a\x6e\x6a\xb4\xbd\xaf\
\x04\xfd\x9d\x65\x1f\x95\xbf\x7a\x6d\xf8\x2c\x49\x38\xd4\x5b\xd1\
\x37\x2e\x9c\xe3\xdf\x7a\xc5\x4d\x4f\x36\x80\x0e\xa0\xf9\xd6\xc6\
\x8d\xff\x76\x50\x7f\xff\xa5\x85\x82\x3b\x67\x4f\x41\x8b\x99\x98\
\xa8\xb2\x6b\xd7\xce\x5c\xab\xd3\x0b\xd3\x74\xd9\xb4\x7e\x3f\xbd\
\x81\x17\x59\x60\xb6\x62\x04\xc4\x5e\x9b\x67\xc1\xde\x1d\x62\x56\
\x18\xc7\xf4\xc0\x58\xb4\xd8\x73\x92\x2b\xd6\xaf\xdf\x72\x7f\x35\
\x68\xaa\x35\xd0\x09\xf4\x00\x45\xa0\x10\x46\xe1\xe0\xc6\xcd\x9b\
\x7e\x56\xa9\x74\x2e\x02\x2b\x01\xeb\x15\x8b\x62\xff\xfd\x0f\x70\
\xd7\xad\x5b\x57\x71\x5d\x57\x4b\xa5\xa4\x92\x52\x49\x29\x95\x52\
\x4a\x6a\xad\x95\x10\x52\x49\x29\xa5\x10\x48\x21\x64\xaa\xe8\x34\
\x91\x9b\xd4\x39\x26\x01\x91\x58\x6b\x63\x6b\x4d\xd2\x6c\x36\xc3\
\x5a\x2d\x88\xca\x1d\xe5\xf1\x5d\xbb\x76\xd6\x32\xef\x4c\xde\xf9\
\xe5\x5d\xbe\x10\xc2\x4a\x29\x47\xc2\x30\x7a\x41\x64\x40\x7b\x33\
\x8b\xbb\x80\xcc\x26\xca\xec\x73\x09\x28\x03\xad\x73\x0d\x5b\xa9\
\x54\xc4\x51\x47\x1d\xd5\xb9\x68\xd1\xa2\x52\x47\x47\x87\x2c\x16\
\x8b\xda\x75\x5d\xd9\x1a\xad\x7f\x2b\x90\xe9\x9e\x48\x48\x29\xad\
\x94\x12\xad\x75\x22\x84\x30\x52\x4a\x23\x53\x1d\xc6\xd6\xda\x28\
\x8e\xe3\xb8\x5e\xaf\xd7\xc6\xc7\xc7\x1b\x6b\xd7\xae\x1d\x7b\xfa\
\xe9\xa7\x47\xeb\xf5\xfa\x6c\xdd\xbe\x05\x22\xa0\xda\x62\x98\x9e\
\x32\xa5\x43\x4e\x1b\x4e\x36\xd4\x24\x8b\xd8\x52\xa9\x44\xb9\x5c\
\xc6\x71\x1c\x9b\xed\x36\xad\xe3\x38\xf9\x6b\x46\xc2\xb8\xae\x8b\
\x52\xca\x2a\xa5\x6c\x06\xde\x6a\xad\xad\x94\xd2\x2a\xa5\x6c\x46\
\x04\x29\xa5\xa9\x56\xab\x6c\xdd\xba\xd5\x0e\x0c\x0c\x58\x68\xff\
\x7f\x1c\xd3\x48\x24\xff\x03\x59\x56\xe3\x0b\xd4\x6d\xfb\x67\x00\
\x00\x00\x25\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\
\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x31\x2d\x31\x35\x54\x31\x37\
\x3a\x30\x32\x3a\x33\x35\x2d\x30\x37\x3a\x30\x30\x10\x90\x85\xa6\
\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\
\x61\x74\x65\x00\x32\x30\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\
\x33\x3a\x32\x36\x3a\x31\x35\x2d\x30\x37\x3a\x30\x30\x06\x3b\x5c\
\x81\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\
\x64\x69\x66\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\
\x30\x39\x3a\x33\x31\x3a\x32\x34\x2d\x30\x37\x3a\x30\x30\xf9\x59\
\xc2\xe4\x00\x00\x00\x67\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\
\x65\x00\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\
\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\
\x65\x6e\x73\x65\x73\x2f\x62\x79\x2d\x73\x61\x2f\x33\x2e\x30\x2f\
\x20\x6f\x72\x20\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\
\x69\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\
\x69\x63\x65\x6e\x73\x65\x73\x2f\x4c\x47\x50\x4c\x2f\x32\x2e\x31\
\x2f\x5b\x8f\x3c\x63\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\
\x69\x66\x79\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x30\x33\
\x2d\x31\x39\x54\x31\x30\x3a\x35\x33\x3a\x30\x35\x2d\x30\x36\x3a\
\x30\x30\x2c\x05\xbc\x4f\x00\x00\x00\x13\x74\x45\x58\x74\x53\x6f\
\x75\x72\x63\x65\x00\x4f\x78\x79\x67\x65\x6e\x20\x49\x63\x6f\x6e\
\x73\xec\x18\xae\xe8\x00\x00\x00\x27\x74\x45\x58\x74\x53\x6f\x75\
\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\x2f\x2f\x77\
\x77\x77\x2e\x6f\x78\x79\x67\x65\x6e\x2d\x69\x63\x6f\x6e\x73\x2e\
\x6f\x72\x67\x2f\xef\x37\xaa\xcb\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
\x00\x00\x03\x78\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x03\x3f\x49\x44\x41\x54\x78\xda\xad\x95\x8f\x4b\x13\x61\
\x18\xc7\x0d\x28\x03\x11\xcf\x52\x96\xf7\xab\x61\x69\x14\x05\xfe\
\x09\x01\x44\x40\xad\xa2\xa8\x48\x8d\xae\x0c\x82\x4a\x29\xca\x52\
\x22\xa7\x23\x47\xaa\xcd\x48\x75\x29\x6b\x67\x35\xc4\xd2\x50\x65\
\x4b\x99\xcd\x2d\x64\x9a\x99\x9c\xb5\x2c\x98\xd5\x05\x9a\x55\x12\
\x97\x8a\xa2\x69\x7e\xbb\x9d\xcc\x08\x33\xeb\xea\x81\x87\xf7\xee\
\xe5\x7d\x3e\x3c\x3f\xbe\xef\x5d\x08\x00\xc5\xff\xc4\x1c\x8e\x76\
\xa2\xa3\xe3\xb9\xe0\xf5\xfa\x16\x0c\x08\xf2\xfe\x16\x5c\x37\x33\
\x03\xb4\xb5\x3d\xfb\xbf\x60\x39\x5b\x04\xac\xb9\xb9\x73\x5e\x80\
\xdd\xee\xe5\x1e\x3c\x78\x22\xaa\x02\x77\x76\xbe\x50\xc0\xb5\xb5\
\x9e\x9f\x02\x78\xde\xc1\x75\x77\xfb\x21\x8a\x1f\xa0\x0a\xec\x72\
\x3d\xc1\xe4\xe4\x34\x64\xd0\x5c\x40\x61\x61\x15\xe7\xf1\x08\x08\
\x98\x20\xf4\xa9\x03\x37\x34\xb4\x41\x92\x46\x51\x5c\x5c\xa3\x04\
\x64\x64\x94\x71\x2e\x57\xb7\x02\x1d\x1e\x1e\x87\xd5\x6a\xe7\x55\
\x81\x6d\x36\x27\x06\x06\x86\x90\x9b\x5b\x89\xa3\x47\x8d\x72\x4f\
\xbb\x64\xe0\x18\xfa\xfb\x3f\xa1\xa4\xa4\x56\x28\x2b\xbb\x47\xa8\
\x02\x5f\xbf\x5e\x0f\xbf\x7f\x00\xe7\xcf\x97\xa2\xa6\xc6\xad\x00\
\x7d\xbe\x37\xc8\xc9\xb9\x21\x18\x0c\x56\x42\xb5\x2a\x4c\xa6\x6a\
\xa5\xbf\x72\xc9\xe8\xed\x15\x15\xd9\xa5\xa5\x99\x04\xd9\x89\x3f\
\x92\x5b\x6b\x06\xbd\xcb\x7b\x91\xc9\xee\x32\x30\xd9\x4f\x8d\x0c\
\x17\xdc\x3f\x93\x7a\x09\x7a\xbd\x05\x01\xd9\x39\x1c\x1d\x48\x4a\
\xd2\x0b\x89\x89\x7a\x62\x51\x1d\xd7\x1e\xa7\xb5\xce\x73\xb4\x30\
\xd4\x48\x03\xfe\x58\xe0\x63\x3c\x46\x1f\xc5\xe3\xe5\x55\x56\xf0\
\x5f\x61\x39\x5b\x99\x11\x01\xc9\x65\x66\x9a\xb1\x6f\xdf\x05\x41\
\xa7\x3b\x4b\x2c\x7a\x41\x78\x8e\x22\x9c\xe7\x62\x24\xb8\xa3\xf0\
\xe9\x2e\x89\xb7\x16\x06\xc3\x0e\x2d\x30\x30\x0b\x1f\xeb\x59\x8f\
\xfb\x8d\xc9\x30\x5c\xbc\x86\xd3\x07\x0f\x21\x08\x5d\x14\x5c\x91\
\x44\xf1\x63\xb7\xc2\xd1\x6d\xd4\xa0\xe9\x0c\xad\x94\xdf\x67\x62\
\x37\x8f\xb7\x6a\x95\xcc\x31\xb2\x11\x18\xdc\x84\xc1\xbb\x6b\xf0\
\xf6\x66\x2c\x9e\xe7\x31\xa7\x64\xe7\x7c\x79\xcc\xef\x5b\xd1\x94\
\xba\x02\x5f\xad\xa1\x28\x4f\xa2\x8a\x82\x87\xda\xb3\x18\xe2\x73\
\x3d\x03\x88\xb1\xf8\xd6\x1b\x87\x57\x56\x2d\x30\xb4\x01\x13\x3d\
\xf1\x98\x7a\xb1\x4e\x59\xfd\xe5\xab\x25\x79\x16\x09\x0b\x82\x1f\
\x9f\x0d\xc3\x87\xfc\x65\xc8\xdb\x41\x9e\x0a\x1e\x92\x33\xe7\x27\
\x9c\x31\xf8\xda\xc6\xa0\x3d\x87\x11\xde\x37\xca\xe0\xc1\xb8\x59\
\xf7\xad\x05\x5e\xc9\xab\xb8\x16\x42\x01\x2b\x2e\x08\x6e\x3d\x1e\
\x06\x98\x43\x50\x75\x68\x85\x94\xbf\x93\x2c\xb2\xa5\x90\xee\x41\
\xcb\x4a\x4c\xd8\xa3\x11\x18\xa8\x33\x9d\x26\xfa\xab\x19\xc0\xcf\
\xe2\xdd\x4d\x56\x7a\x7d\x95\xe5\xfc\x26\xb6\x6e\xf2\x21\x8b\xcf\
\x76\x06\x2d\xe9\xf4\xae\x5f\x82\x0b\x74\x1a\xf7\x17\x43\x88\x02\
\x47\xa5\xec\x77\x96\xa2\xcf\x14\x89\xfa\x34\x92\x97\xd5\xa2\xf4\
\xf1\xcd\x0d\x12\xd3\xae\x18\x78\xb3\x98\xb9\xaa\x7c\x26\x5a\x9c\
\xf1\xac\x42\x63\x1a\x9d\xfd\x4b\x70\xd6\x16\x92\xc8\xd9\x4a\xf2\
\x0d\x29\x11\x52\xcb\x89\x08\xd8\x8e\x68\x84\x8a\x64\x4a\x19\xe2\
\x0f\x88\x06\xa3\x35\x2b\x51\x9f\x4a\x6f\x0e\xee\xc9\xcf\x6e\x78\
\x22\x71\xe7\x18\x95\xad\xfa\xe6\xb5\x66\x68\xc4\xe9\xea\x30\x58\
\x92\x29\x3e\xf0\x5e\xba\x9f\x22\x3c\x99\xd1\xd2\xd8\xed\x70\x54\
\x72\xff\x00\x36\x1f\xa0\xf8\x29\xcb\x32\xf8\xf4\xe1\xc8\xdd\x46\
\xd6\x55\x1c\xd0\x88\x23\xa5\xa1\xe8\xd1\x47\xc0\x9c\x48\x25\xa8\
\x06\x17\xed\x21\xb5\x55\x87\xa3\x24\x94\xca\x21\xe5\xb3\x3e\x52\
\xb8\x04\xa6\xdd\x64\x9d\xea\x5f\x53\xd0\x8c\x3a\x32\xc1\xbc\x37\
\x5a\x6c\x3f\xb9\x1c\x8e\x14\x39\xf3\xed\x24\x7f\x59\x47\xce\xfb\
\x08\x7d\x07\xda\xb0\x04\xf6\xc6\x1c\xb1\x3a\x00\x00\x00\x00\x49\
\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\x61\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x06\xf3\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\x03\x36\x90\xc6\xc8\xc8\x40\x0a\xf8\x0f\xc5\xdf\
\x81\xf8\x1f\x03\x83\x95\xbe\x81\xfe\x5c\x4e\x46\x16\xc1\x53\x57\
\xaf\x6c\xdc\xfb\xeb\xe7\xc4\x97\x0c\x0c\xd7\xc0\xea\xd0\xec\x03\
\x08\x20\x16\x06\x2a\x82\xff\x4c\x4c\x91\x32\x06\x26\x01\x7a\xea\
\xca\x76\x61\x65\xc5\x12\x7f\x66\x74\x33\x58\x7c\xfb\x90\x26\xfd\
\xee\x8b\xf3\xfc\xd7\x2f\xd3\xde\x30\x30\xec\x43\xd7\x03\x10\x40\
\x2c\xf8\x7c\x44\x2c\x00\x85\xd5\x1f\x06\x86\x08\xf3\xec\x92\x65\
\x1e\x15\xe5\x0c\x82\x02\x7c\x0c\xbf\x1e\x5c\x67\xe0\x12\xff\xc3\
\x60\xa6\xce\xc6\xc0\x75\x97\x4f\xf9\xf0\x9b\xd7\x05\x6f\xfe\xff\
\xbb\x0e\x54\xfa\x1c\x59\x2f\x40\x00\x31\xe1\x32\x94\x8d\x04\xfc\
\x9b\x81\x41\x4c\x42\x4b\xad\x5a\x2f\x2a\x8a\x41\x4a\x4c\x90\xe1\
\xe7\xe7\xcf\x0c\xdb\x6e\xfd\x67\xd8\xa9\x57\xc0\xf0\x21\x38\x91\
\xe1\x0f\xcb\x0f\x86\x2f\xff\xff\x71\x01\x95\x8a\xa2\xdb\x03\x10\
\x40\x38\x1d\xc0\x42\x24\x06\xf9\x9e\x85\x91\x21\x3b\xb2\xb1\x48\
\xc7\xc2\x88\x8f\xe1\xca\xa1\xf5\x0c\xe7\x2e\xbd\x66\x30\x31\x55\
\x62\x78\xf6\x83\x9b\x61\x03\x9b\x39\xc3\xa5\xd0\x52\x86\xff\x9c\
\x3c\x3f\x81\x4a\x7f\xa0\xdb\x03\x10\x40\x38\x1d\xf0\x87\x48\xfc\
\x8d\x81\x41\xcd\xc8\xdb\x29\x5f\x2f\x24\x84\xe1\xf3\xc3\xf3\x0c\
\x6f\xbe\x0b\x33\xa8\xe8\xa8\x32\x48\x4a\xf1\x30\xf0\x70\xb2\x31\
\xdc\xbb\xf9\x84\xe1\x9b\xa8\x22\x83\xac\x9c\x92\x24\x50\x39\x3b\
\xba\x3d\x00\x01\x84\x33\x0d\xfc\x23\x22\xee\x41\x6a\x78\x39\xd8\
\x9a\xfc\x5b\x5a\xf8\x7f\xbd\xb9\xc9\x70\xec\x2a\x1f\x83\xa8\x9e\
\x3d\xc3\x7f\x60\xb0\xbc\xfe\xc8\xc0\xf0\xeb\xc5\x09\x06\x19\xa6\
\xeb\x0c\xaf\xef\x2b\x31\x7c\x78\xfe\x04\xa4\x85\x07\xdd\x0c\x80\
\x00\xc2\x19\x02\xcc\x44\x60\xa0\x03\x3c\x9c\xf3\x72\x82\xa5\x74\
\x24\x18\x4e\x9e\x7c\xc1\xc0\x28\x63\x07\x4e\xbd\x3f\x7f\x31\x30\
\xbc\x7c\x0f\x8c\xf0\x77\xeb\x18\x12\xb8\x26\x33\x7c\xda\xdd\xfb\
\xe7\xe2\xa7\x77\x17\x80\x5a\x3e\xa0\xdb\x03\x10\x40\x38\x43\x80\
\x9d\x40\xaa\xff\x0c\x54\x22\xa1\xa4\x54\xe7\x94\x9b\xcc\xf2\xfc\
\xfa\x45\x86\x67\x8c\x66\x0c\x62\x5c\x6c\x0c\x3f\x80\xb1\xcc\x02\
\x4c\x99\xf7\xaf\xdd\x62\xd0\xf9\x7d\x8a\xe1\xd5\xf3\x5f\x0c\x7b\
\x2f\xdf\xbb\x0a\x2c\x1f\xf6\x00\xb5\x3d\x44\x37\x0b\x20\x80\x70\
\x86\x00\x13\x1e\xcc\x08\x09\x81\x44\xf7\xe2\x3c\x4b\x1e\xa1\x77\
\x0c\xc7\x2e\x73\x31\xb0\x09\xcb\x30\xfc\x06\xfa\xfc\x37\x30\x04\
\x3e\x02\x6d\xfb\x74\x76\x09\x83\xf4\xdf\x37\x0c\xd3\xf6\x30\x7c\
\x39\xf7\x8b\x61\x3f\x50\xcb\x71\x48\x92\x41\x05\x00\x01\x84\xd3\
\x01\x3f\xf1\xe0\x2f\x0c\x0c\xb2\xaa\xe6\x16\x15\x36\x49\x8e\x0c\
\x57\x8f\x5d\x64\xf8\xc8\x66\xca\xc0\xca\x04\x09\xfa\x7f\x40\xfa\
\xf6\xd5\xc7\x0c\x3a\x9f\x16\x33\x5c\xbf\xc9\xc0\xb0\xe4\x16\xc3\
\x39\xa0\x96\xdd\x40\xfc\x18\x9b\x3d\x00\x01\x44\x72\x36\x04\x15\
\x50\x6c\x2c\x6c\xf9\x7e\x4d\xf9\xf2\xff\x3f\x5e\x60\x38\x77\x47\
\x96\x81\x9d\x47\x90\xe1\xd7\x77\x48\xc8\x7c\x00\xba\xee\xfb\xb1\
\x6e\x06\xb5\xbf\x0f\x18\x26\x1e\x60\x78\x09\x4c\x7a\xbb\x80\xc2\
\x67\xa1\x99\x06\x03\x00\x04\x10\x13\xbe\x34\x80\x0d\x03\x13\x9e\
\xb1\x69\xa0\x57\x8e\xb2\x8d\x28\xc3\xd3\x2b\xd7\x18\x7e\xf2\x1a\
\x31\x30\x02\x5d\xf5\x17\xe8\x7b\x50\xea\xbf\x7e\x78\x3f\x83\xcb\
\xef\x39\x0c\xfb\xcf\x33\x30\x6c\x7c\xc3\x70\x14\xa8\x05\x14\xfc\
\xaf\x70\xd9\x03\x10\x40\x24\x15\xc5\x20\x2f\x08\x0b\x09\x37\x7b\
\x54\xc5\xb2\x33\xbc\x3c\xc4\x70\xff\x39\x50\x3b\x87\x14\xc3\x3f\
\x60\xbc\x30\x02\x5d\x77\xf3\xca\x4b\x06\xd5\x9b\x45\x0c\xc2\xc0\
\x2a\x69\xe2\x29\x86\xdb\xc0\x08\xdf\x09\xd4\x72\x19\x5f\xc9\x0e\
\x10\x40\x4c\xf8\x52\x3a\x3a\x06\x7a\x32\xc8\x36\x3d\xcc\x53\x44\
\xee\x17\xc3\x8f\x3b\x47\x18\x5e\x7e\x97\x67\x60\x67\x61\x62\x00\
\x55\x9c\x0f\x1e\x7d\x67\xf8\x7d\xa8\x80\x21\x40\xf8\x02\xc3\x92\
\x63\x0c\xbf\x8f\x7f\x67\x38\x00\xd4\x72\x04\x92\x61\x70\x03\x80\
\x00\xc2\xe9\x80\xdf\x68\xf8\x2b\x03\x83\xa0\xbc\x96\x5a\xbd\x6d\
\x8a\x03\x03\xc3\x93\x03\x0c\x3f\x5e\x5c\x65\x78\xf6\x96\x19\x9c\
\xe5\x6e\xde\x78\xc3\xf0\x76\x77\x0e\x43\x8a\xe8\x0a\x86\x5b\x77\
\x18\x18\x66\x5d\x67\xb8\xf0\x1b\x12\xf7\x77\x08\x15\x66\x00\x01\
\xc4\x42\x8c\xcb\xfe\x43\xf8\x71\x0e\xe9\xbe\x7a\x1c\xac\x8f\x18\
\x18\x5e\x9c\x62\xe0\x60\x7c\xc5\x70\xfd\xc2\x49\x86\x3d\xe7\xf9\
\x19\x34\xfe\x2d\x60\xc8\x57\xdd\xc2\x20\x04\xb4\xb5\xf5\x28\xc3\
\xa7\x9b\xff\xc0\xf1\x7e\x12\x12\x68\xf8\x01\x40\x00\xb1\xe0\x2b\
\x09\x61\x00\x58\xb6\xa8\x6a\x59\x19\x56\x1b\x07\xa8\x03\xc3\x7a\
\x3d\x30\xa9\x5f\x67\xe0\x60\xfd\xcf\x50\x62\xbe\x94\xe1\xc1\xd3\
\x65\x0c\x66\x82\x5f\x18\x78\x81\x56\xed\x00\x26\xb9\x95\xcf\x19\
\x4e\x40\xb3\xdd\x53\x62\xaa\x72\x80\x00\x62\x21\x24\x01\x4a\x78\
\x5c\x9c\xdc\x45\x9e\xa5\xfe\xa2\x0c\x9f\x80\x59\xfa\x2d\x10\xff\
\xf9\xc1\xf0\xff\x2f\x03\x83\xb2\xc0\x57\x06\x65\x56\xa0\x03\x81\
\x2d\x8d\xd7\xc0\x80\x99\x73\x96\xe1\xd9\x0b\x48\x89\x77\x81\xc8\
\xea\x84\x01\x20\x80\x98\x08\x35\xb1\x80\x0e\xb0\xd2\xf3\x52\x4f\
\x95\xd5\x05\xa6\xa5\x67\x07\x81\x65\xd9\x4b\xb0\xc4\x3f\x60\x70\
\xff\x02\xe6\xf9\xaf\xef\x80\x5c\x60\x09\xbf\xfb\x14\xc3\xbf\x1d\
\x5f\x19\x0e\x42\xb3\xdd\x1b\x62\x1b\x33\x00\x01\x84\x33\x04\xbe\
\x22\x1c\x21\xf5\xf9\xe6\x75\xe6\xcb\xab\xbf\x32\x48\xca\x3d\x64\
\x10\xe6\x00\xe6\x08\xa0\xc5\xff\x81\xf1\xf2\x17\x48\x33\x02\xf3\
\xda\x8b\x7b\x0c\x0c\xb3\x6f\x33\xdc\xf8\x0a\xf1\xfd\x0d\x52\x9a\
\x71\x00\x01\x84\x33\x04\x80\xb5\x29\xc3\x7b\x48\xd1\xcb\xae\x63\
\x65\xca\xa0\xe1\xda\xce\xf0\xf7\xba\x0a\xc3\xbd\x4b\x5c\x0c\x1f\
\x98\x98\x18\xfe\x03\x83\xe6\x2f\x50\xd1\x3f\xa0\x5f\x57\x9f\x61\
\xf8\x76\xec\x37\xc3\x5e\xa0\xf2\x43\x90\x92\x9a\x78\x00\x10\x40\
\x38\x1d\xc0\x0a\x49\x88\xec\xda\x0a\x1c\x05\x06\xa9\xa9\x0c\xac\
\x9f\x2f\x32\x88\x03\x3d\x27\xfb\x98\x97\xe1\xf3\x5e\x29\x86\x47\
\x5f\xd8\x19\x98\x80\xf9\xff\x16\xb0\x95\xb7\xe0\x39\x03\xb0\xbe\
\x01\xfb\xfe\x11\xa9\x0d\x59\x80\x00\xc2\x5b\x19\x71\x32\x30\x84\
\x3b\x24\x79\x9b\x70\x08\x01\x1b\x33\x17\x16\x02\xe3\xe5\x0f\x03\
\xdb\xf7\x77\x0c\xd2\x77\xff\x30\x7c\xdf\x22\xc2\x70\xea\x3c\x33\
\xc3\xbc\x6b\x0c\x6f\xaf\x43\x52\xfd\x19\x62\xb2\x1d\x3a\x00\x08\
\x20\x16\x3c\x4d\x32\x6e\x5d\x03\xa1\x34\xad\xd0\x24\x60\x61\xba\
\x16\x98\xfa\x1f\x80\x13\xc6\xff\x77\xcc\x0c\x5f\x5e\x7f\x65\xb8\
\xfb\xec\x0f\xc3\xc2\x4f\xff\x9e\xed\x85\x14\x38\x20\xdf\xbf\x20\
\xa7\x29\x0f\x10\x40\x38\x1d\x00\x6c\x3b\x99\xd9\x84\xba\x58\x33\
\x83\x52\xdb\xed\xad\x10\xcb\x3f\xb1\x30\xfc\x7b\xcf\xc2\xf0\xe0\
\xcd\x1f\x86\xf9\x9f\x7e\xdc\xdd\xc8\xf0\x7f\x31\x50\x29\x50\x92\
\xe1\x0a\xb1\xd9\x0e\x1d\x00\x04\x10\x4e\x07\x48\x0b\x33\xd8\x2b\
\xea\x08\x03\xd3\xf4\x36\x60\xc1\xf3\x08\xdc\x94\x60\xfc\xc0\xc2\
\xf0\xe9\x2d\x03\xc3\xba\x0f\xbf\x3e\x6d\x67\xf8\xbf\x05\xa8\x6c\
\x35\x03\xb4\xc7\x43\x2e\x00\x08\x20\x9c\x0e\xb8\x2b\xe6\xe5\x73\
\xe9\xc4\x03\x06\xe5\x6f\x67\x18\xc4\x40\xf9\xf1\x0b\x50\xe9\x3b\
\x16\x86\x53\xaf\x7f\x33\x2c\xf8\xf3\xf7\x38\x30\xb2\x81\x2e\x63\
\xb8\x45\x69\x6f\x0a\x20\x80\x70\x26\xc2\xe7\x7a\xc5\x0c\xec\x19\
\x6b\x18\xd6\x8a\xd6\x33\xec\xbd\x25\xcb\xf0\xfb\xc1\x1f\x86\x9b\
\x4f\xff\x31\xb4\x7f\xfa\x79\x19\xd8\xb0\x03\x96\xc7\x0c\xa7\x71\
\x35\x32\x48\x01\x00\x01\x04\xee\x2c\x62\xc3\x1a\x7a\x33\x67\x6c\
\xb8\xfe\xef\xff\xa6\x37\xff\xff\x6f\xbb\xf4\xe6\xff\x22\x5b\xf7\
\xff\x01\xc0\xd4\x00\xd4\x53\x09\xc4\x8a\xd4\xb2\x0f\x20\x80\x70\
\x46\xc1\xf3\x27\x0f\xce\x2c\x5e\xf6\x36\x5d\x48\xf0\x1b\xc3\xa7\
\xc7\x97\x3e\xef\xbb\xc7\x7c\xf7\x35\x03\xc3\x1a\x68\xbc\xdf\xa7\
\x56\x87\x16\x20\x80\x18\x71\x75\xcf\x19\x19\xc5\x84\x99\x39\xa4\
\x13\xff\xfd\x7e\xaf\xfc\xff\xef\x53\x60\x83\xf2\x0f\x28\xa5\x5f\
\x82\x36\xad\xff\x53\x12\x02\xc8\x00\x20\xc0\x00\xbe\xfd\x98\x77\
\x14\xb9\x22\xb6\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\
\x00\x00\x06\xd4\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x06\x66\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x1a\x70\x07\x00\x04\x10\x0b\x32\x87\xd1\x64\
\x16\x2e\x75\xaa\x0c\xff\x19\x56\x32\xfc\xfe\xab\x02\x64\xff\x02\
\x8b\x80\x92\x0e\x23\x0e\x33\x59\x98\xde\x31\x30\x31\x26\x01\xd9\
\x07\xb0\x29\xf8\x7f\x26\x0d\xce\x06\x08\x20\x16\xa2\x9c\xf9\xf3\
\x8f\x83\xa2\x0c\xbf\x61\x67\xb1\x25\x03\x17\x07\x33\xd0\x1d\xff\
\x21\x0e\x60\xf8\x0f\x45\x90\x84\xcc\x08\x74\x10\x0b\x33\x13\x43\
\xdb\xbc\x0b\xfc\xc7\x4f\x3d\xf3\x60\xe0\x60\x3e\x40\xc8\x68\x80\
\x00\x22\xce\x01\x7f\xfe\x33\x0a\xf1\xb0\x32\x04\x3a\x2a\x02\x2d\
\x40\xf6\xf6\x7f\x54\x0c\xca\x51\x8c\x2c\x0c\x4b\xb6\xdd\x61\x38\
\xfe\xfb\xdf\x7f\x06\x76\x66\x4c\xb3\x18\x51\x83\x0d\x20\x80\x88\
\x73\x00\x23\xc3\xff\x7f\x40\xf3\xbe\x7c\xff\xc5\x20\xc0\xc5\xca\
\x70\xec\xc9\x7f\x86\xf7\xdf\xff\x33\x30\x02\x2d\xfc\xfb\xe7\x2f\
\xc3\x6f\x20\x66\x61\xf8\xc7\x60\x26\xcd\xc0\x20\xc6\xcf\xc6\xf0\
\xeb\xf7\x3f\xb0\x1e\xcc\x14\x87\x19\x67\x00\x01\xc4\x42\x52\x8a\
\x05\xea\xff\x07\xb4\x74\xed\x4d\x26\x86\xab\xaf\x19\x19\x58\xfe\
\xfd\x66\xf8\xfd\xeb\x1f\xc3\xf7\xef\x7f\x18\x78\x98\xfe\x30\x68\
\xf9\xb2\x32\x48\x30\xfe\xc7\xad\x19\x0b\x00\x08\x20\x92\x1c\x00\
\x0a\xe1\x7f\xff\xfe\x31\xb0\x02\xbd\xc7\xfc\xff\x2f\x03\x33\xd0\
\x01\xff\xff\xfd\x62\x60\xf9\xff\x07\xc8\xff\x03\x74\x1c\x13\x38\
\x3d\x60\x78\x1e\x87\xe5\x20\x00\x10\x40\x44\x3b\xe0\x3f\xdc\x11\
\xa0\x60\xff\xcd\xf0\xf7\xe7\x5f\xa0\x6b\x7e\x31\xfc\xf9\xf5\x07\
\x88\x81\x7c\xe6\x3f\x0c\xff\xff\xb0\x02\x1d\xf4\x1f\xd5\x7a\x3c\
\x96\x83\x00\x40\x00\x11\xeb\x80\x3f\xb0\x3c\x07\x4a\x0b\x7f\x7e\
\xff\x05\x5a\x0a\xcc\x8d\xff\x20\x96\x83\x31\xf3\x5f\x60\x08\xa0\
\xa4\x9b\xbf\x84\x2c\x07\x01\x80\x00\x42\x77\x00\x2f\xc3\xdf\x7f\
\xba\x0c\x7f\xff\xb3\x20\x79\xfa\x3b\xc3\xaf\xbf\xea\x20\x4b\x41\
\x71\x00\x8c\x01\xa0\x03\x40\x71\x0f\x0a\xfe\x3f\x60\xfa\xf7\x4f\
\x20\x66\xfd\xcb\xf0\xf7\xef\x5f\x70\x14\xfd\xf9\x03\x54\xf4\xeb\
\xaf\x2c\x10\x1b\x03\xf5\x73\xa1\x84\x06\x0b\xd3\x4d\x20\xeb\x15\
\x4c\x08\x20\x80\xd0\x1c\xf0\x7f\x86\x20\x1f\x7b\x14\x2b\x90\xf5\
\xf7\x1f\xa2\xa4\xf9\xc3\xc6\xcc\x20\xc8\xcb\xc6\xc0\xc4\xf4\x1f\
\x1a\x02\x7f\xc0\x18\x1c\x02\x40\xc7\x80\xf1\xff\x7f\x0c\xff\xfe\
\xfe\x03\xbb\x5a\x90\x9b\x95\x81\x5f\x80\x33\x9e\x95\x87\x35\x1e\
\xc5\x74\xa0\x71\x6f\xbf\xfe\x06\x95\x0d\x8e\x30\x31\x80\x00\x42\
\x75\xc0\xf7\xbf\xa2\x66\x16\xe2\x0c\x53\x2a\x6c\x80\x59\xeb\x0f\
\xd8\x32\x90\x89\xff\x80\x86\xb3\xb3\x32\x33\xb0\x02\x1d\xf0\x13\
\x18\xf7\x7f\xff\x40\x82\x1e\xe4\x80\xbf\xbf\x40\x18\x98\x06\x80\
\x3e\x07\xa9\xfb\xfe\xfd\x37\x43\x55\xb2\x2e\x43\x66\x98\x3a\x30\
\xcb\x03\x1d\x0c\x0c\xb8\xbf\x40\x87\x89\x8b\x70\x32\x74\x2f\xb9\
\xce\x30\x7b\xf9\x35\x11\x64\x2b\x01\x02\x08\xd5\x01\x1c\xcc\xcd\
\xfb\x8f\x3e\xb2\xba\xf3\xf0\x23\xb7\x87\xb5\x2c\xd0\xfc\xdf\xe0\
\x20\x67\x06\x1a\x04\x2c\x08\x80\x96\xff\x66\x60\x02\x25\xc2\xdf\
\x90\xa0\x67\x80\x45\x01\x08\x03\x2d\x07\x15\x3b\xbf\x80\x6a\x80\
\x45\x01\x83\x80\x28\x1b\xc3\xf7\x1f\x90\x68\xe1\xe5\xe6\x60\x78\
\xf9\xe9\x0f\xc3\xa6\xdd\xf7\xff\x02\x7d\xd1\x8b\x6c\x25\x40\x00\
\xb1\xa0\x65\x97\xc3\xbf\x7e\xfc\xed\xcf\x6f\x3b\x54\xb3\x77\xbe\
\x3f\x83\xb4\x30\x1b\xc3\xe3\x77\xbf\x19\xe6\x9d\xfd\xc3\xf0\xeb\
\xd7\x5f\x06\x46\x90\x85\x40\xcb\x1f\xbd\xf9\xc5\xc0\xf4\xf7\x37\
\x24\x2a\x40\x0e\x01\x86\xc8\x57\x60\x48\x34\xad\x7d\xca\xc0\xca\
\xf8\x17\x1c\x4a\x5f\xbf\xfe\x62\x48\x75\x13\x67\x30\x56\xe1\x65\
\xf8\xcf\xc4\xc2\x90\xd7\x73\x92\xe1\xe5\xab\x6f\xeb\x18\x78\x58\
\x97\x22\x5b\x09\x10\x40\x4c\x18\x79\x8d\x93\xa5\xe3\xd6\xad\xb7\
\x27\x1a\x67\x9c\x01\x3a\x88\x85\x41\x82\xe7\x3f\x03\x3f\x30\x81\
\x6d\xbb\xfa\x83\x61\xef\x4d\x20\xbe\xfe\x8d\xe1\xfd\xa7\x9f\x0c\
\xff\xa1\xa1\x00\xca\x0d\xff\x80\x69\xe0\x3b\xb0\x94\xdc\x77\xe9\
\x1d\xc3\xd6\xd3\x6f\x18\xd6\x1d\x7c\x06\xf4\xf9\x1f\x06\x75\x69\
\x2e\x06\x21\x41\x2e\x86\x79\x5b\xee\x31\x1c\x38\xf4\xf8\x29\x03\
\x17\x4b\x19\xd0\x8e\xdf\xc8\x56\x02\x04\x10\xb6\xea\xf8\x2b\x03\
\x1f\x7b\xf6\xbc\x95\x57\xdf\x2c\xdd\x7a\x9b\x81\x93\x87\x83\x21\
\xde\x90\x99\xc1\x42\x1a\x18\xff\x40\x4b\xd8\x81\x39\xf2\xff\xdf\
\xdf\x50\xcb\x7f\x83\xcb\x81\xdf\xbf\x21\xa1\xc1\xce\xf8\x0f\xcc\
\x57\x96\x60\x67\xa8\x09\x97\x67\x90\x04\xc6\xfb\xb9\x3b\x9f\x18\
\x3a\x67\x5f\xfc\x03\xb4\x3c\x0f\x98\x28\x1e\xa0\x5b\x06\x10\x40\
\x4c\x38\x8a\xcd\x73\xff\x18\x19\x7b\x4a\xba\x8f\x31\x5c\xbb\xff\
\x89\x41\x54\x90\x8d\x21\xdb\x9a\x9d\x41\x88\xe3\x1f\xc3\xe7\xaf\
\xd0\xc2\x07\x96\xfa\xa1\x18\x14\x0a\xdf\xbe\xfd\x64\x60\x02\x46\
\x53\x35\xd0\x72\x0d\x19\x6e\x86\x6f\x7f\x99\x18\x0a\x7b\x4f\x33\
\x7c\xfc\xf8\x6b\x21\x30\xee\xd7\x61\xb3\x0a\x20\x80\x98\x70\x16\
\x7b\x1c\x2c\x13\x5f\xbe\xfc\xba\x3e\xa5\xee\x00\xc3\xbb\x2f\x7f\
\x19\xd4\x25\x58\x19\xca\x9c\xb9\x81\xc5\xef\x1f\xa0\x45\xbf\xc0\
\xbe\x87\x25\x40\x10\xfb\xc7\x8f\xdf\x60\xf1\xb2\x20\x59\x06\x67\
\x7d\x21\x06\x56\x2e\x0e\x86\xaa\x29\xe7\x19\x2e\x5c\x78\x75\x1e\
\x18\xef\x55\x0c\x38\xaa\x08\x80\x00\xc2\xd7\x22\xfa\xc1\xc0\xc3\
\x9e\x75\xfc\xf8\x93\x4b\x35\x53\xcf\x32\xb0\x01\x0d\xb4\x53\xe5\
\x60\xc8\x75\xe2\x03\xc7\xf7\x0f\x60\x76\xfb\x0b\x2d\x86\x41\xb9\
\xe3\xdd\xc7\xef\x0c\x29\xae\x92\x0c\xd1\x0e\x12\x0c\x02\x82\xdc\
\x0c\xb3\x37\xdd\x63\x58\xb2\xee\xd6\x1b\xa0\xe5\x49\xc8\x05\x0f\
\x3a\x00\x08\x20\x02\x4d\xb2\xff\x2f\x80\xe9\x21\x7e\xfa\x92\x2b\
\x6f\x26\xae\xb8\xce\xc0\xc5\xcb\xc9\x10\x68\xc4\xcb\x90\xed\x22\
\xc4\xf0\xe5\xeb\x4f\xb0\x43\x40\xa5\xe0\xbb\xf7\xdf\x19\x62\xec\
\xc5\x18\x72\x7d\x65\x80\x89\x8e\x9b\x61\xcf\xb9\xd7\x0c\x8d\x93\
\xcf\xff\x06\x26\xe8\x0c\x60\xbc\x5f\xc0\x67\x03\x40\x00\x31\x11\
\x51\x07\x5f\x60\x60\x63\x2e\x2c\xef\x3e\xc1\xb0\x7c\xcf\x23\x06\
\x41\x21\x6e\x86\x04\x3b\x21\x86\x12\x5f\x09\x70\xdc\x7f\x02\xe6\
\x88\x64\x37\x49\x86\xaa\x30\x05\x06\x09\x51\x6e\x86\x8b\x0f\x3e\
\x33\xa4\x37\x1e\x65\xf8\xfe\xeb\x4f\x2b\xb0\xd8\x5d\x4b\xc8\x78\
\x80\x00\x22\xae\x32\x62\x63\x5a\xf2\xe7\xe7\x5f\xe1\xb4\x9a\x43\
\x7d\xbf\xeb\xad\x99\x22\x5d\x64\x19\xe2\x1d\x44\x19\x14\x84\x59\
\xc0\x89\xd2\x51\x5f\x90\x41\x4c\x84\x9b\xe1\xe4\x8d\x8f\x0c\xc9\
\xb5\x47\x18\xde\xbc\xfb\x31\x09\x98\xea\x9b\x18\x88\xe8\x72\x00\
\x04\x10\x0b\xd1\x75\x31\x3b\xf3\xc4\x6f\x3f\xfe\xb2\x65\x35\x1d\
\xed\xfa\xfc\xcd\x94\x21\xd6\x43\x81\xc1\xdb\x8c\x05\x52\x5c\xb3\
\x30\x33\xec\x3d\xff\x86\x21\xab\xf5\x04\xc3\xab\x97\x5f\x67\x00\
\xe3\xbd\x84\xe1\x3f\x03\x51\x3d\x1e\x80\x00\x62\x44\xee\x19\xe1\
\x69\x15\xc3\xaa\x58\x06\x86\xdf\xff\x42\x19\x7e\xfd\x9b\xe4\x6a\
\x2b\x23\x91\x14\xa4\xca\xc0\x09\xac\xa8\x56\xed\x7a\xc0\xb0\x6c\
\xdb\xdd\xaf\xc0\x56\x59\x2d\xd0\xa1\xfd\x04\xfd\x83\xd4\x2a\x06\
\x08\x20\xd2\x1c\x80\x00\x5a\x0c\xdf\x7e\xe7\x00\xe3\xd8\x91\x91\
\x89\x91\xf5\xff\xcf\xbf\xa7\x80\x41\x3e\x03\x98\xe0\x0e\x11\x15\
\xa0\x48\x0e\x00\x08\x20\xc6\x81\xee\x1b\x02\x04\xd0\x80\xf7\x8c\
\x00\x02\x68\xc0\x1d\x00\x10\x40\x03\xee\x00\x80\x00\x03\x00\xa7\
\x41\xee\x45\xc4\x9b\xf9\x86\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x05\x7e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x05\x10\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x2c\x20\x82\x91\x31\x39\x8d\x87\x8b\xa9\x8e\x83\x9d\x89\xfb\xdf\
\xff\xff\x7f\x41\x62\xe0\x80\x61\x04\x31\xc0\x88\x01\x26\x86\x1c\
\x5e\xff\x19\xd0\xe4\x61\xfa\x90\xe5\x31\xf4\x31\x32\xfe\xfd\xf3\
\x8f\xe1\xcf\xcf\xbf\x93\xfe\xff\x9f\xd7\x08\x10\x40\x8c\xa0\x28\
\xe0\xe3\x4d\x7b\xda\xd8\x13\x2f\xc5\x2b\x2f\xc5\xf0\xf5\xdb\x7f\
\x86\xbf\xff\x18\x18\x80\x6a\x18\xfe\x02\x75\xfd\x05\x3a\xe7\x0f\
\x88\xfe\x07\xc5\x50\xf6\x1f\xa8\x1c\xb2\x5a\x10\xfd\x0f\x99\x0f\
\x94\x07\x32\xc1\x34\x48\x3d\x48\x8e\x81\x85\x91\xe1\xc3\xd3\xd7\
\x0c\x17\xe6\xce\x7b\xf5\xeb\xeb\x0c\x71\x80\x00\x02\x87\x00\x37\
\x17\x2b\x97\x84\x8e\x32\xc3\x0f\x71\x09\x06\xf6\x6f\x10\x43\x59\
\x90\x0c\x62\xf9\x8b\x30\x1c\xe6\x00\x98\xe5\x7f\x91\x2c\xff\x8b\
\x84\x41\x6a\x7f\x83\xe8\xff\xa8\x6a\xff\x03\x6d\xfc\xcd\x21\xc8\
\xc0\xc4\xce\xc1\x0a\xb2\x1b\x20\x80\xc0\x0e\xf8\xf7\x8f\xe9\xef\
\x97\x2f\x7f\x18\x1e\x03\xd9\x1f\x3f\x41\xc2\x0e\x64\xe0\x7f\x98\
\xaf\xfe\xa3\x5a\xfe\x0f\x66\x30\x4c\x0e\x29\x84\x60\xec\xff\x50\
\xf5\x70\xbd\x50\xcc\xcc\x01\x34\xff\xc7\x6f\xa0\xd9\x4c\xa0\xf0\
\x60\x00\x08\x20\x48\x1a\x60\x62\x62\xf8\xf5\x87\x91\x61\xe5\x9a\
\x07\x0c\xdf\x3f\x7e\x67\x60\x60\xc2\x8c\x5f\x6c\xe0\x3f\x72\x44\
\x23\x33\x19\x19\x30\x34\x82\xb8\x4c\x40\xf1\x7f\xcc\x6c\x0c\xd2\
\xb2\x7c\x60\x3b\x41\x00\x20\x80\x58\x20\x1a\x98\x19\x3e\x7c\xfd\
\xcb\xe0\x2c\xf5\x81\xa1\x30\x57\x16\xe8\xd2\xff\x0c\xe8\xb9\x93\
\x11\x27\x07\x37\x40\x56\xf6\x1f\xc8\x61\x03\xc6\xff\xc2\xdd\x2f\
\x19\x96\x5c\xff\x0d\x4c\x8a\xcc\x60\x71\x80\x00\x62\x81\xb8\x8e\
\x89\xe1\x37\x30\x95\x08\x8b\xf0\x30\xa8\x2a\x09\x53\x39\xa3\xfd\
\x07\xc7\xe5\x3f\x60\x3c\x30\x31\xb3\x30\x48\x8a\xff\x64\xf8\x73\
\x05\x14\x1c\x90\x10\x00\x08\x20\x88\x03\x18\x99\x20\xa9\xf4\xef\
\x3f\xf2\xac\x80\x06\x17\x88\xfe\x0f\x8e\xf3\x7f\x50\xfa\x3f\x54\
\x0c\x98\xb3\x80\x66\xf3\xf2\xfe\x07\xe6\x88\xbf\xc0\xb4\xc1\x0c\
\x77\x00\x40\x00\x41\xa2\x80\x89\x19\x18\xec\x8c\xf8\x23\x1c\xab\
\xc5\x10\x1f\xc2\x68\x84\x85\x30\x47\x21\x1c\xf0\x1f\x5e\x18\x30\
\x82\x13\xe6\x7f\x26\x48\x14\x00\x04\x10\x13\x24\x04\x18\xc1\x21\
\x40\x56\xf0\x32\x20\x1c\x81\x6c\x39\x32\x06\x39\xec\xdf\xbf\xff\
\x50\x17\x03\xd9\xa0\x04\xc1\x08\x49\x21\x00\x01\x04\x89\x02\x60\
\x70\xfc\x05\x0a\xb2\x50\xe4\x73\x06\xb8\xe5\x88\x28\xf8\x07\xe5\
\x43\xd9\xe0\xfc\x09\xcd\xa6\x4c\x10\x07\x00\x04\x10\x24\x22\x80\
\x0e\xf8\xf3\x8f\x12\x9f\xa3\xfb\x9a\x01\x8d\xfd\x0f\x11\x0d\x0c\
\x90\xb2\x81\x81\x19\xe2\x5d\x80\x00\x82\x86\x00\x23\xc4\x55\xff\
\xc9\x8b\x73\x98\x1c\x8c\x8f\xe1\x73\xa0\x03\x40\x89\x10\x2e\x0e\
\xa9\x12\xc0\xfa\x00\x02\x08\x5a\x0e\xb0\x00\xd3\x00\x23\x11\x69\
\x10\xd3\xe7\x90\x92\x14\x39\xbe\xff\xa1\x25\x48\x44\x1a\x00\xa7\
\x03\x06\x48\x14\x00\x4b\x22\x30\x1b\x20\x80\x90\xd2\x00\x31\xbe\
\x67\x40\x09\x72\x90\x45\x7f\xff\xc2\x52\xfb\x3f\xb8\xdc\xbf\x7f\
\x08\x1a\xe4\x20\x98\xe5\x60\x07\x81\xcd\x60\x04\xdb\x09\x02\x00\
\x01\x04\x77\xc0\x9f\x7f\x58\xca\x4f\x9c\xf9\xfc\x3f\xdc\x97\xc8\
\x89\x10\x35\xff\x43\x82\x1d\x16\x02\x7f\xff\x01\xf3\xff\x5f\x66\
\xb0\xcb\xc0\x6e\x86\x66\x43\x80\x00\x62\x41\x4e\x84\xff\x19\x89\
\xf7\x39\x22\xbe\x91\x83\x9a\x01\x25\x0d\xc0\x1c\x03\xe6\x83\xd4\
\xfd\x83\x84\x00\x38\x96\xa0\xb9\x00\x20\x80\xe0\x25\x21\x28\x1b\
\x22\x3b\xe0\x3f\x52\x4d\x83\xcd\xe7\xc8\x71\x0b\x4b\xe5\x98\x89\
\xf0\x1f\xdc\x01\x30\x36\xd8\x1c\xb0\x5d\x90\x28\x00\x08\x20\x48\
\x08\x30\x33\x81\x2b\x20\x06\x26\xcc\x04\x87\x88\xd7\xff\x58\x13\
\x17\xc2\xe7\x0c\x18\xa1\x02\x0e\xfa\xbf\x10\x8b\xff\xfc\x01\x05\
\xfd\x5f\x78\x22\x64\x82\x46\x01\x40\x00\x21\xd2\xc0\x7f\xe4\xa2\
\x18\xb9\x38\x65\xc0\x61\x29\x7e\x9f\xc3\xca\x7f\x94\x50\xf8\x0b\
\x55\xf7\x9f\x01\x5e\x1d\x03\x04\x10\xb4\x28\x66\x66\x40\xae\x87\
\xd0\x2d\x47\x2e\xd3\x91\x13\x1f\x6a\xbc\xff\xc7\xe1\x18\x24\xc7\
\xfe\xfb\x07\x6d\x38\x22\x6a\x43\x80\x00\x42\x4d\x84\x28\x71\x8e\
\x59\xe0\x20\x1b\x86\x9c\xb5\x50\xe3\x1a\xe4\xf3\xbf\x60\x71\x50\
\xb0\xc3\x72\xc3\x1f\x20\xfe\xfb\xef\x3f\xbc\x71\x00\xcb\x86\x00\
\x01\xa8\x2c\x83\x14\x00\x80\x10\x04\x62\xff\xff\xb3\xa9\xd5\xc2\
\x1e\x82\x20\x0f\x51\x43\xf9\x41\xf8\xc6\x22\x42\x6b\x37\x62\x6b\
\x95\xdc\x37\xdc\xb8\x80\xf9\x9c\xc8\x5f\x9b\x26\x71\xc8\xa8\x46\
\xc5\xb1\x5c\x50\x43\x64\x74\x16\xca\x01\x0b\x37\x8c\x53\x5d\x08\
\x5b\x00\x01\x88\x28\x77\x1c\x00\x40\x10\x86\x62\x74\xf1\xfe\x47\
\x95\xc4\x5f\xb4\x02\x1a\x5c\x59\xda\x3c\xda\x3a\x01\x35\x50\xb9\
\x11\x97\x4a\x73\xe1\x6f\x82\x0a\x28\x3e\x33\x03\xa3\x84\x47\x0b\
\x9e\x8d\xd7\x7f\xc0\xeb\xb6\xed\x8f\xe1\x8a\xca\xec\x26\xd1\x88\
\x12\xf6\xd1\xbb\xdc\xb3\x13\x38\x02\x08\x56\x17\x30\xf1\xf2\xb2\
\x33\x9c\xbf\xc7\xce\x10\xd1\x7b\x1f\xec\x18\x70\xad\x05\x2b\x6a\
\xff\x23\xb5\x11\x41\x16\x31\x40\xe4\xc1\x16\x82\xfc\x07\xaf\x74\
\x18\xe1\x7d\x03\x58\x7a\xfe\x87\x54\x7e\x30\x33\x7d\x63\x78\xf1\
\x19\x18\x8a\x7c\x9c\x0c\x7f\x19\x21\x95\x01\x40\x00\x81\x1d\xf0\
\xfb\x1f\xe3\x9f\x77\x6f\xde\x32\x70\xcb\x4b\x30\xbc\xfb\xf2\x17\
\xac\x09\xd6\x2a\x86\xb7\x82\x19\xa0\xcd\x6b\xa4\xd6\x30\x8c\xff\
\x8f\x01\xa9\x65\x8c\xd4\x82\x46\x37\xe3\x3f\xb8\x5f\xc0\xc4\xc0\
\xf4\xe3\x3d\x3c\xc1\x03\x04\x10\xd8\x01\xbf\xfe\x31\x4c\x3c\xb6\
\xf1\x60\x3e\x13\xa8\xd1\xf6\xff\xff\x3f\x6c\xad\xdb\xff\x58\xaa\
\x24\x0c\xfe\x7f\xfc\xf2\x50\xe3\x18\xff\xfd\x07\x26\xa2\x7f\x7f\
\x16\x82\xc4\x00\x02\x88\x71\xa0\x3b\xa7\x00\x01\x34\xe0\x9d\x53\
\x80\x00\x1a\x70\x07\x00\x04\x18\x00\x56\x99\xc4\xad\x26\xe6\xd3\
\x76\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0e\x4a\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x00\x48\x00\x00\
\x00\x48\x00\x46\xc9\x6b\x3e\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x0c\x42\
\x49\x44\x41\x54\x68\xde\xed\x9a\x7d\x6c\xd5\xd7\x79\xc7\x3f\xe7\
\x9c\xdf\xef\xfe\xee\xbd\xf8\xda\x5c\x5e\x6c\x0f\xfc\x32\x1a\xd7\
\xd0\x80\x33\x12\x2a\xb2\x41\x18\x21\xca\xdc\x04\x10\xa3\x0d\xac\
\x62\x49\x34\x16\xa9\x89\xa2\x54\x50\xb5\x51\x44\x93\x4a\x49\x15\
\xb5\xcb\x3a\x4d\x61\x68\xd9\x1a\x2d\x51\xa5\xa6\x6a\x57\x2d\x59\
\x32\x5e\x1a\xda\x94\xaa\xb0\x40\x82\xb3\x18\xec\x05\xf3\x62\xe3\
\x60\xb0\xb1\x31\x06\x5f\xfb\xbe\xfd\xde\xcf\xfe\x30\xf7\xca\x76\
\x8c\x71\x42\x48\x34\xa9\x8f\xf4\x48\x57\xbf\xf3\x7b\x79\xbe\xe7\
\xfb\x3c\xcf\x79\xce\x73\xae\xd0\x5a\xf3\xff\x59\xe4\xe7\x6d\xc0\
\x1f\x00\x7c\xde\x06\x5c\xaf\x18\x00\xa1\x10\x88\x71\x03\x21\xa0\
\x80\x63\xd3\xa7\xf3\xf4\xca\x95\x78\x52\x22\xb5\x66\x74\xcc\x4c\
\xf4\x7b\x82\x6b\x7f\xa9\xb5\x7e\x5c\x6b\x5d\x2a\xa5\xdc\x01\xbc\
\x3c\x99\x41\x5a\x6b\x0c\xc3\x60\xe9\xd2\xa5\x98\xa6\x89\xd6\x9a\
\x30\x0c\x8b\x1a\x04\x01\xbe\xef\xe3\xba\x2e\x61\x18\x8e\x00\xb8\
\x81\xf2\xb0\xef\xfb\xff\x6c\x9a\xa6\x69\x59\x16\x99\x4c\xe6\x25\
\xc3\x30\x84\x10\xe2\xa5\x49\x67\xd5\x30\x10\x42\x4c\xe9\x03\x37\
\xca\x85\x4c\xe0\x87\xae\xeb\xbe\x98\x48\x24\xcc\xc7\x1f\x7f\x9c\
\xed\xdb\xb7\x53\x55\x55\x85\xeb\xba\xdb\x81\xc6\xab\x3d\xa8\xb5\
\x26\x1a\x8d\xa2\x94\xfa\xdc\x00\x24\x80\x5f\xe6\xf3\xf9\xef\xd6\
\xd4\xd4\xf0\xdc\x73\xcf\xb1\x6c\xd9\x32\x66\xcf\x9e\xcd\xd6\xad\
\x5b\x29\x29\x29\x99\xe6\xfb\xfe\x2f\x80\x3b\xae\x06\xc0\xb2\x2c\
\xa4\x94\x4c\x25\xc5\x7f\xda\x00\xe6\x01\xbf\xce\xe5\x72\x5f\x5d\
\xbc\x78\x31\xcf\x3e\xfb\x2c\xb5\xb5\xb5\x64\x32\x19\xd2\xe9\x34\
\xf5\xf5\xf5\x3c\xf6\xd8\x63\x00\x33\xc2\x30\x7c\x59\x08\xf1\x47\
\x42\x08\x46\x2b\x50\x04\xf0\x59\x33\x70\x4f\x18\x86\xfb\x6c\xdb\
\xfe\xb3\x35\x6b\xd6\xf0\xf4\xd3\x4f\x53\x5e\x5e\x4e\x36\x9b\xc5\
\xf7\x7d\xf2\xf9\x3c\xe7\xce\x9d\x63\xc9\x92\x25\x3c\xf4\xd0\x43\
\x04\x41\x50\xaf\xb5\x7e\x19\x98\x3e\xc6\x20\x29\x99\x36\x6d\xda\
\x94\x66\xff\xd3\x04\x70\xbf\xe7\x79\xaf\x87\x61\x38\xef\x81\x07\
\x1e\x60\xeb\xd6\xad\xc4\x62\x31\x32\x99\x0c\xf9\x7c\x1e\xc7\x71\
\x00\x88\x46\xa3\x64\xb3\x59\xd6\xae\x5d\xcb\xfa\xf5\xeb\xb1\x6d\
\xfb\x5e\x60\x87\x10\x42\x09\x21\xd0\x5a\xa3\x94\x22\x1e\x8f\x4f\
\x19\xc0\xf5\x66\x21\x01\x7c\xd7\x75\xdd\x1f\xc4\xe3\x71\x1e\x79\
\xe4\x11\x1a\x1b\x1b\x8b\x33\x1e\x86\x21\x96\x65\x61\x59\xd6\x98\
\x87\x7c\xdf\xe7\xfe\xfb\xef\xa7\xa3\xa3\x83\xd6\xd6\xd6\x07\x63\
\xb1\xd8\x59\xe0\x7b\x42\x08\x4c\xd3\x24\x1a\x8d\x7e\x26\x0c\x4c\
\x03\x7e\xec\x38\xce\x0f\x66\xcd\x9a\xc5\xb6\x6d\xdb\x68\x6c\x6c\
\x44\x6b\x4d\x10\x04\x44\x22\x11\x4a\x4a\x4a\x8a\x3a\x6d\xda\xb4\
\xa2\x5a\x96\x45\x22\x91\x60\xcb\x96\x2d\x54\x57\x57\xe3\x38\xce\
\x53\xc0\xe6\x02\x4b\x53\xf5\xff\xeb\x01\x50\xa9\xb5\xde\x6d\xdb\
\xf6\xc3\x8b\x16\x2d\xe2\xc9\x27\x9f\x64\xe1\xc2\x85\xf8\xbe\x8f\
\xd6\x1a\xd3\x34\xb1\x2c\x0b\xd3\x34\x51\x4a\x61\x9a\x26\x91\x48\
\x64\x8c\x02\xd4\xd4\xd4\xb0\x6d\xdb\x36\x2a\x2b\x2b\xf1\x3c\x6f\
\x47\x18\x86\x8d\x91\x48\x64\xca\x19\x08\x3e\x99\x0b\x2d\x0e\xc3\
\xf0\xe7\xae\xeb\x7e\x69\xd5\xaa\x55\x6c\xdc\xb8\x91\x44\x22\x51\
\xfc\xa8\xef\xfb\x28\xa5\xb8\x78\xf1\x22\x2d\x2d\x2d\x9c\x3f\x7f\
\x9e\x59\xb3\x66\x91\x4c\x26\x8b\xb1\x00\x23\x8b\x55\x81\x89\xbb\
\xef\xbe\x9b\x3d\x7b\xf6\x24\x3c\xcf\xfb\xb7\x58\x2c\xb6\x5e\x29\
\xf5\xbf\x41\x10\x08\xc0\xd3\xe3\x56\xff\xeb\x05\xb0\x29\x08\x82\
\xed\x52\xca\xf2\x0d\x1b\x36\xb0\x7c\xf9\x72\xa4\x94\xc5\xa0\xf3\
\x3c\x0f\x29\x25\x43\x43\x43\x1c\x38\x70\x80\xbd\x7b\xf7\x32\x7b\
\xf6\x6c\xca\xca\xca\x30\x4d\x13\x80\x30\x0c\x01\x08\x82\xa0\x68\
\x98\x69\x9a\x34\x34\x34\xe0\xba\x6e\x4d\x18\x86\x07\x86\x86\x86\
\xfa\x85\x10\x83\x52\xca\xcb\xc0\x80\x10\xa2\x0f\xe8\x01\xce\x02\
\xa7\x84\x10\x27\x00\x67\x3c\x00\x09\xcc\x05\x92\x40\x0a\xe8\x03\
\xdc\x51\x0b\xfa\x16\xd7\x75\x9f\x4f\x24\x12\x72\xd3\xa6\x4d\xcc\
\x9d\x3b\x17\xc7\x71\xa8\xaa\xaa\x42\x6b\x8d\xeb\xba\x00\x28\xa5\
\x18\x1c\x1c\xa4\xab\xab\x8b\x77\xdf\x7d\x97\xd5\xab\x57\x53\x53\
\x53\x43\x43\x43\x03\xa5\xa5\xa5\x58\x96\x85\x61\x18\x28\xa5\xf0\
\x3c\x8f\x7c\x3e\x8f\x6d\xdb\xe4\xf3\x79\xb2\xd9\x2c\x99\x4c\xa6\
\x24\x97\xcb\x95\xe4\xf3\x79\x0a\x9a\xcd\x66\xc9\xe5\x72\xb8\xae\
\x8b\xe7\x79\x81\x94\xb2\x4d\x6b\xbd\x4d\x6b\xfd\xab\x02\x80\x99\
\x18\xc6\x76\xea\xea\x36\x52\x52\x22\xc2\x0b\x17\x82\xb0\xb7\xb7\
\x43\xf9\xfe\x6e\x29\xc4\xaf\x34\xac\x77\x5d\xf7\x3b\x55\x73\xe6\
\xb0\x69\xd3\x26\x3c\xcf\x23\x95\x4a\xb1\x64\xc9\x92\xa2\xdf\x17\
\x44\x6b\x8d\x94\x92\x8a\x8a\x0a\x32\x99\x0c\x9d\x9d\x9d\xa4\x52\
\x29\xf6\xef\xdf\x8f\x61\x18\xcc\x98\x31\x83\x64\x32\x49\x22\x91\
\x20\x16\x8b\x11\x8b\xc5\xb0\x2c\x8b\x48\x24\x82\x65\x59\x94\x96\
\x96\x92\x4c\x26\xc7\xb0\x14\x86\x21\x8e\xe3\x30\x38\x38\x48\x7f\
\x7f\xbf\xea\xec\xec\x6c\xc8\x64\x32\x2f\x0a\x21\x16\x09\xad\x35\
\x9e\x10\x7f\xaf\xbe\xf5\xad\x27\xe4\xa3\x8f\x82\x6d\x43\x36\x0b\
\x1d\x1d\xa4\x5e\x7b\x8d\x17\xba\xbb\xc3\xfd\x95\x95\x62\xc1\x17\
\xbe\x20\xee\xbb\xef\x3e\xba\xbb\xbb\xf1\x7d\x9f\xbb\xee\xba\x8b\
\x58\x2c\x46\x10\x04\x63\x7c\x4c\x4a\x49\x3a\x9d\x26\x95\x4a\xb1\
\x77\xef\x5e\xde\x7f\xff\x7d\xaa\xab\xab\x49\x26\x93\x48\x29\x19\
\x18\x18\x60\x78\x78\x18\xcf\xf3\xc6\x00\x1f\x5d\xbc\x15\xea\x21\
\xcb\xb2\x50\x4a\x15\xb3\x92\x52\x8a\x30\x0c\x49\xa5\x52\xf8\xbe\
\x7f\x5c\x4a\xb9\x54\x68\xad\xc9\x97\x94\xb4\x46\x5f\x7d\xb5\x41\
\x94\x96\x8e\x18\x1f\x04\xf4\x0e\x0f\xf3\xa3\x03\x07\x38\xfa\xe1\
\x87\xfc\xc5\xf2\xe5\xfc\xf9\x8a\x15\x1c\x6d\x69\x21\x97\xcb\xb1\
\x66\xcd\x1a\x66\xcd\x9a\x85\xef\xfb\x13\x06\x8a\xd6\x9a\x74\x3a\
\x8d\xe3\x38\x5c\xbe\x7c\x99\x5c\x2e\x47\x79\x79\x39\x55\x55\x55\
\xa4\x52\x29\xba\xba\xba\xe8\xed\xed\x25\x97\xcb\x15\xcb\x63\xcf\
\xf3\xf0\x7d\x9f\x30\x0c\x49\x24\x12\xb4\xb4\xb4\x70\xf9\xf2\x65\
\x0c\xc3\x38\x29\x84\x78\x0b\x88\x5d\x79\x7d\x4a\x4a\xd9\x2e\xa5\
\xdc\x23\xa5\xec\x36\x00\xbc\x20\x10\xd6\x99\x33\x88\x64\x12\x6c\
\x9b\x6c\x36\xcb\xdf\xbd\xf3\x0e\xa7\x86\x86\xf8\xab\xb5\x6b\x69\
\x68\x68\xa0\xad\xad\x8d\x74\x3a\xcd\x6d\xb7\xdd\x46\x32\x99\xc4\
\xb6\xed\x49\xa3\x3d\x1e\x8f\x63\x9a\x26\xb1\x58\x0c\x21\x44\x91\
\xad\xb2\xb2\x32\x6e\xb9\xe5\x16\x6a\x6b\x6b\xe9\xed\xed\xa5\xaf\
\xaf\x0f\xdb\xb6\x11\x42\xa0\x94\x42\x08\x81\x65\x59\x04\x41\xc0\
\xa1\x43\x87\xd0\x5a\x57\x4a\x29\x7f\x29\xa5\x7c\x7b\xa2\xef\x48\
\x00\xc7\xb6\x8f\x79\xef\xbc\x03\xfd\xfd\xd0\xdb\xcb\xff\xb4\xb7\
\x73\x6c\x60\x80\xaf\xac\x5a\xc5\x9d\x77\xde\x49\x67\x67\x27\xf9\
\x7c\x9e\xb9\x73\xe7\x72\xd3\x4d\x37\x61\xdb\x36\xbe\xef\x4f\xaa\
\x41\x10\xa0\x94\x22\x12\x89\x60\x9a\x26\x9e\xe7\xe1\xba\x2e\xb6\
\x6d\xe3\x38\x0e\xf1\x78\x9c\xba\xba\x3a\x6e\xbd\xf5\x56\xea\xeb\
\xeb\x29\x2b\x2b\xc3\xf3\x3c\xb2\xd9\x2c\xa9\x54\x8a\x64\x32\xc9\
\xa2\x45\x8b\x10\x42\x94\x85\x61\xf8\x52\x10\x04\xf3\xc3\x30\xfc\
\x48\x4a\x35\x18\xc9\x47\xfb\x73\xcd\xcd\x5f\xb7\x2a\x2b\x21\x9f\
\x67\x5a\x26\x83\x15\x8b\x71\xfa\xcc\x19\x8e\x1c\x39\x42\x45\x45\
\x05\xb3\x67\xcf\xa6\xa2\xa2\x02\xa5\xd4\x55\x5d\xe7\xe3\x48\x21\
\x76\xa2\xd1\x28\xd5\xd5\xd5\xcc\x99\x33\x87\xe1\xe1\x61\xce\x9f\
\x3f\xcf\xa5\x4b\x97\xc8\x66\xb3\x54\x55\x55\x61\xdb\x36\xed\xed\
\xed\xf3\xa5\x94\x3f\x03\x56\x6b\xad\x2f\x6a\xad\x29\xd4\x4e\x42\
\x6b\xcd\x19\x21\x1a\x8c\x92\x92\xf7\xe6\xdc\x73\x8f\x25\xa5\x44\
\xdb\x36\xff\x68\xdb\xfc\x36\x1e\x47\x09\x41\x59\x34\xca\xbc\x79\
\xf3\xb8\xf7\xde\x7b\x99\x3b\x77\x2e\x9e\xe7\x5d\x37\x80\x09\xdd\
\x41\x4a\x84\x10\xb8\xae\xcb\x85\x0b\x17\x8a\x01\xdf\xd4\xd4\x44\
\x4f\x4f\x0f\x96\x65\xed\x02\x36\x00\x6e\x31\xf8\xb5\xd6\x74\x08\
\x41\x08\xbb\x2a\xe6\xcf\x5f\x5b\x56\x51\x01\x8e\xc3\xe5\xee\x6e\
\x7e\xa3\x75\xee\x77\x0d\x0d\xbf\x39\x5f\x56\xb6\x48\x67\xb3\x75\
\x35\xd5\xd5\x6c\xde\xbc\x99\x99\x33\x67\xde\x30\x10\x85\x6c\x54\
\xc8\x38\xae\xeb\x72\xee\xdc\x39\x76\xef\xde\x4d\x4f\x4f\x0f\x91\
\x48\xe4\x05\xe0\x9b\x85\xfb\xd5\x33\xcf\x3c\x43\xdf\xf7\xbf\x8f\
\x0f\x8e\x9f\xcb\x7d\x3d\x19\x86\x90\x4a\x11\x73\x5d\x92\xfd\xfd\
\xe6\x1f\x77\x75\xbd\xee\x44\xa3\xeb\xfb\x2b\x2b\x23\xc3\x97\x2e\
\xad\xe8\xe9\xe9\xa1\xbe\xbe\x1e\xcb\xb2\x28\xf8\xe4\x8d\xd0\x20\
\x08\x08\xc3\x10\xa5\x14\xe5\xe5\xe5\xcc\x9b\x37\x8f\x8e\x8e\x0e\
\xd2\xe9\xf4\x52\xa5\xd4\x65\xa0\xa9\xc8\xc0\x51\x21\xd0\x30\x5d\
\x08\xd1\x54\x1f\x89\x7c\x31\x1e\x86\x10\x04\x0c\x6b\x4d\x87\xd6\
\x29\x47\xa9\x65\xbf\x58\xb9\xf2\xf8\xd9\xf2\xf2\x5f\x87\xd9\x6c\
\xe3\xe2\xc5\x8b\xd9\xb0\x61\x43\x71\x96\x3e\x0b\x89\x44\x22\x9c\
\x3e\x7d\x9a\x57\x5e\x79\x05\xc7\x71\x3c\xc3\x30\x36\x02\xff\x25\
\xb9\xe2\x50\x1e\xa4\xf2\x5a\xff\xf8\xa2\xe3\x80\xe7\x41\x18\x52\
\xaa\x35\x71\x98\x1e\x06\xc1\xb7\x57\x35\x37\x13\x73\xdd\xbf\x89\
\xc4\x62\x4d\x2d\x2d\x2d\xec\xdb\xb7\xaf\xb8\x4a\x06\x41\x70\xc3\
\x35\x9f\xcf\x53\x5b\x5b\xcb\xba\x75\xeb\x50\x4a\x99\x61\x18\xbe\
\x0c\xdc\x51\x04\xe0\x02\x3e\xbc\x76\x1e\x2e\x8f\xce\xf0\x15\x80\
\x0d\x6b\x67\xa6\x52\x95\xf5\x67\xcf\xf6\x79\xa6\xb9\x29\x62\x9a\
\xa7\x0f\x1e\x3c\x48\x53\x53\x13\x42\x88\x31\x7d\x9b\x1b\xa9\xae\
\xeb\xb2\x70\xe1\x42\x56\xac\x58\x01\x30\x53\x6b\xfd\x94\x64\x64\
\xf6\xf1\x46\x00\x74\x65\x60\x6f\xdf\x28\x00\xa5\x40\x04\x2a\x73\
\xb0\xfa\x4f\xda\xda\x98\x3e\x3c\xdc\xa9\x4d\xf3\x6f\x81\xc1\xb7\
\xde\x7a\x8b\x93\x27\x4f\x22\xa5\xfc\x4c\x58\x28\xac\x2f\xb7\xdf\
\x7e\x3b\xe5\xe5\xe5\x68\xad\x6f\x1a\xc3\xc0\x15\x16\xfe\xa5\x13\
\xdc\x02\x0b\x0a\x98\x01\xe4\xe0\x4f\xe3\xb9\x1c\xf3\x3b\x3b\x09\
\xa5\xfc\x6f\xa5\xd4\x13\xae\xeb\xf2\xe6\x9b\x6f\xd2\xdd\xdd\x8d\
\x10\xe2\x86\x03\x00\x70\x1c\x87\xb7\xdf\x7e\x9b\x4b\x97\x2e\x21\
\xa5\x3c\x31\x11\x80\x83\x29\x78\xfd\xec\x28\x16\xa6\x8d\x30\x54\
\x97\x05\x51\x77\xf2\x24\xc9\xe1\x61\x42\xc3\x78\xc9\x34\xcd\xa7\
\x86\x86\x86\xd8\xbd\x7b\x37\xa9\x54\xea\x86\xba\x53\xa1\x48\xdc\
\xb5\x6b\x17\x07\x0f\x1e\x04\x68\x96\x52\x7e\x7b\x8c\x0b\x15\x34\
\x80\xe7\x4f\x82\x93\x2b\x64\x00\x20\x84\x19\x0e\x98\xd2\xf7\xa9\
\x3b\x75\x0a\x46\xf2\xf5\x0f\x4d\xd3\x7c\xb1\xbf\xbf\x9f\x7d\xfb\
\xf6\x61\xdb\x76\x31\x05\x7e\x9a\x2a\x84\xa0\xaf\xaf\x8f\x37\xde\
\x78\x83\xe3\xc7\x8f\x63\x9a\xe6\x4e\x21\xc4\x3d\x40\xc7\x48\x2d\
\x34\x4e\x7d\x38\x3c\x08\xaf\x76\x8e\x62\xc1\x03\xc3\x03\x91\x07\
\x2a\xba\xba\x48\xa4\x52\x84\x23\x65\xee\x77\x22\x91\xc8\x7f\x9e\
\x3a\x75\x8a\x03\x07\x0e\xe0\x79\xde\xa7\x96\x99\xc2\x30\x44\x08\
\x41\x7b\x7b\x3b\x3b\x77\xee\x2c\x2c\x64\xff\x2a\x84\xd8\x04\x5c\
\x84\x2b\xb5\x90\xcb\x47\x25\x80\xe7\x3b\xe0\xab\x8b\x20\xee\x8f\
\x00\xf3\x04\x68\x01\x18\x8e\xc3\xec\xbe\x3e\xd2\x33\x66\x20\x3c\
\x2f\x0b\x3c\x6c\x9a\xe6\x17\x5b\x5a\x5a\x1a\xe2\xf1\x38\x4b\x96\
\x2c\x61\xa2\xc2\xeb\xe3\x48\xa1\x53\x77\xec\xd8\x31\x0e\x1d\x3a\
\x84\xe3\x38\x4e\x24\x12\xd9\x06\x6c\x1f\xfd\x5e\xa3\xe0\x42\x13\
\xc8\xfb\x7d\xb0\xb7\x0b\xbe\xe6\x8e\x00\xb8\x60\x5c\xc1\x1a\x02\
\xa5\x17\x2e\xa0\xe6\xcf\x1f\x71\x25\xad\x2f\x09\x21\x36\x1b\x86\
\xb1\xa7\xa9\xa9\xa9\xb2\xa4\xa4\x84\xba\xba\xba\x4f\x5c\x6e\x28\
\xa5\x08\x82\x80\xa3\x47\x8f\xd2\xdc\xdc\x8c\x10\xe2\x92\x61\x18\
\xdf\x00\x5e\x1f\x7f\xef\x55\x19\xb8\x72\x7d\x4f\x3b\x7c\x2d\x02\
\xd8\x70\x3a\x52\x98\x1d\x20\x36\x30\x80\x95\xcf\xe3\xc6\xe3\x88\
\x91\xd5\xb8\x59\x08\xf1\x48\x10\x04\xff\xde\xd4\xd4\x14\x2b\x29\
\x29\x61\xfa\xf4\xe9\x1f\xbb\x72\x35\x0c\x03\xc7\x71\x38\x7c\xf8\
\x30\xed\xed\xed\x18\x86\xd1\x23\x84\x78\x40\x6b\xfd\xfb\x09\x99\
\xd2\x5a\xb3\xfd\xea\xbd\xf8\x05\x0a\x5a\x80\x88\x03\xeb\x04\xec\
\x2a\xce\x12\xf0\xe1\x97\xbf\x4c\xdf\xcd\x37\xa3\xc6\xce\xf4\x5f\
\xfb\xbe\xff\xd3\x64\x32\xa9\x56\xae\x5c\x59\xdc\x9c\x4c\x45\x22\
\x91\x08\xd9\x6c\x96\xc3\x87\x0f\xd3\xd7\xd7\x87\x52\x6a\x9f\x10\
\x62\x33\xd0\x7d\xb5\x83\x95\x49\x19\x00\x7a\x35\x84\x1a\xda\x05\
\xfc\x6e\xf4\x80\x06\xa2\xa9\x14\xe2\xa3\x7e\xfe\x73\xd3\x34\xbf\
\x34\x38\x38\xf8\xbd\xa6\xa6\x26\x96\x2d\x5b\x56\xdc\x2a\x5e\x4d\
\xb4\xd6\xc4\x62\x31\xfa\xfb\xfb\x79\xef\xbd\xf7\x18\x1e\x1e\xc6\
\x34\xcd\x9f\x68\xad\xb7\x00\x99\x49\x19\xbb\x06\x80\x04\x23\x87\
\x15\x3f\x05\xb2\xa3\x07\x7c\xc0\x1c\x1c\xc4\xf0\x3c\xb4\x52\x30\
\x16\xc8\xb3\xa6\x69\xd6\xf6\xf6\xf6\x3e\xf8\xc1\x07\x1f\xb0\x60\
\xc1\x82\x62\xdb\x65\xbc\xe1\x85\xed\xe6\x99\x33\x67\x68\x6d\x6d\
\xc5\x75\x5d\xdf\x30\x8c\x1f\x01\xcf\x70\xd5\xf0\x1c\x07\x60\x92\
\xbb\x6e\x06\x9a\x81\x1d\xe3\x07\x04\x20\xd2\x69\x44\x10\x10\x1a\
\xc6\x78\x26\x5c\xe0\x51\xc3\x30\x2a\x4e\x9d\x3a\xd5\x68\x59\x16\
\xd5\xd5\xd5\x64\xb3\xd9\x62\xbd\x5f\xe8\x44\x47\xa3\x51\x3a\x3a\
\x3a\x68\x6b\x6b\x43\x08\x31\x6c\x18\xc6\x37\xb5\xd6\xaf\x5c\xcb\
\xf0\x31\x00\x26\x49\x76\x87\x34\xdc\x07\x0c\x4f\x04\x20\x9c\x3c\
\x4d\x66\x85\x10\xdf\x50\x4a\xfd\xbe\xad\xad\x6d\x5e\x34\x1a\xa5\
\xb4\xb4\x94\x5c\x2e\x87\x10\xa2\xd8\xdc\x3a\x76\xec\x18\x5d\x5d\
\x5d\x28\xa5\xce\x09\x21\x1e\x04\xf6\x4f\xd5\x78\xb8\x76\x73\x37\
\x03\x9c\xbb\xea\xe8\x95\xd3\xcd\xf1\xa7\x2c\xa3\x4e\x5b\xce\x0a\
\x21\x1e\xd6\x5a\x0f\xb7\xb6\xb6\x92\xcd\x66\x8b\x3d\x1e\x21\x04\
\x2d\x2d\x2d\x05\xe3\x8f\x0b\x21\xd6\x7d\x5c\xe3\xa7\x02\xe0\x9a\
\x22\xae\xec\x63\x27\xd1\xdf\x2a\xa5\x1e\xf4\x3c\xcf\x39\x71\xe2\
\x44\xb1\x29\x70\xe4\xc8\x11\x06\x06\x06\x30\x4d\xf3\x3f\xa4\x94\
\x77\x00\x47\x3f\xc9\xf7\xaf\xeb\x80\x23\x88\xc7\xd1\x4a\x4d\x94\
\x89\xc6\xcb\x4e\xa5\xd4\x13\xe9\x74\xfa\x9f\x9a\x9b\x9b\x09\x82\
\x00\xd7\x75\x51\x4a\xfd\x03\xf0\x14\x53\x08\xd6\x1b\x02\x20\x34\
\x0c\xf4\x14\xcf\x73\x81\x1d\x4a\x29\x1c\xc7\xd9\x0c\xb8\x4a\xa9\
\x9f\x69\xad\x5f\x60\xd2\x10\xbc\xb6\x88\x3f\xfc\x5b\xe5\x73\x96\
\xff\x03\x78\xa9\x39\x37\xc6\x78\x8a\x32\x00\x00\x00\x25\x74\x45\
\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\x74\x65\x00\x32\x30\
\x30\x39\x2d\x31\x31\x2d\x31\x35\x54\x31\x36\x3a\x30\x38\x3a\x34\
\x34\x2d\x30\x37\x3a\x30\x30\x76\x96\xce\x47\x00\x00\x00\x25\x74\
\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\x00\x32\
\x30\x31\x30\x2d\x30\x32\x2d\x32\x32\x54\x31\x33\x3a\x34\x38\x3a\
\x33\x38\x2d\x30\x37\x3a\x30\x30\x28\x74\xc0\x74\x00\x00\x00\x25\
\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\x79\x00\
\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\x30\x39\x3a\x32\x32\
\x3a\x31\x33\x2d\x30\x37\x3a\x30\x30\x98\xc8\x9f\x4a\x00\x00\x00\
\x35\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\x74\x74\
\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\x6d\x6d\
\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\x65\x73\
\x2f\x4c\x47\x50\x4c\x2f\x32\x2e\x31\x2f\x3b\xc1\xb4\x18\x00\x00\
\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\x79\x2d\x64\x61\x74\
\x65\x00\x32\x30\x30\x39\x2d\x31\x31\x2d\x31\x35\x54\x31\x36\x3a\
\x30\x38\x3a\x34\x34\x2d\x30\x37\x3a\x30\x30\x29\x27\xb8\x73\x00\
\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\x00\
\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\x79\
\x71\xc9\x65\x3c\x00\x00\x00\x0d\x74\x45\x58\x74\x53\x6f\x75\x72\
\x63\x65\x00\x4e\x75\x76\x6f\x6c\x61\xac\x4f\x35\xf1\x00\x00\x00\
\x34\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\
\x68\x74\x74\x70\x3a\x2f\x2f\x77\x77\x77\x2e\x69\x63\x6f\x6e\x2d\
\x6b\x69\x6e\x67\x2e\x63\x6f\x6d\x2f\x70\x72\x6f\x6a\x65\x63\x74\
\x73\x2f\x6e\x75\x76\x6f\x6c\x61\x2f\x76\x3d\xb4\x52\x00\x00\x00\
\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\x44\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x06\xd6\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x62\x41\x17\x60\x34\x99\x05\x65\x00\xf1\x8f\
\x7f\x0c\x0c\xbf\xff\x43\xd8\x70\x05\x0c\x7c\x0c\x7f\xff\x4f\x65\
\xf8\xf2\x47\x90\x81\x9d\xa5\x99\xe1\xff\xff\x93\x0c\x7f\x81\xe2\
\xff\x80\xea\x80\xca\x81\x72\x0c\x70\xfe\x5f\x24\xb1\x7f\x10\xb1\
\xff\xbf\x0a\x51\xec\x03\x08\x20\xdc\x21\x00\x4a\x1a\xac\x40\x9b\
\xd1\x55\xfc\xfe\xa7\x2b\xcc\xc7\x1e\xe3\xea\xac\xe0\xcd\xfc\xfb\
\xef\x1e\x86\xef\x7f\xaa\x81\xa2\xec\xe4\x86\x00\x40\x00\xe1\x8f\
\x02\x66\xa0\x03\x38\x98\x51\xc5\xfe\xfe\x67\xe2\x60\x62\x64\x98\
\xd1\xee\xc8\xb0\x7a\x8e\x37\x8f\xa2\x2c\x7f\x0b\xc3\xfb\x1f\xbb\
\x80\x21\xa1\x4b\x8e\x03\x00\x02\x08\xbf\x03\xfe\x43\x55\x70\xa0\
\x2a\xfb\x03\x0c\xd2\x3f\xbf\xff\x31\x04\xba\x2b\x31\xec\xdb\x10\
\xcc\x10\x9b\xa8\x67\xc7\xf8\xe5\xcf\x6e\x60\x68\x14\x00\xa5\xd9\
\x48\x71\x00\x40\x00\x11\x97\x08\x19\x81\x21\xc1\xca\x84\xe6\x36\
\x70\xa4\x32\x28\x48\xf3\x30\x2c\x98\xe8\xca\x30\x6b\x9a\x9b\xb8\
\x88\x20\x47\x3f\xc3\xe7\x5f\x0b\x81\xe9\x44\x94\x58\x07\x00\x04\
\x10\x71\x0e\xf8\x0f\x4d\x94\x2c\xe0\xd4\xf8\x1d\x92\x16\x81\x09\
\x0a\x98\xd8\x9e\x7f\x04\x12\x40\x46\x4a\xb4\x36\xc3\x9e\x2d\x21\
\x0c\xc6\xe6\x92\x11\x0c\x6f\xbf\x6f\x07\x26\x38\x6d\x62\x8c\x06\
\x08\x20\x16\x2c\x62\xaa\x0c\x3f\xff\xda\x30\xfc\x01\x26\x59\x46\
\x06\x48\x29\x05\xf2\xec\x1f\x20\xf3\xff\xff\x3f\x0c\xdf\xfe\x68\
\xfc\xe1\x60\x65\x00\x15\x60\x8c\x8c\xff\x18\xe6\x5f\x62\x62\x90\
\xe2\x65\x60\x88\xd4\xf9\xc3\xa0\xaf\x25\xc2\xb0\x6b\x7d\x30\x43\
\x79\xcd\x21\xe3\x39\xd3\x2f\xec\x01\xe6\x92\x7c\x06\x16\xa6\x55\
\xf8\x1c\x00\x10\x40\x2c\x58\x7c\xbb\x5a\x49\x86\x57\x5f\x90\x9b\
\x0d\x98\xde\xfe\x43\x3c\xff\x0f\x9a\xb5\x80\xd4\xef\xef\x7f\x19\
\x44\xf9\xd8\x19\xd8\x58\x98\x18\xfe\xff\xfb\xc7\xf0\x0b\x98\x4d\
\x17\x5f\x61\x65\x78\xf8\x91\x91\x21\xc5\xf0\x2f\x83\xb4\x00\x1b\
\xc3\xac\xc9\xae\x0c\x4a\x8a\x02\x12\xb5\x55\x87\x56\xfc\xfd\xf3\
\x5f\x88\x81\x95\x79\x06\x03\x03\xf6\x12\x17\x20\x80\x30\xcb\x81\
\xbf\xff\x94\x3a\x4b\xcc\x19\xbc\xac\xa4\x18\xbe\x7e\xff\x03\xcc\
\x08\x8c\x0c\x8c\x4c\x4c\x90\xa2\x00\x94\x16\x80\x2c\x66\x60\xc4\
\xb1\x03\x73\xc8\xcf\x1f\xbf\x81\x21\xc3\xc4\xc0\x01\x14\x3f\xfd\
\x9c\x85\xe1\xe9\x67\x66\x86\x3c\xd3\xbf\x0c\x3a\xe2\x0c\x0c\x95\
\xc5\xa6\x0c\x12\xe2\x5c\x8c\x99\xe9\xbb\x27\xff\xfc\xf5\x87\x9d\
\x81\x99\x79\x22\x36\x07\x00\x04\x10\xb6\x34\xf0\x8b\x1d\xe8\xbb\
\x7f\x3f\x7f\x03\x7d\xfb\x8b\xe1\x37\xd0\x92\xdf\x40\xf6\xdf\x5f\
\x7f\x18\xfe\xfd\x01\x06\xc3\x5f\x08\xfd\xfd\xe7\x1f\x86\xbf\xc0\
\xa8\xf9\xf3\xe7\x0f\xc3\x9f\x9f\xbf\x18\xb8\x98\xfe\x30\xbc\xfa\
\xc6\xc0\xd0\x76\x8c\x99\xe1\xe0\x7d\x46\x70\x70\x25\xc6\x68\x33\
\x4c\x99\xe2\xc2\xc2\xce\xc2\xd8\xc7\xf0\xfb\xaf\x1f\x36\x07\x00\
\x04\x10\xb6\x34\x00\x34\xf4\x2f\xd0\xe7\xff\x19\x76\x5d\xf8\xc0\
\xb0\xec\xc4\x47\x06\x6e\x4e\x56\x06\x56\x36\x56\x06\x66\x56\x16\
\x20\x86\xd0\xac\xac\xcc\x0c\x2c\x6c\x2c\x40\x4b\x99\x19\x98\x81\
\x39\xef\xd7\xaf\xdf\x0c\x6c\xc0\x0c\xf8\xf3\x0f\x0b\xc3\x84\x33\
\x4c\x0c\x5f\x80\xd9\xd4\x5b\xed\x1f\x43\x4a\xa2\x0e\xc3\x97\x2f\
\xbf\x98\x0a\xf3\x76\x4f\x65\x60\x66\xbb\x0e\x34\xfe\x36\xb2\x5d\
\x00\x01\xc4\x82\x33\xe7\x01\xf1\xcb\xf7\xbf\x18\x4e\xdd\xfa\xc8\
\xc0\xcb\x03\x8c\x73\x76\x36\x06\x16\x76\x88\x43\x58\x58\xd9\xc0\
\x96\xb3\x00\xd9\x5c\xc0\x04\xc9\xc6\xc1\xc8\xf0\xe7\x17\x24\x8d\
\xb0\x01\xcb\x44\x46\x26\x16\x86\xd9\x17\x98\x80\xe9\xef\x1f\x83\
\xbb\xca\x7f\x86\xdc\x2c\x43\x86\xcd\x9b\xee\xc8\xec\xdb\xf3\x20\
\x07\xa8\x2a\x1f\xd9\x1e\x80\x00\xc2\x9a\x0d\xff\x01\x13\xdf\x3f\
\x50\xc2\x03\x26\x7f\x56\x20\x06\x26\x47\x06\x16\x60\x56\x63\xf9\
\xf7\x07\x8a\x7f\xc3\xd9\xff\x40\x51\x00\xf4\x3d\x0c\x83\xa2\x8b\
\x09\x24\x07\x34\x79\x1e\x30\x87\x5c\x7b\xf5\x0f\x18\xfd\x8c\x0c\
\x59\xd9\x86\x20\x6f\x39\xa2\xdb\x05\x10\x40\x38\x43\xe0\xdf\xff\
\x7f\xc0\xe8\xfe\x03\x34\xf0\x27\xc3\x6f\x36\x46\xa4\x02\x01\x94\
\x1b\x11\x69\xfa\x3f\x72\x61\x01\x6d\x5b\x80\xf2\x0e\x0b\x30\x3a\
\xbe\xfd\x65\x61\xf8\xfc\x13\x22\xc6\xcd\x0d\x2a\x20\x19\x31\x4a\
\x49\x80\x00\x62\xc1\x5d\xf8\x80\x8a\x5b\x60\x62\xfb\xf6\x9b\x81\
\x15\xe8\x1d\x50\xfa\x63\x01\x86\x0a\x2b\x30\xe1\x31\x43\xd9\x7f\
\x80\x6c\x0e\x44\xe6\x80\x17\x9a\x20\x2b\x3f\xff\x62\x62\x88\xd4\
\xfb\xc7\x60\x2e\x09\x11\x5f\xbc\xf8\x0a\x28\x75\x9d\x41\xb7\x06\
\x20\x80\xf0\x84\xc0\x7f\x60\x35\xf0\x9f\x81\x8b\xf9\x1f\x03\x3b\
\x30\x2e\x59\x81\x98\x19\x44\x33\x02\xa3\x02\x68\x0b\x0b\x23\x30\
\x8e\x19\x40\x51\xc0\xc8\xf0\x9b\x11\x5a\x62\xfd\x87\xd4\xc2\xc0\
\x40\x63\x08\xd1\x63\x62\x88\xd5\x01\x56\x64\x2c\x9c\x0c\x1b\x37\
\xdf\x63\x58\xb6\xf8\xfa\x17\x60\xb0\xcc\x40\xb7\x07\x20\x80\x58\
\x70\x15\xbd\x9f\xbf\xfd\x61\x70\x37\x12\x62\xb0\xd2\x12\x00\x5a\
\xcc\xc8\xc0\xc4\xc2\xcc\xc0\x04\xa2\x81\x65\x02\x33\x10\x83\x68\
\x50\xc8\xf4\xec\xfe\xc0\x70\xee\xc9\x2f\x06\x3e\xa0\xcf\xbf\x83\
\x4a\x4b\x60\xb0\xc4\x9a\xb2\x32\x24\x1a\x03\xcb\x0a\x4e\x0e\x86\
\x83\x47\x1e\x33\xa4\xa6\xed\x00\x99\x5a\xcb\xc0\xc4\x78\x04\xdd\
\x2a\x80\x00\xc2\xe2\x00\x46\x66\x76\x36\x26\x06\x21\x01\x4e\x06\
\x4e\x60\x0a\x67\x67\x03\x5a\x0c\x0a\x57\x50\x81\x04\x6a\x1e\x00\
\x2d\x06\x31\x7e\x02\xcb\x81\xdf\xbf\xfe\x02\x13\xe8\x3f\x70\x3a\
\xf9\x08\x74\x35\x27\x27\x1b\x43\xbe\x1d\x37\x43\xa8\x11\x1b\x03\
\x27\x2f\x27\xc3\x89\xd3\x2f\x18\xa2\xa3\xb7\x32\xbc\x7e\xf1\x65\
\x1a\x03\x07\xdb\x04\x70\xf0\xa0\x01\x80\x00\xc2\x70\xc0\x7f\x66\
\x86\x2f\x3d\x4b\xae\x0a\xac\xde\xcb\xc3\xf0\xfb\x0f\x22\x51\x31\
\xfe\x63\x04\x87\xef\x9f\x5f\xff\x18\x84\x79\xd8\x18\x4a\x53\x75\
\x19\x40\xe9\xea\x07\x30\xd5\xbf\xfb\xf4\x8b\x41\x57\x1e\x28\xe6\
\xc5\xcb\xe0\xa8\xc1\x01\xb6\x7c\xf3\x8e\x07\x0c\x49\x49\x3b\x19\
\xde\xbc\xf8\x36\x89\x81\x8b\xbd\x04\x9c\x40\x99\x19\x31\x1c\x00\
\x10\x40\x2c\x58\xaa\xde\xe4\x83\xc7\x9e\x39\x03\x83\xf2\x2f\xbc\
\x29\xf6\x17\x5e\x19\x01\x53\xe5\x5f\x59\x61\x21\xce\xf8\xd4\x08\
\x75\x06\x1e\x11\x76\x86\xaf\xdf\x7e\x31\xb8\x00\x2d\xad\xf2\x17\
\x66\xd0\x90\xe1\x62\x60\x64\xe7\x60\xe8\x99\x72\x81\xa1\xae\xfa\
\xe8\xef\xef\xdf\xff\xb4\x31\xf0\xb2\x36\x02\xf5\xe2\x6c\x7a\x03\
\x04\x10\xb6\x34\xb0\x0b\xd8\x0a\xda\x05\x0a\x0a\x44\x8a\x84\x3a\
\x00\x14\x84\x4c\xcc\xc6\x2c\x3c\xac\xf1\xa0\x64\x07\x2c\xe3\x19\
\x92\x1d\x84\x19\x74\xe5\x38\x19\xa4\xc4\x79\x18\x3e\x7e\xff\xcf\
\x50\x5a\xbc\x9f\x61\xe1\xdc\x2b\x6f\x19\x38\x58\x32\x19\x38\x59\
\x56\x33\x10\x68\xf5\x03\x04\x10\x0b\x49\xed\x27\x48\x52\xe7\x02\
\x07\xca\x3f\x48\x61\x65\xa6\xc2\xc5\x20\x28\xc2\xc3\x70\xfa\xe2\
\x3b\x86\xbc\xf2\x23\x0c\xe7\x8e\x3d\x3b\xcf\xc0\xcf\x96\x04\x54\
\x7b\x01\xdc\x18\x25\x00\x00\x02\x88\x38\x07\xc0\x5a\xb6\xc8\x42\
\x40\xcb\x79\xb9\x81\xda\x99\x59\x19\x26\xcc\xbe\xce\xd0\xd6\x73\
\xfa\xcf\xc7\x37\x3f\x16\x31\x08\xb0\x57\x01\xd5\xbf\x24\xc6\x72\
\x10\x00\x08\x20\xfc\x0e\x60\x84\xc5\xff\x3f\x0c\x61\x11\x61\x4e\
\x86\xe7\x6f\x7e\x33\xe4\x35\x1c\x66\xd8\xb7\xfd\xc1\x33\x60\x70\
\xe7\x31\xf0\xb1\xad\x05\x5b\x4c\x42\x67\x0b\x20\x80\xf0\x3b\x00\
\x5c\xaa\xa0\x99\x06\xcc\x93\xff\x80\xe5\x41\xef\xdc\x2b\x0c\x6b\
\xd7\xdd\xf9\xf3\xf2\xd9\x97\x0d\x0c\xbc\x6c\x65\x40\x57\xdd\x07\
\x3b\x96\x44\x00\x10\x40\x2c\x78\xe3\xfb\x07\x16\xaf\xb0\x32\xdd\
\x7e\xf5\xf1\xe7\xf1\x69\xb3\xaf\xf0\x03\x8b\xc3\x6e\x06\x5e\xf6\
\xa5\xc0\x04\xfa\x1b\x5b\x1e\x27\x06\x00\x04\x10\xe3\x40\x77\x4e\
\x01\x02\x68\xc0\xfb\x86\x00\x01\x34\xe0\x0e\x00\x08\x30\x00\xdb\
\x43\x72\xa0\x2a\x63\x1e\xb1\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x04\xc6\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\
\x01\x42\x28\x9b\x78\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\x43\x49\x44\
\x41\x54\x58\x85\xcd\x57\x4b\x6f\x1c\x45\x10\xfe\xaa\xab\x7b\x66\
\x76\x67\xbc\x99\xc5\x96\xd7\xeb\x68\x51\x14\x10\x0e\x48\xe1\x21\
\x21\xf9\x10\x59\x1c\x82\x20\x42\x42\xf2\xc1\xe2\x60\x9f\x80\x28\
\xc6\x37\x9f\xf2\x1f\xb8\x71\x5b\x62\x41\x38\xd9\x07\xe4\x83\x4f\
\x48\x20\xe5\x80\xac\x1c\x2c\x21\x11\x40\x09\x09\x20\x04\x58\x89\
\x6d\xc0\xec\x26\x59\x3f\x76\x5e\xcd\xc1\x8f\x9d\xd9\x99\xb1\xf3\
\x42\xa6\xa4\x3a\x4c\x75\x4d\xd7\x37\x5f\x57\x57\xd5\x90\xd6\x1a\
\x47\x29\xe2\x48\xa3\xff\x1f\x00\xc8\x87\x71\x7e\xbf\x6e\x0d\x11\
\xc4\x28\x0b\x31\x16\x41\xd7\xa2\x48\x97\x01\x40\x08\x6a\x08\xd0\
\x72\x18\x45\xf3\x1a\xd1\xc2\xa7\x53\xdb\xb7\x1e\x74\x4f\x7a\x90\
\x1c\x98\x9c\xb1\xab\x5a\xd3\x2c\xa0\x87\x9f\x72\x4b\x5c\xee\xb1\
\x4d\x4b\x49\x18\x6a\x07\xbf\xe7\x07\xd8\xf6\x03\x34\xee\x6f\xb4\
\xff\x69\xde\x0b\x01\x5a\x22\xd2\x13\x97\x2e\x6c\xac\x3c\x36\x80\
\xf3\xf5\xe2\x38\x88\xea\x03\xbd\x6e\x61\xb0\xaf\xac\x88\xe8\x40\
\x7f\xad\x35\xee\xfc\xdd\xf0\x57\xd7\x9b\x5b\xd0\x7a\xea\x93\xa9\
\xcd\xb9\x47\x02\xf0\xee\x47\x65\x57\x59\xde\x9c\x94\x72\xe4\xe4\
\xf1\x8a\x53\xb0\x8c\xee\x50\x07\x02\xd9\xda\xf6\xf0\xeb\xed\xb5\
\x56\x10\x84\x8b\xfe\xb6\x31\xfe\xd9\x74\xa3\x99\xe5\x97\x9b\x84\
\x6c\x79\x73\x6e\xc9\x39\x7b\xea\xc4\xa0\x63\x1a\x12\x51\x14\x75\
\xa9\x3e\x50\x4d\x43\xe1\xd4\x89\xe3\x8e\x5b\x72\xce\xb2\xe5\xe5\
\xb2\x90\xc9\xc0\xf9\x7a\x71\xdc\x50\xf2\xd2\x73\x4f\x0f\x3a\x59\
\x94\xff\x79\xed\x59\x7c\xf5\xf9\x6a\xc2\xf6\xc6\x3b\x03\xe8\x7f\
\xf9\x97\x94\xaf\xd6\x1a\x3f\xfd\x71\xa7\xe5\xf9\xc1\x64\xd6\x71\
\xa4\x18\x98\x9c\xb1\xab\x92\xb9\x5e\x1b\xe8\x73\x34\x34\x22\x1d\
\xa5\xd4\xe0\x02\x98\x39\xa1\x06\x17\x92\x7e\xbb\x4c\x69\xad\x51\
\xab\xf4\x39\x92\xb9\x3e\x39\x63\x57\x0f\x05\xa0\xa4\x9a\xed\x75\
\x4b\x05\x43\xca\x5c\x7a\x41\x94\x02\x00\xa2\xa4\x9f\xee\xa8\xa1\
\x24\x7a\xdd\x52\x41\x49\x35\x7b\x20\x80\xe9\xcb\xa5\x21\x16\x3c\
\xec\x3a\x45\x95\x3e\xf3\x8e\x12\x89\x14\x00\x22\x91\xf2\x0b\x63\
\x7a\xcc\x29\x28\x16\x3c\x3c\x7d\xb9\x34\x94\xcf\x80\x34\x46\xed\
\xa2\xc9\x3b\x34\xea\x5c\x25\x42\x06\x00\x20\xd4\xba\xa3\x19\xcc\
\xd9\x45\x93\x21\x8d\xd1\x44\xc8\xf8\x83\x21\xc5\x98\xa5\xa4\x19\
\x45\x9d\xc4\x6c\xfe\xf8\x4c\x02\xa3\x06\xb0\xb9\x1a\xed\xd0\x1e\
\x93\xb5\xdf\x23\x14\xdb\x27\xbb\x19\x86\xfb\x7c\x27\x31\x4d\x25\
\xcd\x20\x08\xc6\x00\x7c\x98\x09\x80\x49\xd4\x88\x08\x51\x14\xed\
\xdb\xae\x5d\xc9\xba\xa9\xcd\x14\x80\x9f\xaf\x37\x81\xeb\x69\xdf\
\x91\xa1\xce\xc7\x10\x11\x98\x44\x2d\xbe\x9e\x00\x20\x98\xcb\x1a\
\x3b\x54\xee\x83\xea\x0a\xf4\xb0\x12\x67\x73\x2f\x46\x2e\x00\xc9\
\xc9\xaf\x07\x00\x29\x1f\xaa\x5f\xa5\x01\xe8\xae\xfd\x38\x59\x57\
\x92\x47\xc0\xdc\x08\xc3\xb0\x12\xaf\x4d\x4f\x92\x81\xdd\xe4\x6d\
\xe4\x03\x10\xb4\x1c\x86\x54\x89\xa3\x7e\xfd\xed\x64\x12\x02\xc0\
\xda\xb2\x87\x1b\x3f\xdc\x49\xd8\x5e\x38\x3d\x88\x4a\xad\xbb\x5f\
\x00\x2b\xd1\x52\x67\x7f\x16\x60\x41\xcb\xf9\x00\x98\xe7\x65\xa4\
\x4f\xfb\x41\x60\xee\xd9\x6e\xdb\xa9\xda\x81\x52\xff\x9b\x29\x66\
\x8a\xfd\xf7\x70\xdb\xfe\x32\xe5\x1b\xef\x59\x26\x73\x9b\x99\xe7\
\xe3\xcb\x89\xb4\x15\xac\x16\x2c\xd3\x08\x0f\x6b\x34\x40\x46\x25\
\x44\xbc\x12\x66\x17\x30\xcb\x54\xa1\x60\xb5\x90\x0b\xe0\xe2\xb9\
\x9b\xb7\x98\xc5\x92\x5d\x30\xfd\xac\x1e\xb0\xa7\x99\x85\x08\x48\
\x75\xca\x30\xa6\x76\xc1\xf2\x99\x79\xe9\xe2\xb9\x9b\x89\x69\x29\
\x95\xe2\xa2\xc0\x13\x2e\xdb\x37\xb7\xda\x9e\xf2\xfc\x20\x4d\x29\
\xb0\x5f\x8a\x13\x36\x21\x12\xd7\x37\x2e\x86\x92\x70\x7b\xec\xad\
\xd0\xc0\x44\x2a\x5e\xb7\x61\x7a\xe4\xc6\x0a\x29\x31\x35\xd0\xe7\
\xb6\xb4\x4e\xd3\x19\xee\x5e\xd3\xf4\x11\x20\x93\x76\xad\x35\xaa\
\x7d\x6e\x8b\x94\x98\x9a\x1e\xb9\x91\x1a\xd1\x72\x27\xa2\x8f\xbf\
\x7e\xf1\x8b\xbb\xad\xcd\xb3\x2b\xeb\x0d\xa3\xdb\xa7\xc7\x2a\xc3\
\x2d\x56\x76\x1e\x76\x97\x9a\x9b\x6b\xb8\xbf\x9d\xb8\x61\x20\x22\
\x54\xfb\xca\xde\x31\xa7\x78\xe5\x83\xd7\xbe\x7f\x2b\x2b\x4e\x6e\
\x95\xb1\x34\x8f\xf3\x31\x7b\xae\xa7\x68\x8d\xfc\xb6\xf2\x97\xb3\
\xd5\xf6\xb0\x17\xf1\xee\xe6\x3a\xee\x6e\xae\xe7\xbd\x0a\x00\x28\
\x98\x06\x4e\x54\xfb\x5b\x4a\xf1\xa2\x0a\xc4\x78\x9e\xdf\xa1\x43\
\xe9\xcc\xd5\x57\xc6\x49\xeb\xfa\xda\x7a\xb3\xb0\xba\xde\x54\x87\
\xf9\x13\x11\x06\x7a\x5d\xbf\xd2\xeb\x6e\x69\xa2\xa9\x0b\x67\xbe\
\x7d\xb4\xa1\x34\x01\x62\xf1\xd5\x2a\xb4\x3f\xab\x81\xe1\xc6\xbd\
\x16\x37\x5b\x1b\x66\xdb\xf3\xe1\xf9\x21\x00\xc0\x90\x0c\xd3\x50\
\x70\x7b\xec\x76\xb9\xe4\x84\x04\x2c\x81\xd4\xc4\x85\x91\x6f\x1e\
\x7f\x2c\x8f\xcb\xe5\xab\x2f\x0d\x69\x4d\xa3\x41\x14\x8d\x11\xa8\
\x26\x98\xca\x00\x10\x85\xba\xa1\xa1\x97\xa5\x10\xf3\x44\x7a\xe1\
\xbd\x33\xdf\x3d\xd9\x1f\x93\xff\x52\x8e\xfc\xdf\xf0\xc8\x01\xfc\
\x0b\x5d\x94\xad\x35\x93\x65\x15\xa5\x00\x00\x00\x00\x49\x45\x4e\
\x44\xae\x42\x60\x82\
\x00\x00\x04\x39\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x00\x49\x44\x41\x54\x78\x5e\xa5\x94\xff\x8b\x54\x55\
\x18\xc6\x3f\xe7\x9c\x3b\x33\xbb\x3b\xcb\xcc\xae\xae\x9a\x62\x8b\
\xa9\x56\xea\x22\x99\x10\x1b\xe0\x2a\x14\x45\x00\x42\x06\xd2\x1f\
\x11\x54\x04\xf4\x53\x3f\x16\x11\x11\x54\x14\x04\xf5\x53\x04\x41\
\x82\x94\x84\xe4\xb0\xa8\x68\x81\x41\xd9\x22\x96\xed\xae\xee\xea\
\x18\xe2\x98\xee\xac\x33\xf7\xcb\xdc\x7b\xcf\x39\xdd\x7b\xf0\xe2\
\xc0\x56\x60\xbd\xf0\xf0\xce\x73\xcf\xfb\x3e\xf7\xbc\x0f\x77\x5e\
\x61\xad\xe5\x7e\xc3\xfb\xdc\x53\xaf\xee\x7a\x65\x6e\xc7\xaa\x1d\
\x6b\x52\x9b\xda\x85\xa5\x85\xf6\xc7\xdf\x7c\xb8\xb5\xfd\x46\x37\
\xa6\xa8\xe1\x3f\x84\x2d\xd9\xd2\xe4\xd8\xe4\x03\xdb\x46\xb6\x0d\
\x86\x36\xa4\x56\xae\x95\xc0\x0e\x01\xff\x4f\x58\x68\x41\x90\x04\
\xa6\x13\x77\x08\x08\x08\x93\xd0\x82\x00\xe0\xbe\x85\x07\x3f\xa9\
\xec\xb2\xca\x8e\x5b\x05\x0a\x59\x0e\xe3\x80\x3b\xf1\x1d\x42\x42\
\x82\xc4\xb7\x76\xc0\x3e\x3b\xfa\xf6\xb0\x2f\x52\x01\x86\x45\xe7\
\xb1\x10\xa2\x02\x88\x7f\xf4\xf4\x09\x55\x7a\xeb\xa3\x37\xaf\x3e\
\x35\xfe\xf4\x48\x98\x06\x84\x26\xca\x90\x65\x22\x02\x7c\x3e\xbb\
\xfe\x29\xe7\xba\xe7\xb0\x15\x8b\x2d\x83\x5a\x94\x8b\xde\xf8\xf8\
\xf8\xe9\x03\x07\x0e\x4c\x0e\x0d\x0d\xd9\x4a\xa5\x42\xa9\x54\x42\
\x29\x25\x00\x99\x24\x89\x8d\xe3\x38\x1f\x95\xaa\xad\xaa\x4e\x7c\
\x87\x28\x8d\x08\x75\x48\xa0\x03\x7e\x5e\xfe\x89\xe9\xdb\xd3\x5c\
\x36\x97\x90\x03\x02\xa3\x9c\xff\x10\xdb\xf5\xde\xf0\xf0\xf0\x93\
\x47\x8e\x1c\x51\x42\x08\xfa\xe3\xee\x24\x00\x4e\xec\xe5\xe9\x97\
\x88\xbd\x1e\xd7\xba\xd7\x98\x6f\xcf\xf1\xdb\xed\x0b\xdc\xd2\xb7\
\xc9\x2c\x40\x0e\x0a\x0c\x20\x8b\xde\x80\x8a\xa7\x94\x72\x02\xff\
\x16\x9e\xf0\x38\xff\xc7\x0c\xdf\x5d\x3a\x86\x54\x0a\x00\x9f\x0e\
\xae\x0d\x81\xd2\x8a\x7a\x67\x38\xbf\xad\x43\xfb\xda\xb2\x95\x59\
\xac\x50\xf5\x7d\x9f\xe5\xe5\x65\x8a\x50\x52\x71\xec\xc5\x06\xef\
\x3d\xf4\x01\xa7\x0f\xfd\x40\xe3\xf9\x13\x8c\xd9\x35\x00\x88\x04\
\x36\x46\x1b\xf9\x7a\xef\xb7\x4c\x4f\x9d\x62\x7a\xf2\x14\xfe\x3b\
\x3d\xe3\xe5\xe3\xde\xea\xde\x02\x2c\xdd\xc8\xe7\xd7\xe6\x05\x74\
\xa8\xd1\xda\x60\xbc\x3c\x3b\x90\xea\x14\xbf\x15\x70\xfc\xec\x71\
\x7a\x71\x8f\x28\x08\x29\xd5\x4a\x6c\x5f\xb5\x83\x31\xbd\x86\xa3\
\xa7\x8e\x52\x92\x25\xaa\xb2\x0a\x09\xc2\xb3\x58\x71\x33\x69\x21\
\x85\xe4\xc7\x9b\x67\xf9\xa5\x7b\x0e\x19\x48\xc2\x24\xe0\xaa\xbd\
\x42\x90\xe5\x30\x0d\x89\x74\xc4\x33\xf1\x73\x7c\x79\xfd\x0b\x82\
\xd8\xc7\x18\xc3\x23\xf5\x47\xd9\xb9\x7a\x82\xba\x19\xe1\xfd\x8b\
\xef\x82\xc2\x45\xae\xe9\xe5\x05\x0b\xcb\x97\xe9\x26\x5d\x5e\xff\
\xfe\x35\x12\x93\xb0\x59\x6d\x41\xa2\x98\xd7\xb3\xa0\x00\x01\x56\
\x40\x37\xf6\xe9\x78\x1d\x84\x02\x12\x28\x87\x65\x64\x94\x5f\x22\
\x5c\xf1\xb1\x7a\x3a\xd5\xdc\x8c\x5a\xae\xf1\xb1\x07\x1f\x07\x05\
\xab\xd3\x31\x04\x82\xda\x50\x1d\x64\x3e\x13\x0e\x83\x17\x06\xd9\
\xfd\xf0\x1e\x30\x60\xb7\x1a\x6c\x62\x39\xaf\xcf\xb3\xae\xb9\x9e\
\xdd\xe3\x7b\x40\x83\xd0\xd0\xe0\x24\x5e\x9a\xa6\x6c\x2f\xed\x24\
\x4a\x22\x5e\x28\x1d\x42\x1b\x8d\xee\x69\xd2\x24\xc5\xa4\x3a\xe3\
\x06\xad\x53\xe7\xb3\xff\x67\xc0\xde\x2b\xfb\xc8\x7b\x4c\xc6\x75\
\x6a\x5c\xbe\xd3\xec\xb0\x2e\x5e\x47\xaa\x35\xc2\x40\xc3\x9e\xb4\
\x62\xd3\xa6\x4d\xe9\xfc\xfc\xbc\xb2\xd6\x3a\xdf\xf2\xdc\x6a\xb5\
\x88\xa2\x88\x0d\x1b\x36\x38\xee\x60\x0c\x5f\x1d\x3e\xcc\xc1\x83\
\x07\x0b\x8e\xb9\x7b\x76\xf2\xc4\x09\xa6\xa6\xa6\x0a\x4e\xf6\xa7\
\xd3\xb2\xd7\xeb\x51\x88\x16\x39\x83\xbb\x95\x6b\x2e\x60\x2d\x49\
\x92\x38\x5e\xa0\x38\x4f\xd2\xb4\xe0\x4e\xa3\x5a\xad\x22\x7d\xdf\
\x77\x63\xf6\x15\x17\xc2\x4e\xac\x5f\x3c\x8e\xe3\x7b\xdc\xda\xa2\
\xde\xbd\xd0\x02\x42\x08\x94\x94\x8c\x8e\x8e\xe2\x65\xc2\x72\x66\
\x66\xc6\x89\x17\x58\x5a\x5a\x22\x7b\x4e\xb3\xd9\x74\x5c\xa7\xa9\
\xf3\x7a\x71\x71\x91\x46\xa3\xe1\x6a\xd2\x0c\xc5\xd9\xe5\x85\x05\
\x3c\xcf\xa3\x5c\x2e\xbb\x5d\x33\x32\x32\x22\x3c\x9b\xc5\xc4\xc4\
\x84\xe8\xf7\xac\x75\xe3\x06\xed\x76\x9b\xcd\x5b\xb6\x38\x5e\x8c\
\x38\x37\x37\xc7\xbe\xfd\xfb\x11\x90\x73\x57\x2f\x80\x33\x67\xce\
\xb0\x3f\x7f\x2e\x25\x52\x88\x5c\x18\x09\xac\xb0\x41\x17\xe3\xdd\
\x1b\xbb\xb0\x67\x85\x6d\xe4\xe3\x7b\x9e\xb3\x41\xe6\xc2\x4a\x51\
\xaf\xd7\x85\x04\x9c\x88\x6b\xee\xf7\x58\xeb\x7e\xee\xe0\xea\xb4\
\x2e\x6a\x8b\x35\xe8\x04\xc1\x79\xec\x90\x6d\x4c\xc4\xda\xb5\x6b\
\x7f\xcf\x16\xce\xe6\xbf\x59\x9b\xb2\xef\x77\x91\x05\xe0\x08\xc0\
\xc0\xc0\x00\xb5\x5a\xcd\x7d\x05\x59\xb6\x79\xce\xf6\x3a\xb3\xb3\
\xb3\x17\xff\x02\x94\x66\xfa\x33\xc9\xd2\xe3\x5a\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x04\xfb\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\
\x0d\xd7\x01\x42\x28\x9b\x78\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x02\xd8\
\x49\x44\x41\x54\x68\xde\xe5\x99\xc1\x6b\x53\x41\x10\xc6\xbf\x9d\
\x79\xf5\x5a\xa4\x20\xad\x58\x2a\x05\xff\x10\xcf\xed\x51\x29\x01\
\xa1\x82\x82\x1e\x44\x53\x10\xbc\x14\xfa\x82\xc5\x43\x11\x52\x72\
\x51\xac\x48\xf1\xa0\xb4\x05\x4f\xe6\xee\x1f\x20\x88\x22\x1e\x44\
\x0f\x6d\x3c\xaa\x18\xbd\xb4\x3b\xb3\x59\x0f\x4d\x9e\x7d\x7d\x69\
\xd2\xa6\xe0\x7b\xab\x03\x7b\x48\xc2\x24\xdf\x2f\xbb\x33\xf3\x25\
\x6b\xbc\xf7\x08\x39\x28\x6f\x01\xff\x3d\x40\x74\xd4\x84\x72\xb9\
\x3c\x6f\x8c\xb9\x9b\xb3\xee\x4a\xb5\x5a\x8d\x53\x00\xcb\xab\xab\
\x67\x8d\x33\x4f\x22\xe6\xf3\xfb\xab\xc2\x39\x57\xb9\x75\x65\x36\
\x06\x00\x11\x99\xaf\xd5\x6a\x03\x7d\x6a\xab\xd5\x4a\x96\x73\x2e\
\xf5\xf8\xa0\xe7\xbb\xc5\xd2\xd2\xd2\x02\x80\x34\x80\xb3\xee\xd5\
\xf8\xe9\xb1\x89\x53\x23\x23\x30\xc6\xa4\x12\xde\xbc\xff\x90\x24\
\xec\xec\xec\x1c\x4b\x78\x3f\xc1\x9d\xd5\xab\xb9\xec\xd5\x90\x00\
\xa8\xe8\xc4\xc9\xe1\x61\xbc\x7e\xfb\x0e\xce\xed\x23\xf7\xa8\x77\
\x4b\xee\x17\xde\xfb\x43\x0b\xee\xbc\x76\x98\xae\xd8\x1d\x40\x15\
\x22\x0a\xa7\x0e\x77\x6e\x5c\x37\x07\x25\x6f\x6f\x6f\x2f\x96\x4a\
\xa5\x5c\x6b\xc0\x18\x53\xc9\x00\x38\x55\x88\x58\xa8\x6a\xcf\xe4\
\x8d\x8d\x8d\x45\x00\x8b\x79\x02\xec\x8d\xa4\x8d\xaa\x2a\xac\x15\
\xa8\xe8\x71\xde\x2f\x5f\x00\x51\x81\x3a\xc9\x5b\xd3\x80\x00\x4e\
\x61\x45\xa1\xce\xe5\xad\x69\x30\x00\xa7\x0a\xb5\x02\x17\xf2\x11\
\xb2\x6a\xa1\x1a\xea\x11\x52\x07\x2b\x0a\x09\xec\x08\xa5\xe6\x80\
\x8a\xc0\x49\x6f\x80\xb9\xb9\xb9\x97\x00\xa6\x72\xd6\x5d\xaf\x56\
\xab\xd3\x29\x00\xa7\x0a\xb1\x02\xef\x1d\xae\x95\x6f\xa7\xc6\xa1\
\x07\x2a\x8f\x96\xef\xc7\x00\x60\xad\x9d\x2a\x80\x17\x4a\xbe\xc0\
\x3f\x3b\xe0\x14\x56\x04\xa3\xa3\x63\x99\x84\xcd\xad\xcd\x00\xbc\
\x90\x2a\x44\x04\x5b\x8d\xad\x6e\xe4\x61\x78\x21\x2b\x0a\x55\xc5\
\xb3\x95\x87\xa6\x47\x72\xbd\x54\x2a\xe5\x5e\x03\x19\x00\xd7\x9e\
\xc4\xae\x8f\x17\x5a\x5f\x5f\x9f\xce\x59\x7c\x2a\x52\x73\x40\xad\
\xf4\x35\x73\x45\x8b\x14\xc0\x8e\x08\x24\x64\x00\xd1\x80\x77\x00\
\xc0\xa1\x3a\x40\xd1\x22\x01\x20\x22\x30\x31\x88\xc2\xfa\xa7\x65\
\x0f\x00\x83\x99\x41\xc4\x79\x6b\x1a\x10\x80\x09\x11\x33\x38\xb0\
\x1d\x48\xe6\x00\x11\x21\xe2\x08\xc4\xbd\x01\x0a\x6b\xe6\x88\x78\
\x77\x17\xa2\x21\x5c\xbc\x7c\x35\x55\xcd\xae\x85\xca\x8b\xa7\x8f\
\x63\xa0\xc0\x66\x8e\x98\xc0\x11\x63\xfc\xcc\x38\xfc\x3e\x23\xf1\
\xa5\xd1\x28\xbe\x99\xeb\x14\x71\xa3\xd1\xc8\x92\x1b\x53\x7c\x33\
\x47\x44\xed\x2e\x44\x78\xbe\xf2\x20\x3c\x33\xc7\x6d\x00\xee\x53\
\xc4\x85\x35\x73\xc4\xbc\xbb\x82\x9d\x03\xb4\x3b\x07\x82\x9e\xc4\
\x11\x85\xbc\x03\xed\x36\xca\x1c\x2a\x40\xa7\x0b\x71\xc0\x47\x88\
\x03\xac\x81\xd4\x24\x26\x26\x98\xfe\x5e\x28\x06\xb0\x90\xb3\xee\
\xec\x25\x5f\x67\x07\x86\xa2\x13\xb8\x39\x5f\x49\x8f\xc3\x96\xaf\
\xd7\xee\xc5\xd3\x00\x60\xad\x5d\x28\x80\x17\xca\x5e\xf2\x11\x51\
\xf3\xeb\xb7\xef\xc3\xe7\x26\x27\x33\x97\x7c\x1f\x3f\x7f\x4a\x26\
\x6f\x61\xbd\x50\x64\xf8\x42\xf3\xc7\xaf\x4b\xcd\xe6\xcf\xd9\x4c\
\x86\xf1\x95\x6e\xc9\xfd\xe2\x6f\x78\x21\x73\xd4\xdf\xc1\x33\x33\
\x33\xb1\xf7\x3e\xd7\x1a\x30\xc6\x54\xd6\xd6\xd6\xe2\x81\x00\x8a\
\x16\x61\xf5\xcc\x7f\x11\xe0\x37\xca\x49\x61\x45\xc1\x6f\xd2\xbb\
\x00\x00\x00\x25\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\
\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x31\x2d\x31\x35\x54\x31\
\x37\x3a\x30\x32\x3a\x33\x35\x2d\x30\x37\x3a\x30\x30\x10\x90\x85\
\xa6\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\
\x65\x61\x74\x65\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\
\x30\x39\x3a\x33\x31\x3a\x30\x39\x2d\x30\x37\x3a\x30\x30\xab\xf6\
\x1c\xe5\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\
\x6f\x64\x69\x66\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\
\x54\x30\x39\x3a\x33\x31\x3a\x30\x39\x2d\x30\x37\x3a\x30\x30\xda\
\xab\xa4\x59\x00\x00\x00\x67\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\
\x73\x65\x00\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\
\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\
\x63\x65\x6e\x73\x65\x73\x2f\x62\x79\x2d\x73\x61\x2f\x33\x2e\x30\
\x2f\x20\x6f\x72\x20\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\
\x74\x69\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\
\x6c\x69\x63\x65\x6e\x73\x65\x73\x2f\x4c\x47\x50\x4c\x2f\x32\x2e\
\x31\x2f\x5b\x8f\x3c\x63\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\
\x64\x69\x66\x79\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x30\
\x36\x2d\x30\x33\x54\x30\x39\x3a\x35\x38\x3a\x31\x37\x2d\x30\x36\
\x3a\x30\x30\xd8\xd5\x41\x44\x00\x00\x00\x19\x74\x45\x58\x74\x53\
\x6f\x66\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\
\x63\x61\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\x13\
\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x00\x4f\x78\x79\x67\x65\
\x6e\x20\x49\x63\x6f\x6e\x73\xec\x18\xae\xe8\x00\x00\x00\x27\x74\
\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\
\x74\x70\x3a\x2f\x2f\x77\x77\x77\x2e\x6f\x78\x79\x67\x65\x6e\x2d\
\x69\x63\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\xef\x37\xaa\xcb\x00\x00\
\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x13\x8e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x49\xd2\x00\x00\
\x49\xd2\x01\xa8\x45\x8a\xf8\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x11\xa1\
\x49\x44\x41\x54\x68\xde\xbd\x9a\x69\x8c\x64\x57\x75\xc7\xff\xe7\
\xde\xfb\xd6\xda\xab\xbb\x7a\x9b\x9e\x99\x1e\x7b\x16\x7b\xcc\xe2\
\x15\x50\xc8\x82\x88\xc1\x36\x63\x63\x88\x08\x31\x1f\x92\xaf\x91\
\x10\x5f\x90\x12\xa2\x84\x04\x45\xc0\x87\x44\x91\x12\x12\x24\x50\
\xa4\x80\x42\x12\x40\x04\x6f\x08\x2f\xe3\x05\x07\x27\x08\x6c\x63\
\x33\x1e\x8f\x3d\xc3\xcc\x78\xec\x59\xbb\xab\xbb\xab\xbb\xeb\xd5\
\xf2\xd6\x7b\xef\xc9\x87\xea\x1e\xb7\x27\xb6\x67\x06\x08\xa5\x3a\
\x3a\x6f\xb9\x75\xfb\xfc\xee\x39\xf7\x9c\xf3\xaa\x9a\xf0\x4b\xbe\
\x1e\x79\xfc\x41\x30\xf3\x5b\x8e\x21\x22\xdc\x72\xf3\xbe\x5f\xf6\
\x4f\xbd\xf1\xdc\x97\xfb\x81\x47\x7f\xf0\x10\xac\xb5\x00\x00\xcf\
\xf3\xd0\xeb\xf7\x84\xa3\x1c\x9f\x88\xaa\x00\xca\x00\xbc\xf5\xa1\
\x19\x80\x01\x33\xf7\xb4\xd6\x69\xa5\x5c\xb1\x69\x96\x9e\x9f\xe7\
\xb6\x0f\xde\xf1\xeb\x07\xd8\xff\xd8\x83\x00\x2c\xd2\x34\x13\x52\
\xc9\xa6\x14\x72\xaf\x94\xf2\x3a\x29\xe5\x5e\x29\xd5\x36\x29\x45\
\x5d\x90\xf0\x00\xc0\x5a\x9b\x19\x63\xba\xc6\x9a\xd3\xc6\x98\xc3\
\xd6\xda\x03\xc6\xe8\xc3\xc6\xd8\x55\x29\xa5\x25\x22\xec\xbb\xf5\
\xce\x5f\x1f\xc0\xfe\xc7\x1e\x00\x91\x10\xc6\x14\x73\x42\xc8\xf7\
\x7b\xae\xb7\x2f\x08\xc2\x1b\x4a\x61\x69\xdc\x0f\x02\xcf\x75\x5c\
\x21\xa5\x04\x11\x01\x60\x58\x6b\xa1\xb5\x41\x9e\x67\x36\x49\x93\
\x2c\x8e\xe3\x4e\x92\xc6\xcf\xe5\x79\xfe\xa0\xd6\xfa\x09\x29\xe5\
\x49\x6b\xad\xbd\xfd\xb6\x8f\xfc\xff\x02\xec\x7f\xec\x01\x08\x21\
\x60\x8c\x69\x12\xd1\xad\xbe\xef\xff\x51\xad\x5a\x7f\x77\xbd\xd6\
\xa8\x07\x41\x00\x06\x23\xcb\x33\xa4\x49\x8c\x34\xcb\xa0\xb5\x06\
\x00\x28\xa5\xe0\x79\x1e\x7c\xcf\x87\xe3\x38\x60\xcb\x88\x93\x18\
\x51\x14\x75\x7b\xbd\xe8\xe9\x34\xcb\xfe\x8d\xd9\xee\x07\xb0\x6a\
\x8c\xc1\x47\xee\xf8\xd8\xaf\x1e\xe0\xe1\x47\xbf\x0f\xe5\xb9\x28\
\xd2\x6c\xa7\xe3\x38\x9f\xac\x55\xeb\x7f\x30\x31\x31\x39\x13\x86\
\x21\xd2\x34\xc1\xca\x4a\x07\x4b\xcb\xcb\x58\x5d\xeb\xda\xc1\x30\
\xd1\x69\x6e\xb4\x31\xb0\x00\xa0\x24\x09\xcf\x95\xaa\x52\x0a\xd4\
\xd8\x58\x5d\x8c\x8f\xb7\xd0\xa8\xd7\xa1\xa4\x8b\xc1\xa0\x8f\xe5\
\xce\xf2\x7c\xaf\x1f\x7d\xa7\x28\x8a\xaf\xe4\xba\x78\xd9\x51\x0a\
\x1f\xbd\xe3\xf7\x7f\x75\x00\x8f\x3c\xfe\x20\x88\x48\x68\xad\xaf\
\xf3\x7d\xff\xaf\x26\x5a\x53\xb7\x4c\x4c\x4c\xfa\x79\x91\x61\x7e\
\xfe\x2c\x4e\x9f\x3e\xcb\xf3\x8b\xdd\x78\x2d\xa6\x68\x68\xc2\x28\
\x43\x69\xa0\xd9\xcb\x2c\xa4\x01\x00\x01\x2d\x15\x32\xcf\xa3\xb8\
\x5c\x56\x71\xad\x59\xa2\xda\x96\xa9\x46\xb8\x75\xeb\x2c\x4d\x8c\
\x4f\x80\x01\x2c\x2d\x2d\xa6\x9d\xce\xf2\x23\x69\x96\x7e\x41\x4a\
\x79\x80\xb5\xb6\x77\xde\xf9\xf1\x5f\x1e\xe0\xfe\xef\xdf\x8d\x30\
\x0c\x49\x6b\x7d\xa3\xef\x07\x9f\x9f\x9d\x99\xbd\xb9\xd9\x1c\x57\
\xab\xdd\x0e\x8e\x1d\x3f\x86\x93\xa7\x97\xe2\x76\x4f\x2d\xf6\x31\
\xbe\x58\xc8\xc6\x00\xd2\x33\x44\x82\x09\x20\x06\x98\x99\x61\x19\
\x6c\x2d\x83\xd9\x82\x6c\xae\x7c\x44\x95\xba\x58\x99\x9c\xa9\xdb\
\xc9\x2b\xb6\x4f\x85\x3b\xe6\x76\x20\xf0\x03\x2c\x2f\x2f\xeb\x85\
\xf6\xfc\xe3\x69\x96\x7e\x4e\x81\x9e\x1d\x66\x29\x7f\xe2\xe3\x7f\
\x78\xc9\x00\xea\x8d\x2e\x4a\x29\x91\x65\xd9\xce\xc0\x0f\xfe\x7c\
\x66\x7a\xf6\xe6\xb1\xb1\x96\x9a\x6f\x9f\xc5\x4b\x87\x0f\xdb\x13\
\x67\xfb\x2b\x1d\x3d\x79\xaa\x70\x26\xbb\xd2\xf1\x4d\x20\x49\x08\
\x82\x04\x40\xcc\xa3\x8a\x60\x2d\xb3\x65\x66\x6b\x89\x8d\x25\x36\
\xd6\xd7\x09\x07\xab\x19\x37\x7b\x83\xb5\xe5\x95\x5e\xb2\xb0\x3d\
\x8e\x93\xb1\x3d\xbb\x77\x8b\x89\xc9\x49\x65\xd9\xde\x7c\x6e\xfe\
\x5c\x92\xa6\xe9\x9f\x09\x12\xc7\x2f\xc7\x03\xf2\xc2\x0b\xdf\x7b\
\xe0\x1e\x30\x73\xcd\x71\x9c\x3f\x9d\x9e\x9a\xf9\xc4\xd4\xe4\x94\
\x3b\xdf\x3e\x8b\xe7\x0f\xbe\x68\x8e\x9d\x4b\x17\x3a\xb8\xf2\x38\
\x85\x53\x83\xd0\xf7\x84\xef\x90\x54\x8a\xa4\x92\x42\x28\x49\x90\
\x42\x90\x1c\x69\x48\x41\x24\x05\x11\x11\x48\x10\x09\x22\x00\x90\
\x36\xa7\x4a\x3c\xd0\x41\x37\xe9\xaf\x38\x36\xef\x95\xea\xb5\x8a\
\x18\x6b\x8e\x09\xad\xf5\x8e\x38\x1e\x92\xd6\xfa\xa9\x8f\x7d\xec\
\xf7\xb2\x7b\xee\xbe\xef\x17\xf6\x80\x24\xa2\xdb\xea\xb5\xfa\x5d\
\x93\x13\x53\xfe\xea\xda\x0a\x5e\x3a\xfc\x73\xfb\x4a\xbb\x58\xe8\
\xca\x9d\x27\xbc\xa0\x5e\x78\xae\x50\x92\x88\x88\x46\x55\xd6\x5a\
\x16\x71\x9a\x39\xda\x58\xc1\x0c\x58\x66\xb6\x0c\x26\x90\x75\x1d\
\x27\x13\x02\x86\x8c\x15\x96\x98\x2d\x13\x6b\x5b\x8d\xdb\x46\xbe\
\x2c\xe7\xcf\xc1\x73\x4f\xcc\x5c\xb3\xf7\x6a\x31\x3d\x35\xed\x0f\
\x87\xc3\xbb\x56\x8a\xce\xd3\xd6\xd8\xef\x02\x30\x97\xed\x81\x7b\
\xee\xff\x0e\x88\x68\xce\xf7\x82\xcf\x6e\xdb\x36\xf7\x4e\x21\x04\
\x1d\x39\x72\x18\x3f\x3f\xb9\xda\x59\xa1\x2b\x4e\xb8\x61\x33\x0f\
\x7d\xa9\x1c\x29\x84\xa3\xa4\x50\x52\x08\x47\x09\x91\x17\xda\x3b\
\xd5\x5e\xd9\x62\x4d\x31\x66\xad\xa9\x1b\xad\xeb\x69\x96\x35\xd6\
\xfa\x71\xa9\x52\x0a\x86\x9e\xa3\x2c\x88\x40\x00\x88\x40\x44\x20\
\x03\xb7\x48\xad\x1b\x73\xda\x29\x95\x3c\x94\xc6\xc7\x5b\x50\x52\
\x96\xa2\x5e\xb7\x5c\xe8\xe2\x47\x77\x7e\xf4\xc3\xdd\xfb\xee\xfd\
\xde\xe5\x79\x80\x88\x24\x80\x0f\xd4\xeb\xf5\xf7\x94\xcb\x65\x3a\
\x75\xfa\x55\x9c\x3c\xbb\x94\xac\xd9\xe9\x53\x2a\x6c\xa6\xa1\x2f\
\x94\x23\xa5\x90\x52\x90\x14\x44\x62\x3d\x36\x92\x2c\x97\xf5\x92\
\xe3\x7f\xf8\xbd\x3b\xfc\x89\x7a\xc8\x00\xb0\xb8\x16\xe3\xbe\xff\
\x79\x45\x08\x01\xe9\xba\x92\x48\x93\xd0\x42\x58\x63\x2d\xac\x65\
\x90\xb1\x22\xb3\xd5\x61\x3b\xcd\x4e\x9d\x3c\xbb\x58\x1e\x1b\x1b\
\x0b\x1a\x8d\x26\xd5\x6b\x8d\xf7\x24\x49\xfa\x01\x10\x7d\xed\x52\
\xbc\x20\x36\x0e\xbe\xfe\x8d\xaf\xc1\x18\xdd\x72\x1d\xf7\x96\xb1\
\xb1\xf1\x7a\x92\xc4\x38\x7b\x6e\x9e\x3b\xb1\xb7\x68\xfd\xc9\x5e\
\xe8\x2b\xe5\x2a\x25\x5c\x47\xbe\x5e\x5c\x29\x1c\x25\xc9\x73\x15\
\x26\x1b\x21\xb7\x6a\x0a\xad\xaa\xc2\x64\x23\x84\xef\x2a\x28\x25\
\xc9\x71\x24\x39\x8e\x12\x8e\x23\x85\xe3\x28\x52\x4a\x8e\x44\x4a\
\x1a\x70\x73\xad\xdd\x93\x8b\xed\xf6\x22\x83\x80\xf1\xb1\xf1\xba\
\xeb\x38\xb7\x58\xad\x5b\x5f\xfe\xca\x97\x2e\xea\x81\xf3\x00\x46\
\x4b\x30\x63\x4f\x18\x96\xae\x0d\xc3\x12\x56\xd7\x56\xb0\xbc\x3a\
\x48\x86\xd4\x5a\xf6\xfc\x80\x5d\x57\x8d\xc2\x46\x49\x72\x95\xa4\
\xf3\x00\x4a\x0a\x47\x49\x21\x88\x88\x19\x64\x8d\x85\xb1\x16\x0c\
\x06\x09\x82\x92\x92\x1c\xa5\x84\xe3\x48\x72\x94\x24\x25\xc5\x48\
\x2b\x49\x8e\x12\x44\xca\xb3\x6b\xba\xb1\xb4\xb8\xda\x4b\xe2\xe1\
\x00\xd5\x6a\x0d\x61\x18\x5e\xcb\xe0\x3d\xf6\x12\x3a\x9d\xf3\x00\
\xca\xd1\x52\x08\x71\x6d\xb9\x5c\x9e\x01\x18\xab\xab\xab\x88\x52\
\xd9\x63\xaf\x19\x7b\xae\x92\x8e\x14\xa4\x94\x80\xe3\x48\x72\x5c\
\x49\xae\xa3\xe0\x39\x8a\x5c\x47\x91\xa3\x46\xb9\x94\x08\xa3\x94\
\x23\x46\x81\x2e\x88\xc8\x75\x24\xb9\x8e\x84\xeb\x48\x38\x8e\x84\
\xeb\x2a\x38\xce\x08\x40\x2a\x49\x4a\x09\x64\x54\x1d\xac\x0e\x10\
\x45\xbd\x1e\x5c\xd7\x45\xb9\x5c\x99\x11\x42\x5e\x2b\x60\xe5\xc5\
\x00\xce\xef\x01\x22\x78\x4a\xaa\xbd\x41\x10\x7a\x45\x91\x23\xea\
\x0d\x4c\xc6\xa5\x9e\x72\x03\xe3\x28\x21\xa5\x14\x00\x91\xe8\xc7\
\x99\x47\x60\x29\xa5\x20\x31\x4a\x91\x88\x86\xa9\x6b\x2c\x0b\x5a\
\xdf\xa1\xeb\x7b\x15\x96\x99\x06\x49\x1a\x58\x06\x69\x63\x59\x1b\
\xcb\xc6\x32\x03\x64\x5c\xd7\xc9\x14\xa4\x01\x88\x0c\x3c\x3d\x34\
\x41\xaf\xd7\x1f\x4c\xcc\x02\xb2\x14\x96\x3d\x25\xd5\x5e\x22\xf2\
\x00\xc4\x97\x08\x40\x25\x29\xd5\x36\xd7\x75\x29\xcb\x52\xc4\x69\
\xae\x8d\x1c\x8b\x1d\xc7\x81\x14\x82\x84\x94\x94\x66\x99\x73\xec\
\xe4\xc2\x74\xe0\x49\xd7\x53\x12\xa0\xd1\x5b\x1b\x4b\xcd\xaa\xe7\
\x38\x6a\xa3\x1b\x05\x1c\x47\xa0\x56\x72\x9d\x4e\x34\x98\x4a\xe2\
\x21\x5b\x1e\x55\xe8\xbc\x30\x18\x66\x36\xdd\x36\x33\x79\xc6\x73\
\xdd\xb4\x30\xcc\x49\x41\x45\xdf\xba\xfd\x41\x9c\x69\x63\x8d\x0c\
\x7c\x9f\xa4\x94\xdb\x88\x44\xe9\x92\x01\x00\x84\x42\x88\xa6\x94\
\x12\x71\x92\xa0\xd0\xac\x59\x86\xb9\x14\x92\x84\x14\xa4\xa4\x20\
\x66\x88\xb2\xaf\xdc\x0f\xbf\x77\x87\x3f\xd9\x08\xd8\x32\x68\x23\
\x4a\x5d\x47\xa2\x56\x72\xc1\xa6\x00\x03\xdc\x28\x7b\xb8\xeb\xfd\
\xbb\x44\x56\x18\x0f\x00\x98\x47\x35\x63\x3d\x3b\x21\xc9\x0d\xaf\
\xc6\x79\x72\xfc\xdc\x60\x38\xbf\x92\xa6\xbb\x9a\x29\xf6\x4e\x98\
\xdd\xd6\x5a\xcf\x71\x5d\x48\x21\x9a\x00\xc2\x4b\x0e\x21\x66\x76\
\x01\x04\x04\x82\x31\x06\x96\x89\x85\x74\x2c\x09\x42\x5a\x58\x9d\
\x6a\x70\x56\xb0\x72\x94\xc4\x64\x23\xe0\xc9\xba\x07\x63\x2d\x00\
\x3a\xbf\xd5\xd8\x6a\xf0\xf9\x13\x83\x5a\x28\xb1\x51\x6a\x2c\x03\
\x52\x08\x6b\x2c\x23\x37\xc8\x5f\x78\xa5\xbf\xd2\x8e\x78\xb5\x3b\
\xc8\x75\x96\x5b\xae\x2a\x9b\xe4\x1a\x05\x33\x43\x08\x01\x10\x05\
\xeb\x36\x5d\x1a\x80\xb5\x4c\x96\xed\xf9\xe7\x5b\x21\x04\x48\x08\
\x74\xfa\x3a\x39\xbe\x10\x0f\x92\x82\x8d\x2b\x74\x75\x4b\x59\x6f\
\x29\x0c\x94\x05\x11\x83\x48\x8c\x62\x86\x00\x7e\x0d\x86\x41\x20\
\x62\x02\xd8\xf2\x48\x8c\x61\xab\x2d\xdb\xa4\xb0\xdc\x8d\x75\xfe\
\xea\x92\x8e\x0b\x76\x0a\x21\x25\x49\x45\x90\x52\x40\x08\x26\x21\
\x68\x63\x41\xc1\xd6\x5e\x34\x0d\x6d\x02\x30\x99\xd1\x26\xb1\xd6\
\x42\x4a\x09\x47\x09\x51\x24\x1a\x87\x4e\x0f\xa3\xb3\x2b\x59\xaa\
\x1c\x05\xc9\x85\x13\xd8\xbc\x38\xb9\x38\xd0\x99\x66\x80\x79\xd4\
\xec\x10\xc8\x73\x24\xea\x15\x0f\xb0\x06\x0c\x30\x43\xf0\x6a\x3f\
\xe3\x34\x37\xb0\xcc\xcc\x16\x4c\x02\x68\xaf\xc4\x94\xe5\x06\x52\
\xba\x60\x28\x58\x6b\x20\x2c\x10\x7a\x42\xf9\x1e\x49\x29\x24\x8c\
\x49\xa1\xb5\x4e\x8c\x31\xd9\x25\x03\x68\x6d\xe2\xa2\x28\x56\x8b\
\x22\x87\xa3\x1c\xf8\xae\x54\x71\x12\xf3\x7c\x57\xa4\x16\x82\x47\
\xf9\x51\x9a\xc5\x9e\x1e\x7c\xf3\x89\x57\x8c\xe7\xca\xd1\x7a\x13\
\x60\x8c\x15\x5b\xc6\xfc\xe0\xe3\xef\xdb\x25\x9a\x15\x07\x00\xb0\
\xd2\xcf\xf8\x3b\x4f\x1c\xb7\x67\x3a\x49\x4c\x42\x58\xac\x7b\x36\
\x2b\x34\x2d\xf6\x74\x2c\x9d\x92\xb5\x56\x12\xc0\x90\x12\x18\x2b\
\x23\xa8\x84\xae\xa3\x94\x83\x3c\xcb\x50\x14\xc5\xaa\x36\x26\xbe\
\x74\x80\x22\x1f\xe6\x79\x76\x26\x49\x12\x34\x9a\x75\x84\x81\xab\
\x58\x0f\xdd\xb4\x08\xad\x90\x12\x16\x04\x2b\xbd\x34\x91\xe3\x47\
\x5e\x1d\xb0\x20\x21\x36\x62\x15\xb6\xc8\x42\xcb\xe9\xd5\x85\xb6\
\xa1\x20\xc1\x0c\x20\xd7\x96\x4e\x77\x92\xf4\xc5\x8e\xfb\x12\x4b\
\x3f\x66\x6b\x89\xed\x46\x88\x96\x2d\x94\x4a\x85\xb1\x60\x48\xb8\
\x04\xb1\xa5\xc6\xb5\x46\xb5\xe4\x0a\x29\x31\x8c\x87\xc8\xf2\xec\
\x4c\x51\x14\xc3\x4b\x06\x30\xc6\x64\x59\x96\xbd\xd8\xef\xf7\xd2\
\xb1\xf1\x71\xbf\x5a\x29\x8b\xa6\xdf\xa9\x07\xaa\x70\x86\xd6\xc9\
\x14\x84\xb0\x90\xda\x28\xbf\xaf\x94\x80\x90\x12\x42\x08\x22\x21\
\x18\xd9\xd0\x08\x91\x5b\x10\x01\x42\xac\x37\x6d\x04\x29\xa5\x95\
\x7e\x65\x00\xa7\x34\xb0\xd6\xc2\x1a\x0b\x6b\x0d\xac\x31\x20\x63\
\x48\xc0\xc0\x5a\x70\x23\xd4\xfe\x8e\x16\xb5\x9a\xf5\x9a\xb2\xd6\
\x22\x8a\xa2\x34\xcb\xb2\x17\x8d\x2e\x2e\x1a\x42\xe7\x2b\xb1\x94\
\xd2\xe4\x45\x71\xb0\x1b\x45\xf3\x5a\x6b\x54\xab\x55\x6c\x1b\x93\
\xad\xb9\x5a\xd6\xb0\x2c\xd8\x30\x59\xcb\xc4\x16\x04\xc3\x02\x96\
\x69\xe4\x15\x08\x8c\x42\x8c\xf8\x7c\xab\xb9\xb1\xaf\x09\x10\xa3\
\x1a\x02\x21\x05\x8d\x9a\x40\x41\x42\x08\x12\x42\x8e\x12\x85\x14\
\xd8\x39\x5e\x34\x76\x4e\x05\xad\x6a\xb5\x8a\x78\x18\x63\xad\xbb\
\x36\x9f\xe7\xf9\x41\x52\xce\xa5\x37\x73\x9f\xfa\xe4\xa7\x61\xad\
\x3d\x1a\x45\xd1\xf3\x51\x37\x42\xb9\x5c\xc1\xf4\x78\xa9\x7c\xdd\
\x74\x32\x17\x38\x56\x69\x26\x36\x20\x36\x4c\xd6\x80\xac\x81\x60\
\x03\x69\x2d\x49\xcb\x34\x0a\x25\x31\x5a\xf5\x91\x6c\xb4\x13\x4a\
\x42\x2a\x05\x29\xd5\xc8\x6b\xeb\x42\x52\x00\x42\xa0\xec\xb1\xf3\
\xae\xad\xc5\xdc\xb6\xa9\x46\xd9\xf3\x02\x2c\x77\x96\xd1\xed\x76\
\x9f\x37\xc6\x1c\xfd\xec\x67\xfe\xf2\x62\xf6\xbf\x06\x00\x00\x82\
\xe4\x72\x92\xc4\xfb\x17\x16\xe6\xd7\x04\x49\xb4\xc6\xc7\xc4\xdb\
\xb7\x60\xee\xda\xc9\xfe\x34\xd1\x68\xa5\x2d\x88\x47\x5a\xd8\x75\
\xcd\x4c\x82\xf3\xc2\x50\x7b\x2d\xa6\x73\x9d\x21\xcd\x77\x86\xd4\
\x5e\x8b\xa9\xd0\x96\xc4\xeb\x0c\x1f\xa5\x66\x21\x04\x04\x8d\xf4\
\x4d\x5b\x92\xe9\x1b\x76\xf8\x73\x53\xad\x09\x91\xa5\x29\xce\x9c\
\x39\xbd\x36\x8c\x87\xfb\x95\x10\xcb\x17\xb5\x1e\x17\x3c\x0f\x18\
\xd6\x06\x16\x3f\x58\xee\x2c\x3f\xd3\x59\xee\x7c\xb0\xd5\x1a\xa7\
\x6d\x53\xc3\xf2\x6f\x0f\xa3\xb7\xad\xe4\xa5\xfe\xc9\x61\x6d\x8d\
\xe8\x7c\xd7\x06\x08\xc1\x10\x12\x52\xb9\x66\x79\x88\xc1\xb7\x9f\
\x3c\x65\x3d\x47\xf1\x46\xb6\x59\x1e\x22\x56\x65\xd7\xb2\x94\x04\
\x66\x30\x0b\x08\xc1\xa3\x1c\x4f\x96\x77\x35\xb3\xc6\xcd\xbb\x8a\
\xb7\xed\xde\x36\x5b\xf6\xfd\x00\xc7\x8e\x1f\xe3\xf6\x62\xfb\x19\
\xa3\xcd\x0f\xac\xe5\xcb\x7f\x22\x7b\xe8\x81\x87\xb1\x6f\xdf\xad\
\xbd\x3c\xcf\x0b\x6d\xcc\x6f\xb5\xc6\x5b\xe5\x72\xa5\x4c\x2e\x92\
\x72\x48\x43\xb7\x1d\x07\x2b\x7d\xe3\x67\x52\x4a\x12\x62\xb4\x91\
\xa5\x14\x90\x8e\x6b\xac\x57\xe9\x46\xa8\xb6\x57\xb9\xba\xb0\x66\
\xab\x0b\x11\xaa\x0b\x36\x68\x2e\x91\x1b\x26\x58\xff\xa6\x02\x0c\
\x58\x30\x8c\x05\xcf\x96\x93\xca\x9d\x7b\xba\xd7\xfd\xc6\x9e\xb1\
\xed\x5b\xa6\x67\xc4\xea\xea\x2a\x0e\x1e\x3a\xb8\xd4\xe9\x2c\xff\
\x0d\x11\xff\xf8\x33\x7f\xf2\x17\x7c\xd9\x00\x00\xb0\xef\xf6\xdb\
\xb8\x28\xf2\x33\x79\x9e\x8d\x33\xf3\xb5\x13\x13\x93\x2a\x0c\x03\
\x51\x91\x49\xbd\xae\x06\xfe\x6a\xe6\x76\x7b\x3a\xc8\x48\x48\x28\
\xb9\x9e\x8d\x94\xc3\xd2\x2b\x65\x2a\x2c\x67\x4e\x50\xc9\x54\x50\
\xca\xa4\x1b\x66\x50\x7e\x0e\xac\x57\x55\x00\xd6\x32\x60\x19\x3b\
\xaa\x83\xfa\x47\x76\xaf\x5d\xff\x9b\xbb\x6b\x57\xee\xd8\xb6\x55\
\x25\x49\x82\x17\x0e\x1d\x8c\xcf\x9c\x3e\xfd\x75\x63\xcd\xbf\x1c\
\x3b\x76\x3c\x9d\xdb\x31\x87\x23\x87\x7f\x7e\xf9\x00\x0f\x3d\xb8\
\x1f\xb7\xdf\xb1\x2f\x2b\x8a\xe2\xd5\x38\x8e\xe7\x88\xc4\xce\xc9\
\x89\x49\x19\x86\xbe\xa8\x3a\x69\x63\xc2\xeb\xd7\x08\x9c\x77\x0b\
\x3f\x2e\xe0\x18\x21\x36\xbc\x31\xea\x58\xc5\xe8\xab\x08\x62\x66\
\x62\x6b\xc9\x5a\xc6\xba\x70\x28\x0b\xf7\xc6\xd6\xea\xec\xbe\x2b\
\xa3\xeb\xdf\xbd\xb3\x31\xb7\x6d\x76\x56\xe5\x79\x81\x9f\x1d\xf8\
\x19\x9e\x7d\xee\xd9\x57\x8f\x1c\x3d\xfa\xed\x43\x87\x0e\xb5\x87\
\xc3\xd8\x68\xad\xf5\xdb\xde\x7e\x0d\xae\xbf\xe1\x3a\x1c\x7a\xe1\
\xc5\x4b\x07\x00\x80\x87\x1f\xda\x8f\x7d\xfb\x6e\x5f\x4d\xb3\xe4\
\x44\x7f\xd0\xbf\x82\x80\x1d\xad\x56\x8b\xaa\x95\x8a\xa8\x07\xa6\
\x3a\x13\xf4\x27\x27\xbd\x41\x09\x80\x4e\xd9\xc9\x35\x94\xb5\x24\
\x19\x20\x30\x13\x2c\x8f\x56\xdb\x1a\x0b\x62\x23\x4a\x22\x75\x77\
\x57\xd6\x26\x7e\x77\xcb\xd2\x35\xef\xdb\x51\xbc\xfd\x1d\x57\x4c\
\xb4\xa6\xa7\xa6\x44\x96\x66\x38\xf0\xfc\x01\x3c\xfb\xdc\xb3\x68\
\xb7\xdb\x7e\x92\xa6\xd7\xfa\x41\xf0\x7e\x47\xa9\x9b\x84\x10\xb0\
\xd6\x9e\xb4\xd6\x9a\xb7\xf2\xc4\x9b\x36\x4b\xff\xf8\xe5\x7f\x40\
\x9a\xe6\x24\x04\x5f\x1b\x86\xe1\xe7\xb6\x6f\xdf\x7e\xeb\xee\x5d\
\xbb\xfd\xb0\x54\x42\x9c\x0c\xd0\x8d\x7a\xb6\x13\x65\xc3\x85\x81\
\x5a\x3a\x17\x87\x4b\x4b\x59\x18\x0d\x8c\x9f\x14\x2c\x0d\x40\x70\
\xa8\x90\x15\x99\x05\x13\x7e\x5c\xdb\x52\x4a\x27\x66\x6b\x3c\x31\
\xd3\x2c\x97\x5a\x63\xe3\xc2\xf3\x7c\xac\xac\xac\xe0\xf0\x91\x97\
\xe2\x9f\x3e\xfb\xec\xe9\x53\x67\xce\x6c\xbf\xfa\xaa\x3d\x41\xa5\
\x52\x81\xe3\x28\xc4\x49\x62\x8f\x1f\x3d\xf6\xf2\xc2\x42\xfb\xf3\
\xcc\x7c\x37\x11\x65\xf7\xde\x7d\xff\xe5\x01\x00\xc0\xdf\x7f\xe9\
\xef\x40\x05\xa1\x10\xc5\x1e\xd7\x71\xff\xb8\xd5\x6a\xdd\x75\xe5\
\x15\x3b\xa7\xa7\xa7\xa7\xa0\x1c\x85\x34\x4b\x91\xc4\x31\xe2\x34\
\x37\x71\x66\xf2\x54\x73\xae\x2d\x34\x00\x38\x82\x54\xe0\x0a\xb7\
\x12\x38\x6e\xb9\x14\xca\x72\xa9\x0c\xcf\xf3\x91\x26\x29\x4e\x9f\
\x39\x8d\xe3\xc7\x8f\x2d\x2c\x2d\x2f\x7d\xeb\xe9\x67\x9e\x7b\x3a\
\xea\xf5\xbf\xf8\xee\x9b\xae\xdf\x3d\x36\x36\x86\x66\xb3\x89\xe6\
\x58\x03\x2b\x2b\x2b\x78\xfa\xe9\x67\x8e\xb6\x17\xda\x5f\xb0\xd6\
\xde\xc3\xcc\x69\x18\x2a\x7c\xeb\x3f\xee\xbd\x78\x08\x6d\xbc\x1e\
\xd9\xff\x18\xf6\xdd\x7e\x1b\xb2\xa2\x58\x31\x5a\xff\xb4\xd7\xef\
\x9f\xe8\x74\x3a\xd5\x28\xea\x8e\x83\xe1\x97\xc2\x32\xaa\x95\x2a\
\x6a\xd5\xaa\x68\xd6\x2a\x4e\xab\x5e\xf2\xa7\x9a\xe5\x70\xba\x59\
\x09\xa7\xc6\x6a\x7e\x6b\xac\xe1\xd4\xaa\x35\xe1\x79\x3e\xd2\x34\
\xc5\xe9\x53\xa7\xf0\xe2\x4b\x87\xa2\x63\xc7\x8f\xfe\x68\x69\x79\
\xe9\x6f\x8b\xa2\xf8\xd7\x87\x1f\xfd\xaf\xb3\x81\xef\xdf\xdc\x68\
\xd4\xae\x10\x42\xa0\xd7\xeb\x63\x38\x18\x62\x72\x72\x02\xad\xd6\
\xf8\x78\xd4\x8d\xae\x19\x0c\x06\xcb\x5a\xeb\xa3\xcc\xe2\xff\x84\
\xd3\x45\x1f\x9a\x1f\xde\xff\x08\x1e\x7f\xf4\x71\xac\xac\x2e\x25\
\xcf\x1f\x78\xfe\xb0\x90\xe2\xc9\x28\x8a\x4e\x2c\x2e\x2e\x9a\xa5\
\xc5\x45\xbf\xdb\x8d\xdc\x24\x49\x5d\x5d\x14\x30\xc6\xc2\x18\x0b\
\x5d\x18\x24\x49\x8a\x6e\x14\x61\xa1\xbd\x80\x97\x5f\x3e\x1e\x1f\
\x3e\x72\xf8\xdc\xb1\xe3\xc7\x9e\x9c\x9f\x9f\xff\x6a\x7b\xa1\xfd\
\x4f\xdf\xfe\xd6\x7f\x3e\x75\xcf\xdd\xf7\x25\x5e\x10\x22\x2c\x85\
\x37\x96\xcb\xe5\x1b\x4a\x81\x4f\x4b\x4b\x8b\xe8\xf7\x07\x28\x0a\
\x83\x99\x99\x19\x4c\x4c\xb4\xc6\xa3\x28\x7a\x47\x1c\xc7\xcb\xcc\
\x7c\x6c\xef\x35\x57\xbf\x0e\xe2\x52\x7f\xa1\x79\xdd\xb8\x5b\x6e\
\xf9\x80\xbc\xf1\xa6\x1b\x5a\x8e\xeb\x5c\xe3\x38\xce\x3b\x5d\xd7\
\xbd\xca\xf3\xbc\x59\xc7\x71\xeb\x4a\x4a\x1f\x00\xb4\xd1\x59\x9e\
\xe5\x51\x9a\xa5\xe7\xe2\x38\x3e\x36\x1c\x0e\x0f\x9d\x3d\x7b\xee\
\xc8\xe3\x8f\x3d\xb1\xd2\x59\xee\x98\x8d\x39\x5d\xcf\xe3\x9d\x57\
\x5d\xfd\xa1\x89\x89\x89\x2f\x5e\xb5\xe7\xca\x5d\xa1\xef\xa2\xd7\
\xeb\xa1\x54\xaa\x60\xeb\xd6\x59\xec\xdc\x75\x25\xfa\xfd\x3e\x9e\
\xfa\xc9\x53\x47\xdb\xed\xc5\x2f\x5a\x6b\xef\x66\xe6\xb4\x52\xa9\
\xe0\xdf\xbf\xf1\xcd\x4b\x02\xa0\x4d\x7a\xb3\x30\x00\xcc\xed\x98\
\x73\x6f\x7a\xd7\x0d\xa5\x52\x18\x56\xa5\x52\x25\x29\x85\x67\x2d\
\x53\x96\x65\x45\x3c\x1c\x26\x8b\x4b\xcb\xc3\x43\x2f\xbc\x98\x44\
\xdd\xc8\x60\xd4\xba\x88\x0b\x17\xa4\x5c\xad\xfa\xb3\xdb\x77\xdc\
\x39\x35\x35\xf1\xe9\xbd\x57\xed\xda\xe1\x7b\x2e\xa2\x28\x42\xb9\
\x5c\xc6\xd6\xad\x5b\xb1\x7b\xcf\x2e\x44\x51\x84\xa7\x7e\xf2\xd4\
\xd1\xf9\xf9\x85\x2f\x68\xad\xbf\xeb\x38\x4e\x7e\xef\xdd\xf7\x5f\
\x14\xe0\xcd\x8c\x17\x17\x68\xbc\xc5\xfd\xcd\xf2\x66\x63\xe0\x05\
\x41\xb0\x75\xfb\xdc\x87\x66\x67\xb7\x7c\x6a\xef\xd5\xbb\xb7\x07\
\xbe\x8b\x6e\x37\x42\xa9\x34\x82\xd8\x73\xd5\x79\x88\x97\xe7\xe7\
\xdb\x7f\x4d\x84\x7b\x00\xa4\x17\xdb\x03\x9b\x8d\x13\x6f\xa1\xc5\
\xfa\x7e\x92\x18\xf5\x57\x9b\xb5\xdc\x74\x7f\xf3\xb8\x8d\x31\x0e\
\x00\xd7\x68\x2d\x07\xfd\xfe\x3c\x84\xec\xe5\x85\xbe\xa2\x51\x6f\
\xd4\x2b\xe5\x12\xfa\xfd\x1e\x92\x24\x85\xd6\x1a\x33\x33\x33\x68\
\x4d\xb4\x9a\x6b\xdd\xee\x35\xf1\x70\x78\x0a\xc0\xcb\x97\x03\xf0\
\x46\xc6\x13\x2e\x0e\xb7\x19\xf2\xcd\x3c\xa4\x00\x38\xc6\x18\x1a\
\xf6\x7b\x67\x58\xc8\x6e\x9e\x17\x57\x36\x9b\xcd\x5a\xa5\x52\x42\
\xaf\xf7\x1a\xc4\xb6\xed\xdb\xe0\xb8\x6a\x7c\x61\x7e\x7e\x90\x24\
\xe9\x0f\x2f\x17\x00\x17\x9c\xbf\xd1\x7d\x7a\x93\xcf\x6f\x68\x5e\
\x97\x37\x9a\x4b\x18\x63\xcc\xa0\xdf\x3b\x09\x21\x97\xf3\xa2\xd8\
\xd5\x68\xd6\xeb\x95\x72\x19\xbd\x5e\x0f\x00\xd0\x6c\x36\xb0\xb6\
\xd6\xd5\x67\x4e\x9f\xf9\x61\x14\x45\x97\x05\xf0\x46\xd7\x37\x1f\
\xf3\x05\x1a\xc0\xe8\x17\xcb\x4d\x46\xdb\x4d\x7a\x43\xcc\xa6\xeb\
\x0c\x00\xd6\x18\x3d\x1c\x0c\x5e\x25\x29\xd7\xf2\x5c\xef\x6c\x34\
\xea\xf5\x66\xb3\x81\x5a\xbd\x86\xa8\xd7\xc3\x0b\x07\x0f\x1d\x6a\
\x2f\x2e\xfe\xf3\x93\x4f\x3c\xf9\xea\x45\xeb\xc0\x05\xc6\xf2\x05\
\x06\x6d\x96\x0b\x0d\xdd\x30\x6c\xe3\xd8\x00\xd0\x17\x48\xb1\xe9\
\xd8\x6c\x12\x36\x46\x9b\x41\x7f\x70\x0a\x42\xf4\xb3\xbc\xd8\xe9\
\x7b\x5e\xb5\xd7\xef\xdb\x23\x47\x8e\x9e\x38\x79\xf2\xe4\x57\x0f\
\x1e\x38\xf8\xe3\x2c\xcb\x7f\xb1\x3a\x80\x37\x0f\x9d\xb7\x0a\xa3\
\xb7\x9a\x7b\x63\x73\x3b\x9b\x44\x01\x70\x5c\xdf\x2f\xcd\x6e\xdb\
\xfe\x3b\xd5\x5a\xed\x77\x08\xbc\xd6\xeb\x76\xff\xfb\xcc\xa9\x53\
\x07\xf2\x3c\xef\x03\x48\x2f\xf7\x9f\x3d\x36\x62\xf8\x52\x42\xea\
\x72\xe7\xdd\x9c\xcd\x14\x5e\xcb\x50\x8e\x94\xd2\xf3\x83\xa0\xac\
\x8b\xc2\x66\x59\xb6\xe1\xb5\xec\x17\x01\x78\x2b\x03\x7e\x15\x73\
\x6c\xce\x52\x1b\x69\x77\x03\x66\xe3\x7c\x63\x11\x0b\x00\xc5\xff\
\x02\x12\xd2\x41\x9a\x06\x51\x80\xd4\x00\x00\x00\x25\x74\x45\x58\
\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\x74\x65\x00\x32\x30\x30\
\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\x3a\x35\x31\x3a\x32\x31\
\x2d\x30\x37\x3a\x30\x30\x82\x80\x0a\xca\x00\x00\x00\x25\x74\x45\
\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\x00\x32\x30\
\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\x33\x3a\x32\x36\x3a\x31\
\x38\x2d\x30\x37\x3a\x30\x30\x67\xec\x3d\x41\x00\x00\x00\x25\x74\
\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\x79\x00\x32\
\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\x30\x39\x3a\x31\x31\x3a\
\x34\x30\x2d\x30\x37\x3a\x30\x30\x93\x15\x56\xb1\x00\x00\x00\x34\
\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\x74\x74\x70\
\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\x6d\x6d\x6f\
\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\x65\x73\x2f\
\x47\x50\x4c\x2f\x32\x2e\x30\x2f\x6c\x6a\x06\xa8\x00\x00\x00\x25\
\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\x79\x2d\x64\x61\x74\x65\x00\
\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\x3a\x35\x31\
\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\xdd\x31\x7c\xfe\x00\x00\x00\
\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\x00\x77\x77\
\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\x2e\x6f\x72\x67\x9b\xee\
\x3c\x1a\x00\x00\x00\x17\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\
\x00\x47\x4e\x4f\x4d\x45\x20\x49\x63\x6f\x6e\x20\x54\x68\x65\x6d\
\x65\xc1\xf9\x26\x69\x00\x00\x00\x20\x74\x45\x58\x74\x53\x6f\x75\
\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\x2f\x2f\x61\
\x72\x74\x2e\x67\x6e\x6f\x6d\x65\x2e\x6f\x72\x67\x2f\x32\xe4\x91\
\x79\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x13\x85\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x49\xd2\x00\x00\
\x49\xd2\x01\xa8\x45\x8a\xf8\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x11\x98\
\x49\x44\x41\x54\x68\xde\xbd\x9a\x69\x8c\x64\x57\x75\xc7\xff\xe7\
\xdc\xfb\x96\x7a\xb5\x57\x75\x55\x2f\xd3\xd3\xd3\xe3\xd9\xec\x19\
\xc0\xe3\x8d\x25\x0a\x21\x21\x06\xdb\x8c\x1d\x03\x22\x2c\x1f\x92\
\xaf\x91\x10\x5f\x90\x12\xa2\x84\x04\x45\xc0\x87\x44\x91\x12\x12\
\x24\x50\xa4\x80\x42\x16\x10\xc1\x36\x46\x78\x19\x2f\x2c\x8e\x10\
\xd8\xc6\x66\x3c\x1e\x7b\x86\xd9\xf0\x4c\x4f\x4f\x75\x75\x57\x77\
\x75\xbd\x5a\xde\x7e\xef\xcd\x87\x9a\x1e\xb7\x27\xf6\x2c\x40\x78\
\xd2\xd1\xbd\xef\xbd\x5b\xb7\xcf\xef\x9e\xff\x3d\xf7\xde\xaa\x26\
\xfc\x8a\xd7\x63\x4f\x3e\x0c\x63\xcc\x65\xdb\x10\x11\xee\xb8\xfd\
\xc0\xaf\xfa\xa7\x5e\xbf\xef\x6b\xfd\xc0\xe3\xdf\x7b\x04\x5a\x6b\
\x00\x80\xe3\x38\xe8\x0f\xfa\x6c\x49\xcb\x25\xa2\x12\x80\x02\x00\
\xe7\x42\xd3\x18\xc0\xd0\x18\xd3\xcf\xb2\x2c\x2a\x16\x8a\x3a\x8a\
\xa3\x8b\xfd\xdc\xf5\xde\x7b\x7e\xf3\x00\x07\x9f\x78\x18\x80\x46\
\x14\xc5\x2c\xa4\xa8\x09\x16\x7b\x85\x10\x37\x09\x21\xf6\x0a\x21\
\xe7\x84\xe0\x0a\x13\x3b\x00\xa0\xb5\x8e\x95\x52\x3d\xa5\xd5\x82\
\x52\xea\xa8\xd6\xfa\x90\x52\xd9\x51\xa5\x74\x57\x08\xa1\x89\x08\
\x07\xee\xbc\xf7\x37\x07\x70\xf0\x89\x87\x40\xc4\xac\x54\x3a\xcf\
\x2c\xde\xed\xd8\xce\x81\x5c\xce\xbb\x25\xef\xe5\x27\xdc\x5c\xce\
\xb1\x2d\x9b\x85\x10\x20\x22\x00\x06\x5a\x6b\x64\x99\x42\x92\xc4\
\x3a\x8c\xc2\x38\x08\x82\xd5\x30\x0a\x9e\x4f\x92\xe4\xe1\x2c\xcb\
\xbe\x2f\x84\x38\xa3\xb5\xd6\x77\xdf\xf5\xfe\xff\x5f\x80\x83\x4f\
\x3c\x04\x66\x86\x52\xaa\x46\x44\x77\xba\xae\xfb\xc7\xe5\x52\xe5\
\x6d\x95\x72\xb5\x92\xcb\xe5\x60\x60\x10\x27\x31\xa2\x30\x40\x14\
\xc7\xc8\xb2\x0c\x00\x20\xa5\x84\xe3\x38\x70\x1d\x17\x96\x65\xc1\
\x68\x83\x20\x0c\xe0\xfb\x7e\xaf\xdf\xf7\x9f\x89\xe2\xf8\xdf\x8d\
\xd1\x07\x01\x74\x95\x52\x78\xff\x3d\x1f\xfa\xf5\x03\x3c\xfa\xf8\
\x77\x21\x1d\x1b\x69\x14\xef\xb4\x2c\xeb\xe3\xe5\x52\xe5\x23\xcd\
\xe6\xe4\x8c\xe7\x79\x88\xa2\x10\x6b\x6b\xab\x58\xe9\x74\xd0\x5d\
\xef\xe9\xe1\x28\xcc\xa2\x44\x65\x4a\x41\x03\x80\x14\xc4\x8e\x2d\
\x64\x31\x9f\x93\xf5\x7a\x85\x27\x26\x1a\xa8\x56\x2a\x90\xc2\xc6\
\x70\x38\x40\x67\xb5\xd3\xea\x0f\xfc\x6f\xa6\x69\xfa\xa5\x24\x4b\
\x4f\x59\x52\xe2\x03\xf7\xfc\xe1\xaf\x0f\xe0\xb1\x27\x1f\x06\x11\
\x71\x96\x65\x37\xb9\xae\xfb\xd7\xcd\xc6\xd4\x1d\xcd\xe6\xa4\x9b\
\xa4\x31\x5a\xad\x45\x2c\x2c\x2c\x9a\xd6\x72\x2f\x58\x0f\xc8\x1f\
\x29\xcf\x8f\x91\x1f\x66\xc6\x89\x35\x84\x02\x00\x46\x26\x24\x62\
\xc7\xa1\xa0\x50\x90\x41\xb9\x96\xa7\xf2\x96\xa9\xaa\xb7\x75\xeb\
\x2c\x35\x27\x9a\x30\x00\x56\x56\x96\xa3\xd5\xd5\xce\x63\x51\x1c\
\x7d\x4e\x08\x71\xc8\x64\x99\xbe\xf7\xde\x0f\xff\xea\x00\x0f\x7e\
\xf7\x3e\x78\x9e\x47\x59\x96\xdd\xea\xba\xb9\xcf\xce\xce\xcc\xde\
\x5e\xab\x4d\xc8\x6e\x6f\x15\x27\x4e\x9e\xc0\x99\x85\x95\xa0\xdd\
\x97\xcb\x03\x4c\x2c\xa7\xa2\x3a\x84\x70\x14\x11\x63\xac\x7e\x18\
\x63\x0c\xb4\x01\xb4\x36\xc6\x18\x0d\xd2\x89\x74\xe1\x17\x2b\xbc\
\x36\x39\x53\xd1\x93\xd7\x6d\x9b\xf2\xb6\xcf\x6f\x47\xce\xcd\xa1\
\xd3\xe9\x64\x4b\xed\xd6\x93\x51\x1c\x7d\x46\x82\x9e\x1b\xc5\x91\
\xf9\xd8\x87\xff\xe8\xaa\x01\xe4\xeb\x3d\x14\x42\x20\x8e\xe3\x9d\
\x39\x37\xf7\x17\x33\xd3\xb3\xb7\xd7\xeb\x0d\xd9\x6a\x2f\xe2\xe5\
\xa3\x47\xf5\xe9\xc5\xc1\xda\x6a\x36\x79\x36\xb5\x26\x7b\xd2\x72\
\x55\x4e\x80\x99\x48\x02\x63\xcf\x8d\x01\xb4\x31\x46\x1b\x63\xb4\
\x26\x28\x4d\x5a\x69\x37\x0b\x4d\xae\x1b\xeb\x5a\x7f\xb8\xde\x59\
\xeb\x87\x4b\xdb\x82\x20\xac\xef\xd9\xbd\x9b\x9b\x93\x93\x52\x1b\
\x7d\xfb\xf9\xd6\xf9\x30\x8a\xa2\x3f\x67\xe2\x93\xd7\x12\x01\x71\
\xe9\x83\xef\x3c\x74\x3f\x8c\x31\x65\xcb\xb2\xfe\x6c\x7a\x6a\xe6\
\x63\x53\x93\x53\x76\xab\xbd\x88\x17\x0e\xbf\xa4\x4e\x9c\x8f\x96\
\x56\xb1\xe3\x24\x79\x53\x43\xcf\x75\xd8\xb1\x48\x48\x49\x42\x0a\
\x22\xc9\x0c\x21\x98\x84\x60\x48\x41\x24\x98\x88\x99\x40\x44\xc4\
\x44\x44\x64\x08\x2c\x75\x82\x62\x30\xcc\x72\xbd\x70\xb0\x66\xe9\
\xa4\x9f\xaf\x94\x8b\x5c\xaf\xd5\x39\xcb\xb2\xed\x41\x30\xa2\x2c\
\xcb\x9e\xfe\xd0\x87\x3e\x18\xdf\x7f\xdf\xb7\x7f\xe9\x08\x08\x22\
\xba\xab\x52\xae\x7c\x74\xb2\x39\xe5\x76\xd7\xd7\xf0\xf2\xd1\x9f\
\xeb\x5f\xb4\xd3\xa5\x9e\xd8\x79\xda\xc9\x55\x52\xc7\x62\x29\x98\
\x88\xc6\xfe\x81\x00\x68\x6d\x30\x08\x42\x2b\x8e\x53\xa1\xc7\x91\
\x30\x44\xac\x73\x39\x37\x66\x66\x45\x0a\x46\x6b\x63\x34\x91\xc9\
\x74\x29\x68\x2b\x71\x4a\xb4\xce\xc3\xb1\x4f\xcf\xec\xdb\x7b\x03\
\x4f\x4f\x4d\xbb\xa3\xd1\xe8\xa3\x6b\xe9\xea\x33\x5a\xe9\x6f\x01\
\x50\xd7\x1c\x81\xfb\x1f\xfc\x26\x88\x68\xde\x75\x72\x9f\x9e\x9b\
\x9b\xbf\x91\x99\xe9\xd8\xb1\xa3\xf8\xf9\x99\xee\xea\x1a\x6d\x3f\
\x6d\x7b\xf5\xd4\x73\x84\xb4\x24\xb3\x25\x99\xa5\x60\xb6\x04\x93\
\x94\x02\x61\x14\xb9\xa7\x7e\xb1\x30\x13\x05\x83\x89\x2c\x09\x2b\
\x83\xfe\xa0\xda\xe9\xae\xe7\x2b\x95\xd2\xc8\x75\x6c\x0d\x10\x68\
\xbc\xab\x20\x22\x90\x82\x9d\x46\xda\x0e\x4c\xb4\x9a\xcf\x3b\xc8\
\x4f\x4c\x34\x20\x85\xc8\xfb\xfd\x5e\x21\xcd\xd2\x1f\xdd\xfb\x81\
\x3f\xe8\x7d\xfb\x81\xef\x5c\x5b\x04\x88\x48\x00\x78\x4f\xa5\x52\
\x79\x7b\xa1\x50\xa0\xb3\x0b\xaf\xe0\xcc\xe2\x4a\xb8\xae\xa7\xcf\
\x4a\xaf\x1e\x79\xae\xb0\xac\xb1\x4c\x58\x32\x81\x05\x83\x89\x00\
\x02\xf9\xad\x91\x37\x55\xcb\x15\x3f\xf8\xee\xbd\xb2\x52\x70\x71\
\x7e\xa5\x8f\x6f\x3e\xf1\x12\x33\x20\x6c\x4b\x10\x11\x71\xc6\x6c\
\x94\xd6\xd0\xda\x80\x94\xe6\x58\x97\x46\xed\x28\x3e\x7b\x66\x71\
\xb9\x50\xaf\xd7\x73\xd5\x6a\x8d\x2a\xe5\xea\xdb\xc3\x30\x7a\x0f\
\x88\xbe\x72\x35\x51\xe0\x8d\xca\x57\xbf\xf6\x15\x28\x95\x35\x6c\
\xcb\xbe\xa3\x5e\x9f\xa8\x84\x61\x80\xc5\xf3\x2d\xb3\x1a\x38\xcb\
\xca\x9d\xec\x7b\xae\x94\xb6\x14\x64\x5b\x82\x6d\x4b\x90\x10\x24\
\xa2\x28\x72\x7b\xfd\x81\xb7\xd8\x5a\x29\x77\xbb\xdd\xea\xcd\x7b\
\xa6\xe5\xae\xd9\x2a\x26\x6b\x2e\xa6\x1b\x45\xb8\x8e\x05\x69\x09\
\xb2\x2c\x49\x96\x25\xd8\xba\x50\x97\x52\x8c\x4d\x08\x1a\x9a\xda\
\x7a\xbb\x2f\x96\xdb\xed\x65\x03\x02\x26\xea\x13\x15\xdb\xb2\xee\
\xd0\x59\xd6\xf8\xe2\x97\xbe\x70\xf5\x11\x50\x99\x80\x31\xd8\xe3\
\x79\xf9\xfd\x9e\x97\xc7\xf2\x4a\x0b\x9d\xee\x30\x1c\xd1\x54\xc7\
\x75\x73\xb0\x6d\x49\x63\xb9\x30\x59\x92\x69\x34\x0a\xed\x23\xc7\
\x4e\x4f\x39\x92\xec\x52\xde\x11\xef\xdc\x3f\x2b\xdf\x71\xe3\x56\
\xd2\x3a\x33\x66\x9c\x4b\x41\x4c\x90\x42\xb0\x35\x9e\x31\x9a\x48\
\x13\x29\x0d\xde\xd0\x11\x69\xa4\xe4\xe8\xf5\xac\xba\xb2\xdc\xf5\
\x9b\x73\xa3\xa1\x57\x2a\x95\xe1\x79\xde\xfe\xc1\x70\xb0\x47\x83\
\xda\x57\x0d\x20\xad\x4c\x30\xbb\xfb\x0b\x85\xc2\x0c\x60\xd0\xed\
\x76\xe1\x47\xa2\x0f\xa7\x16\x38\xb6\x64\x29\x98\xa5\xdc\x00\x10\
\xa4\x8d\x16\x9e\x23\xdc\x8f\xdc\xbe\xcf\xd9\xb1\xb5\x6e\x72\x8e\
\x84\xd6\x19\xd2\x34\x21\x66\x69\x88\x08\x4c\x74\xb1\x3d\x08\x6c\
\x00\x4d\x4c\x50\xca\x00\x44\x00\x11\x0c\x69\x13\xab\xd2\xb0\x3b\
\xf4\x7d\xbf\xdf\xf7\xb6\xcc\x94\x50\x28\x14\x67\x3a\xab\xab\xfb\
\x19\xfa\x47\x57\x92\xd1\x45\x09\x11\xc1\x91\x42\xee\xcd\xe5\x3c\
\x27\x4d\x13\xf8\xfd\xa1\x8a\x4d\xbe\x2f\x6d\x4f\x59\x82\x49\x0a\
\x06\x8f\xf5\x4f\x2c\x98\x98\x19\x44\x80\x36\x06\xa3\x30\xa1\x6e\
\x3f\x04\xc0\x10\x42\x82\xc7\x79\x93\x08\x04\x79\x21\x6a\x52\x8c\
\x65\x23\x84\x20\x31\x9e\xf8\xe3\x67\x42\x10\x84\x93\x8d\x54\xae\
\xdf\x1f\x0c\x15\x01\xc8\x7b\x05\x47\x0a\xb9\x97\x88\x1c\x5c\xe1\
\x92\xaf\x02\x50\x5e\x08\x39\x67\xdb\x36\xc5\x71\x84\x20\x4a\x32\
\x25\xea\x81\xb4\x24\xc4\xd8\x61\x12\x3c\x76\x9c\x99\xc9\xb1\x2d\
\x13\x26\x3a\xbd\xff\x07\xc7\x48\x30\x51\xbd\xe4\xca\x8f\xdd\x75\
\x23\xaa\x05\x1b\x84\x0b\x03\xcc\x44\x42\x32\x09\x29\x48\x83\xa0\
\xc7\xc8\xe3\x97\x4a\x03\x80\x49\x95\x41\x98\x52\x3a\xd0\xf6\x60\
\x18\xc4\x99\xd2\x4a\xe4\x5c\x97\x84\x10\x73\x44\x9c\x07\x10\x5c\
\x6d\x16\xf2\x98\xb9\x26\x84\x40\x10\x86\x48\x33\x93\x19\xe1\x25\
\x82\xc7\xa3\xbe\xb1\x48\x09\xc1\xc4\x44\x28\x97\xf2\xd9\x3b\x6e\
\xdd\xb7\xac\xb4\xa6\x6e\x6f\x60\xaf\x2c\xb5\x27\xd3\x54\x59\x82\
\xc9\x18\x8c\x93\x26\x11\x20\x98\x21\x05\x93\x36\x30\x06\xe3\x75\
\x03\x4a\x9b\x28\xd1\xaa\xbd\x9e\x44\xa7\x5a\xa3\x51\x6b\x2d\x8a\
\x76\xd5\x22\xec\x6d\xaa\xdd\x5a\x6b\xc7\xb2\x6d\x08\xe6\x1a\x00\
\xef\xaa\x23\x60\x8c\xb1\x01\xe4\x08\x04\xa5\x14\xb4\x21\xcd\xc2\
\xd2\xc4\x8c\x30\x35\x59\x90\x2a\x93\x77\x49\xe6\x05\x59\xc4\x44\
\x52\x08\xd4\x6b\xa5\x54\x30\x43\x30\xd3\xfa\xea\xaa\x21\x22\x10\
\x33\x11\x60\x36\x12\xfe\x86\xec\x84\x06\x25\x99\x51\xfd\x48\xa5\
\x4b\xdd\x28\x3c\xdd\x0e\x46\x67\x96\x83\xb0\x37\x4c\xb2\x38\xd1\
\xa6\x24\x75\x98\x64\x48\x8d\x31\x60\x66\x80\x28\x77\xc1\xa7\xab\
\x03\xd0\xda\x90\x36\xfa\xe2\xf9\x96\x99\x89\x98\xb1\x3a\xc8\xc2\
\x93\x4b\xc1\x30\x4c\x8d\xaa\xe4\x6d\x39\x59\x75\xdc\x66\xd9\x76\
\x2a\x79\xe9\x14\x72\xd2\x72\x2d\x23\x94\x86\x36\x20\x03\x02\x98\
\x08\x66\x1c\x00\xa3\x35\xcc\x30\x32\x49\xe2\xab\xd1\x8a\x1f\x47\
\xe7\xd7\xe2\xf0\x7c\x37\x8e\x3a\x7e\x9c\x8e\xc2\x54\x29\x65\xc0\
\x42\x40\x48\x82\x10\x0c\x66\x43\xcc\xb4\x31\xa0\x30\x5a\x5f\xf1\
\xbc\xb2\x09\x40\xc5\x2a\x53\xa1\xd6\x1a\x42\x08\x58\x92\x39\x0d\
\x33\x1c\x59\x18\xf9\x8b\x6b\x71\x24\x2d\x41\xdd\x00\xf1\x62\x2f\
\x0b\x5d\x3b\x66\xcf\x95\x5c\xc8\x09\x59\x70\xa5\x48\x82\x51\x11\
\xc3\xb4\x1e\x25\x86\xa2\x0c\x30\x06\x26\x48\x0c\x56\xfc\x64\xf4\
\xb3\x75\xff\x7c\x2a\xb4\x3f\x08\x33\x9d\x24\x4a\x67\x4a\xc1\x18\
\x82\x90\x12\x44\x0a\x5a\x13\x58\x03\x9e\xc3\xd2\x75\x48\x08\x16\
\x50\x2a\x42\x96\x65\xa1\x52\x2a\xbe\x6a\x80\x2c\x53\x41\x9a\xa6\
\xdd\x34\x4d\x60\x49\x0b\xae\x2d\x64\x10\x06\xa6\xd5\xe3\x48\x83\
\x0d\x48\xc0\x10\x91\x32\xac\xa3\x8c\x74\x12\x1a\xf2\x63\x95\x12\
\x19\x13\x0d\x63\xb3\x85\xb3\x24\xca\x8c\x9d\xa8\x71\x10\x93\xcc\
\x20\x4c\x75\xb6\x1a\xea\x84\x5c\x64\x1a\x0c\x96\x80\x64\x82\x51\
\x0a\x9a\x5e\x1d\x5c\x21\x80\x7a\x01\xb9\xa2\x67\x5b\x52\x5a\x48\
\xe2\x18\x69\x9a\x76\x33\xa5\x82\xab\x07\x48\x93\x51\x92\xc4\xe7\
\xc2\x30\x44\xb5\x56\x81\x97\xb3\xa5\xc9\x46\x76\x94\x7a\x9a\x85\
\xc0\x38\x8b\x30\x34\x31\x88\x98\x40\x6c\x98\x18\x60\x06\x58\x8c\
\x55\x43\x04\x22\x36\xe3\x14\x4f\x04\x22\x10\x0b\x23\xa4\x34\xac\
\x35\x69\xad\x41\x1b\xce\xab\x71\x7a\x37\x00\x6c\x02\x6f\x29\x9b\
\x72\xb5\x94\xb7\x59\x08\x8c\x82\x11\xe2\x24\x3e\x97\xa6\xe9\xe8\
\x4a\x00\x17\xd7\x01\xa5\x54\x1c\xc7\xf1\x4b\x83\x41\x3f\x62\x96\
\x28\x15\x0b\x5c\x73\x93\x4a\x4e\xa6\x56\x66\x58\x6b\xb0\xd1\x60\
\xa3\xc0\x46\x83\x2e\xde\x6b\x12\x5a\x83\x8d\x01\x19\x80\x0c\x31\
\x83\x88\x31\x3e\x2b\xd1\x05\x8d\x4b\xb0\x10\xaf\x6b\x44\xc2\xd4\
\x3c\xe3\x6c\x6f\x50\xa3\x56\x29\x4b\xad\x35\x7c\xdf\x8f\xe2\x38\
\x7e\x49\x65\xe9\x15\x25\x74\x11\x40\x08\xa1\x92\x34\x3d\xdc\xf3\
\xfd\x56\x96\x65\x28\x95\x4a\x98\xab\x8b\xc6\x7c\x39\xae\x6a\xc3\
\x46\x19\xd2\xda\x8c\x1d\x57\x10\x46\x83\xb5\x26\x36\x1a\xc2\x18\
\x62\x0d\x82\x21\x26\x08\x66\xb0\x60\x10\x6f\x64\xa1\x0b\x00\x52\
\x40\x88\xb1\x8d\xd7\x92\x71\x49\x82\xb1\x73\x22\xad\xee\x9c\xca\
\x35\x4a\xa5\x12\x82\x51\x80\xf5\xde\x7a\x2b\x49\x92\xc3\x24\xad\
\xab\xdf\xcc\x7d\xe2\xe3\x9f\x84\xd6\xfa\xb8\xef\xfb\x2f\xf8\x3d\
\x1f\x85\x42\x11\xd3\x13\xf9\xc2\x4d\xd3\xe1\x7c\xce\xd2\x32\x33\
\x64\x14\xc8\x28\x43\x5a\x81\xb4\x1a\x83\x68\x4d\xac\x0d\x31\xe2\
\x44\x51\x6b\xa5\x8f\xb3\x4b\x3d\x3a\xbb\xd4\xa3\x56\xa7\x8f\x24\
\x53\x24\xe4\x78\xa4\x85\x78\x6d\x14\x48\x8c\xe5\x57\x70\x8c\xf5\
\xd6\xad\xe9\xfc\xdc\x54\xb5\xe0\x38\x39\x74\x56\x3b\xe8\xf5\x7a\
\x2f\x28\xa5\x8e\x7f\xfa\x53\x7f\x75\x25\xff\x5f\xbb\x9d\x66\x12\
\x9d\x30\x0c\x0e\x2e\x2d\xb5\x7e\xaf\x56\xaf\x55\x1b\x13\x75\x7e\
\xf3\x96\xf3\xf3\x27\xfd\xc1\xe2\x4f\x57\x1a\xe7\x34\xd8\x10\x08\
\x04\xbe\xb0\xb5\x61\x02\xd8\xb0\x74\x54\xbb\xa3\x86\x5f\xfe\xce\
\x8b\xda\xb2\xa4\x01\x80\x34\xcd\xa8\x3b\xd2\x81\x35\xed\x68\x12\
\x1b\xc7\x0e\x03\x63\x0c\xd8\x18\x18\x6d\x60\x98\x71\xdb\x4c\x38\
\x7d\xcb\x76\x77\x7e\xaa\xd1\xe4\x38\x8a\x70\xee\xdc\xc2\xfa\x28\
\x18\x1d\x94\xcc\x9d\x2b\x7a\x7f\x29\x80\x32\x99\x82\xc6\xf7\x3a\
\xab\x9d\x67\x57\x3b\xab\xef\x6d\x34\x26\x68\x6e\x6a\x54\xf8\x9d\
\x91\xff\xa6\xb5\x24\x3f\x38\x33\x2a\xaf\x8f\x27\x30\x01\xe3\x09\
\x6c\x88\x19\xec\x95\x43\x9e\xbd\xf1\xe5\xbe\xd1\x8c\x0b\x27\x34\
\x63\x00\xab\xc6\x9a\x9c\x42\x64\x40\x04\x63\x60\x0c\x83\x79\x0c\
\x61\x48\x9b\x5d\xb5\xb8\x7a\xfb\xae\xf4\x4d\xbb\xe7\x66\x0b\xae\
\x9b\xc3\x89\x93\x27\x4c\x7b\xb9\xfd\xac\xca\xd4\xf7\xb4\x36\xd7\
\x7e\x22\x7b\xe4\xa1\x47\x71\xe0\xc0\x9d\xfd\x24\x49\xd2\x4c\xa9\
\x77\x36\x26\x1a\x85\x42\xb1\x40\x36\xc2\x82\x47\x23\xbb\x1d\xe4\
\xd6\x06\xca\x8d\x85\x10\xe3\x3d\xd1\x05\x39\x08\x69\x19\x99\x2f\
\xc5\x4e\xa1\x12\xdb\xf9\x4a\x6c\xe5\xcb\xb1\xf4\x4a\xb1\x70\xbc\
\x04\xc4\x17\x47\x1e\x06\xd0\x30\x50\x1a\x66\xb6\x10\x16\xef\xdd\
\xd3\xbb\xe9\xb7\xf6\xd4\xb7\x6d\x99\x9e\xe1\x6e\xb7\x8b\xc3\x47\
\x0e\xaf\xac\xae\x76\xfe\x96\xc8\xfc\xf8\x53\x7f\xfa\x97\xe6\x9a\
\x01\x00\xe0\xc0\xdd\x77\x99\x34\x4d\xce\x25\x49\x3c\x61\x8c\xd9\
\xdf\x6c\x4e\x4a\xcf\xcb\x71\x51\x84\x95\x8a\x1c\xba\xdd\xd8\xee\
\xf5\xb3\x5c\x4c\x2c\x30\xde\xa1\x0a\xb0\x60\x5c\x80\x22\x66\x41\
\x34\x5e\x8e\x09\xc6\xd0\x86\xf3\x06\xe3\x73\x33\xb4\xc1\xf6\xd2\
\xb0\xf2\xfe\xdd\xeb\x37\xff\xf6\xee\xf2\x8e\xed\x73\x5b\x65\x18\
\x86\x78\xf1\xc8\xe1\xe0\xdc\xc2\xc2\x57\x95\x56\xff\x7a\xe2\xc4\
\xc9\x68\x7e\xfb\x3c\x8e\x1d\xfd\xf9\xb5\x03\x3c\xf2\xf0\x41\xdc\
\x7d\xcf\x81\x38\x4d\xd3\x57\x82\x20\x98\x27\xe2\x9d\x93\xcd\x49\
\xe1\x79\x2e\x97\xac\xa8\xda\x74\x06\x65\x82\x49\x7a\xa9\x1b\xa4\
\xb0\x14\xf3\x6b\xa3\xc1\x9b\xbe\x1f\x35\x66\x7c\x7c\xbc\x60\xc6\
\x13\xa9\x7d\x6b\xa3\x3b\x7b\x60\x87\x7f\xf3\xdb\x76\x56\xe7\xe7\
\x66\x67\x65\x92\xa4\xf8\xd9\xa1\x9f\xe1\xb9\xe7\x9f\x7b\xe5\xd8\
\xf1\xe3\xdf\x38\x72\xe4\x48\x7b\x34\x0a\x54\x96\x65\xd9\x9b\xde\
\xbc\x0f\x37\xdf\x72\x13\x8e\xbc\xf8\xd2\xd5\x03\x00\xc0\xa3\x8f\
\x1c\xc4\x81\x03\x77\x77\xa3\x38\x3c\x3d\x18\x0e\xae\x23\x60\x7b\
\xa3\xd1\xa0\x52\xb1\xc8\x95\x9c\x2a\xcd\xe4\x06\x93\x93\xce\x30\
\x0f\x20\x8b\x8c\x95\x64\x90\x5a\xd3\x78\x31\x33\x86\x36\xbe\xd4\
\x82\x56\x1a\x64\x14\xe7\x39\xb2\x77\x17\xd7\x9b\xbf\xbf\x65\x65\
\xdf\xef\x6e\x4f\xdf\xfc\x96\xeb\x9a\x8d\xe9\xa9\x29\x8e\xa3\x18\
\x87\x5e\x38\x84\xe7\x9e\x7f\x0e\xed\x76\xdb\x0d\xa3\x68\xbf\x9b\
\xcb\xbd\xdb\x92\xf2\x36\x66\x86\xd6\xfa\x8c\xd6\x5a\x5d\x2e\x12\
\x6f\xb8\x59\xfa\xa7\x2f\xfe\x23\xa2\x28\x21\x66\xb3\xdf\xf3\xbc\
\xcf\x6c\xdb\xb6\xed\xce\xdd\xbb\x76\xbb\x5e\x3e\x8f\x20\x1c\xa2\
\xe7\xf7\xf5\xaa\x1f\x8f\x96\x86\x72\xe5\x7c\xe0\xad\xac\xc4\x9e\
\x3f\x54\x6e\x98\x1a\xa1\x00\x82\x45\xa9\x28\x8a\x38\xd7\x74\x83\
\xf2\x96\x7c\xd4\x9c\x2d\x9b\xe6\x4c\xad\x90\x6f\xd4\x27\xd8\x71\
\x5c\xac\xad\xad\xe1\xe8\xb1\x97\x83\x9f\x3e\xf7\xdc\xc2\xd9\x73\
\xe7\xb6\xdd\x70\xfd\x9e\x5c\xb1\x58\x84\x65\x49\x04\x61\xa8\x4f\
\x1e\x3f\x71\x6a\x69\xa9\xfd\x59\x63\xcc\x7d\x44\x14\x3f\x70\xdf\
\x83\xd7\x06\x00\x00\xff\xf0\x85\xbf\x07\xa5\x84\x94\xd3\x3d\xb6\
\x65\xff\x49\xa3\xd1\xf8\xe8\x8e\xeb\x76\x4e\x4f\x4f\x4f\x41\x5a\
\x12\x51\x1c\x21\x0c\x02\x04\x51\xa2\x82\x58\x25\x51\x66\x92\x4c\
\x23\x03\x00\x8b\x49\xe6\x6c\xb6\x8b\x39\xcb\x2e\xe4\x3d\x51\xc8\
\x17\xe0\x38\x2e\xa2\x30\xc2\xc2\xb9\x05\x9c\x3c\x79\x62\x69\xa5\
\xb3\xf2\xf5\x67\x9e\x7d\xfe\x19\xbf\x3f\xf8\xfc\xdb\x6e\xbb\x79\
\x77\xbd\x5e\x47\xad\x56\x43\xad\x5e\xc5\xda\xda\x1a\x9e\x79\xe6\
\xd9\xe3\xed\xa5\xf6\xe7\xb4\xd6\xf7\x1b\x63\x22\xcf\x93\xf8\xfa\
\x7f\x3e\x70\x65\x09\x6d\x5c\x8f\x1d\x7c\x02\x07\xee\xbe\x0b\x71\
\x9a\xae\xa9\x2c\xfb\x69\x7f\x30\x38\xbd\xba\xba\x5a\xf2\xfd\xde\
\x04\x0c\xdc\xbc\x57\x40\xa9\x58\x42\xb9\x54\xe2\x5a\xb9\x68\x35\
\x2a\x79\x77\xaa\x56\xf0\xa6\x6b\x45\x6f\xaa\x5e\x76\x1b\xf5\xaa\
\x55\x2e\x95\xd9\x71\x5c\x44\x51\x84\x85\xb3\x67\xf1\xd2\xcb\x47\
\xfc\x13\x27\x8f\xff\x68\xa5\xb3\xf2\x77\x69\x9a\xfe\xdb\xa3\x8f\
\xff\x60\x31\xe7\xba\xb7\x57\xab\xe5\xeb\x98\x19\xfd\xfe\x00\xa3\
\xe1\x08\x93\x93\x4d\x34\x1a\x13\x13\x7e\xcf\xdf\x37\x1c\x0e\x3b\
\x59\x96\x1d\x37\x86\xff\x8f\x9c\x2e\x0b\x00\x00\x8f\x1e\x7c\x0c\
\x4f\x3e\xfe\x24\xd6\xba\x2b\xe1\x0b\x87\x5e\x38\xca\x82\x9f\xf2\
\x7d\xff\xf4\xf2\xf2\xb2\x5a\x59\x5e\x76\x7b\x3d\xdf\x0e\xc3\xc8\
\xce\xd2\x14\x4a\x69\x28\xa5\x91\xa5\x0a\x61\x18\xa1\xe7\xfb\x58\
\x6a\x2f\xe1\xd4\xa9\x93\xc1\xd1\x63\x47\xcf\x9f\x38\x79\xe2\xa9\
\x56\xab\xf5\xe5\xf6\x52\xfb\x9f\xbf\xf1\xf5\xff\x7e\xfa\xfe\xfb\
\xbe\x1d\x3a\x39\x0f\x5e\xde\xbb\xb5\x50\x28\xdc\x92\xcf\xb9\xb4\
\xb2\xb2\x8c\xc1\x60\x88\x34\x55\x98\x99\x99\x41\xb3\xd9\x98\xf0\
\x7d\xff\x2d\x41\x10\x74\x8c\x31\x27\xf6\xee\xbb\xe1\x35\x10\x57\
\xfb\x0b\xcd\x6b\xda\xdd\x71\xc7\x7b\xc4\xad\xb7\xdd\xd2\xb0\x6c\
\x6b\x9f\x65\x59\x37\xda\xb6\x7d\xbd\xe3\x38\xb3\x96\x65\x57\xa4\
\x10\x2e\x00\x64\x2a\x8b\x93\x38\xf1\xa3\x38\x3a\x1f\x04\xc1\x89\
\xd1\x68\x74\x64\x71\xf1\xfc\xb1\x27\x9f\xf8\xfe\xda\x6a\x67\x55\
\x6d\xf4\x69\x3b\x8e\xd9\x79\xfd\x0d\xef\x6b\x36\x9b\x9f\xbf\x7e\
\xcf\x8e\x5d\x9e\x6b\xa3\xdf\xef\x23\x9f\x2f\x62\xeb\xd6\x59\xec\
\xdc\xb5\x03\x83\xc1\x00\x4f\xff\xe4\xe9\xe3\xed\xf6\xf2\xe7\xb5\
\xd6\xf7\x19\x63\xa2\x62\xb1\x88\xff\xf8\xda\x7f\x5d\x15\x00\x6d\
\x2a\x37\x9b\x01\x80\xf9\xed\xf3\xf6\x6d\x6f\xbd\x25\x9f\xf7\xbc\
\x92\x90\x32\x2f\x04\x3b\x5a\x1b\x8a\xe3\x38\x0d\x46\xa3\x70\x79\
\xa5\x33\x3a\xf2\xe2\x4b\xa1\xdf\xf3\x15\xc6\x7b\x2f\xbe\x74\x40\
\x0a\xa5\x92\x3b\xbb\x6d\xfb\xbd\x53\x53\xcd\x4f\xee\xbd\x7e\xd7\
\x76\xd7\xb1\xe1\xfb\x3e\x0a\x85\x02\xb6\x6e\xdd\x8a\xdd\x7b\x76\
\xc1\xf7\x7d\x3c\xfd\x93\xa7\x8f\xb7\x5a\x4b\x9f\xcb\xb2\xec\x5b\
\x96\x65\x25\x0f\xdc\xf7\xe0\x15\x01\xde\xc8\x79\xbe\xa4\xc4\x65\
\xde\x6f\xb6\x37\x6a\x03\x27\x97\xcb\x6d\xdd\x36\xff\xbe\xd9\xd9\
\x2d\x9f\xd8\x7b\xc3\xee\x6d\x39\xd7\x46\xaf\xe7\x23\x9f\x1f\x43\
\xec\xb9\xfe\x22\xc4\xa9\x56\xab\xfd\x37\x44\xb8\x1f\x40\x74\xa5\
\x39\xb0\xd9\x39\xbe\x4c\xc9\x17\xe6\x93\xc0\x78\x7f\xb5\xb9\x14\
\x9b\xde\x6f\x6e\xb7\xd1\xc6\x02\x60\xab\x2c\x13\xc3\xc1\xa0\x05\
\x16\xfd\x24\xcd\xae\xab\x56\xaa\x95\x62\x21\x8f\xc1\xa0\x8f\x30\
\x8c\x90\x65\x19\x66\x66\x66\xd0\x68\x36\x6a\xeb\xbd\xde\xbe\x60\
\x34\x3a\x0b\xe0\xd4\xb5\x00\xbc\x9e\xf3\x84\x2b\xc3\x6d\x86\x7c\
\xa3\x08\x49\x00\x96\x52\x8a\x46\x83\xfe\x39\xc3\xa2\x97\x24\xe9\
\x8e\x5a\xad\x56\x2e\x16\xf3\xe8\xf7\x5f\x85\x98\xdb\x36\x07\xcb\
\x96\x13\x4b\xad\xd6\x30\x0c\xa3\x1f\x5e\x2b\x00\x2e\xb9\x7f\xbd\
\xf7\xf4\x06\x9f\xdf\x28\xcd\x05\x7b\xbd\xbe\x58\x29\xa5\x86\x83\
\xfe\x19\xb0\xe8\x24\x69\xba\xab\x5a\xab\x54\x8a\x85\x02\xfa\xfd\
\x3e\x00\xa0\x56\xab\x62\x7d\xbd\x97\x9d\x5b\x38\xf7\x43\xdf\xf7\
\xaf\x09\xe0\xf5\x9e\x6f\xae\x9b\x4b\x4a\x00\xe3\x5f\x2c\x37\x39\
\xad\x37\x95\x1b\xa6\x36\x3d\x37\x00\xa0\x95\xca\x46\xc3\xe1\x2b\
\x24\xc4\x7a\x92\x64\x3b\xab\xd5\x4a\xa5\x56\xab\xa2\x5c\x29\xc3\
\xef\xf7\xf1\xe2\xe1\x23\x47\xda\xcb\xcb\xff\xf2\xd4\xf7\x9f\x7a\
\xe5\x8a\xeb\xc0\x25\xce\x9a\x4b\x1c\xda\x6c\x97\x3a\xba\xe1\xd8\
\x46\x5d\x01\xc8\x2e\xb1\x74\x53\x5d\x6d\x32\xa3\x54\xa6\x86\x83\
\xe1\x59\x30\x0f\xe2\x24\xdd\xe9\x3a\x4e\xa9\x3f\x18\xe8\x63\xc7\
\x8e\x9f\x3e\x73\xe6\xcc\x97\x0f\x1f\x3a\xfc\xe3\x38\x4e\x7e\xb9\
\x75\x00\x6f\x2c\x9d\xcb\xc9\xe8\x72\x7d\x6f\x4c\x6e\x6b\x93\x49\
\x00\x96\xed\xba\xf9\xd9\xb9\x6d\xef\x2a\x95\xcb\xef\x22\x98\xf5\
\x7e\xaf\xf7\x3f\xe7\xce\x9e\x3d\x94\x24\xc9\x00\x40\x74\xad\xff\
\xec\xb1\xa1\xe1\xab\x91\xd4\xb5\xf6\xbb\x39\x9b\x49\xbc\x9a\xa1\
\x2c\x21\x84\xe3\xe6\x72\x85\x2c\x4d\x75\x1c\xc7\x1b\x51\x8b\x7f\
\x19\x80\xcb\x39\xf0\xeb\xe8\x63\x73\x96\xda\x48\xbb\x1b\x30\x1b\
\xf7\x1b\x83\x98\x02\x48\xff\x17\x2a\x28\x31\xec\xe8\x9a\x9b\xdf\
\x00\x00\x00\x25\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\
\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\
\x32\x3a\x35\x31\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\x82\x80\x0a\
\xca\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\
\x65\x61\x74\x65\x00\x32\x30\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\
\x32\x33\x3a\x32\x36\x3a\x31\x38\x2d\x30\x37\x3a\x30\x30\x67\xec\
\x3d\x41\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\
\x6f\x64\x69\x66\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\
\x54\x30\x39\x3a\x31\x31\x3a\x33\x39\x2d\x30\x37\x3a\x30\x30\x0c\
\x48\x1a\x7b\x00\x00\x00\x34\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\<｜fim▁hole｜>\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\
\x63\x65\x6e\x73\x65\x73\x2f\x47\x50\x4c\x2f\x32\x2e\x30\x2f\x6c\
\x6a\x06\xa8\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\
\x79\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\
\x38\x54\x31\x32\x3a\x35\x31\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\
\xdd\x31\x7c\xfe\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\
\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\
\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\x17\x74\x45\x58\
\x74\x53\x6f\x75\x72\x63\x65\x00\x47\x4e\x4f\x4d\x45\x20\x49\x63\
\x6f\x6e\x20\x54\x68\x65\x6d\x65\xc1\xf9\x26\x69\x00\x00\x00\x20\
\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\
\x74\x74\x70\x3a\x2f\x2f\x61\x72\x74\x2e\x67\x6e\x6f\x6d\x65\x2e\
\x6f\x72\x67\x2f\x32\xe4\x91\x79\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
\x00\x00\x09\xe8\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x09\x7a\x49\x44\x41\x54\x78\xda\x6c\
\x88\xc1\x0d\x80\x40\x10\x02\xe1\xb4\x5b\x3b\xf1\x63\x35\x36\xe4\
\xcb\x22\x14\x0e\xbd\xfd\x98\x38\xc9\x84\x09\xb4\x8d\x07\x2e\xc4\
\x3f\xf9\x95\x71\x8b\x1c\xaa\xfa\xcb\x06\xf1\xc4\xdd\x56\x68\x72\
\x44\x7a\xa8\x19\xb8\xaa\x0b\xef\xc7\xbb\x5d\x00\x31\x31\x50\x02\
\xfe\x31\x22\x61\x26\x7d\x86\x3f\xff\x3a\x18\xbe\x7f\x5d\x0b\x34\
\x5e\x89\x58\x23\x00\x02\x88\x32\x07\x30\x40\x43\x06\x14\x42\x3f\
\x7e\xfc\x8a\xb3\x8d\x65\x88\x73\x48\x0a\x64\xf8\xf2\xf9\x08\xc3\
\xdf\x3f\xb1\xc4\x68\x07\x08\x20\xca\x1d\x00\x8a\xa2\xff\xc0\x20\
\xfe\xfd\xef\xaf\xb2\x88\x22\xc3\x82\xac\x39\x0c\x7d\xa9\x53\x25\
\x39\x18\x59\x16\x30\xfc\xf8\xda\xcf\xc0\xc8\xc8\x86\x4f\x37\x40\
\x00\xb1\x10\x69\x8b\x08\xc3\xff\x7f\x9a\x0c\x7f\xfe\xab\x32\xfc\
\x65\xe0\x06\xfa\xf8\x1f\xc3\x7f\x68\x14\x80\x43\x80\xe9\x37\xc3\
\x0f\x06\xc5\xaf\xdf\xbf\x02\xed\x63\x64\x28\xf4\xce\x62\x30\x51\
\x36\x61\x4a\x99\x98\x51\x70\xeb\xc1\x75\x6d\x06\x4e\x21\x50\x68\
\xbc\xc4\x66\x30\x40\x00\xe1\x77\xc0\x3f\x06\x45\x86\x5f\xff\xf3\
\x81\xb4\x2b\x17\x37\x8f\xba\xb4\x90\x34\x33\x0f\x1b\x2f\xd0\x2d\
\x0c\xd0\x04\xc9\x00\x4d\x90\xc0\x18\xf8\xf6\x8b\x41\x4e\x48\x81\
\xe1\x37\xc3\x37\x86\x43\x7f\x57\x32\xd8\x6a\x84\x32\x1c\x6c\xdd\
\xc5\x10\xdc\x1e\xe5\x7a\xec\xe2\xd1\x8d\x0c\x9c\x82\x01\x40\xd5\
\x2f\xd0\xad\x00\x08\x20\x46\xac\xb9\x80\x91\x81\x0d\x68\x52\x19\
\xc3\x5f\xc6\x4a\x17\x2d\x17\xae\x54\xdb\x54\x06\x67\x55\x57\x06\
\x61\x1e\x01\xa0\xbd\xff\x19\xfe\x33\xfc\xc7\x4c\x0a\x40\xc8\xcc\
\xc8\xcc\xf0\xf9\xff\x7b\x86\x29\x5f\x72\x19\x38\x18\x78\x18\x92\
\xf9\x9b\x18\x18\xbe\xf0\x30\x04\x34\x45\x32\xec\x3f\x7b\xe0\x04\
\x03\xa7\x80\x17\xc3\x7f\xa0\x02\xa4\x5c\x00\x10\x40\xd8\x1c\xc0\
\x09\x0c\xce\x59\xd2\x42\x32\x31\x93\x23\x27\x33\x04\x1a\x04\x30\
\x7c\x62\x78\xc3\x70\xf6\xcb\x01\x86\xdb\xbf\x2e\x33\x7c\xff\xff\
\x0d\xa8\xfb\x3f\xce\xf4\xf0\xf7\xff\x1f\x86\x17\x7f\x1f\x00\xd5\
\x7d\x61\xe0\x61\x12\x60\x48\x14\xa8\x62\x10\xfe\xa5\xc0\xe0\x52\
\x11\xcc\x70\xe1\xce\xb5\x26\x06\x56\xf6\x7a\xb0\x03\xb6\x3d\x04\
\xeb\x00\x08\x20\xf4\x28\x60\x06\xfa\x7c\xbe\x82\x98\x42\xf8\xf6\
\xbc\x1d\x0c\x4a\x12\xf2\x0c\xf3\x9f\xf7\x30\xec\xff\xb2\x91\xe1\
\xe3\xdf\xb7\x0c\x9c\x4c\xdc\x0c\xac\x8c\xec\xf8\x13\x24\x10\xb0\
\x31\xb2\x82\x13\xc9\xd3\xbf\xb7\x18\x2e\x33\x9d\x61\x08\x16\x37\
\x64\xd0\x94\xd7\x62\xb8\x70\xed\x92\x0a\x03\x33\x07\x8a\x0e\x80\
\x00\x62\x41\xd1\xfc\xe7\x7f\xa4\x08\xa7\x48\xf8\xda\x94\x75\x0c\
\xe2\x02\x42\x0c\x25\xd7\x12\x18\xce\x7f\x3b\xce\x20\xcd\xa6\xc0\
\x10\x2c\x94\xc9\x60\xc1\x67\xcf\xc0\xc5\xcc\x0b\x8d\x82\xff\xe8\
\xf6\x32\xfc\xfb\xf3\x8f\xe1\xed\xcf\x37\x0c\x5d\xcf\x2b\x18\xde\
\xfc\x79\xc1\x90\x28\x56\xc0\x10\x2c\x96\xca\xd0\xbb\x72\x06\xc3\
\xca\x5d\xab\xbf\x30\x70\xf2\x4e\x47\x77\x32\x40\x00\x21\x87\x80\
\x30\xd0\xf7\x75\x15\xfe\x95\x0c\x46\xb2\x86\x0c\xd9\x57\xa3\x19\
\xf6\x7d\xd8\xc1\xe0\xc4\xef\xc3\x50\xaf\xd8\xc3\xc0\xf9\x87\x97\
\xe1\xd0\x8d\x63\x0c\x4f\xdf\x5f\x60\x60\x62\x60\x44\x2d\x09\x81\
\xec\xdf\x7f\xfe\x30\x98\xc8\x1b\x32\x28\xca\xab\x30\xfc\xfc\xf6\
\x9f\x21\x43\xb2\x96\x21\x44\x32\x86\xa1\x73\xf9\x34\x86\x8a\xd9\
\x8d\x3f\x18\x98\xd9\x93\x80\x2e\x3d\x82\xee\x00\x80\x00\x42\x38\
\xe0\xcf\x7f\x4f\x11\x01\x51\x95\x38\xc3\x38\x86\xb5\x0f\x97\x33\
\x6c\x7e\xb6\x91\x41\x87\xdb\x80\xa1\x49\x61\x02\xc3\xcd\x47\x77\
\x19\x72\x96\xe6\x31\x9c\xbf\x73\x0e\x58\xd4\xfe\xb9\x03\x2e\x66\
\xff\x33\x31\xc2\x8b\xe7\x7f\x8c\xff\x18\x3e\x7f\xd7\xc9\x0a\x2f\
\x13\x6c\x56\x28\x65\x68\x56\x9c\xc8\xa0\xc8\xa6\xce\x90\x3f\xa3\
\x96\x61\xd2\xda\x99\x5f\x18\x58\xb9\xd2\x19\x98\x98\x57\xc3\x43\
\x0d\xa9\x48\x06\x08\x20\x84\x03\x7e\x32\x38\x3b\x68\x3b\x30\x72\
\xb0\x71\x30\xf4\xdd\xee\x66\x78\xfa\xf1\x2b\xc3\x34\xd5\x52\x86\
\x37\x6f\x3e\x30\x04\x4d\x0a\x62\x78\xf9\xe6\xd9\x42\x06\x0e\xde\
\x62\x06\xe6\xff\x6f\xc1\x25\x1f\x03\xac\x6c\x67\x84\xd0\xec\x4c\
\xdb\x99\x18\x99\x3d\x84\x38\x44\x18\x9e\x3d\x7b\xc3\xe0\x3f\x27\
\x8e\x61\xef\xa9\xbd\xf7\x19\x38\xf9\xd3\x80\x96\xef\x01\x5b\xfe\
\x1f\xaa\xf6\x1f\xc2\x01\x00\x01\xc4\x82\x94\x8f\x74\x2d\x15\xad\
\x80\xd4\x3f\x86\x68\xc9\x44\x86\x58\xc9\x64\x06\x47\x11\x27\x86\
\x96\xcd\x1d\x0c\x2f\x5f\x3f\x3b\xce\xc0\xcd\x97\x02\xb4\xec\x0f\
\xd0\x04\x06\x06\x16\xa0\x41\xbf\x18\x21\x71\x0f\x32\xec\x1f\x2b\
\x48\x8a\x91\x8d\x89\x8d\x61\xd9\x81\xb5\x0c\x85\xb3\xeb\x19\x5e\
\xbd\x7a\xb1\x99\x81\x47\x30\x1b\x68\xe0\x63\x70\x59\xfd\x1f\x5a\
\x67\xa0\x01\x80\x00\x42\x38\x80\x91\x51\xe6\xd5\xe7\xd7\x0c\xc7\
\x6e\x1f\x67\x50\xfa\xa7\x01\xd6\x70\xe4\xd6\x09\x86\x83\xb7\x8e\
\x02\xf3\x06\xeb\x0e\x86\xff\xcc\x7f\x18\x80\x21\xcd\xc0\xfa\x1f\
\x62\x10\x07\x90\xfd\x1b\x68\xf9\x17\x4e\x88\x7e\x36\x1e\x86\xa5\
\x07\x37\x32\x4c\x58\x3f\xe7\xdd\x3f\x50\xa5\xc4\xcd\xd7\xcd\x00\
\xd4\x02\x29\xac\x98\x19\x18\x70\xe4\x5c\x80\x00\x42\x94\x03\x29\
\xec\xe7\x58\xfe\x31\x29\x00\xed\xf8\xf3\x1f\x5a\xba\x31\xfe\x67\
\x66\xf8\xf3\x97\x89\xe3\x3f\x03\x53\x19\x90\x33\x83\x81\xf5\x37\
\x24\xec\xff\x31\x49\x02\xe9\x67\xc0\x10\xf8\xcf\xf0\x4e\x00\x66\
\xd6\x1e\x86\x5f\xff\xf8\x18\x98\x58\x32\x80\xd1\x74\x0e\xe8\x58\
\x26\x70\x99\x82\x5a\x63\x42\xd3\x0e\xf3\x9f\xff\xfb\x6e\xfe\x00\
\x69\x02\x08\x20\xa4\x28\x60\xb4\xfe\xf3\x0f\x58\xab\x80\x32\xf0\
\x3f\x68\x7c\x81\x68\x60\xd0\x00\xf1\x77\x06\xe6\xbf\xa0\x20\x17\
\x67\xf8\xfb\xaf\x1f\x18\x24\xb2\x40\x09\x5b\x48\x6e\x84\x07\x6b\
\x16\x03\x33\xcb\x33\x20\xfd\x05\xe8\x58\x90\x5a\x4f\xa0\xda\x85\
\x0c\xdf\x7f\xfe\x01\x5a\xf8\x0f\x58\xaa\x42\x1c\xc0\xc8\xc2\xc2\
\xc0\xc6\x09\x8c\x16\x06\x63\x90\x26\x80\x00\x42\xce\x86\xdf\x19\
\x18\x81\x0a\x98\x18\x21\x09\xec\x3f\x94\x06\x05\x23\x38\xb2\x7f\
\x79\x02\x0d\xeb\xe5\xe1\x11\xd3\xfc\xfa\xe3\xe7\x21\x78\x88\x32\
\xff\x86\x34\x38\xfe\x33\xdd\x82\x86\x29\x44\xfd\xaf\xdf\x22\xf2\
\x62\xb2\xc2\x13\xb2\x5a\x19\x38\x18\xb9\x80\x85\x27\x23\x03\x13\
\xeb\x3f\x60\x69\x78\x9d\xa1\x7a\x7a\x2f\x3c\x15\x02\x04\x10\x0b\
\x8e\x88\x81\x60\x16\xb0\xe5\x5c\x0c\x3f\xbe\xd7\xb1\x31\x73\x94\
\xb5\xc4\xf6\x33\x32\x33\xb1\x32\x14\xcf\x2e\x00\xa6\x05\x60\xdc\
\xff\x01\x96\x8a\xa0\x74\xc1\xf4\x07\x12\xc4\x8c\xb0\x56\x13\x30\
\xce\xbf\x7e\xb3\xb5\xd5\x34\x63\x08\xb0\x74\x65\x78\xcb\xf0\x00\
\x58\xba\x7f\x63\x90\x66\xd0\x62\xe0\x62\xe5\x66\xf8\xfb\xe3\xcf\
\x7b\x98\x55\x00\x01\x84\xbd\x3d\xc0\xf4\x0f\x82\x19\x18\x64\x19\
\xbe\x7c\x5b\xaf\x2a\xa6\x5e\xbe\xad\x62\x07\x63\xa9\x4f\x01\x03\
\x17\x1b\x17\xa8\xcc\xf8\xcf\xf0\x97\x15\x52\x15\x63\xa9\x96\x18\
\xbe\x7d\xc9\xe6\xe2\xe4\x8b\xce\xf6\x4b\x05\xd6\x23\xaf\x19\x9a\
\x9f\x67\x30\x4c\x7a\x59\xc3\xf0\x8b\xe1\x33\xc3\xf1\x0b\xe7\x80\
\x59\xfe\xf7\x43\x98\x6a\x80\x00\x42\x84\x00\x46\x3b\xef\xbf\x29\
\xc3\xe7\x1f\x4b\x3c\xcd\x7c\xd5\xe6\xa7\xcd\x63\x10\x16\xe0\x65\
\xf8\x03\x34\xe2\xd7\xcf\x5f\x0c\x0c\x9f\xff\x6a\x31\x70\x7c\x5d\
\x09\x74\x00\x13\xa2\x4d\x00\x8e\x63\x60\x5c\x33\x29\x4b\x09\x4b\
\x19\xf7\xe4\xb5\x33\x58\xe8\xe8\x33\xcc\x7c\xd5\xc4\xf0\xf4\xcb\
\x33\x86\x70\x91\x2c\x06\xb6\xff\xbc\x0c\xab\xf6\x6f\x03\x46\x1b\
\xdb\x51\x98\x2d\x00\x01\x84\x9c\x08\x91\xec\xfe\xaf\xcb\xf0\xed\
\xc7\xc6\x70\x87\x18\xc9\x85\x40\xcb\x9f\xfe\xbb\xc3\x30\xe9\x7e\
\x29\x43\xa1\x7c\x1b\x83\x9d\x9a\x2d\x43\x79\x6c\x8d\x28\x33\x2b\
\x67\x18\xbc\x4d\x00\x6d\xac\x82\xea\x02\x25\x29\x65\x06\x0f\x53\
\x07\x06\x59\x71\x31\x86\xc5\x2f\x27\x31\x6c\x79\xb3\x82\x41\x9e\
\x4d\x8d\xc1\x47\x30\x96\x61\xcb\xe1\x83\x0c\xe7\x2e\x5d\xfe\xc4\
\xc0\xce\xb9\x1e\x66\x15\x40\x00\xb1\x60\xa9\xd0\x64\x18\xbe\xfe\
\x58\x9b\xe4\x92\x2e\x39\x37\x6d\x06\xc3\xe9\x0f\x87\x18\xda\x1e\
\x94\x80\x0b\xa8\x27\x9f\x1e\x31\x48\xcb\xc9\x33\x94\x26\xe4\x01\
\x93\xc8\x7f\xec\xd5\x31\xb0\x42\xb9\xfb\xe5\x32\x43\xcf\xf5\x39\
\x0c\xe7\xbf\x9e\x60\x90\x62\x95\x61\x28\x50\x6c\x65\xf8\xfd\x99\
\x89\xa1\x62\x5a\x2f\xa8\x31\x33\x17\x18\xbf\x17\x60\x3a\x00\x02\
\x08\x51\x0e\x24\xf0\x40\x44\x7e\x7d\x9f\x6c\xac\x68\x9e\x73\xa4\
\x6e\x3f\xc3\xf1\xf7\xfb\x19\x1a\xef\xe5\x33\xb0\x30\xb1\x00\x0b\
\x3f\x36\x60\x9e\x00\x55\x43\x8c\x58\x1b\x24\x10\xeb\x19\x81\x0d\
\xa8\x9f\x0c\xef\xff\xbc\x65\x00\xea\x60\x30\xe5\xb3\x61\x28\x53\
\x69\x66\x10\xfe\x2f\xc3\x10\x51\x53\xc0\xb0\x79\xef\xee\x53\x0c\
\xdc\x3c\x2e\x40\xa5\x9f\xff\x1f\x87\xb8\x01\x20\x80\x58\x50\x9a\
\xd8\xe0\xe0\x67\x79\xff\xe5\xdb\x67\x86\x4f\x1f\x3e\x31\xf0\x31\
\xf2\x03\x4b\x58\x36\x86\xf7\x7f\x3f\x31\x70\x03\xdb\x02\x42\xac\
\x22\x40\x87\xb0\xe0\x75\x80\x20\x13\x27\x83\x19\x9f\x23\x83\xaf\
\x58\x08\x83\x85\xb0\x2d\xc3\xc5\xdb\x77\x18\x42\x3a\x63\x19\x4e\
\x9d\x39\x73\x81\x81\x97\x2f\x02\xa8\xf5\x33\xb2\x1e\x80\x00\x42\
\x84\x40\x2c\x1f\x4c\x88\x97\xe1\xcb\x97\x2d\x0e\xba\x6e\x76\x6b\
\xb3\x97\x33\x3c\xfe\x77\x8f\x21\x1b\xd8\x2e\x78\xf7\xfb\x0d\xc3\
\x02\x8d\x75\x0c\xca\x5c\xc0\x76\x29\xd3\x5f\xcc\x94\x0f\x75\x00\
\x33\x10\x32\xfe\x61\x66\xb8\xfd\xf4\x11\xc3\xec\x9d\xab\x19\xd6\
\xec\xd8\xca\xf0\xe1\x13\x30\xc1\x72\x70\x01\xf3\xee\x7f\x78\x9b\
\xf0\xff\x09\x48\x08\x00\x04\x10\xa6\x03\xc0\x65\x37\x8b\x04\xc3\
\xe7\x2f\x5b\x4d\x54\x2d\x8d\x96\x67\x2e\x60\x60\xe4\xf9\xc3\xd0\
\x70\xb3\x8a\xa1\x54\xa9\x8a\xe1\xc6\xd5\xc7\x0c\x53\xb7\xcd\x66\
\x60\x63\xe5\x82\x26\x3e\x44\x8f\x09\x54\xfa\x7e\xff\xf5\x8b\xe1\
\xd1\xeb\x57\x0c\x8f\x5f\xbc\x78\xff\xff\xdb\x8f\x33\x0c\x6c\x1c\
\xfd\xc0\x54\xbf\x1d\x23\xb3\x42\x1d\x00\x10\x40\x38\x1c\x00\xea\
\x56\xb1\xca\x01\x1d\xb1\x40\x5d\x46\xdb\x71\x4a\x42\x2f\x83\xa1\
\x92\x26\xc3\xcf\xbf\xbf\x18\x66\x6c\x5f\xca\xd0\x3c\xb7\xfe\x31\
\x03\x1b\xdf\x22\x48\x36\x64\x42\xca\x86\xc0\x92\xe8\x3f\xf3\x0f\
\x06\x26\xb6\x87\xc0\x62\xef\x34\x30\xb1\x5d\x41\x2b\xae\x31\x1c\
\x00\x10\x40\x78\x9a\xe5\xff\x1f\x31\x70\xf1\x79\xdd\x7c\x7c\xa7\
\xcf\xb7\x23\x32\xb3\x26\xb8\x94\x21\xd7\x33\x9e\x81\x8b\x1d\xe8\
\x73\x36\xde\xbb\x0c\x1c\xdc\x35\xe0\x12\x0f\xa5\x1c\x40\x62\x83\
\x2d\xfe\x8f\x68\xaf\xe1\x00\x00\x01\x44\xa0\x63\xf2\xff\x07\xd0\
\xa2\xac\x1f\xbf\xfe\x5d\xa8\x59\xd8\xdc\x7a\xed\xf1\x6d\x11\x41\
\x1e\x61\xa0\x99\xac\x4c\xc0\xe6\x2f\xa4\x18\x06\xd5\x17\x28\x89\
\x92\xb0\xa5\xc8\x00\x20\x80\x08\xf7\x8c\x40\xbe\x60\x66\x99\xc5\
\xc0\xc1\x72\x78\xd9\xee\xb5\x13\x19\x59\xb9\x5c\x81\x4d\x2c\x56\
\xf4\x76\x29\xb9\x00\x20\x80\x88\xec\x9a\x81\x6c\x62\xba\xce\xc0\
\xc9\xe5\xfd\xff\x37\x73\x25\x30\xde\x15\xa1\xde\xa4\xd8\x09\x00\
\x01\x06\x00\x00\x1a\x79\xe3\x89\x7d\x54\xa5\x00\x00\x00\x00\x49\
\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x09\x85\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x09\x17\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x62\x41\xe6\xac\x66\x64\x44\x91\xfc\xcb\xc0\
\x10\x05\x8c\xa0\x0c\x26\x56\x56\xf9\x5f\xbf\x7f\x1f\x07\xba\xb6\
\xf3\x1f\x03\xc3\x79\xa0\x38\xc3\x1f\x88\x3c\x03\x72\x04\xfe\x87\
\x60\x95\xdf\x0c\x0c\x15\xcc\x2c\x2c\xce\xbf\xff\xfc\x79\x0f\xe4\
\x2f\x00\xea\x9b\x0e\x54\xff\x1b\xa4\x07\xa8\x9f\xa1\x0a\x29\xda\
\x01\x02\x08\x67\x08\x00\x0d\xa9\xe5\x53\x53\x5b\x6c\xbd\x64\x89\
\xad\xd3\xde\xbd\x72\x86\x4d\x4d\xe1\xff\x59\x59\xb7\x03\x2d\x75\
\x66\xc4\xa1\x07\x28\x67\x04\xb4\x64\x87\x51\x7e\x7e\x72\xe0\xde\
\xbd\x0a\xbe\xeb\xd6\x19\x8a\x9b\x99\x4d\xfc\xce\xc0\x30\x11\xdd\
\xb3\x30\x00\x10\x40\x0c\xa0\x44\x08\xc3\xab\x80\x02\x20\xbc\x94\
\x81\xa1\x65\xbb\x9e\xde\xff\x8f\xd7\xae\xfd\x47\x06\xf7\x96\x2e\
\xfd\xbf\x80\x8b\xeb\xf5\x1c\x06\x06\xb7\xd9\x40\x75\x33\x80\x78\
\x3a\x14\x4f\x65\x60\x30\x9c\xc8\xcc\x7c\xf7\x5c\x5f\x1f\x58\xed\
\x2f\x20\xfe\x0b\xc4\x9f\x9f\x3d\xfb\xbf\xdc\xc9\xe9\x7f\x33\x03\
\xc3\xdc\x0e\x06\x06\xd6\x56\x50\x28\x21\xd9\x09\x10\x40\x18\x0e\
\x58\xc2\xc0\x50\xb7\x5d\x5f\xff\xff\x97\x7b\xf7\x20\xb6\xee\x5d\
\xf3\xff\x4f\x96\xef\xff\xbf\x4f\x21\xfc\x7b\xcb\x97\xff\x9f\xcb\
\xc5\xf5\x0a\x68\xb9\xd3\x4c\xa0\xfa\x69\x40\x3c\x05\x64\x39\x23\
\xe3\xfd\x0b\x50\xcb\x3f\xbd\x7d\xf5\xff\x5e\x42\xc0\xff\x27\x33\
\xfb\xfe\xff\x04\xf2\xbf\xbc\x7c\xf9\x7f\x89\x83\xc3\xff\x7a\xa0\
\x9b\xdb\x18\x18\xd8\x90\xed\x04\x08\x20\x14\x07\xac\x00\xc6\xf9\
\x16\x75\xf5\xff\x9f\x6f\xdc\x00\x1b\xf4\xef\xe0\xa6\xff\x7f\x4c\
\xf9\xff\xff\x94\x60\xf8\xff\x3d\xd4\xfc\xff\xaf\x97\x4f\xc0\xe2\
\x77\x96\x2c\xf9\x3f\x93\x9d\xfd\x15\xd0\x72\x2b\x20\xd6\x98\xc0\
\xc8\x78\x0b\xe6\xf3\xcf\x1f\x3f\xfc\xbf\x1b\xe1\xf9\xff\x02\x2b\
\xc3\xff\xf3\xa2\x8c\xff\x1f\xce\x9b\xfa\xff\x07\x50\xfc\xe3\xf3\
\xe7\xff\xe7\x5a\x5a\xfe\x6f\x64\x60\x28\x43\xb6\x13\x20\x80\x50\
\x1c\xb0\x8c\x81\xe1\xe8\xc3\xe5\x2b\x20\x96\xef\x59\xfd\xff\x8f\
\x99\xd0\xff\x9f\x1a\x0c\xff\xbf\x19\x30\xfc\xff\x24\xc7\xf0\xff\
\x63\xa0\xf1\xff\x1f\x4f\xee\x83\xe5\x6f\x01\x1d\x31\x85\x8d\xed\
\x69\x1f\x03\xc3\xbd\x73\xdd\xdd\x10\xcb\x81\x3e\xbf\x13\xe1\xfe\
\xff\x22\x0f\xc3\xff\x0b\x32\x0c\xff\xcf\x88\x32\xfc\x3f\x21\xcc\
\xf6\xff\xce\xd4\x5e\xb0\x23\xee\xec\xd9\xf3\xbf\x89\x9d\xfd\x0a\
\xb2\x9d\x00\x01\x84\x92\x30\x18\x81\xa9\x9d\x5b\x59\x19\xcc\xfe\
\xb7\x6e\x21\xc3\xdf\x47\xef\x18\xfe\x4a\x00\x13\x17\x30\x75\xfd\
\xe3\x03\xa6\xfc\x93\x67\x19\x7e\x67\x86\x30\xfc\x9d\xb6\x86\x41\
\x35\x3a\x9a\xe1\xcf\x8f\x1f\x52\x3f\x3e\x7e\x64\x30\x2c\x2a\x62\
\xf8\xf2\xfe\x2d\xc3\xcb\xcc\x18\x86\xaf\xdb\x76\x31\xfc\x17\x00\
\xea\x01\x26\xf7\x7f\x6c\x0c\x0c\xbf\x9e\xfd\x62\x78\xbf\x78\x31\
\x83\x48\x62\x06\x03\xaf\x9c\x1c\x03\x0b\x37\xb7\x08\xb2\x9d\x00\
\x01\x84\x12\x02\x8b\x18\x18\xd6\x5c\x6e\x69\x01\xfb\xe6\xcf\xc3\
\xdb\xff\xbf\x85\x9a\xfc\xff\x24\xcf\xf0\xff\x83\x0e\xc3\xff\xb7\
\xda\x0c\xff\x5f\x69\x32\xfc\x7f\x26\xc9\xf0\xff\xb9\xa7\xc1\xff\
\x2f\x8f\xef\x81\x13\x19\x38\xa1\xbd\x7b\xfd\xff\x4e\x88\xd3\xff\
\x0b\xbc\x40\x9f\x4b\x33\xfc\x3f\x2b\xc5\xf0\xff\x14\x10\x1f\xe1\
\x02\x86\x80\xae\xd2\xff\x27\xc7\x0e\xfd\xff\x03\x54\x77\x66\xf6\
\xec\xff\xd5\x4c\x4c\xfb\x91\xed\x04\x08\x20\x14\x07\x00\x53\xbf\
\xc9\x62\x0e\x8e\x17\xa0\xd4\x0e\x4e\xc9\x2f\x9f\xfe\xff\x18\x64\
\xfe\xff\x8d\x14\xc4\xf2\xe7\xea\x0c\xff\x9f\x00\xf1\x03\x60\xd0\
\x3e\xf2\x30\xfa\xff\xe9\xe9\xa3\xff\x9f\x3e\x7f\xfa\x7f\x27\xcc\
\x0d\x1e\xec\x60\xcb\x81\x8e\x3c\xc2\x09\xb4\x5c\x47\xf9\xff\x93\
\x53\x27\xc0\x96\xdf\xde\xb9\xf3\x7f\xab\x90\xd0\xb7\x1a\x06\x06\
\x2f\x64\x3b\x01\x02\x88\x11\xb9\x2e\x58\x0e\x2c\x88\x7e\x01\x53\
\x37\x03\x17\xd7\x0a\xbb\xb9\x73\x45\x15\x23\x22\x18\x7e\x3e\xbd\
\xcf\xf0\x25\x33\x98\xe1\xd7\x99\xf3\x0c\xff\x78\x81\x41\xfb\x1f\
\x12\xbc\x7f\x3e\x00\x33\xb6\x8d\x25\x03\x03\x37\x0f\xc3\xe7\x2d\
\xbb\x19\xfe\xc3\xe4\x40\x65\xc8\x47\x06\x06\x66\x79\x79\x06\x99\
\x85\x2b\x18\x24\x4c\x2c\x18\x1e\xec\xdb\xc7\xb0\x2a\x32\xf2\xeb\
\xe7\x57\xaf\xd2\x80\xb1\xb2\xac\x01\xc9\x4e\x80\x00\xc2\x70\x00\
\xc8\x00\xa0\x23\xdc\x80\x8e\x58\x6a\x3f\x7b\xb6\x88\x72\x54\x14\
\xc3\xf7\xa7\x0f\x19\x3e\xa6\x06\x31\xfc\x38\x73\x8e\xe1\x3f\x1f\
\x34\x7e\x41\x16\x7d\x05\xd2\x40\x0d\xff\x39\x81\x0e\x02\x89\x01\
\x8d\xfa\x09\x74\x18\xb3\x82\x02\x83\xec\xbc\xa5\x0c\x12\x16\x56\
\x0c\x0f\x76\xed\x62\x58\x19\x19\xf9\xf3\xeb\xbb\x77\x69\xac\x0c\
\xa0\x58\x66\x60\x40\x76\x00\x40\x00\x31\xe1\xa8\x20\x76\xfd\xfe\
\xf6\x2d\x62\x4f\x62\xe2\xab\xdb\x4b\x96\x30\x70\x4a\xcb\x33\xf0\
\xcc\x58\xc5\xc0\x6c\x64\x00\xf6\x39\xc8\xa7\x60\x0b\xd9\x81\x18\
\x6a\x39\xc8\xe1\x3f\x3f\x01\x43\x45\x49\x9e\x41\x76\xe1\x72\x06\
\x71\xa0\xe5\xf7\x77\xef\x66\x58\x11\x15\xf5\xe5\xcb\xbb\x77\x49\
\x30\xcb\xd1\x01\x40\x00\xa1\x38\xe0\x3f\x6a\x25\xb1\xf7\xff\xaf\
\x5f\x81\xbb\x52\x52\x1e\x5f\x9b\x3f\x9f\x81\x53\x4e\x99\x41\x60\
\xc1\x56\x06\x16\x6b\x5b\x86\x3f\xdf\xa0\x96\xc2\x30\xc8\x41\xc0\
\xf2\x96\x55\x53\x8b\x41\x6e\xc9\x5a\x06\x61\x53\x0b\x86\x3b\x5b\
\xb6\x30\x2c\x0b\x09\xf9\xf0\xfd\xed\xdb\x38\x50\xb0\x63\xb3\x03\
\x04\x00\x02\x08\x25\x1b\x7e\x46\x52\x00\xa5\xdf\xfc\xfe\xf9\xf3\
\xd7\xcf\x0f\x1f\x18\xc0\xe5\x3f\x2f\x2f\xc3\x3f\x6e\x2e\x48\xb6\
\xfc\x0f\xc1\x7f\x61\x34\x50\x8c\x99\x83\x83\x81\x49\x40\x10\xac\
\x16\x94\x3d\x7f\x7c\xfb\xf6\x1b\xc8\x7e\xf9\x07\x52\xb7\x80\x43\
\xe9\x1f\x9a\x03\x00\x02\x08\x67\x08\x80\x2a\x16\xa0\xa6\xed\xf6\
\xdd\xdd\xca\x86\x85\x85\x0c\x5f\xdf\xbd\x62\x78\x95\x14\xcc\xf0\
\x65\xeb\x4e\x70\x9c\xff\x83\xfa\x1e\x66\x39\x28\x3a\x3e\x9f\x3a\
\xc7\x70\x27\x22\x90\xe1\xed\x8d\x6b\x0c\x3a\xc0\x72\x22\x74\xde\
\x3c\xd1\xff\x6c\x6c\xeb\x7f\x21\x55\x60\xe8\x21\x00\x10\x40\x58\
\xd3\x00\xd0\x5c\xc3\x7f\xcc\xcc\xab\x6d\xfb\xfa\x94\x0c\x4b\x4a\
\x18\xbe\x7c\x7c\xcf\xf0\x2a\x3d\x9a\xe1\xcb\xb6\xdd\xc0\x50\x80\
\x06\x3b\xa8\x4a\xfe\x01\x4c\xb0\x5f\xa1\x3e\x03\x79\x8d\x87\x81\
\xe1\xe3\xc9\x4b\x0c\x37\x62\xa3\x18\x5e\x5c\xbd\xc2\xa0\x13\x1b\
\xcb\x10\x3c\x77\xae\x18\x13\x27\xe7\x8a\xdf\xa0\x84\x8d\x05\x00\
\x04\x10\x46\x08\x00\x0d\x33\xfc\xc3\xc8\xb8\x0e\xe8\x73\x25\x90\
\xcf\xbf\xbc\x7b\xcd\xf0\x2a\x2d\x8c\xe1\xeb\xce\x3d\x0c\x0c\x02\
\x10\xcb\x40\xc1\xfe\x0b\x94\x0d\x55\xd4\x19\xd8\x0d\x0c\xc0\x6c\
\x58\xf6\x64\xe4\x67\x60\xf8\x74\xe6\x22\xc3\x35\xa0\x23\x9e\x01\
\x1d\xa1\x1b\x13\xc3\x10\x3a\x77\xae\x08\xd0\x11\x4b\x7e\x83\xb2\
\x38\x1a\x00\x08\x20\x74\x07\xa8\xfe\x65\x66\x5e\x61\xdb\xdb\xab\
\xa0\x0f\xb2\xfc\xd3\x47\x86\x97\xd9\xf1\x40\x9f\xef\x61\xf8\xcf\
\x8f\x48\x70\x60\xcb\x81\x59\x4d\x7a\xf6\x32\x06\xf9\x45\x6b\x19\
\xd8\x8d\xf5\x19\x7e\xbe\x43\x72\x04\x30\x24\x3e\x9c\xbf\xcc\x70\
\x25\x3e\x1e\xe8\x88\xab\x0c\x3a\x91\x91\x0c\xa1\x33\x67\x8a\x02\
\xd3\xc8\x72\xa0\x12\x4b\x64\x3b\x01\x02\x08\xa5\x24\x04\xb6\x1a\
\x16\x1c\x2a\x2c\x84\x54\xa9\xaf\x9e\xff\xbf\x13\x09\xad\x58\x40\
\xc5\xab\x34\xb4\x84\xe3\x66\xf8\x7f\x5c\x53\x01\x58\xc2\x1d\xff\
\xff\x1d\xa8\x0e\x54\xc9\x3c\xbd\x7e\xf5\xff\x3e\x23\xdd\xff\xeb\
\x81\x7e\xd8\x00\x54\xbf\x16\xa8\x66\x15\xb0\x24\x5c\x0c\xe2\x1b\
\xea\xff\xbf\x7d\xf6\x0c\x58\xdd\xae\x8e\x8e\xff\x99\x0c\x0c\xdb\
\x90\xed\x04\x08\x20\x94\x10\x60\x62\x61\x71\x52\x0a\x09\x01\xa7\
\xd8\xd7\x65\x19\x0c\x5f\x56\xef\x84\x54\x2c\xff\x11\x3e\x67\x96\
\x07\x16\x32\xf3\x97\x32\x88\x03\xb3\xda\x83\x4d\x9b\x18\xae\x03\
\xcb\x09\x51\x0d\x2d\x06\x95\xc5\xcb\x18\xb8\x8c\x80\x21\xf1\x05\
\x91\x3d\x19\x81\xf9\xef\xd5\xf9\x8b\x0c\x17\x32\x32\x19\xde\xbf\
\x7b\xc7\xa0\xe6\xeb\xcb\xc0\x29\x20\x60\x80\x6c\x27\x40\x00\xa1\
\x38\xe0\xcf\xbf\x7f\x6f\x7e\xbc\x7e\xcd\xc0\x0c\x64\xb3\x59\x3a\
\x30\xfc\x13\x64\x63\xf8\xf3\x13\x12\xef\x60\xcb\x95\x95\x18\x64\
\x17\x2c\x63\x10\x37\x07\x96\x70\x7b\xf6\x30\xac\x8e\x8f\xff\xbc\
\x2a\x21\xe1\xdd\x15\xa0\x23\x24\xb4\x74\x18\xd4\x17\x2d\x61\xe0\
\x06\x39\xe2\x3b\xb4\x6c\xf8\x03\x31\x57\xd0\xca\x92\x81\x8d\x9b\
\x9b\x01\x58\x26\x30\xfc\xfc\x09\x72\x22\x02\x00\x04\x10\x4a\x14\
\xf4\x32\x30\x64\x2f\x31\x33\xfb\xff\x19\xd8\x78\x00\xb5\x64\x40\
\x8d\x89\x13\xc2\x4c\xff\x0f\x33\x32\xfc\x3f\xa9\xab\x02\xaf\x58\
\xee\x00\x2b\x96\x16\x01\x81\x6f\xd5\x0c\x0c\x81\x55\x0c\x0c\x36\
\x95\x6c\x6c\xaf\xce\x2c\x5a\x04\xd6\x73\xff\xca\xe5\xff\x1b\x8c\
\x8d\xfe\xcf\x02\x06\x3f\x08\xef\x2b\x29\xfe\xff\xea\xfb\xf7\xff\
\x1f\x3e\x7e\xfc\x3f\xc9\xcb\xeb\x7f\x0a\x03\x43\x2b\xb2\x9d\x00\
\x01\x84\x9e\x06\xd8\x80\x4d\xa6\xe9\xcb\x80\xcd\xa7\xcf\xc0\x66\
\x14\xc8\xc0\x3b\x53\x7b\xfe\x9f\xb2\x34\x87\x57\xa9\x77\xf6\xee\
\xfd\xdf\x26\x26\xf6\xa5\x12\xd8\x7a\x02\x36\xb1\x18\x6a\x81\xb8\
\x14\x98\xba\xcb\x39\x38\x5e\x9d\x06\xd6\xa2\x60\x3d\x67\xce\xfe\
\x5f\x6d\x6e\xfe\x7f\x77\x5e\xde\xff\x57\x3f\x7e\xfc\xff\xf0\xe9\
\xf3\xff\x99\xa1\xa1\xff\x13\x18\x18\xd6\x67\x31\x30\xf0\x21\xdb\
\x09\x10\x40\x28\x95\xd1\x24\x48\x65\xc4\x0a\xcc\xda\x33\x14\x9c\
\x9c\x92\xfc\x97\x2e\x65\x60\x93\x90\x00\x96\x68\x5f\x19\x78\xb8\
\xb8\x19\xee\x03\x2b\x96\x55\x68\x15\xcb\x3f\x68\x09\x07\xae\xc0\
\x38\x39\x97\x02\x53\xbb\x88\x3e\x30\xff\xbf\x7f\xf3\x86\x81\x0d\
\x58\x72\x32\xff\xfc\xc9\xb0\x32\x35\x95\xe1\xf8\xaa\x55\x9b\x80\
\xe5\x57\x34\xb0\x40\xfa\x32\x15\xc9\x4e\x80\x00\xc2\xe6\x00\x10\
\x66\x01\x3a\x62\x8a\xac\xa5\x65\xba\x7d\x73\x33\x03\xaf\xa4\x24\
\xc3\xa3\x63\xc7\x18\x76\x95\x97\x7f\x06\x56\x2c\x19\xc8\x65\xfb\
\x3f\xa4\x22\x16\x18\xf5\xce\xc0\x3e\xc4\x32\x8f\x96\x16\x31\x0d\
\x4f\x4f\x86\xef\xc0\xe2\x78\x57\x5b\x1b\xc3\xb9\xed\xdb\xd7\x03\
\x2d\x8f\x07\x95\xf6\xa0\x12\x11\xd9\x01\x00\x01\x84\xcb\x01\x20\
\xcc\x06\x2c\xe8\x8a\x18\x59\x58\x22\x58\x05\x04\xc4\xbf\xbe\x79\
\x73\x15\xa8\xb9\x17\x98\x40\xb7\xa3\x95\x9a\xc8\x7a\x40\x39\xc8\
\x1c\x98\x6e\xab\xb9\x84\x84\x8c\x7f\x7e\xfd\xfa\x09\x98\xe8\x36\
\x00\x43\xab\x0d\x5a\xd5\x30\xa0\x3b\x00\x20\x80\x18\x07\xba\x73\
\x0a\x10\x40\x03\xde\x37\x04\x08\xa0\x01\x77\x00\x40\x80\x01\x00\
\xa8\xdb\x4a\x1b\x31\xff\xfc\x96\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
\x00\x00\x08\x17\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\xa8\x00\x00\x00\xa8\x08\x06\x00\x00\x00\x74\x4b\xa5\xb4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x15\x88\x00\x00\x15\x88\
\x01\xc4\xd7\x40\xa0\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x94\x49\x44\
\x41\x54\x78\x9c\xed\xdc\x5d\xa8\x65\x65\x1d\xc7\xf1\xef\x7f\xc6\
\xf1\xa5\x98\xc9\x3c\x4e\xa3\x52\x96\x16\x98\x2f\x0c\x6a\x31\x34\
\x63\x52\x9a\x4d\xbe\x6b\xe3\xa0\x45\x28\x04\x22\x74\x91\x85\x18\
\x61\x45\xa5\x52\x43\xa0\x17\xa5\x17\x51\x37\x95\x51\x59\x08\x82\
\xd2\x8b\x10\xdd\x58\x58\x88\xf6\x62\x8e\xe9\x50\xa3\x94\x15\xcd\
\x98\x99\xd3\x4c\xa3\xf9\xeb\x62\xed\x68\x38\xce\x39\x7b\xed\x73\
\x9e\x67\x3d\xff\xb3\xe7\xf7\x81\xcd\x61\x38\x67\x3f\xeb\x3f\x9b\
\xef\x59\x6b\xaf\x7d\xd6\xde\x21\x09\xb3\xac\x96\xb5\x1e\xc0\x6c\
\x3e\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\
\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\
\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\xa9\
\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\
\xd4\x1c\xa8\xa5\x76\x50\xeb\x01\x22\xe2\x78\x60\x55\xeb\x39\x6c\
\x4e\x8f\x4b\xfa\x57\xab\x8d\x47\xcb\xb7\x1d\x47\xc4\x32\xe0\x8f\
\xc0\xd1\xcd\x86\xb0\x71\x3e\x24\xe9\xcb\xad\x36\xde\xfa\x10\xbf\
\x01\xc7\x99\xdd\xa6\x96\x1b\x6f\x1d\xe8\x65\x8d\xb7\x6f\xe3\x9d\
\x15\x11\xaf\x6e\xb5\x71\x07\x6a\xe3\x1c\x04\x5c\xd4\x6a\xe3\xcd\
\x02\x8d\x88\x75\xc0\xeb\x5a\x6d\xdf\x26\xd2\xec\x30\xdf\x72\x0f\
\xea\xbd\xe7\xd2\xb1\x31\x22\x5e\xd9\x62\xc3\xcd\xce\xe2\x23\x62\
\x1b\xf0\xc6\x26\x1b\x87\x3d\xc0\xdf\x81\x67\x67\xdd\x76\x03\x6b\
\x80\x63\xe8\x4e\xde\xd6\x00\x51\x79\x96\x97\xe8\x5e\xc9\xf8\xcb\
\xe8\xb6\x03\x58\x09\xcc\x00\x47\x8e\xbe\xce\x00\x87\x56\x9e\x63\
\x9c\xcd\x92\xee\x1a\x7a\xa3\x4d\x5e\x07\x8d\x88\x53\x19\x2e\xce\
\xbd\xc0\xaf\x81\x5f\xec\x73\x7b\x4c\x3d\x7e\x33\x23\xe2\xcd\xc0\
\x27\x81\xf7\x03\xcb\x2b\xcc\xf6\x23\xe0\x63\x92\x7e\xd3\x63\x96\
\x19\xe0\x6d\xc0\x19\x74\xaf\x7e\xac\x03\x0e\xab\x30\xd3\x5c\x36\
\x01\x83\x07\x8a\xa4\xc1\x6f\xc0\xcd\x80\x2a\xde\x76\x01\x77\x00\
\xe7\x00\x87\x14\x98\xf7\x9d\x74\x7b\xba\x92\x33\x6e\x59\xe4\x4c\
\x2b\xe8\x22\xfd\x02\xf0\xd7\xca\x8f\xa7\x80\x7f\x00\x07\x0f\xde\
\x4a\xa3\x40\xb7\x56\x7a\x10\xef\x07\xae\x06\x56\x55\x98\xf9\xeb\
\x05\xe7\xfc\x27\x30\x53\x70\xb6\x15\xc0\x66\xe0\xbe\x0a\xbf\x48\
\xfb\xde\xce\x9b\xfa\x40\x81\x93\x2a\x3c\x70\xdf\x07\x4e\xae\x3c\
\xf7\x71\x05\xe7\xbd\xbd\xf2\x9c\x5f\x02\x5e\xa8\xf0\x38\x7f\x75\
\xe8\x5e\x5a\x9c\xc5\x97\x3c\x7b\xdf\x4a\xf7\x5b\x7d\xbe\xa4\xdf\
\x16\x5c\x77\x7f\x9e\xa4\x7b\x3e\x5b\xc2\xef\x0a\xad\xf3\x32\x92\
\xfe\x20\xe9\x5a\x60\x2d\xdd\x73\xdc\x92\x2e\x19\xfd\x79\x7a\x30\
\x2d\x02\xdd\x5c\x60\x8d\x67\x80\x6b\x81\xb5\x92\x7e\x58\x60\xbd\
\xb1\x24\xfd\xef\x6c\xbb\x84\xbf\x15\x5a\x67\x4e\x92\xb6\x4a\x3a\
\x17\xb8\x18\x78\xa2\xd0\xb2\xab\x81\xb7\x17\x5a\xab\x97\x41\x03\
\x8d\x88\x37\xd1\xfd\x66\x2f\xc6\x4f\x81\x53\x24\xdd\x26\xe9\xc5\
\x02\x63\x4d\xe2\xa9\x42\xeb\xec\x28\xb4\xce\x58\x92\xee\x01\x4e\
\x01\x3e\x43\xf7\xfc\x74\xb1\x06\x7d\xd1\x7e\xe8\x3d\xe8\x62\xf7\
\x9e\xb7\x03\x67\x49\xfa\x73\x89\x61\x16\x60\x4f\xa1\x75\x9e\x29\
\xb4\x4e\x2f\x92\xf6\x4a\xba\x09\x38\x0f\xd8\xb9\xc8\xe5\xde\x5b\
\x60\xa4\xde\x86\x0e\x74\xa1\xcf\x3f\x77\x03\x57\x49\xfa\xb0\xa4\
\x17\x4a\x0e\xd4\x48\x89\x3d\xd9\xc4\x24\xdd\x07\xbc\x05\x78\x68\
\x11\xcb\x1c\x1b\x11\x6f\x2d\x34\xd2\x58\x83\x05\x1a\x11\xaf\x07\
\x16\xf2\x1f\x7b\x0a\xd8\x20\xe9\x8e\xc2\x23\x1d\x90\x24\x3d\x49\
\xf7\x62\xff\xd7\x16\xb1\xcc\x60\x87\xf9\x21\xf7\xa0\x0b\xd9\x7b\
\xfe\x89\xee\x90\xfe\xcb\xd2\xc3\x1c\xc8\x24\xed\x91\xf4\x41\xe0\
\x13\x0b\x5c\xc2\x81\xd2\xfd\x75\xe4\x5d\x92\x7e\x5f\x63\x18\x03\
\x49\x5b\x58\x58\xa4\x27\x44\xc4\x49\xa5\xe7\xd9\x9f\x41\x02\x8d\
\x88\x63\x80\xf5\x13\xdc\x65\x27\x70\x8e\xa4\x6a\xaf\x17\x5a\x67\
\x14\xe9\xa7\x16\x70\xd7\x41\x4e\x96\x86\xda\x83\x6e\xa2\xff\x55\
\x41\xcf\x02\xef\x96\xf4\x48\xc5\x79\x6c\x1f\x92\x3e\x07\x7c\x7a\
\xc2\xbb\x0d\x72\x98\x1f\x2a\xd0\xbe\x87\xf7\xbd\xc0\x05\x92\x1e\
\xae\x39\x8c\xbd\x9c\xa4\x9b\x81\x1b\x27\xb8\xcb\xe9\x11\xf1\x86\
\x3a\xd3\xfc\x5f\xf5\x40\x23\xe2\x35\xc0\x99\x3d\x7f\xfc\x7a\x49\
\x3f\xab\x39\x8f\xcd\x4d\xd2\x67\x81\x6f\x4f\x70\x97\xea\x87\xf9\
\x21\xf6\xa0\x97\xd2\xef\x5a\xca\x3b\x25\xdd\x56\x7b\x18\x1b\xeb\
\x6a\x60\xec\xf5\xa9\x23\xd5\x0f\xf3\x43\x04\xda\xe7\xf0\xfe\x18\
\xdd\x03\x63\x8d\xa9\xfb\x90\x86\x4d\x74\xe7\x02\xe3\x6c\x88\x88\
\x35\x35\xe7\xa9\x1a\x68\x44\x1c\x01\x9c\x3d\xe6\xc7\x76\x01\x97\
\x49\x7a\xbe\xe6\x2c\xd6\x9f\xa4\x6d\xc0\x95\x74\x97\xd8\xcd\x67\
\x19\x70\x49\xcd\x59\x6a\xef\x41\x2f\x66\xfc\xdb\x4a\xae\x91\xf4\
\x68\xe5\x39\x6c\x42\x92\xee\xa5\x7b\xe7\xc3\x38\x55\x0f\xf3\xb5\
\x03\x1d\x77\x71\xc8\x5d\x92\xbe\x55\x79\x06\x5b\xb8\x1b\xe9\xde\
\xa5\x30\x9f\xb3\x23\xe2\xf0\x5a\x03\x54\x0b\x34\x22\x56\xd1\xbd\
\x27\x68\x2e\xcf\xd1\x5d\xd3\x69\x49\x8d\xae\x81\xbd\x86\xf9\x2f\
\xd4\x5e\x01\x5c\x58\x6b\x86\x9a\x7b\xd0\x0b\x81\x43\xe6\xf9\xfe\
\x0d\x92\x9e\xae\xb8\x7d\x2b\x40\xd2\x56\xe0\xf3\x63\x7e\xac\xda\
\x61\xbe\x66\xa0\xf3\x1d\xde\x1f\x00\x9a\x7d\x62\x9a\x4d\x6c\x0b\
\xdd\xdb\x6b\xe6\xf2\x9e\x88\x78\x45\x8d\x0d\xd7\x0c\xf4\x1b\xc0\
\xbd\xc0\xec\xab\xde\x5f\xa4\x3b\x31\x6a\x72\x4d\xa4\x4d\x4e\xd2\
\x5e\xba\x43\xfd\xfe\xce\xea\x1f\xa0\xbb\xe0\xa4\xca\x07\x5c\x54\
\x0b\x54\xd2\xdd\x92\x2e\xa2\xfb\x94\x8e\x8f\x00\x0f\x8e\xbe\x75\
\xab\x7a\x7c\x50\x81\xe5\x22\xe9\x7e\xe0\x2b\xa3\x7f\x3e\x0c\x7c\
\x1c\x38\x4e\xd2\x7a\x49\x5f\x94\xb4\xab\xc6\x76\x07\xfd\xe8\x9b\
\x88\x38\x11\xd8\x2e\x69\xf7\x60\x1b\x2d\x28\x22\x7e\x00\x9c\x5b\
\x60\xa9\xd3\x96\xe2\x35\xae\xa3\x13\xdf\xa3\x24\x3d\x3e\xd4\x36\
\x07\xfd\xe8\x9b\xd1\x13\x6e\x5b\xa2\x24\x3d\x47\xf7\xea\xcb\x60\
\x5a\x7f\x3e\xa8\xd9\xbc\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\xa9\
\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\
\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\x81\
\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\
\x40\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\
\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\
\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\
\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\
\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\
\xe6\x40\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\
\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\
\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\
\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\x6a\xa9\x39\xd0\xc9\
\x94\x7a\xbc\xfc\xb8\xf7\xe4\x07\x6a\x32\x2b\x93\xad\x33\xf5\x1c\
\xe8\x64\x0e\x4f\xb6\xce\xd4\x73\xa0\x93\x71\xa0\x03\x73\xa0\x93\
\x71\xa0\x03\x73\xa0\x3d\x45\xc4\xc1\xc0\x61\x85\x96\x7b\x55\xa1\
\x75\xa6\x9e\x03\xed\xaf\x64\x54\xde\x83\xf6\xe4\x40\xfb\x2b\x19\
\x95\x03\xed\xc9\x81\xf6\xe7\x40\x1b\x70\xa0\xfd\xcd\x24\x5d\x6b\
\xaa\x39\xd0\xfe\x4e\x2f\xb8\xd6\x69\x11\xb1\xbc\xe0\x7a\x53\xcb\
\x81\xf6\xb7\xa1\xe0\x5a\x2b\x81\xb5\x05\xd7\x9b\x5a\x0e\xb4\x87\
\x88\x08\x60\x7d\xe1\x65\xcf\x2c\xbc\xde\x54\x72\xa0\xfd\x6c\x04\
\x8e\x28\xbc\xe6\xfb\x0a\xaf\x37\x95\x1c\x68\x3f\xd7\x55\x58\x73\
\x7d\x44\xac\xab\xb0\xee\x54\x71\xa0\x63\x8c\x22\xda\x58\x69\xf9\
\x1b\x2a\xad\x3b\x35\x1c\xe8\x3c\x22\x62\x35\xf0\xbd\x8a\x9b\xb8\
\x34\x22\x3e\x5a\x71\xfd\x25\xcf\x81\xce\x21\x22\xd6\x00\x77\x03\
\xc7\x56\xde\xd4\x2d\x11\xf1\x81\xca\xdb\x58\xb2\x1c\xe8\x2c\xd1\
\xb9\x1c\x78\x84\xb2\x2f\x2d\xcd\x65\x39\xf0\xcd\x88\xf8\x6e\x44\
\x1c\x35\xc0\xf6\x96\x94\x90\xd4\x7a\x86\xe6\x46\x61\x9c\x08\x5c\
\x00\x5c\x01\xbc\xb6\xd1\x28\xff\x01\x7e\x0c\xdc\x09\xfc\x1c\xd8\
\x26\xe9\xdf\x8d\x66\x49\x61\xea\x03\x8d\x88\xa3\x81\x77\xd0\xfd\
\x79\xf1\xc8\x59\x5f\x57\x03\xc7\x93\xf7\xf2\xb7\x97\x80\xed\xc0\
\xd3\xc0\x0e\x60\xe7\xac\xaf\xdb\x25\xfd\xa4\xd9\x74\x03\x38\x10\
\x02\xbd\x02\xf8\x4e\xeb\x39\x2a\xf9\x95\xa4\x53\x5b\x0f\x51\x93\
\x9f\x83\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x0e\x84\
\x93\xa4\xd5\xc0\xc9\xad\xe7\xa8\xe4\x79\x49\x0f\xb6\x1e\xa2\xa6\
\xa9\x0f\xd4\x96\x36\x1f\xe2\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\
\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\
\xe6\x40\x2d\x35\x07\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\
\x52\x73\xa0\x96\x9a\x03\xb5\xd4\x1c\xa8\xa5\xe6\x40\x2d\x35\x07\
\x6a\xa9\x39\x50\x4b\xcd\x81\x5a\x6a\x0e\xd4\x52\x73\xa0\x96\xda\
\x7f\x01\xf5\x70\xad\x3a\xf1\xc7\x57\x9c\x00\x00\x00\x00\x49\x45\
\x4e\x44\xae\x42\x60\x82\
\x00\x00\x01\x3d\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\
\x01\x42\x28\x9b\x78\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\xba\x49\x44\
\x41\x54\x58\x85\xed\xd6\x31\x0a\x02\x41\x0c\x05\xd0\xff\x67\xa6\
\x58\x11\x05\x4b\x4b\x4f\xa3\xb5\x85\x62\x9f\x63\xcd\x05\xb4\xd8\
\x5a\x3d\x84\x57\xf0\x02\x82\xb0\x32\xa0\x88\x3b\x1e\x40\x17\x76\
\x25\xb0\x85\x49\x9b\x22\x2f\x09\x81\x50\x44\xd0\x67\xb8\x5e\xab\
\x1b\xc0\x00\x06\x30\x80\x01\x00\x84\xa6\xc4\xbc\xdc\x6d\x0b\x97\
\x87\x1a\x45\xee\x35\xd3\x61\xb9\x5a\xb7\x06\xc4\x18\xb9\x99\x8e\
\x16\xb3\x09\xc7\x1a\x80\xf3\x35\x57\x31\x46\x8a\x48\x6e\x05\x00\
\x00\x06\x07\x16\x3a\x1b\x62\xa8\x1b\x73\x8d\x00\x04\x82\x03\xaf\
\x02\x40\xf8\x68\xbc\x05\xc0\x13\xd0\x02\xf8\xd7\x0f\x00\xd5\x09\
\xb0\x3b\xc0\x79\x82\x85\x0e\xc0\xf9\x8e\x00\x11\xc9\x97\x63\xb9\
\xbf\x9d\x92\xca\x19\x3e\x9e\x48\xdf\x2e\x00\x00\x68\x3f\xa1\x01\
\x0c\x60\x00\x03\xfc\x3d\xe0\x0d\x62\x08\x25\xb8\x8c\xc0\x27\xd8\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x12\xf3\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x03\xd0\x00\x00\x02\xb3\x08\x06\x00\x00\x00\xf6\xb9\xe5\xa8\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x2e\x23\x00\x00\x2e\x23\
\x01\x78\xa5\x3f\x76\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\
\x65\x52\x65\x61\x64\x79\x71\xc9\x65\x3c\x00\x00\x12\x80\x49\x44\
\x41\x54\x78\xda\xec\xda\x5f\x68\x9d\xe5\x1d\xc0\xf1\xe7\x34\xe7\
\x5f\xad\x5b\x73\x62\xa9\x54\x5b\xc9\x08\x14\xc5\xb6\x68\xb2\x48\
\x6f\xc6\x32\xc7\x60\xbb\xf4\xaa\xe9\x81\x46\x48\xa1\xd4\x3f\x30\
\x1c\x65\x82\x57\x2d\x54\x61\x17\xb5\xca\xaa\x48\x20\x71\x84\x99\
\x16\x77\xe1\xa0\x1b\xae\x17\xc3\xe6\x6e\x38\x76\x5a\xd2\x5e\x59\
\xea\x9c\xad\x96\x7a\x31\x54\x3c\x39\x6f\x4e\x4c\xde\x25\xcc\x0b\
\x31\x1d\xf4\xbc\xbc\x8e\x27\xc7\xcf\x07\x4e\x73\xf5\x83\x97\xdf\
\xfb\xf0\xf6\x7c\x39\x6f\xa1\x54\xa9\xa6\x01\x00\x00\x00\xfe\x6b\
\xb6\x9d\xb4\x46\xac\x61\xad\x0d\x56\x00\x00\x00\x00\x02\x1a\x00\
\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\
\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\
\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\
\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x40\x37\x28\x66\x1d\x6c\
\x27\x2d\xdb\x23\x1a\xb5\xbe\x5a\x68\xce\x27\x1d\xcf\x4d\x4f\x4d\
\x86\xd1\x7a\xdd\x02\x89\xc2\xb3\x47\x8e\x84\x93\xa7\x5e\xe9\x78\
\x6e\x70\xcf\xae\xf0\xb7\x77\xff\x6e\x81\x44\xa3\x5c\xdd\xe8\xbb\
\x05\xeb\xde\xde\x47\x86\x43\x63\xee\x72\xc7\x73\xe3\x63\x07\xc2\
\x6b\x13\x13\x16\x48\x14\xce\xcc\xcc\x84\xb1\xf1\x83\x16\x91\x23\
\xbf\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\
\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\x00\x00\x02\
\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x00\x02\x1a\
\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\
\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\
\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\x00\x00\x00\
\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x20\
\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\
\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\
\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\
\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\
\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\
\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x08\x68\x00\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\
\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\
\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\
\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\
\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\
\x03\x00\x00\x80\x80\x06\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\
\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\
\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\
\x00\x10\xd0\x00\x00\x00\x70\x5b\x8a\x56\x00\x90\xaf\xe5\x9b\xef\
\x85\xa5\x77\xcf\x76\x3c\x37\xb4\x74\x3d\xec\xdf\xbd\xbd\xe3\xb9\
\xfb\xee\x2e\x86\xc5\xb3\x27\x3a\x9e\x2b\xf4\x6e\x0d\x85\xcd\x5b\
\xdd\x30\x72\x37\xbc\x63\x4b\xa6\xb9\xa5\xb9\x73\x96\x47\x34\x76\
\x6e\x2e\x85\x9e\x0c\x67\xb9\xbf\xd8\x74\x96\x89\x46\xdf\x67\xef\
\x67\x7a\x26\xdf\x51\xee\xe9\xfd\x7c\x74\x60\xc4\x06\x6f\xf1\xfd\
\xa9\x54\xa9\xa6\x59\x06\xdb\x49\xcb\xf6\x88\x46\xad\xaf\x16\x9a\
\xf3\x49\xc7\x73\xd3\x53\x93\x61\xb4\x5e\xb7\x40\x72\xb5\x1a\xb3\
\xad\x37\x5e\xb5\x08\x00\x80\x2e\xe3\x15\x6e\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\xf1\x2b\x66\x1d\x7c\xf6\xc8\x11\xdb\
\x23\x1a\x0b\xc9\x42\xa6\xb9\x3f\xbc\xf9\x66\xb8\xd0\x68\x58\x20\
\xb9\x1a\x5a\xba\x1e\x7e\x6e\x0d\x00\x00\x5d\xa7\x50\xaa\x54\x53\
\x6b\x00\xc8\xcf\xfe\xdd\xdb\xc3\x6f\x07\x96\x2d\x02\x00\xa0\xcb\
\x78\x85\x1b\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x40\xfc\
\x8a\x59\x07\x07\xf7\xec\xb2\x3d\xa2\x71\xf1\xd2\xe5\xb0\x9c\x76\
\x3e\xb7\x73\xe0\x07\xe1\xce\x4d\x9b\x2c\x90\x5c\xdd\x77\xf7\xea\
\xa3\xf5\x13\x8b\x00\x00\xe8\x32\x85\x52\xa5\x9a\x66\x19\x6c\x27\
\x2d\xdb\x23\x1a\xb5\xbe\x5a\x68\xce\x27\x1d\xcf\x4d\x4f\x4d\x86\
\xd1\x7a\xdd\x02\xc9\xd5\xe2\xd9\x13\xa1\xf5\xc6\xab\x16\x01\x00\
\xd0\x65\xbc\xc2\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\
\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x04\x34\x00\x00\
\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\
\x20\x7e\x45\x2b\x00\xc8\x57\xa1\x77\xeb\xba\xb8\xce\x9e\x07\x1e\
\x0c\xa5\xfb\x07\xdd\x30\x72\xf7\xab\x97\x67\x32\xcd\xbd\xf8\xcb\
\xba\xe5\x11\x8d\x17\x4f\xff\x25\x5c\xff\xe4\xdf\x1d\xcf\xfd\xe8\
\xa1\xfb\xc3\x63\x3f\xf6\x6c\x25\x0e\x97\xae\x7e\x14\x5e\xff\xd3\
\x6c\xc7\x73\xbd\xa5\x0d\xff\xfa\xf5\xb6\xc5\xdf\xd9\xa0\x80\x06\
\xf8\xf6\x03\x7a\xf3\xfa\x08\xe8\xd5\x78\x2e\xef\x3b\xea\x86\x91\
\xbb\x89\xc7\x7f\x93\x69\xee\x94\xf3\x48\x44\xfe\x78\xe2\xcf\xa1\
\x31\x77\xad\xe3\xb9\x2f\x77\x8d\x84\x7d\xce\x32\x91\xb8\x32\x33\
\x13\x26\x1a\xbf\xcf\x32\xfa\xc1\xf1\xa4\xe5\x20\xdf\x82\x57\xb8\
\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\
\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\
\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\x00\
\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\
\x00\x08\x68\x00\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\
\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\
\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\
\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\
\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\
\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x80\x80\x06\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\
\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\
\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\
\x04\x34\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\
\x34\x00\x00\x00\x08\x68\x00\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\
\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\
\x00\x40\x40\x03\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\
\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\
\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x04\x34\x00\x00\x00\
\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\
\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\
\x68\x00\x00\x00\xb8\x2d\x85\x52\xa5\x9a\x66\x19\xdc\x74\x47\xd5\
\xf6\x88\x46\x73\x3e\xc9\x34\x57\x2a\xf6\x84\x72\xb9\x64\x81\xe4\
\x6a\xf0\xde\xbb\xc2\x5b\x0f\xa6\xd1\x5f\xe7\xb1\x1b\xd5\x30\x75\
\xe9\x63\x37\x8c\x68\x9e\xc9\xbe\x5b\x10\x93\xf9\x56\x12\xd2\x0c\
\x8f\xf2\x0d\x1b\x0a\x61\x63\xb5\x62\x81\x44\x61\xe9\xcb\xa5\x90\
\xb4\x17\xb3\x8c\x7e\xd4\x4e\x5a\xdb\x6d\x70\xad\xe2\xff\xfb\x3f\
\x47\x88\xc9\xe2\xca\x43\x65\xf5\x03\x79\x4a\x92\x85\x95\x7f\xcb\
\xd1\x5f\xe7\xc2\xe2\xa2\x67\x39\x5d\x11\xde\x10\x93\xe5\xe5\xd4\
\x59\xa6\x1b\x6c\xb2\x82\x5b\xf3\x0a\x37\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\
\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\
\x80\x80\x06\x00\x00\x80\xf8\x15\x4a\x95\x6a\x9a\x65\x70\x7a\x6a\
\xd2\xf6\x88\xc6\xa1\xc3\x87\x43\xd2\x5e\xec\x78\xee\x99\xa7\x9f\
\x0a\x0f\x0f\x0e\x5a\x20\xb9\xea\xfb\xec\xfd\xb0\x77\xf6\xf5\xe8\
\xaf\xf3\xca\x9e\x47\xc3\x95\xfe\x9f\xb8\x61\xe4\x6e\x6c\xfc\x60\
\xa6\x39\xdf\x2d\x88\xc9\xf1\xe7\x8f\x87\xf7\xae\xfe\xb3\xe3\xb9\
\x5f\xfc\xec\xa7\x61\xff\xfe\xba\x05\x12\x85\x0b\x8d\x46\x38\x79\
\xea\x95\x2c\xa3\xff\x68\x27\xad\x1f\xda\xe0\x5a\xc5\xac\x83\xa3\
\x75\x0f\x06\xe2\xf1\xc4\x4a\x08\x87\x0c\x01\xbd\x1a\xcf\xce\x32\
\x79\x5b\x9a\x3b\x17\x9a\xeb\x20\xa0\x77\x0f\xdc\x1b\x86\xf6\x39\
\xff\xc4\x13\xd0\x9e\xc7\xc4\xe4\xa5\x97\x4e\x66\x9a\xdb\xb6\xed\
\x1e\x67\x99\x6e\xf0\x85\x15\xdc\x9a\x57\xb8\x01\x00\x00\x40\x40\
\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\
\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\
\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\
\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\
\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\
\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\
\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\
\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\
\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\
\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\
\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\
\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\
\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\
\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\
\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\
\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\
\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\x00\x00\x02\
\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\
\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\
\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\
\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\
\x68\x00\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\
\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\
\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\
\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\
\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\
\x80\x80\x06\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x08\x68\x00\x00\x00\xe0\x6b\x0a\xa5\x4a\x35\xb5\x06\x80\
\xfc\x0c\xef\xd8\x12\xde\x1e\x2a\x47\x7f\x9d\xcf\x7d\xd8\x13\x26\
\x1a\xd7\xdc\x30\x00\xe0\x9b\x3e\x6d\x27\xad\x9a\x35\xac\xe5\x17\
\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\
\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\
\x00\x00\x00\x04\x34\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\
\x00\x00\xba\x42\xa1\x54\xa9\xa6\x59\x06\xdb\x49\xcb\xf6\x88\x46\
\xad\xaf\x16\x9a\xf3\x49\xc7\x73\xd3\x53\x93\x61\xb4\x5e\xb7\x40\
\x72\xb5\x34\x77\x2e\x34\x5f\x78\x32\xfa\xeb\xac\x3e\x76\x20\x94\
\xf7\x1d\x75\xc3\xc8\x5d\xb9\xba\x31\xd3\x9c\xef\x16\xc4\x64\xef\
\x23\xc3\xa1\x31\x77\xb9\xe3\xb9\xf1\xb1\x03\xe1\xb5\x89\x09\x0b\
\x24\x0a\x67\x66\x66\xc2\xd8\xf8\xc1\x2c\xa3\xb3\x2b\xcf\xe4\x11\
\x1b\x5c\xcb\x2f\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\
\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x40\x40\x03\x00\
\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\
\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\
\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\
\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\
\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x00\x02\x1a\x00\x00\x00\x04\
\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\
\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x04\x34\
\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\
\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\
\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\
\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\
\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x20\xa0\x01\x00\x00\
\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\
\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x40\
\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\
\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\
\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x00\x02\x1a\x00\
\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\
\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\
\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\
\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\x00\x00\x00\x20\
\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\
\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x20\xa0\
\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\
\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\
\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\x0d\x00\x00\
\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x00\
\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\
\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x10\xd0\x00\
\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\x06\x00\
\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\
\x00\xf0\x35\xc5\xac\x83\x87\x0f\x1d\xb2\x3d\xa2\xb1\xb0\xd0\xce\
\x34\x77\xfa\xf4\x4c\x38\x7f\xfe\xbc\x05\x92\xab\xfe\x62\x33\x3c\
\xb9\x0e\xae\xf3\xad\xd9\x46\x78\xe7\xaf\x9e\xe5\xc4\xc3\x77\x0b\
\x62\x72\xe3\xe6\xcd\x4c\x73\x17\x2f\x5e\x70\x96\x89\xe7\x1c\xdf\
\xf8\xd8\x12\x72\x56\x28\x55\xaa\xa9\x35\x00\xe4\x67\x78\xc7\x96\
\xf0\xf6\x50\x39\xfa\xeb\x7c\xee\xc3\x9e\x30\xd1\xb8\xe6\x86\x01\
\x00\xdf\x34\xdb\x4e\x5a\x23\xd6\xb0\x96\x57\xb8\x01\x00\x00\x40\
\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\
\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\
\x00\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\
\x00\x00\x00\x04\x34\x00\x00\x00\xc4\xaf\xb8\xf2\x39\x66\x0d\x74\
\x81\x87\x56\x3e\xbd\x19\xe6\x2e\xae\x7c\x3e\xb5\x3e\xf2\xb4\xfd\
\x7b\x95\xfe\x10\xd2\xc7\x63\xbf\xce\x9d\x77\xf6\xcc\xae\xfc\x39\
\xef\x8e\xf1\x2d\x18\xc9\x38\xe7\x3c\x12\x93\xfe\xaf\x3e\x9d\xfa\
\xe0\xab\x0f\xac\x67\xce\xf0\xff\x50\x48\xd3\xd4\x16\x00\x72\xf4\
\xf9\xe8\xc0\x6a\x3c\xbc\xb3\x0e\x2e\xf5\xd8\xf7\xcf\x5c\x3d\xea\
\x8e\x01\x00\xdc\x1e\xaf\x70\x03\x00\x00\x80\x80\x06\x00\x00\x00\
\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\
\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x00\x01\
\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\
\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\x08\x68\x00\
\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\
\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\x68\x00\x00\
\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\
\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\
\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\
\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\
\x34\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\x00\x00\x80\x80\
\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\
\x00\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x80\x80\x06\
\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\
\x00\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\
\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\
\x00\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\
\x40\x40\x03\x00\x00\x00\x02\x1a\x00\x00\x00\x04\x34\x00\x00\x00\
\x08\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\
\x40\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x08\
\x68\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\
\x03\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\
\x00\x00\x00\x10\xd0\x00\x00\x00\x20\xa0\x01\x00\x00\x40\x40\x03\
\x00\x00\x80\x80\x06\x00\x00\x00\x01\x0d\x00\x00\x00\x02\x1a\x00\
\x00\x00\x04\x34\x00\x00\x00\x7c\xc7\xfd\x47\x80\x01\x00\xf7\x97\
\x58\xc2\x71\xe4\x3e\xe5\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\
\x60\x82\
\x00\x00\x04\x4e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x03\xcb\x49\x44\
\x41\x54\x58\x85\xc5\x97\xcb\x6e\xdb\x46\x14\x86\xff\xb9\x91\x43\
\x51\x8c\x15\x59\xa8\x9d\xd6\x41\x11\xa0\x28\x60\xa0\xed\xba\x40\
\x37\x7a\x8a\xbe\x86\x91\x27\xf0\x23\x04\x7e\x22\xed\xb2\x11\xba\
\x33\x60\x74\x99\x22\x29\x7a\x01\x2a\xea\x46\x91\x73\xed\x42\x9e\
\x69\x6c\x51\x8e\xa4\x0a\xed\x01\x04\x11\x1c\xce\x99\x6f\xfe\x73\
\xe6\x1c\x92\x78\xef\xd1\x66\x84\x10\xda\x3a\x70\xa0\x79\xef\x5d\
\xeb\x3a\x6d\x00\x37\x37\x37\x17\x97\x97\x97\xaf\xbd\xf7\x47\x81\
\x20\x84\xb8\xbb\xbb\xbb\x37\x57\x57\x57\xef\xdb\xc8\x1e\xfc\x86\
\xc3\x21\x1f\x8f\xc7\x6f\x95\x52\xfe\x98\xbf\xf1\x78\xfc\x76\x38\
\x1c\xf2\xc7\xeb\x6d\xec\x70\x3e\x9f\x13\xc6\x98\x3c\xc6\xce\x3f\
\x36\xc6\x98\x9c\xcf\xe7\xe4\xf1\xfd\xa3\xc6\xf9\x10\xfb\xdf\x01\
\xf8\x2e\x0f\xfd\x3a\x59\xa2\x31\xad\x49\xdc\x6a\x94\x00\x5f\x0e\
\x8a\xe3\x01\xfc\xfc\xcb\xef\xd0\x9e\xa0\x69\x1a\x78\xef\xe1\x9c\
\x03\xa5\x14\x59\x96\x61\xb9\x5c\x82\x52\x0a\xce\x79\x1c\xcb\x3b\
\xd9\x71\x00\x1a\xa5\xe1\x01\x70\xce\xb0\x58\xac\xe0\xbd\x07\xe7\
\xeb\x29\x8c\x31\x38\xe7\xa0\xb5\x46\xa7\xd3\x81\x52\x0a\x84\x10\
\x48\x29\xc1\x08\x60\x8c\x01\x00\x10\x42\xc0\x18\x3b\x0c\xe0\xa7\
\x77\x7f\xa1\x51\x1a\x8c\x25\xc8\x73\x1a\x17\x8f\x47\xe8\x5e\x85\
\x60\xde\x7b\xa4\x82\xe1\xfb\xaf\xce\x76\xda\xfd\x27\x01\x16\x8b\
\x05\xe6\x8b\x25\x18\x63\xd0\x5a\x83\x10\x82\x7e\xbf\x8f\xd9\x6c\
\x06\xad\x35\x4e\x4e\x4e\x50\x96\x25\x84\x10\x30\xc6\xc0\x7b\x8f\
\x8b\xcf\xcf\x77\x5e\xfc\x93\x00\x49\x92\x20\xcf\xd7\xd7\x52\xae\
\x4b\x03\xa5\x14\x52\xca\xb5\xd4\x8c\xa1\x28\x0a\x08\x21\x60\xad\
\x05\x25\x04\xab\xaa\x8a\xf2\x03\xff\x32\x04\x42\x08\x10\xba\x39\
\x59\x4a\x09\x63\x0c\x08\x21\xc8\xb2\x6c\xfd\x2f\x53\xfc\xf0\xf5\
\x7e\xbb\xdf\x0a\x10\x62\x5c\x96\x25\x16\xcb\xf5\x8e\xa4\x94\xa8\
\xeb\x1a\x94\x52\x50\x4a\xa1\x94\x82\x10\x02\x94\x52\x58\x6b\xf1\
\xe2\xfc\x0c\x5a\xeb\x0d\x5f\x41\x81\x6d\x4d\x6f\xab\x02\xde\x7b\
\xf4\x7a\x3d\x74\x8b\x67\x3b\xed\x84\x12\x82\xf7\x93\x15\x00\xe0\
\xb4\x90\xe8\xa6\xff\xb8\xde\xb6\xf8\x56\x80\xa0\x80\x31\x06\xab\
\xba\x41\xd3\x34\x60\x8c\x81\x10\x02\xce\x79\x94\x3f\xd4\x83\x34\
\x4d\x51\xd7\x35\x6e\xa7\x53\x30\xc6\xf0\xdd\xab\x73\xe4\x09\xdb\
\xf0\xb9\x33\x80\x73\x0e\xce\x39\x54\x55\x85\x72\x3a\x43\x9a\xa6\
\xa8\xaa\x0a\x8c\x31\x30\xc6\x60\xad\x45\x92\x24\x50\x4a\xa1\xaa\
\x2a\x9c\x9e\x9e\x42\x29\x05\x4a\x29\x9a\xa6\x81\x31\x26\x86\x83\
\x10\x02\x4a\x29\x9c\x6b\xaf\xa4\x4f\x2a\x90\xe7\x39\x52\x99\x45\
\x28\x4a\x37\x5b\x87\x52\xea\xfe\xb4\xe4\xf1\xde\x6f\xd3\x1a\x9d\
\x54\xa0\xd7\x49\x1e\xf8\xdb\x1b\x40\x6b\x0d\xa5\x4d\xbc\x16\x42\
\x40\x29\x05\x29\x25\x9c\x73\xb1\x32\xd6\x75\x1d\x41\x00\xa0\x2c\
\x6b\x7c\xf1\x3c\x83\xf7\xe2\x81\xcf\xbd\x00\x9c\x73\x50\x4a\x61\
\x52\x4e\xc1\x39\x87\x10\x22\x2e\x04\x00\xab\xd5\x2a\x16\xa0\xa0\
\x4c\x28\xc7\xd6\xda\x18\x86\x10\x82\x83\x4e\x41\x96\x65\x10\x49\
\xda\x3a\xde\xed\x76\xb7\xce\x23\x84\xe0\x43\x59\xe3\xcf\x85\xc2\
\xcb\x7e\x8e\x93\x4c\xb4\x3e\xbb\x15\x20\xc8\x3b\x9b\xcd\xa0\x8d\
\x8d\x27\x22\x4d\xd3\x38\xd6\xed\x76\x31\x9d\x4e\x63\x7f\x08\x21\
\x32\xc6\x20\x49\x12\x4c\xef\x13\xf9\xb3\xe2\x25\xbc\xe4\x5b\x93\
\xb0\xf5\x85\x24\xe4\x40\x28\x34\x42\x88\x18\xff\x20\x65\x38\x92\
\xc0\xba\x33\x86\x02\xc5\x39\x87\xd6\x1a\x9c\xf3\x98\xfd\x07\x25\
\xa1\x73\x0e\x49\x92\x80\xb2\xf5\x23\xd6\xda\xb8\x58\xb0\x8f\xc3\
\x10\xba\xe2\x1f\x1f\xde\xe1\xe2\x6c\x80\x5e\xbf\x07\x00\x90\x82\
\x45\x88\xbd\x00\xbc\xf7\x58\x2e\x97\x50\x7a\x9d\x64\xab\xd5\x6a\
\x23\x0c\x42\x08\x10\xb2\x7e\x51\x19\x0c\x06\x51\x95\x6f\x5f\xbd\
\x80\x10\x62\xc3\xdf\xce\x00\x61\x92\x10\x02\xce\xaf\x3b\x60\x9e\
\xe7\x31\xc1\xc2\xf1\xb3\xd6\x82\x10\x12\x63\xef\x9c\x43\xb5\x5c\
\xa0\xaa\xaa\x07\xea\xb4\xd5\x8f\x27\x01\x42\x25\xfc\xe6\xe2\xf9\
\x93\x75\xbc\xcd\xaa\x81\xdc\x68\xbf\xc1\xdf\xce\x00\x41\xb2\x8e\
\xd8\xff\xa5\x39\x4f\x9e\x45\x1f\x8f\x7d\xee\x0d\x70\x4c\xdb\x19\
\xa0\x28\x0a\x6f\xad\xad\xb7\x49\x76\xa8\x59\x6b\xeb\xa2\x28\x36\
\x28\x36\x00\x46\xa3\x91\xb9\xbe\xbe\xfe\x71\x32\x99\xbc\x76\xce\
\x1d\xe5\xc3\x85\x52\xea\x6e\x6f\x6f\xdf\x8c\x46\x23\xf3\x78\xac\
\xf5\xeb\x18\xf8\xef\x3e\xcf\xff\x06\x58\x83\xac\x48\x6e\x20\xe6\
\xfb\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x19\x75\
\x00\
\x00\x61\xea\x78\x9c\xed\x9c\x7d\x58\x52\xd9\xd6\xc0\x31\x2c\xad\
\xf1\xb3\x9a\x26\x95\x34\xcd\x32\x6f\x29\xa9\xe5\x47\x21\x54\x36\
\x95\xe3\x07\xf7\xde\x66\xa6\x26\x3f\x98\x46\x1d\xc7\x31\x45\x31\
\x15\x03\xc1\xcc\x34\xd3\xb2\xb4\xd4\xc2\xa4\x9a\x9b\xce\xdc\x29\
\xad\xcc\x30\x3f\x00\xa5\x22\x72\x8c\x8c\x99\x48\x51\x3e\x42\x45\
\x43\xe5\x28\x2a\x20\x28\xef\x11\x6b\xee\xbf\xef\x9f\x73\xdf\x17\
\x9f\x87\xc7\x7d\x60\xed\xdf\x5a\x7b\xed\xb5\xf7\x5a\xe7\x79\xf6\
\x39\x85\x7f\x0f\x3f\x60\xb9\xc2\x7e\x05\x04\x02\xb1\x0c\x3e\xb8\
\xef\x9f\x10\x88\x59\x3b\xf8\xb9\x6a\xbe\x0c\xfc\xe6\x24\x34\xfd\
\x13\xf0\x9f\x69\xda\xde\xe0\x2f\xcd\xc1\x3f\xa2\x79\xec\x59\xf0\
\x7a\x79\xca\xc1\x6f\xd2\x20\x10\xcf\x0d\x0b\x1f\x13\xfc\x6d\x54\
\x06\xf8\xa5\xdd\x89\xcf\x8f\x9c\x38\x84\xfd\xfe\x44\xe6\x31\x5c\
\x1c\x24\x33\x33\xd3\x33\x21\x39\x31\x2d\xe6\x58\x4a\x9c\x27\x16\
\x17\x4f\x19\x47\xd8\x43\x20\xeb\x21\xc1\xfb\xf6\x7c\x89\xaf\x1a\
\xed\x17\xe0\x04\x6f\x1f\x9f\xe9\x5e\x0e\xac\xef\x19\x73\x55\xe8\
\x6f\xec\x4a\x8a\x70\xb9\x0f\x87\x54\xda\x7c\xde\x3b\xfe\xa5\xdb\
\xa3\x9a\x67\x3f\x1f\x5d\xfa\x4f\xb3\xd2\xc3\x9e\x9f\x22\xf5\x89\
\x96\xbc\xed\x4b\x21\x8b\x7f\xf6\xc5\x8c\x59\xe8\x87\x36\x53\xf4\
\xb9\xa9\xd9\x62\xf3\x46\xbe\xb9\xd5\x62\x6b\xb7\xa5\x2d\x6c\xb1\
\x95\x63\xef\xe2\xff\x41\x72\xc7\xbe\x94\x0f\xad\x1f\xcf\x8a\x3f\
\xb4\x7e\xb7\x69\x37\x59\x6c\xfd\xec\x9c\xfb\x01\xf9\xf7\x20\x23\
\xd0\x08\x34\x02\x8d\x40\x23\xd0\x08\x34\x02\x8d\x40\x23\xd0\x08\
\x34\x02\xff\x5f\x00\xef\xeb\xff\x70\x82\x88\x3d\xec\xf2\x8f\xa9\
\xff\xa0\x1a\xbe\xc4\x53\x6b\x12\xae\x91\xa6\xe3\x21\xf8\x4f\x96\
\xe9\xa3\x97\xf4\x65\x6e\x38\x29\x2a\x12\xbf\x33\xf0\x80\xcc\xa6\
\xcf\x92\xa3\xb3\xa3\x56\x9b\x35\x85\x99\x9a\x35\x4d\x5e\x07\xb2\
\xb3\xdb\x48\x3a\x5a\x76\x9e\xbe\x23\x71\xc9\x82\x04\x96\x7b\x22\
\x3d\x10\x13\x48\xa5\x9e\x0d\x84\xc0\x41\x85\x0e\x87\x4d\x88\xcf\
\x3b\x81\xec\xb6\x52\x7e\x7b\xef\xbf\x16\x21\xd4\x26\x2b\x5f\x01\
\x84\x1e\xf5\x78\x42\xfd\x87\xe2\x13\x29\x93\xb0\x29\x17\xba\xd5\
\xd7\x84\xe8\xf0\x98\xdd\xa5\x1c\x93\x3a\x2d\x4d\xed\x76\x58\x10\
\x54\xff\x9a\x7c\x66\x2c\xcd\xb3\x9b\xa0\x55\x47\xc3\x18\x73\x1d\
\xb9\x36\xc0\x05\x10\xf9\xd8\x8e\x49\xeb\x26\x44\xbe\x49\x56\xaa\
\xa3\x57\xa3\x4d\x0d\xc3\x13\xd7\x5f\xad\x73\xc4\xf2\x35\x66\xf2\
\xda\x20\x35\xcd\xcf\xa6\x20\x07\xa7\xc5\xcc\x99\x40\x48\x8d\x0a\
\x53\x60\x07\x51\x14\x91\x68\x2a\x1a\x54\x2c\x17\xbf\x0b\x58\x90\
\x6e\xc5\xf0\x23\xae\x63\x83\x54\x09\xdf\x70\x29\xec\xda\x41\x19\
\xf7\x70\xbd\xd7\x80\x99\x33\xb1\xcd\xed\x6f\xf9\xd0\xbb\xfb\x52\
\x72\x7a\xd2\x21\x98\x20\x15\xa9\xc1\x4a\x20\x63\xc7\xfa\x45\x2d\
\x51\xdb\x3f\xa1\xd5\x67\xca\x03\x0d\x3e\x7b\x94\x1c\x76\x8a\x5a\
\x30\xa0\x9b\x8e\xd3\x91\x9a\x9b\xeb\x54\x3e\x68\x8d\xb5\x5b\xc7\
\xd3\x94\x1b\x57\xcc\xad\x5a\x13\x29\xee\xc0\x40\x06\x04\xf5\xfd\
\x05\x11\xdb\x95\x1d\x83\xab\x2a\x97\xc9\x34\xda\x96\xb9\xef\x8b\
\xa6\xdc\xed\xe6\x3b\x50\x77\x6e\x19\x7c\x70\x51\xa6\xf1\xb6\x0c\
\x81\x90\xc3\x5f\x1e\xc2\xf5\xba\x71\x59\x2b\xe9\xd4\x21\xf5\x5c\
\x7a\xc3\xb3\xc8\xef\xd4\x69\x9e\xce\x88\xac\x6c\x45\x77\xac\x3f\
\x50\x07\x0e\x97\x46\xdb\x83\x81\xaa\x59\x0f\x1c\xad\x39\xd2\x80\
\xac\xd0\xc9\x7b\x11\xef\xd4\x4d\xa6\xca\xfe\x49\x82\xf4\x7c\x52\
\x77\xe6\x61\xae\xa2\x15\x65\x70\x6b\x78\x55\x34\xf2\x7a\x86\x92\
\x5f\xe3\xca\x0b\x08\x70\x2a\xe5\x25\x58\x89\xd1\xb5\x01\x24\x72\
\x80\x2b\x95\x5a\x0a\x7f\x0c\xfb\xc3\xbf\x8e\x41\x15\xf0\x06\x38\
\x63\x9b\x49\x7e\x27\xac\x59\xdb\xcc\x25\xbb\xa1\xb6\xb0\x6f\x1f\
\x9d\x17\xcb\xcb\x65\x6c\x57\x6b\xf6\x80\xf4\xe1\x9d\x7e\x62\x36\
\xac\xdc\x06\xe9\xe9\x4c\xac\xa2\xed\x77\x62\xc7\x36\x59\x49\x5a\
\x14\xad\x23\xae\x39\x0b\x81\xc7\x6c\x49\xcb\xe6\x02\x55\xa1\x52\
\xef\xa5\xa4\x6a\xbe\xf2\x22\x82\x5a\x56\x2f\x85\xd1\x19\x55\x65\
\x64\x45\x19\xaa\x20\x56\x75\xe2\x71\x3d\x3e\x51\xae\x4c\x4b\x6e\
\xb1\x7a\xe7\x17\x43\xb3\xb1\xda\x0e\x86\x5a\x34\xfa\x94\xe2\xc1\
\xf1\x2c\x52\x28\x72\xab\x89\xce\x29\x66\x32\xe1\xe0\xfc\xdb\x8d\
\x4e\x05\x03\xac\x4a\xc4\x68\x19\xeb\x22\x2c\x23\xcd\x1c\x54\xb4\
\xb6\x1c\xe5\xc2\xee\x9c\x16\x12\x0c\x71\xa4\x78\xa5\x99\x4e\xbf\
\x56\xee\x0e\xf0\x56\xb6\xd7\x0e\x8c\x04\x68\xbc\x37\x91\xab\xcb\
\xc8\x6e\x01\xd5\x43\x75\x3e\xb0\x52\x84\x47\x37\x02\xce\x5d\x22\
\xda\x3f\x91\x64\x41\x9d\xdc\x49\x12\x9d\x97\xec\xf5\x07\xde\x14\
\x8a\x99\x2d\x8d\x55\x69\x0d\xd7\x7b\xa3\xa1\x6a\x64\x9a\x29\xb9\
\xb2\x94\xed\xae\xd9\xfe\xd2\x56\x47\x0d\x9a\x2c\xe9\x87\x75\xa0\
\x8a\x39\x05\xfd\x08\x5b\xd2\x5b\x8f\x88\x5b\x70\x67\x62\x24\x66\
\x6b\xd6\x57\x2d\x4f\xb1\x86\xb8\x97\xbd\x69\x26\xbe\xa4\x9d\x0b\
\xbc\x3e\x94\xee\x58\xc6\xcb\x12\x2e\x9b\x4b\x2c\xe5\xd6\x0e\x70\
\xdd\xb3\x60\xb2\xeb\x5b\xd8\xbc\xc1\x8d\x2f\x29\xe9\x2f\x6e\x6b\
\xee\xc0\x51\x43\xd3\x5f\xaa\xdb\xd6\x7a\xe6\x41\xbf\x02\x83\x85\
\x1f\x9f\xab\x28\x85\x59\xa5\x99\xea\x9b\x42\x49\x64\xfb\x52\xf2\
\x78\x29\xf9\x3c\xa7\x36\x6a\x32\x81\xb1\x0f\xc8\xc6\xbd\x75\xd3\
\xce\xad\x64\x56\xac\x25\xf9\xe4\x96\xdc\x5f\xba\xd3\x10\x7f\x07\
\x68\x33\x5b\xa8\xde\x7c\xb9\x72\x25\x93\xcb\x99\xaa\x42\xa0\xdc\
\xb8\x9d\x1a\x11\x18\x54\x7a\x6f\xf4\xa9\x92\xce\x40\xf6\x48\x55\
\xd5\x4c\x27\xd7\x03\x9e\xfa\x62\x63\x31\xfc\x40\xb1\xdb\x63\x32\
\x1c\xb7\x30\xc4\xbf\x07\x9b\x9a\xe1\xd7\x31\x19\x61\xa0\xca\x02\
\x2f\xcd\xbd\xe3\xa7\xe7\x13\x50\xe8\x5c\x7d\x62\x05\x71\xa7\xab\
\x13\x18\x21\xc7\xac\x86\xb4\x73\xde\x96\xf4\x90\xfc\x7e\xa2\x2f\
\xfe\xd1\x4f\x43\x4b\x0c\xf1\xd6\x8a\xe5\x13\xae\xd4\xf3\x65\x1b\
\x73\x51\x6e\xb2\x7a\x4e\x42\x28\xdd\xaa\xf3\xeb\x61\xb4\xb2\xed\
\x85\x57\x45\xf0\x44\xed\x6f\xf1\x79\xe4\xae\xd6\xea\xb4\x42\x89\
\x60\xbc\x21\x69\x8c\xe6\x02\xce\xdc\xef\x2b\xdb\x4d\xbe\x87\xef\
\x55\x7b\xf5\x50\xe1\x11\xb7\xc8\x6b\xcb\x4a\x3a\x67\xd9\xc7\xac\
\x24\x7a\xe2\x11\x17\xb5\x57\x80\x63\xe9\x9c\x57\xcf\xba\xd2\x54\
\xd4\x01\xa0\xf1\x67\x6b\x79\x11\xb6\xde\x4f\x68\x58\xb5\x9b\x1f\
\x79\xbc\x96\x2b\xe3\x56\x20\xc0\x91\x5d\xae\xa2\x96\x2a\x91\x59\
\xb3\xa5\x08\x6b\xe5\x6a\xb5\x97\x52\x1c\xfe\x52\x59\x42\xce\xfe\
\x02\xe9\xa6\x41\x6c\xc4\xcc\x70\x64\xb2\x80\x73\xf5\xa7\x03\xf9\
\xf1\xa7\xac\x1f\x4f\xcd\x38\x3d\xfe\xac\xd3\x44\x08\xb3\x85\x89\
\xe3\x20\x4e\xa5\xc5\x3c\x9d\x42\x4a\x0a\xb5\x0a\xc2\xf5\xb9\x95\
\xb4\x04\x9c\x24\xf7\xb9\x91\x61\x65\x28\xc7\xa1\x69\xf5\x45\x04\
\xac\x6c\x2e\xc6\xdb\x11\x6e\x4b\x7c\x1b\x37\x2f\x3f\x91\x35\xf1\
\x99\x97\x61\xe7\xc3\x63\x1e\x4d\x10\x08\x37\x54\x2b\x99\xca\xcb\
\xa1\x98\x32\x9e\x6c\x20\x2b\xb4\xfa\x59\x2c\x6a\xab\xec\x24\x5a\
\x19\x20\xc1\xd4\x0c\x28\xfd\xa9\xb6\xf3\x0a\x1e\xec\xb9\x93\x37\
\xfa\xb4\x42\x89\x8b\x98\x92\x75\x09\xee\x62\x19\x51\x82\x92\xf4\
\x75\x74\xcc\x99\x14\x9e\x98\x19\xb1\x21\x17\xaa\xe8\x4f\x99\xc6\
\x07\xbe\x24\xd0\x30\xf3\xaa\x01\x64\x80\xa7\xb3\xee\x98\x1f\x96\
\x3c\x2f\xa9\x24\xe2\x23\xdf\x14\x0c\xa8\xb7\x1d\x00\xfa\x83\xbc\
\x1d\x4b\x25\xf7\x0a\xc5\x31\xd1\xe8\x5c\xc1\x9a\x75\x0b\x06\x08\
\x2b\xc6\xbe\x1e\xa6\x34\x30\x95\xdb\x0f\x00\x23\x21\xb8\xf9\xd2\
\xd0\x96\x10\x88\x53\x4d\xec\xd1\x25\x6a\x5e\x40\x56\x55\xf9\xf4\
\x76\xeb\x31\x44\x95\xcc\x86\xf4\x9c\xd8\xbf\x1f\xd8\x91\x2c\x7b\
\x9f\x44\x3b\xf4\x4e\xa0\x48\x4a\x8e\xda\xe4\x65\x6b\xd5\x9a\xea\
\xe2\xcf\x1c\x8d\xa8\x25\x1d\xcc\x90\x65\xd9\x13\x69\x21\x19\x31\
\x0f\x44\x1b\x0b\xfa\x5b\xc7\x34\x13\x17\x61\x25\x1c\x56\xd0\x24\
\xe0\x9c\xa5\xf6\xaf\x9f\x8b\x79\x40\x08\x7d\x56\x10\x90\x1b\x4f\
\xd5\xda\x7e\x18\x7a\x1d\x17\x8a\x29\x9a\x3e\x34\x34\xd7\x55\xa2\
\xfc\x7a\xb8\xd6\xab\xc7\x52\x39\xc7\x19\x41\xa0\x4f\x91\xb3\xab\
\xcd\x4e\x38\xbe\x0c\x51\x3b\x96\xb1\xdc\x7b\xd0\x4a\x1b\xae\x44\
\x83\xdb\x85\xa3\x86\x0c\x23\x3d\xf8\x72\x8f\x6e\xec\x53\x20\xc2\
\x59\xb7\x74\x61\xe4\x2e\xb9\xd0\xd6\xe3\xbf\xb3\xbc\x6f\x07\x8e\
\x96\xa6\x16\x8a\x45\xdf\xa9\x91\x3d\x4e\xa5\x2c\xaf\x00\xc4\xa6\
\x02\x6b\x8e\x24\x06\xa7\xde\xd0\x43\x0e\x7d\x56\xa2\x2c\x1f\x66\
\xc5\x0c\x91\xbf\x65\xc7\x1e\x39\xd0\x49\xc3\x9a\x1a\x62\x0c\x2e\
\x18\x7b\xc5\x37\x9f\xaf\xca\x82\x2b\x0b\x62\x67\xab\xaa\x32\xd3\
\x20\xe4\x6b\xa5\x23\x97\xab\xc2\x39\x4a\x25\xa2\x32\xcd\x7f\x23\
\x5b\xa6\x51\x3f\x63\x55\xc2\x6a\x07\x24\x0f\x61\xf2\xca\x2c\x7b\
\xdd\xbd\x2c\x4d\x22\x6b\x48\x2e\xdb\x2a\xb8\x23\xd2\x9c\x95\xaf\
\x6e\x4a\x48\x11\x77\x2d\x46\x1e\xde\x73\x0f\x11\x26\x6b\x14\xc0\
\xbd\x88\xd4\xd1\x0b\xca\x37\xb2\x16\x6b\xce\x78\xcc\x03\xed\x06\
\x3b\xfd\x91\x3a\xeb\x10\x53\xd4\x80\xf7\x72\xba\xa5\xe4\xd1\xde\
\x85\x44\x98\xa3\x4a\x20\xac\x51\xef\x5c\x3a\xbf\x83\x43\xe5\x3c\
\x64\xe4\xbd\xef\x0f\x08\x40\x6d\xd4\xd6\xc6\xaa\x2e\x8f\x32\x36\
\x69\xe3\xd8\x2f\xe6\x46\x56\xb6\xd2\x26\x08\xe7\x25\x2a\x17\x75\
\x9b\x38\x1b\x4b\x98\xa2\x84\x9e\x86\x62\xcf\x98\x5b\xa5\xdc\x7f\
\xa6\x18\x85\xf3\xc4\xac\x4a\x0b\x16\xae\x9f\x1b\x4f\x2a\x61\x77\
\xcd\xde\x0b\xcd\x21\x5f\x0b\x52\xab\xfd\xb1\xbf\x54\xc7\xd0\xc3\
\x4e\x93\x05\x2b\xa3\xe6\x96\x7d\xd0\xb4\x59\x15\x00\xc6\xf3\xa1\
\x52\x78\x70\x86\x32\xf0\xf9\xf4\x1d\x60\xa2\x13\x71\xdc\x87\x44\
\xb7\x90\x8d\x56\x24\xbd\x56\xb1\x70\xd7\xcb\x63\x60\xe8\x0a\x9f\
\x76\xea\x10\x86\xdc\x4d\xaa\x2b\x20\x7f\x2d\x1b\xd4\x64\xb8\x10\
\x9b\x67\x03\x41\x37\x53\x36\x82\x6e\x9e\x79\x67\xdd\x91\xb0\x5c\
\xdc\x12\x62\xee\x34\xc3\x49\xa9\x8a\x51\xa5\x84\xe6\x5b\x2b\xa7\
\x54\x80\xe4\x01\xfd\x73\x20\xdd\x1e\x61\x6b\x48\xd2\xe2\xb6\xde\
\x0b\xd1\xf5\x11\x37\x51\x71\xf4\x02\x7f\x57\xde\x65\x8b\xda\x58\
\xb5\xb7\x28\x13\x86\x72\x63\x1d\x43\x3e\x98\x10\x24\x5f\x09\x7a\
\x40\xf1\xa4\xad\xb3\xe6\xc9\x7f\x01\x0e\x79\xb6\x65\xcb\x2f\x0b\
\xde\xac\xad\x6e\x6d\xcd\x76\x27\x42\xb1\xd7\xc0\xd1\xb1\x93\x0b\
\x25\x9d\x4e\x95\xac\x7b\x79\x40\x7a\x52\x8c\xfa\x58\xa1\x98\x72\
\x25\xc6\x33\xe2\x16\x56\x75\xc4\x50\x42\x08\xa9\x09\x0d\x6f\xee\
\xbe\xca\xec\x54\xbd\xe1\x00\x70\x8a\xf6\xbc\x36\x20\xa7\x5e\xe5\
\xc6\x4e\x5f\x42\x8c\xcc\x55\x55\xc2\x5e\x56\xa8\xdb\x02\x1d\x74\
\x55\x9d\xab\x55\x6d\x25\xa5\x5d\x5c\x8b\xc3\x28\x7d\x7f\x43\x7b\
\x52\xa1\x55\xeb\x52\x30\x5c\x9f\xfe\x8a\x5a\xe1\xb7\xaa\x8f\x95\
\xb2\x5c\xf2\x0d\x7f\x56\xb4\xb5\x84\x22\x67\x7d\x9f\xe4\xd6\xfe\
\xb9\x21\x31\xe3\x19\x8f\x04\x37\xa9\xb8\xc7\x58\xff\x38\x2b\x31\
\xe5\xd2\xf8\xb1\x34\x4c\x6a\x60\x5d\x6a\x24\x7f\x3b\xb6\x90\x7e\
\x5e\x28\x68\x68\xe7\xf7\xbf\xa9\xfd\x95\x46\x57\x5d\x7a\x23\x4f\
\x91\x79\x31\x29\xae\xb9\x50\x1d\xb3\xe9\xb1\x27\x79\xce\x52\x1e\
\x20\xa2\xe5\xaa\xa7\xbd\x97\x1b\x0a\x9c\x48\x74\x6e\xbd\xf4\x8f\
\x44\x88\x08\xfb\xe6\xe4\x76\x69\xba\x29\xb5\xdc\xa3\xdb\x07\x5b\
\x44\xef\xec\x84\x90\x8e\x44\x27\x53\x2b\x64\x44\x8c\xd9\x84\x7c\
\x47\xb2\x23\x86\x6a\x32\x1e\x9a\x22\x0e\x5b\x88\x23\xd5\xec\xd4\
\xc5\x56\x0b\x49\x88\x05\xc3\x4a\xc2\xf2\x3d\xa7\x50\x7a\x5f\xa4\
\x98\x2e\x46\x4c\xd2\xae\xe5\xd5\x83\xcd\x85\x42\xf8\xb8\x4f\x9d\
\x6a\xbd\x5f\xe2\x6f\x20\x28\xd1\x61\x4a\x3e\xf6\x8a\x86\x6d\xa9\
\xeb\x1f\x8a\xb1\xf0\x7b\x33\xed\xfb\x9e\x1f\xf1\x13\x17\x7d\xbc\
\xd0\x4a\x37\x04\x6e\xf6\x82\xe8\xe9\xf7\x49\x4f\x84\xf3\x5f\xf9\
\x27\xd7\x09\x36\x2e\x56\x63\xbf\x8e\xfd\x9c\x8e\xeb\x59\x93\x4d\
\x40\xa7\x12\x18\xa9\xfd\x57\x70\xd7\x6a\x99\x7c\x9b\xf9\xef\xd6\
\xc4\x7f\x61\xc5\x03\x99\x47\xdf\xf8\x12\xa9\xca\x93\x93\x84\xd6\
\xd9\xde\x74\x73\x33\x3c\x0f\xe4\x30\x7e\x50\xf2\xc5\x29\x5b\xce\
\xe9\x7f\x30\x14\x5d\x0a\x7e\xc9\xb8\x53\x78\x27\x6b\xcc\x15\x3f\
\xb4\x16\x19\xdb\xb3\x32\xb0\xc2\x64\x72\xcc\xf3\xbd\x3c\x63\xb8\
\x20\xf2\x9d\x6a\x67\x0a\xdd\xf2\x5d\xa2\x29\xc3\xcf\x12\xcc\x39\
\xd8\x6a\x73\x2b\x20\x6d\x7c\x46\xce\x58\xc9\xfc\xe0\x64\xd1\xfc\
\x69\xc2\x59\xd6\xc3\x3c\xf9\xc8\x83\x89\x81\xe6\x8d\xb3\xbe\xf9\
\xf5\xfc\x74\x7b\x22\x38\x6b\x0f\x89\x58\x07\x26\xf6\x0c\x20\x2f\
\xd1\xf4\xdb\x24\x87\x9c\x10\x67\x82\xc5\x96\x4e\x8c\x30\xf4\xcb\
\xc1\x88\x9b\xcf\x63\x69\x41\xa2\xe4\x22\x3a\x28\x2b\xf8\x7a\xe4\
\x2a\x54\x35\xab\xdb\x99\xa3\x7f\xb2\x7b\xb6\xab\xa1\xdd\x44\x98\
\x37\x71\x98\x0c\xc9\xf1\x13\x9f\xe4\xa7\x19\x3a\xe8\x6b\x9c\xaf\
\xd2\xf6\x63\x68\x07\xa8\xbe\xb6\x84\xe6\x27\x63\x49\x36\xa0\x5b\
\xa5\x7f\x48\x15\x4b\x81\x27\x6d\xe8\x1b\x67\x41\xcb\x7a\x4b\xe6\
\xdf\x3a\x8c\x23\x96\x19\x2a\xb8\x88\x50\x0a\xa1\x84\xb7\x29\x1a\
\x0d\x3f\x3d\x73\x57\x9d\xbd\xee\xb9\xe2\x6e\x84\x89\x8e\xb0\xa7\
\xaf\xed\xef\xe2\xae\x8f\x55\x28\x09\x0d\xdf\x3b\x3d\x75\x32\x64\
\x4a\x3e\xfd\x93\x7a\xce\x87\x7d\xa9\xa8\x9f\x49\x71\xfb\x50\xe9\
\xea\x90\x75\x1b\xa6\xda\xbe\x9d\xf3\xe9\xd6\xc6\x43\xfd\x77\x7f\
\xfa\xa1\xc4\x15\xab\x1e\x5e\x7f\x29\x7c\xa6\x90\xdf\x9b\x6b\x98\
\xd0\xce\x6a\xda\x54\xd0\x05\xbf\x2e\x56\xbf\xa2\xce\xb6\x31\x8e\
\xe2\x29\x40\xbd\x3e\x3b\x2f\x94\x2f\x17\x2f\x14\xc6\x62\x94\xd4\
\x7a\xaf\xa1\x27\x39\xae\x72\xdc\x4c\xbe\xe3\x24\x06\x9d\xaf\xdf\
\x9c\xa7\x1f\x76\x94\xa5\x6f\x35\xc3\xfb\xfc\xd9\x59\x94\xfe\x24\
\xba\x96\x4e\x13\x69\x7b\x1a\xb3\xbb\x9c\xda\xdc\x98\x94\x0d\x1f\
\x6d\xa9\xa9\xe9\x5c\xad\xfe\xf1\x08\xa3\x9a\x4a\x99\xa1\xef\x98\
\xce\x4e\x0c\x99\x22\x70\x17\x53\x96\x5b\xe8\x3c\x60\x90\x9a\x67\
\x27\x3f\x51\x28\xce\x8c\x47\xa0\x2a\x14\xc4\xfe\xb9\xf0\x1b\xe5\
\x1f\xea\x73\x20\x3f\x14\x65\xf5\x96\x3c\x38\xaa\x88\x60\x98\x01\
\x35\x85\x1f\xaa\x71\x2c\xf7\xee\xab\x6c\xf8\x77\xfa\xd0\xbe\x35\
\xcc\x53\x1f\xeb\x76\xa6\x60\xa2\xe1\x66\x84\x7a\x99\xd0\x03\x44\
\x63\x27\x57\x45\xd8\x18\x5c\xa5\xfb\x42\xf5\xf2\x13\xb3\x9f\x5d\
\x3e\xd8\x73\x42\xb3\x25\xe2\x36\xf4\x77\xdb\x8f\x7e\xbc\x39\xe2\
\x56\xdb\x50\x9f\xf1\x13\xac\x86\x5f\xd6\x5f\xd3\x6a\xe2\xf2\xe7\
\xdd\xc2\xbe\xbf\xe8\xed\x87\x11\x68\x04\x1a\x81\xff\x77\x80\x80\
\x7e\xb4\xe7\x94\x05\x78\xc5\x5c\x4f\x96\x13\x88\xb7\x6d\x17\x7e\
\x61\xe6\x7f\x54\xf0\x6d\xd0\x47\xa5\xf7\x9c\x3f\xf6\x7b\x7b\xf1\
\x23\xeb\xf8\xc1\x8f\x7c\x5f\xd7\x8f\x3a\x1d\x56\x7e\xb4\xc3\x72\
\xf9\x07\xdb\x8c\x38\x23\xee\xbf\x0f\x37\xe7\xd8\xdb\xf5\xf1\x2c\
\xc0\x5f\xdb\x52\x23\xce\x88\x33\xe2\x8c\x38\x23\xce\x88\x33\xe2\
\x8c\x38\x23\xce\x88\x33\xe2\x8c\x38\x23\xce\x88\x33\xe2\x8c\xb8\
\xbf\x2e\xce\x86\x90\xb1\x7e\x01\xb2\xed\xb9\x68\xd6\x11\x93\x60\
\xfa\x97\x36\xd6\x88\x33\xe2\x8c\x38\x23\xce\x88\x33\xe2\x8c\x38\
\x23\xce\x88\x33\xe2\x8c\x38\x23\xce\x88\xfb\x3f\x8f\xfb\x4e\xfa\
\xcd\xc4\xc7\xb3\x00\x7f\x6d\x4b\x8d\x38\x23\xce\x88\x33\xe2\x8c\
\xb8\xff\x05\xee\xe7\x36\x42\x44\x38\x8c\xd3\xb1\x6d\x36\xed\x5e\
\xa2\x50\x1f\x55\xdb\xb9\xcc\xb5\xeb\x8c\x6b\x59\xf9\xd3\x5f\x5a\
\xe2\x6b\x7a\xee\x7c\x7a\x73\xf7\xb7\x9f\xce\x7c\x75\x26\xb7\xe4\
\xfa\xf2\x85\x4e\xbb\xed\xfe\x3c\x5a\x19\xf7\xe7\x81\xca\xcb\xff\
\x39\x97\xf9\x9f\xd3\x98\x46\x41\xa3\xe0\x7f\xbb\xe0\xa8\x5e\x44\
\x86\x30\x1b\x1c\xc6\x11\x0b\x97\x39\xfc\x74\x85\xec\x2c\x32\xc4\
\x54\x2d\xdf\x97\x92\x63\x36\xcd\xeb\x16\x5e\x6c\x4e\x35\xbc\xf0\
\xa8\x2e\xcb\x35\x47\x7b\xdc\x56\x5c\x6f\xdb\x6e\x32\xbe\xbd\x40\
\x31\xa0\xb5\xfc\x41\x84\x78\x74\xa0\x42\x59\xbd\x2a\xa8\xb4\xeb\
\x84\x01\x57\x5f\x3b\x87\xb8\x4f\xb9\x30\x18\x7f\x2e\xa8\xce\x5a\
\x02\x49\x71\xb2\x85\x89\xad\x94\x96\xdf\x13\x94\x01\x03\xc4\x86\
\x9d\xa2\x7b\x2f\x65\xb5\xae\x2d\xba\x62\x83\x75\x4c\xf9\xd1\xfd\
\xc0\xa1\x37\x28\x4c\x64\x3e\xe0\x9b\x0f\x4d\xa1\x98\x5b\xa5\x04\
\xa1\x02\x3d\x2b\xd6\xbf\x5f\xc3\x4e\xd8\x79\xc1\x4e\x9f\xd6\x1f\
\xce\xef\xf2\xea\x5b\x5c\xe2\xad\x75\x83\xae\x6a\xdd\x37\xef\xee\
\x07\x60\xf6\x4f\x34\xfe\x02\x20\x21\x7d\x2e\xb9\xd0\xc8\x6e\xbf\
\x92\x31\x6f\x59\xe7\x70\x76\x28\xee\xe0\xe4\x55\x2f\x3c\x77\x95\
\x38\x8a\x7e\xc0\xb0\x3d\x88\xd3\x3d\x36\xa8\x75\x57\xdf\xc5\xbf\
\xa4\xfa\xbc\xf4\xd2\x5d\xa6\xf2\xc4\x9b\x3a\x4c\xc6\x37\x80\xbd\
\xb6\x99\x8d\x22\xed\x66\x63\xd7\xd6\xb0\x3d\xed\xc2\x79\xa9\x55\
\x17\xb8\xb1\xea\x2b\x16\x4e\x9a\x15\x62\x8a\x27\x27\xe2\xe5\x3f\
\xfe\xd4\x99\xb1\xb2\x95\x1b\x80\x27\xbb\x6a\x60\xa8\x08\x98\x95\
\x34\x91\x95\xaa\xd3\x79\xf5\x6b\x52\xad\xde\xb1\xb6\xed\x48\x71\
\x86\x89\xbd\xc1\x21\xd6\x3a\x61\xee\xc0\xbe\x76\x51\x6f\x9f\x0b\
\x24\xba\x66\xa1\xf3\xb3\xbd\x8f\x97\x76\x6d\x8b\x4a\x0b\xf5\xd5\
\x16\x3b\x67\xaf\x5a\x3c\xb4\x1d\xdd\x83\xfb\xf5\x69\x56\xaf\x76\
\x03\x47\xa1\xf4\x22\xc6\x56\xd9\x60\x83\xf0\x64\x64\x39\xb6\x07\
\xb9\x64\x1b\xe8\xd3\x97\xf4\x0e\x95\xbb\x9d\xb0\xa6\xb2\x4d\xeb\
\xc8\xd0\x1e\x7a\xed\x54\x36\x7f\x71\x8a\x1a\xac\xbf\x34\xa5\x8d\
\x6d\xb8\x6e\x9f\x59\x71\xfc\x42\xb0\xf0\xd9\x36\x7a\xd5\x12\xbe\
\x61\x3f\x14\x2f\x6d\xb4\x05\x4d\xcb\x25\x7f\x6f\x21\x26\xbb\xb2\
\x9c\x78\xfb\xd4\xec\x87\xb3\x03\xc7\xec\x9f\x5f\xdd\xab\xe6\xbb\
\xe2\x7d\x16\x1e\x4a\xba\x63\xd3\x6e\xb2\x9f\xf5\x4e\x27\x27\x3d\
\x44\xcf\x3a\x8f\x84\x4b\xbb\x9d\xca\xc6\x2b\x4f\x50\x83\x69\x21\
\xb3\x51\xaf\xc3\x56\x2d\x8c\x36\xfe\x81\xe6\x4a\xaa\xfb\xd4\x53\
\x92\x98\xd2\x64\xb7\x30\xd5\x39\x15\x7f\xec\x07\x32\x30\x40\x82\
\x3d\xb1\x72\x2f\x5e\xef\x65\x25\xb6\x28\x48\xd8\x5c\xeb\x10\x84\
\x17\x95\x1c\xd0\xfa\x26\x0a\xce\x68\x2d\x56\xe2\xb3\x5c\xfc\x99\
\x5c\x87\x27\xce\xbc\xb0\xc1\x4d\x23\xf9\xff\x92\x97\x26\x53\xaa\
\x9a\x07\xb6\x2f\x05\x78\x9e\x01\xc9\x65\x73\xbe\x3d\xe1\x21\x6b\
\x2d\xd9\xb1\xca\xea\xe3\x22\x9f\x79\xb3\x5d\x63\x66\xf4\xab\x6e\
\xed\x05\x9d\x65\xe2\x4d\x4f\x16\xcc\xbf\xd1\x34\x48\x17\xd7\x16\
\x6b\x73\xd1\x02\x4f\x2b\x46\x99\x44\x14\xac\x27\x58\x48\xfa\x8f\
\x1d\xbd\x34\x89\x77\x7c\x33\x52\xe0\x9e\xa7\x92\x9b\x20\x8a\xd2\
\xfe\x01\xc3\x07\x83\x9a\x86\xe5\x35\xc0\xc5\x29\x2c\xaf\xc2\x4b\
\x3b\xe1\x6f\xc9\x49\xad\x80\x95\x70\x8e\x51\x88\xc9\xa5\xdc\x31\
\x35\x79\xb8\xce\xc9\x8d\xa9\x3d\xf4\x60\x97\xab\x80\x96\x0a\x07\
\xba\x90\x9c\xef\x23\x37\xcd\x25\xae\x24\x26\x05\x4f\x6d\x39\x66\
\x70\xfe\xe6\x5b\x77\x5f\xa7\x99\x52\x6b\xdb\x51\x3e\xf9\x00\x77\
\x53\x0e\x39\x94\xe5\xcf\x4e\x38\x28\xdb\x8e\x24\x9d\x01\x46\xee\
\xf6\xae\xa5\xcf\xc8\xcb\xeb\x3d\x58\x01\xbb\x41\x6d\xc0\xfb\x72\
\xd1\x05\x5d\xb3\xbe\x2f\x54\x30\x39\x25\x7d\xa2\x92\x5c\x26\x1e\
\x7f\x26\xf5\x91\x4a\x3d\xa5\x4f\xb3\x2b\x46\xad\x39\xe3\x81\x3d\
\x61\x26\xc4\x86\x5d\x66\x40\x58\x0d\x44\x68\xaa\x08\x9b\xdc\x90\
\x53\x24\x31\x2c\xb2\xb7\xde\x79\x99\xbc\xd4\x83\xb8\xaa\x19\x88\
\xbe\xea\xd1\x77\xba\x83\xe1\x05\xa9\xdb\x64\x27\x42\x2f\xcc\xa9\
\xbf\x89\xe3\x53\xf5\xdf\x54\x50\x43\x6e\xd5\x87\x9d\x16\x29\xdd\
\x4c\x2e\x83\xf1\xab\xeb\x0b\xaa\x15\x15\x8b\xee\x20\x92\xca\x58\
\x9b\x02\x2c\x0e\x41\x44\x9b\x18\x7e\x1c\x86\x4f\xdd\x89\xea\x84\
\x5f\xa6\xa4\xee\x59\xbb\x8a\x4d\x88\x34\xf4\x23\xf0\x87\xe3\xd7\
\x36\xf0\xe8\x92\xc7\xb0\x0e\xbe\x4b\xd3\x36\xc3\x52\x3e\xb3\xb5\
\x62\x1f\xf5\xc7\x99\x14\x7b\x5a\x04\x0c\xc9\x1e\xe4\xb6\xb0\x56\
\xb7\x5b\x73\x6e\x86\x5c\xe8\x5f\xdb\x51\xc2\x5a\xcd\x2a\x50\x38\
\xb7\x62\x5a\xa7\x7b\xeb\xdb\x64\x68\xe8\xe6\x3d\xa6\x66\x6b\x1b\
\xfd\xce\xf6\x3b\x07\xb4\x6d\x64\x87\x4d\xf6\x94\x98\xe8\x32\x2b\
\x74\xf7\x83\x49\x96\x1c\x52\x73\xd1\xe8\xac\x57\x0e\x83\xb1\x11\
\xab\x8d\xa5\x39\x94\x8c\x65\xec\xf4\x8d\x51\x0b\x93\x5f\x4e\x10\
\xec\x58\x8c\x25\xea\x17\x0f\x86\x17\x9f\x58\x5e\xdd\xe0\x6b\x29\
\x74\x0b\x5a\xd5\x01\x46\xe8\xba\x32\x5e\x82\x4e\x37\xf1\x6a\x23\
\x35\x0a\x57\xe9\xa2\xf6\x92\x76\x4f\x8b\xa0\x78\x06\x5e\xbb\x35\
\x9a\x30\xc0\x85\xe2\x7f\x04\xe7\xcd\x25\x27\x3e\x72\xd9\x5c\xe5\
\xc8\x10\x8e\xa2\xbb\x1f\x26\x6c\x19\xf0\xe0\xad\x1c\xe6\xd1\xb6\
\x5a\x47\x4d\xa6\x7e\x41\xba\x5e\x4a\x8b\x7a\x20\x2a\x59\xf5\xae\
\x25\xe9\x81\xa0\x4a\xaa\x4a\xbe\x20\xb1\xa3\x62\x95\x3e\x79\xfa\
\xca\x65\xb4\xc3\x06\x85\xbf\xf3\xbe\x7e\xaf\xa9\xac\x6d\xd7\x7a\
\xe5\xa8\xfa\xf1\xbf\x75\xde\x70\x0a\xe7\xc8\xb6\xad\x9b\x6b\xc2\
\x0d\x7a\x49\x65\x95\x9d\x71\xdd\x15\x9d\x3f\xc1\xc9\xe9\xda\x66\
\xb1\xe5\xe5\x8d\xb9\x50\x22\x43\xa3\x5d\x21\x61\x0f\xdc\x43\x23\
\x67\x07\x4a\x5c\xb1\x82\x58\xd1\xf9\x63\xcd\xa2\xf3\xa2\x26\xdd\
\x70\x19\x26\x6a\x55\x7b\xad\x7a\x2e\x3d\xd6\x42\xd2\xe2\x9e\x83\
\x2d\x3b\x4e\x59\x4b\xbf\x5a\x8d\xb1\x90\x58\xee\x31\x44\xc9\xb9\
\x23\xc5\x09\xd6\x3c\xb3\x32\x16\xc2\x56\x18\x46\x20\xab\x64\x71\
\xaf\xac\xb3\x27\xbd\xce\x00\x41\x35\x81\x1d\x69\x56\x92\xce\x8d\
\xdd\xfc\x0b\x8d\x28\xe7\x2d\x28\x4c\x8b\xa3\xf8\x97\xb3\x62\x66\
\xa7\x7d\xfe\xb1\xb7\xc7\x7b\xdb\xe5\xd4\x32\x31\x65\x40\x75\x71\
\xb4\x39\xc1\x1a\x18\xc3\x43\x4f\xc2\x4a\xb9\x61\x93\xf5\x48\x4d\
\x63\xb0\x30\x93\x23\x70\xcf\x12\xb8\x6a\xdd\x73\x14\x3e\x61\xa7\
\xe3\x8b\xc5\x2d\xa1\x32\x8d\x63\x87\x60\x3d\xbd\xcf\x07\x61\xcb\
\x30\xac\x86\x7f\x0d\x3e\x18\x3e\x64\xe1\x54\xb3\x56\x68\xcd\xf9\
\x25\x24\x9c\x85\x87\x0d\x05\x03\xc5\xb6\x44\x64\x39\x4f\xac\x7a\
\x02\xc4\x01\x74\x19\xd7\x14\xff\x37\xd0\xa3\x2a\x77\x20\x20\xcf\
\xa9\x8c\xe8\x58\x36\x26\x58\xfd\xef\x96\x89\xde\xe4\x83\xc8\x4c\
\x29\x52\xa2\xb7\xaf\x31\x17\x96\x84\xdc\x56\xf8\xc5\x98\x8b\xe2\
\x8e\xee\xcc\xbe\xb6\x44\x24\x83\x31\x05\xeb\x91\x4e\x63\xfb\xf0\
\x38\xc2\xdf\x0c\x23\xc4\xe3\x92\xa2\xc6\x6b\x2b\xae\xd9\x08\xad\
\xa5\xf1\x97\xa2\x6a\x7e\x51\x24\x2c\xd1\xf9\x48\xbf\x54\x3b\xcb\
\xda\xda\x05\x85\xc0\x4c\xda\xcb\x44\x13\x5d\x75\x82\xe2\xc0\x77\
\x01\x4c\xd4\x39\x73\xab\x6d\x3f\x06\xa9\xdd\x65\xee\x63\x63\xa9\
\xcd\xdf\x52\xa7\xe6\xb2\x56\xe8\x32\x9f\x99\xcf\x23\x8b\x43\x6e\
\x33\xe2\x23\xad\xb2\x51\xa1\x7b\x10\x52\xa1\x58\xeb\x9e\xab\xc0\
\x21\xf5\xd7\xcc\xb9\xaa\xb8\xd7\x15\x13\x82\x7d\x8b\xc1\xd2\xf8\
\xf3\x8b\x20\x87\x8e\x5a\x59\x54\x4d\x21\x50\xcc\x6e\xb5\x98\xf5\
\x8a\xb1\xc0\x2c\x03\x22\xb4\xa7\xeb\xc7\x96\x92\x92\x38\x27\x72\
\x6a\xc1\x29\xd3\x45\x66\xfd\x60\x25\x51\x5e\xce\xa0\x4e\x9c\x99\
\x4f\x6a\xee\xa9\x9a\x11\x65\x29\x9e\xdd\x7e\x25\x6a\x49\xd3\x91\
\x04\xd5\x1b\xd4\xf3\xbf\x57\xc9\x60\x2c\x59\x21\x98\x25\xe0\x15\
\xfb\xb9\x2f\x62\x3c\x11\x86\x2a\xb1\xfa\x88\x3e\x9b\x02\xc4\x16\
\x4b\x94\xff\xbe\x12\x55\x33\xd7\x9e\x26\x7c\x91\x7a\xe1\x5d\x67\
\x76\x7b\x45\xe7\x2d\x78\x90\x7a\x52\x53\x6a\x63\x75\x79\x7d\x2e\
\x14\x9e\xd4\xfb\x19\xf1\xc2\x8b\x31\xba\x98\x83\xf7\x09\x60\x54\
\xbb\xd6\x4a\x35\x11\xe5\x0a\xed\xc0\xe1\x52\x1a\x32\x8b\xb2\xa9\
\x55\x54\x23\x53\x66\xed\xfa\x74\x7e\xc7\xba\x6a\xe5\x76\xb5\xae\
\xa9\x19\x85\xdf\x5a\x68\x58\x61\xf5\x43\x5b\x72\x6b\xaf\x2e\xe3\
\x06\xe4\x73\xdb\x09\x76\x4f\x2a\xb4\xb9\xa2\x73\x92\x4d\xcc\x53\
\xaf\xc1\xf4\xd8\xfd\x62\x0d\x42\x44\xf2\x45\x17\x64\xda\x55\x20\
\x51\xd5\xcf\xb0\x47\x1f\x5d\x22\x64\x09\xe9\xbe\x0c\xe4\x01\x20\
\x2a\xed\x21\x38\x7b\xd4\xe5\x86\x5d\x01\xd8\xd9\xbb\xb9\xdf\x33\
\x51\x98\x3f\x16\x43\x3f\x30\x31\x73\xa4\x48\xa4\xca\x07\x1a\x07\
\x5f\x9b\x54\x97\x82\x1e\x16\xfe\x9e\x34\x99\xc6\xb9\x19\xf6\xcc\
\x81\x3d\x88\xdb\x53\x5b\xbc\x47\x5b\xa9\x38\x24\xec\x04\x02\x51\
\xf4\xf8\xe2\xfe\x92\x7d\x40\x44\xc8\x2d\x43\x0e\x6f\xdc\xaa\x7a\
\x5f\x8d\xaa\xad\x92\x4e\xe3\x38\xca\xc1\x58\x35\xee\xa8\xee\xa8\
\x0d\x63\x35\xbd\xfe\x4c\x4a\x2a\x0c\x6f\x0f\x06\xc7\x0f\x76\x1d\
\xfc\x19\xf6\x88\xcf\x7e\xb9\x66\x59\x5a\x35\x30\x5e\xc3\x97\x61\
\x23\x1c\x7d\x96\x29\x78\x53\x4a\xcd\x44\x25\x95\x70\x1a\xfb\x19\
\x3b\xb0\xf3\xe6\x27\xef\x0c\x9b\x15\x0f\x77\xe5\x45\x86\x7d\xeb\
\xf5\x15\xd4\x92\x00\x3c\xbc\x22\x58\xb1\x86\xed\x9d\x83\xf9\x44\
\x02\x41\xa3\x4d\xcd\xa2\xa3\x1b\xe0\x78\x87\x0e\x19\x85\x99\x44\
\x48\x20\xed\x9f\xf0\x3d\x4b\xe3\xca\xa4\x1e\x32\x4a\x77\x36\x69\
\x3f\xe0\x9b\xe7\x26\xaa\x08\x02\x53\x58\x88\xa1\x62\xcf\xb9\x06\
\x06\x2a\x87\x5b\x08\x0c\x4e\x0e\x27\xae\x12\xd3\x6a\xda\x15\x51\
\x6b\xfa\xab\x25\xcc\x43\x2b\xdb\x4d\xe8\x94\x20\x35\x51\xe8\x27\
\x53\x4a\x89\xa3\x87\xa3\x29\xd8\x9d\x15\xf5\x5d\xab\xa4\x4a\xcb\
\x61\x64\x0c\x90\xbc\x41\x8d\x5b\xd1\xf7\xcf\x61\x83\x3d\xa2\xc6\
\xe7\xad\x7d\x4e\xba\xd7\x5f\xaa\x71\x2e\xc4\x2c\x12\xda\x82\xa1\
\xc2\xda\xc3\xd7\x2e\x4b\x85\xa9\xd9\x20\x87\x74\x0d\x2b\xf4\x2d\
\x92\x29\x1f\xc8\xc6\x4a\xf7\xcd\xbd\x9b\xd5\xf8\x0f\xc9\x62\xd5\
\x08\x0f\x3a\xa5\x9a\x66\x4b\x2c\xa3\x3a\xb7\xce\x39\x1c\x5d\x7c\
\x93\xc7\xef\x0f\x1f\x6d\xd7\xf4\xe6\x84\xef\xba\xd8\x10\x79\x1d\
\xe7\x91\x83\x39\xba\x66\xae\xd7\xd5\x9f\xc9\x03\x31\x6f\x3c\xb0\
\xde\xb2\xdd\x6d\x7d\x65\x6e\x76\x58\x47\x41\x22\x3f\x79\x4d\x85\
\xf6\x9c\xbe\x67\x8e\x09\x6f\x33\x3c\x1e\x8b\x60\x34\x42\xfa\xf7\
\x03\x8d\x85\x40\xa2\x33\xb8\x00\x6d\x89\xcf\x07\xd7\x5a\x01\x53\
\xe0\x8c\x13\x05\x9f\xe9\xd8\x25\x93\xd9\x54\x20\x89\x5e\x00\x74\
\x9d\x51\xce\x88\x68\x7e\x97\x13\x09\xa7\x30\x11\x2b\xe6\x5e\x6b\
\x0d\xaf\xc8\xa8\x97\xbc\x76\x55\xe3\x82\xa7\x7c\xf3\xeb\x3d\x4a\
\x84\xd1\x69\x09\x2b\x89\x1a\x42\x39\x19\xca\x3c\x04\xe6\x62\x47\
\xde\xfe\x09\xcd\xa6\x34\x12\x12\x9d\x87\xbd\xa6\x1c\x3c\x1f\x43\
\x08\x9a\x7d\xbe\xba\xc9\x66\x31\xd6\xe2\x92\xa8\xe3\x8d\xe6\xc2\
\xf0\xd3\xa2\xa3\xf6\xd9\x49\x68\x20\xa3\x93\xdd\x32\xb3\x8c\xe6\
\xe4\x0f\xa0\xdd\x72\xa1\xa1\x75\xa1\xa7\xdd\xf8\x2a\xf1\xd5\x20\
\xfc\x64\x60\x0e\xad\x37\x18\xc8\xba\xa5\x7b\x1d\x2d\xe6\x97\xef\
\x65\xcc\x18\x5e\x60\x01\xe8\x92\x3d\x0a\x49\x49\xf6\xba\x5e\xa4\
\x84\xbf\x57\xfd\x71\xbc\x9e\x89\xb5\x74\xbf\x22\xbe\x8c\x3d\xb3\
\xdf\x67\x0b\xbf\x8b\xfd\xe8\xf1\xf8\x25\x88\x27\x7e\x21\xa4\x98\
\x89\x11\x56\xc3\x08\x7b\x70\x2f\x12\xd2\x33\xb6\x90\xea\xc3\x0b\
\x28\x4b\xcc\xaa\x4f\x81\x85\x18\x63\x66\xa8\xae\xdf\x4d\xf7\x66\
\x3a\xcd\x14\x0b\xc5\x3b\x30\x64\xca\xc8\x2c\xc3\xfb\x04\xa2\x79\
\x47\x4d\xb1\x5c\x41\x5c\x17\xb8\x13\x8e\x28\x12\xb5\xb9\x45\x7d\
\x4c\xde\xaa\x76\x93\xba\x96\x1d\x96\x48\x2a\x3c\x06\x9c\x4e\xa2\
\x1d\x83\xbf\x89\x39\xb6\xd4\x30\xaa\xad\x51\x82\x7f\xa7\x26\x91\
\x81\x90\x76\x82\x07\x89\x26\x4b\x64\x1c\xb2\x31\x5b\x08\xfb\x57\
\x4d\xf7\xe1\xf8\x07\x24\x9e\x1f\x1a\xaf\x2a\x92\x97\xfb\xdd\x28\
\x31\x4d\xd1\x9e\x5a\x34\xaa\x79\x75\x75\xc5\xb1\xd9\xde\xd7\xc3\
\x9d\x6b\x91\x77\xaa\x50\x88\xa5\xc9\xee\x27\xc4\xdf\x2c\xbc\x75\
\xc5\xa3\xb6\x5d\xb1\x5c\x92\x76\xc7\xf1\x1a\x99\x1f\xdd\xb0\x86\
\x11\x96\x63\x58\x19\x15\x7d\x47\xd7\x64\x27\x35\x13\xec\xda\xe0\
\x61\xa7\x44\x7d\x9f\xc0\xc4\x57\x41\xe9\x4f\xfc\x6a\xda\x05\x60\
\x82\xf0\x3b\x95\x4d\x3f\x30\x16\x87\x10\x0d\x70\xcd\x52\xfe\xb1\
\x58\x8c\x75\x1e\xcd\xa3\x67\x26\x4c\x85\xdc\xd4\xbe\x36\xc5\x4f\
\xfa\xe4\x93\xf5\x4f\x6b\x98\xa7\xdc\xc0\x8c\xdc\x17\xef\x41\xc2\
\x50\x56\x60\x83\x54\xf7\xf0\x74\x50\x83\xc1\x26\x08\x2d\xb2\x48\
\x3c\xa6\xd9\xc0\x9e\xcc\xe6\x57\x43\x11\x57\xce\xc3\xc7\x21\x77\
\x5a\xb6\x59\xd2\x8b\xff\xa8\xc8\x9d\x69\x0c\x64\xd4\x8f\xe9\x93\
\xe0\x86\xaa\x73\xfd\xe3\x36\x3f\x3c\x61\xfe\xa0\x0d\xa6\x25\x79\
\x6c\x42\x17\xf2\xc4\x55\xcc\xa9\x34\x35\xc3\xff\xd6\x38\xf8\x0a\
\x1e\xa5\x7d\x3e\x40\x7b\x6b\xb9\x20\x17\x99\x96\xf0\xa3\xf6\xa8\
\x39\x23\x9d\x34\xd2\x06\x6e\x04\xc1\x29\x39\x5b\xea\x46\x2d\xe9\
\x6b\xea\xf4\xa3\xd2\x49\x83\x91\xe2\xf2\x90\x89\xd9\x4b\x09\x0a\
\x8a\x49\xdf\x6a\x7f\xa0\x18\x0c\x40\x07\x47\x0b\xc9\x98\xa6\xad\
\x3e\xea\x24\xda\x50\xae\xdf\x6e\xbc\x97\x86\xb6\x61\xc8\x9a\x15\
\xd8\xbf\xb9\x98\xa0\xbf\x30\x35\x6b\x62\x5d\x77\x26\x6a\x74\x47\
\x81\x35\xcc\x85\xc4\x92\x83\x92\x7f\x6d\x8e\x41\x32\xd6\xb4\x2e\
\x4d\xb9\xb1\xf0\x40\x74\xf8\xe1\xbd\x78\xdc\xae\x1f\x8b\x84\x86\
\x0a\x9c\xdc\xf9\xd3\x3f\x74\xaf\x19\x76\xe4\xf5\x8e\x26\xe8\x70\
\xd0\x48\xe6\x79\x9b\x6a\x84\x63\xcb\x99\xc5\xfa\xb9\xbe\x69\xcd\
\xc9\xf1\x42\xa9\x88\xbc\x19\x66\xb2\x14\x74\xa8\x75\xf3\x86\x3c\
\x72\xd4\xec\x67\x64\xc3\xcc\xa6\x94\x44\xdc\x97\xd5\xad\x75\xcd\
\x81\x7e\x05\xfe\x46\x7e\x0d\xf5\x42\xd8\xb6\x1a\x94\xea\xef\xb6\
\x40\x2f\xaa\x2d\xbf\x04\x2b\x6d\xdd\xe7\xd6\xcf\x80\x22\xac\xd2\
\xaf\xd5\x6c\x71\x27\x9c\xc7\x89\x6d\x19\xa7\xfe\xbd\xf0\xb0\x3d\
\x47\xb4\x9a\x65\xb8\xb5\x9f\xff\xf5\x09\xf6\xc6\x4e\xd0\x3a\xc6\
\x6e\x1b\x83\xd8\x7c\x70\x1e\x56\x7c\x05\xa4\xea\xa1\x8b\xeb\x19\
\x60\xb8\x9e\x84\xd6\x87\x9a\x9a\xa9\x0b\x6c\x7f\x33\xe8\xd8\xd1\
\xe1\xcb\xcc\xfe\xf3\xd1\xc7\x17\x6f\xe7\x19\xfa\x0f\x6d\x88\xba\
\xe5\xbf\xe1\xce\xcb\x28\x68\x14\x34\x0a\x1a\x05\x8d\x82\x46\x41\
\xa3\xa0\x51\xd0\x28\xf8\x17\x12\x44\x9e\xb9\x9a\x0c\x81\x98\x04\
\x2d\x9c\x05\xf8\x6f\xb0\xf7\x2f\x2b\xa8\x37\x11\xd5\xff\xaa\x23\
\xb7\x7e\x45\x5c\xb8\x0e\xfe\x3c\x7c\x5f\xdd\xde\x6f\x73\xff\x07\
\xa3\xb2\xff\x60\
\x00\x00\x07\x1d\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x06\xaf\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x62\x41\x17\x60\x64\xec\x83\x3a\x8d\x11\x88\
\x81\x34\x33\x90\x66\x46\xe7\x03\x31\x23\x48\x37\x98\xd6\x61\xf8\
\xf1\xa7\x9a\x81\x9b\x85\x95\x81\x85\x29\x17\x28\xfa\x1c\x6e\xd8\
\x7f\xa8\x17\x79\x99\x21\x6a\x41\x42\x67\xd2\x50\xec\x03\x08\x20\
\xd2\x43\x00\x96\x64\x18\x19\xd8\x18\xbe\xfd\xce\x64\xfa\xf6\x7b\
\x77\x60\xa0\x5a\x84\xb2\xa2\x40\x20\xc3\xaf\x7f\xd6\x0c\x7f\x81\
\x0a\x40\xf8\x0f\x54\x21\x37\x33\xc4\x11\x38\x00\x40\x00\x91\xee\
\x00\x90\x47\xfe\xfd\x57\x66\x78\xff\x73\xad\xb4\x34\xef\xb4\x85\
\xb3\xbd\x24\xd6\xcd\xf1\x62\x10\x16\x60\x67\x60\xf8\x0d\xb4\xf9\
\x1f\xd4\x01\x20\x75\xdc\x4c\x10\x1a\x0f\x00\x08\x20\x16\x12\x2d\
\x67\x64\xf8\xf1\x37\x9a\xe1\xdf\xbf\xd6\xd8\x44\x5d\xb9\xba\x4a\
\x0b\x06\x15\x05\x7e\x86\xbf\x7f\xff\x31\xfc\xfa\xf5\x17\x11\x3e\
\xa0\x28\x02\x59\xce\x84\x14\x62\x38\x00\x40\x00\x11\xef\x00\x46\
\x46\x1e\x86\x4f\x3f\x3b\x04\x44\xb9\xb2\x3a\x3a\xec\x18\xd3\x13\
\x75\xc1\xa6\xff\xf9\xfd\x07\xd5\x0e\x50\x5a\xe1\x00\xf9\x9c\x11\
\x62\x39\x81\x10\x00\x08\x20\x16\xe2\x82\x9c\x41\x8d\xe1\xdb\xb7\
\x39\x86\xa6\x52\xb6\xd3\xa7\xbb\x31\x98\x1b\x4b\x00\x0d\xff\xcb\
\xf0\xfa\xf3\x7f\x06\x1e\xb6\xff\x0c\xcc\xcc\x60\x5b\xfe\x01\x2d\
\xff\xcb\xc0\x0e\x0d\x76\x22\x8b\x17\x80\x00\x62\x21\x68\xf9\xef\
\xbf\x1e\x8c\x0c\x7f\xa7\xc7\x26\x1b\x2a\xf4\x74\xd8\x31\x88\x8a\
\x70\x32\xfc\x06\xfa\x7a\xf9\x35\x46\x86\xc7\x9f\x98\x18\x8a\x4d\
\x7f\x33\xfc\xff\xc7\xc8\xf0\xfd\xdb\x1f\x26\x86\xaf\xbf\x9d\x80\
\xc1\xce\x01\xd4\xc7\x01\xcf\x3d\x8c\x50\x9a\x95\x89\x89\x81\x93\
\xe5\x2c\x90\x75\x09\xd9\x0a\x80\x00\x62\x21\x60\x79\x2c\x50\xff\
\xcc\xb6\x4e\x47\xce\xb2\x12\x53\x70\xe8\xbe\xf9\xfa\x87\x61\xfa\
\x39\x66\x86\xfd\x0f\x19\x19\x2c\x25\x7e\x33\x30\xfe\xfb\xcb\xc0\
\xc8\xcc\xc2\xa0\xa7\x29\xc2\xc4\xc9\xc8\x98\xc7\xca\xcd\x9c\x07\
\x4f\x07\xcc\x10\x83\x98\x59\x19\x81\xb1\xf7\x9b\xe1\xe6\xf3\x2f\
\xb7\x81\x02\x6a\xc8\xd6\x00\x04\x10\x0b\x4e\xcb\xff\xfe\x89\xe6\
\xe0\x64\x9c\x3d\x61\xa2\x1b\x7b\x7a\xaa\x1e\x38\x84\xaf\xbf\xfe\
\xcf\x30\xe5\x0c\x33\xc3\xa3\x8f\x8c\x0c\x5c\xc0\xd0\x66\xfc\xfb\
\x97\x01\x54\x92\xff\x07\xd2\x0b\x7a\x1d\x80\x39\xef\x3f\x52\xd8\
\x83\x24\x80\x99\x02\x98\x23\x38\xd9\x59\x18\x8e\x5c\x79\xc3\x10\
\x9a\xbf\x4b\x1c\xdd\x2a\x80\x00\xc2\xee\x80\xff\xff\x5c\x59\x58\
\x18\xa7\x4f\x9d\xe6\xc1\x9e\x94\xa0\x03\x36\xec\xf0\xc3\xff\x0c\
\xb3\x2e\x30\x01\x7d\xc2\xc8\xc0\xc9\xfc\x87\xe1\xd3\x8f\x5f\xc0\
\xa8\xf8\xcb\xf0\xe7\x2f\x13\x10\x03\x1d\x03\x0c\xaa\xff\x0c\x20\
\x0b\xff\x01\x33\x09\x90\xfe\xf7\x0f\x68\x0c\x30\x91\x02\xf9\x8c\
\x7f\x59\x18\xd8\x98\xff\x83\x62\xe3\x37\xba\x55\x00\x01\x84\xcd\
\x01\xb2\xc0\xb0\x9f\x50\x57\xef\xc0\x0b\xb1\xfc\x1f\xc3\xd6\x5b\
\x8c\x0c\x73\x2e\x30\x83\xa3\x93\x03\xe8\xf3\xdf\x3f\xff\x30\x30\
\xfd\xfd\xc3\x70\xeb\xe5\x1f\x86\x92\xcd\x7f\x18\xfe\xfc\x01\x3a\
\xe4\xd7\x1f\x60\xa0\x01\xd9\xbf\x7f\x83\x73\xc6\x5f\x20\xfe\xfc\
\xe5\x17\x83\x8b\x16\x37\x43\x96\x87\x38\xd8\x61\xd8\xea\x3d\x80\
\x00\xc2\xe2\x80\x5f\x99\xae\xae\x2a\x5a\xa5\x25\x66\x60\xde\xbe\
\xfb\x0c\x0c\x73\x2e\x02\xe3\x11\x98\xb8\x99\x81\xf1\xfd\xf3\xd7\
\x6f\x86\xbf\x40\xfc\x1f\x68\xd9\x47\x60\xbc\x3e\x7f\xfd\x0b\x6c\
\xf1\x6f\x20\xfb\x0f\x54\xee\x37\x08\x03\xf9\xef\x3f\xfd\x60\x50\
\x11\x61\x82\x67\x0a\x6c\x39\x12\x20\x80\xb0\x38\x80\x31\x30\x36\
\x56\x87\x81\x83\x83\x99\xe1\xda\xab\xbf\x0c\xf3\x2e\x32\x83\x35\
\x32\x01\xb3\xdd\xaf\x5f\x10\x4b\x60\xf8\x1f\xd0\xb7\x2c\xff\xff\
\x00\x03\x09\x58\x16\x00\x31\x03\x94\xfd\x0f\x44\x33\xfc\x61\x60\
\x05\xd2\x4c\xff\xff\x31\xfc\x05\x45\xc7\xff\xff\x58\x73\x26\x40\
\x00\x61\x73\x00\x1b\x3b\x3b\x38\xf9\x32\x7c\xfd\xf5\x9f\xe1\x3b\
\xc8\x5c\x60\x70\xff\x06\x05\xef\xaf\x5f\x48\x0e\x80\x06\xf7\x2f\
\x48\x90\x83\xd9\x40\x5f\xff\xfe\x8d\x70\x20\x28\x24\x40\xa1\x03\
\x0f\x7b\x2c\x41\x00\x10\x40\x58\xea\x82\x7f\x3b\xd6\xad\xbb\x09\
\x2e\x5e\x4d\xa5\xff\x33\x84\xa9\xfe\x62\xf8\xfc\xed\x0f\xc3\xaf\
\x9f\xbf\xa0\x16\x21\xf0\x6f\xa0\x23\xbe\x7f\xff\x0d\xc4\xbf\xa0\
\xf8\x37\x12\xff\x37\xb0\xec\xfa\x05\xd4\xf7\x1b\x9e\x20\xb1\x05\
\x01\x40\x00\x61\x71\x00\xeb\xb4\x95\x2b\xaf\x3d\x99\x33\xf7\x0a\
\xd0\xc5\xac\x0c\xc1\xea\x7f\x19\x42\xd4\x80\xf1\xfd\xf5\x37\xc3\
\x8f\x1f\xbf\xc1\x89\x0b\xe4\xfb\xdf\xc0\xd0\x00\xba\x82\x81\x87\
\xf5\x2f\x10\xff\x03\xe2\xff\x0c\xbc\x6c\xff\x18\x78\x81\x6c\x5e\
\xb6\xff\x60\xcc\xcf\xc1\xc0\xc0\x0e\xac\x86\x81\xf6\xe3\x04\x00\
\x01\x84\x2d\x0a\xae\x02\x63\xbc\xaa\xb4\x74\xff\x02\x39\x39\x3e\
\x26\x4f\x0f\x05\x86\x38\x83\xaf\xc0\xa2\x8d\x89\x61\xce\xb1\xdf\
\x0c\x3f\x81\x21\xc1\x0a\x4c\x0f\x5f\xbe\xfe\x62\xd0\x97\x62\x66\
\xa8\xf2\x12\x03\xe6\x02\x60\xd6\x03\xc5\x31\xd0\x97\xa0\x90\x83\
\x64\xc5\x7f\x60\x36\xc8\x01\xdf\x7e\xfc\x01\xa7\x01\x46\x2c\x51\
\x00\x10\x40\x38\x0a\x22\xe6\xc5\x9f\x3f\xfd\x94\x8a\x8f\xdf\xd2\
\x31\x7f\x81\x37\x83\xb7\xa7\x3c\x43\xb4\xc1\x3f\x06\x01\x56\x76\
\x86\xde\x3d\xdf\x19\xde\x7e\xfc\x09\x4c\xed\x7f\x18\x98\xff\x33\
\x32\x48\xf2\x33\x03\xeb\x02\x36\x60\xa2\x65\x05\xa7\x75\xb0\x43\
\xa0\x8e\x01\xc5\xfd\x2f\x90\x23\x58\x99\x19\xd8\xdf\xff\x06\x49\
\x33\xa3\x5b\x05\x10\x40\xb8\x8b\x62\x26\xd6\xce\xd7\xaf\xbe\xb3\
\x46\x47\x6d\x6a\x9c\x3e\xcb\x9d\x29\x32\x54\x95\xc1\x1b\x58\x01\
\x8a\x72\xf1\x31\xb4\x6d\x79\xc3\x70\xfc\xe6\x77\x86\x9f\x12\xc0\
\x44\xfa\xeb\x1f\x03\x37\x0f\x1b\x43\x55\xdf\x79\x86\x3b\x0f\x3e\
\x32\xb0\x70\x00\x8d\x64\x04\x3a\x80\x11\xda\x82\x02\x52\xac\x6c\
\x4c\x0c\xaf\x3e\xfc\x60\xf8\xfc\xfb\xdf\x77\x74\x6b\x00\x02\x88\
\x05\x67\xab\x07\x14\x5c\xac\x2c\x2d\x1f\x3f\xfc\x7e\x91\x9c\xb0\
\xbd\xf7\xfa\xf5\xb7\x7c\x65\x25\x86\x0c\x16\xaa\xdc\x0c\x7d\x61\
\xff\x19\xba\x36\xff\x63\x78\x03\x0a\x09\x70\xa9\xf7\x9f\x61\xcb\
\x9e\x87\xff\x6e\x9f\x7f\xb9\x0c\x98\x18\xce\x03\xf5\xb2\xa3\x54\
\x46\x20\x5b\x58\x98\x59\x81\xcd\xb6\x53\xe8\x56\x01\x04\x10\x0b\
\xc1\xe6\x17\x07\xcb\x9c\xef\x7f\xfe\xdf\x6d\xae\x3f\x32\xe7\xfc\
\xf9\x97\x4a\x13\xfa\xed\x18\x54\x65\x79\x18\x1a\x02\x19\x18\x6e\
\x3c\xfb\xce\xf0\xeb\x37\x24\x85\x73\x71\x03\x53\x1f\x37\xeb\x6a\
\x06\x2e\x96\x4d\xe0\x5a\x0b\xdd\x01\x4c\xd8\x1b\x06\x00\x01\xc4\
\x44\x54\x1b\x90\x85\x71\x3f\x03\x0f\x87\xe3\x96\x0d\x77\xb6\xb8\
\x79\x6d\x64\xd8\x71\xe8\x25\x83\xa4\x14\x1f\x83\xbe\x02\x37\xb8\
\x22\xfa\xf7\xff\x1f\xc4\xac\xff\x40\xab\x7e\xe3\xce\xf3\xd8\x00\
\x40\x00\x31\x91\xd0\x1c\x7b\xc4\xc0\xcf\x1e\x7a\xef\xce\x87\xba\
\xa0\xf0\x2d\x5f\x1b\x3a\xcf\x32\xfc\xfa\xcf\xcc\x20\x24\xc8\x09\
\x8e\x06\x14\x07\xff\xfc\x4f\x54\x6b\x08\x04\x00\x02\x88\x78\x07\
\x40\x6a\xda\x1f\xc0\x38\x6e\xfe\xf9\x8f\xc1\xa3\xb5\xe9\xe4\x05\
\xff\xe8\x1d\x0c\x57\x6e\x7d\x66\x10\x17\xe1\x06\xd7\x15\x70\x2b\
\x41\x0e\xfa\xfe\x0f\x54\x8f\x11\x6c\x1d\x01\x04\x10\x79\x1d\x13\
\x16\xa6\x23\x0c\xfc\x6c\x4e\xe7\xce\xbc\xec\xf3\x0a\xdb\xfa\xa3\
\xa8\xf9\x24\x30\xaf\x03\xeb\x65\x66\x46\x16\x48\xc5\xc1\x00\x29\
\x7e\xbf\xfd\x23\x18\x12\x00\x01\xc4\x88\xde\x37\x24\xaa\x63\x02\
\x63\x83\x3a\x1b\xff\xff\x3b\x33\xfc\xfe\x57\xc3\xc8\xc3\xc2\xf4\
\x9f\x89\x31\x19\x28\x7a\x07\xa3\x63\x02\x6a\x21\xb3\x40\xf4\xa1\
\x77\x4c\x00\x02\x88\x71\xa0\x3b\xa7\x00\x01\x34\xe0\x7d\x43\x80\
\x00\x1a\x70\x07\x00\x04\x18\x00\x16\x94\xf6\xf0\x5b\x47\x37\xa4\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0b\x54\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd6\x00\x00\
\x0d\xd6\x01\x90\x6f\x79\x9c\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x09\xb4\
\x49\x44\x41\x54\x68\xde\xd5\x5a\x5b\x6c\x9c\x47\x15\xfe\xce\xfc\
\x97\xbd\xfc\xeb\xbd\x38\x17\x93\xd8\x8d\xed\x26\x0d\xb9\xbb\x8d\
\x1f\x0a\x0f\x8d\xfa\x00\xe5\x22\x52\x10\x02\x81\x1a\x55\x11\x08\
\x15\x15\xc1\x2b\xb4\x4f\x81\x27\xc4\x03\x52\x24\x10\x52\x05\x85\
\x88\x46\x55\x69\xda\x50\x1a\xa9\x34\x79\x29\xa2\xaa\x54\x52\x92\
\x26\x69\x92\x52\x25\x6d\x5c\xdb\x71\xec\xb5\xbd\xeb\xf5\xae\xf7\
\xf2\xff\x33\xe7\xf0\xb0\xeb\xf5\xae\xe3\xdb\xda\x0e\x12\x47\xfa\
\xb5\xff\xcc\x3f\x97\xf3\xcd\x77\x66\xce\xcc\x99\x25\x11\xc1\xff\
\xb3\xd8\xad\x14\x3e\xf1\xda\x6b\x49\xd1\xf4\x1d\x81\x44\xd6\xda\
\x31\x09\x9d\xfb\xde\xb7\xbf\x7e\x7d\xed\xed\xac\x90\x81\x3f\x9c\
\x3a\xd3\xbb\xbd\x73\xd3\x87\x7b\xb6\xf7\x86\x62\xb1\x18\xaa\xd5\
\xee\xae\x4b\x44\x8d\x09\xcc\xa6\x0c\x33\x0a\x85\x22\x32\xd9\x0c\
\x06\x47\x46\x30\x3e\x99\xc9\x5a\x81\xd7\x73\xe4\xc8\x57\xa6\xd7\
\x02\x60\xc5\x0c\xdc\xbe\x7e\xf1\xd3\x4d\x89\x43\xc5\x58\xac\x2d\
\xe4\x38\x36\x1c\xc7\x69\xbd\x33\xdb\x06\x0b\xa3\x54\xa9\xa0\xcd\
\xf3\x52\x37\x06\x86\x5e\x05\xf0\xc5\xb5\x00\x50\x2b\x2d\x78\xec\
\xd8\x31\xce\xe4\xf3\xa7\x82\xc0\x47\xbe\x30\xb3\xaa\xce\x42\xae\
\x0b\xcf\x8b\xa2\x3d\x99\x84\x65\xd9\x38\xb8\xf7\xb3\x5f\xf8\xfd\
\x8b\x2f\xff\xe4\x7f\x02\x00\x00\x44\xf8\xd5\xd1\xf1\x09\x28\x45\
\xf0\x7d\xbf\xe5\xce\x88\x08\x91\x70\x18\x5e\x34\x0a\xdb\xb2\xb0\
\x73\xc7\x0e\x24\xbd\xf0\xf1\x13\xa7\xfe\xb6\x7f\xb5\x00\x5a\x9a\
\xc4\x3a\x93\x7e\x6b\x60\x78\xa4\xb8\xad\x73\x6b\xb4\xe2\xfb\xb0\
\x2c\x0b\x27\x4f\x9e\x6c\xb9\x53\x6d\x0c\x76\xef\xdb\x8f\x50\x28\
\x84\x47\x3e\xf7\xb0\x7a\xed\xcd\x73\x67\x5f\x78\xe1\xdc\x03\x4f\
\x3e\xf9\x58\xeb\xd4\x8a\x48\x4b\xcf\x4b\xaf\xff\xfd\x46\xb1\x58\
\x94\xec\xd4\x94\x30\xf3\xaa\x9e\xc9\x6c\x56\x2e\x5c\xba\x22\x22\
\x22\xbe\xef\xcb\xbb\xe7\xcf\xcb\xf3\x7f\x39\x7d\xb2\x55\x5d\x44\
\xa4\x35\x06\x6a\x90\xcb\x20\x82\x70\x75\x05\x3a\x73\xe6\x0c\x32\
\x99\x4c\x4b\x2d\x54\x02\x83\xbe\x87\x1e\xac\x9a\x80\x6d\x63\xcf\
\xae\x5d\xb8\xfa\xd1\xcd\x23\xcf\xbd\xf8\xca\xe9\x1f\x3e\xf1\xad\
\xd3\xf7\x94\x81\x17\x4e\x9f\x39\x5f\x2a\x95\x65\x72\x32\xb3\x6a\
\x06\x6e\x0d\x0e\xcb\xfb\x57\x3e\x90\x59\xd1\x5a\xcb\x8d\x9b\x37\
\xe5\xf8\xf3\x27\x06\x7e\xfe\xf2\xcb\xee\x3d\x65\x80\x45\x0a\x00\
\x60\x59\x56\xeb\xe4\xd5\xa4\x58\x2a\xe1\xdd\x4b\x57\x31\x34\x9a\
\x46\x67\xc7\x66\xdc\xd7\xb9\x15\xf7\x75\x75\x61\x53\x3c\xd6\x1d\
\x4c\xe5\x7f\x04\xe0\xf8\x4a\xdb\x5a\xd2\x91\x0d\xff\x99\x8e\x31\
\x59\xfb\x60\xe0\x31\xd8\x13\x03\xef\x62\xe2\xb7\xbb\x0f\x3f\xfe\
\x83\xa8\xef\x07\xf0\xbc\xe8\xaa\x00\x30\x33\x86\x47\xc7\x70\x6b\
\x70\x08\x1f\x7d\x7c\x0b\xc3\x23\xa3\xb0\x2c\x85\x9d\x3d\xdd\x18\
\xbc\x7d\xbb\x08\x87\xba\x9e\x79\xfa\xe9\xec\x4a\xda\x5a\x94\x81\
\xeb\xa7\xc8\x8d\xc1\x7a\x36\xd9\xde\x19\x6a\xcc\x0f\xbb\xdb\x01\
\x10\x94\x65\x61\x7c\x7c\x1c\x6f\xbc\xf1\xc6\xaa\x99\x00\x00\x57\
\x04\x5f\x3e\xf4\x79\x7c\xfc\xe9\x30\xce\x5f\xba\x82\xa8\x6b\x47\
\x43\xb1\xf8\x4f\x01\x3c\xbb\x26\x00\xd1\x02\x1e\x82\xe5\x84\x02\
\xcd\xd5\x0c\x01\x2a\xd2\x86\xe4\xe6\x8d\x00\x00\x45\x84\x4d\x9b\
\x36\xe1\xe8\xd1\xa3\x6b\x02\x00\x00\xe5\x4a\x05\xdd\xdb\xb6\x61\
\xd7\x03\xf7\xe3\xd2\xfb\x97\x31\x34\x91\xe9\x5b\x69\xdd\x45\x01\
\x68\x8d\x7e\xdb\xb2\x11\x04\x73\x26\x36\x85\x0e\xb4\x27\x12\xd5\
\x8a\xb6\x85\x0b\x17\x2e\xe0\xea\xd5\xab\x6b\x06\xf0\xc4\x91\x23\
\xf0\xa2\x55\x0f\xdd\xde\x9e\xc2\xf0\xc0\x7b\x8f\xfe\xf5\x67\xf6\
\x59\xd6\xe6\xb6\x36\x18\x13\x20\xcd\x8c\x34\x31\xd2\x44\xb8\xf6\
\xdd\xdf\xc8\xc8\xb2\x00\x98\xb1\xd1\x30\x21\xd0\x82\xd9\x4d\xdb\
\xa4\x6c\xc1\xce\x64\x02\x80\x40\x29\x0b\xfd\xfd\xfd\xe8\xef\xef\
\x5f\x33\x00\x00\x88\x46\xc2\xa8\x78\x1e\xc2\xae\x8b\x89\xcc\x54\
\xa4\xe7\xc0\x86\xc7\x12\x31\x05\x13\x30\x8c\x11\x04\x01\x63\x34\
\x5d\xc2\x9d\xd1\xe2\xaf\x00\x3c\xb3\x3c\x03\x06\x71\x18\xa0\x6e\
\x42\x00\x46\x4c\x2f\x1e\x4e\x26\x6a\x00\x79\x55\x5e\x78\xbe\xec\
\xdb\xb7\x0f\xfd\xfd\xfd\x70\x6b\xfb\xa4\x40\x07\xa0\x20\x87\x20\
\x10\xe8\x40\x50\x9d\x6f\x84\x90\xa5\xe0\x86\x2c\xb0\x41\xac\xb1\
\xfe\xe2\x0c\x18\x24\xb4\x01\x44\x0b\x20\x80\xc0\x82\x49\x1c\x84\
\x6d\xdb\x10\x11\x28\xa5\xd6\xc5\xfe\x1b\x25\x1c\x0a\x21\x3f\x9d\
\x83\xcd\x53\x08\xb4\xd4\xd8\x07\x66\x2d\x40\x18\x30\x06\xde\x8a\
\x00\x68\x83\xb8\xa5\x05\x42\x0c\x01\x90\x95\x6d\xd8\xd1\xbb\x63\
\x5d\x15\x9e\x2f\xb6\x6d\x63\x60\x78\x18\x11\xe4\xa1\x35\x43\xeb\
\x86\x13\x87\x00\x86\x01\xcd\x2b\x64\xc0\x30\x12\x6c\x00\x45\x02\
\x41\xd5\x7c\x1e\xed\xda\x0a\x80\x40\x04\x9c\x3d\x7b\x16\xa3\xa3\
\xa3\x6b\x52\xb8\xbd\xbd\x1d\x87\x0f\x1f\xae\xa7\x0b\x85\x02\x86\
\x86\xef\x60\x87\x33\x09\x5f\x0b\xfc\xa0\xd9\x47\x31\x03\xa6\x05\
\x00\x71\x18\x80\x84\x41\x2c\xc8\x07\x36\xec\xf4\x3b\x98\x18\x98\
\x80\x9f\x4f\x63\x67\x30\x8e\x6e\x27\x8d\x4a\x21\x8d\xf2\x74\x1a\
\x95\xfc\x38\xb4\x31\x50\x6e\x0c\xca\x89\x81\xdc\x18\xc8\xf1\x60\
\x85\x62\x50\x6e\x0c\x96\xeb\xc1\x72\x63\x50\xae\x87\x50\x5b\x07\
\x92\x9d\x7b\x90\xec\xdc\xdb\xd4\x67\x7a\x7c\x1c\x53\xb9\x0c\x62\
\xc9\x3c\x74\xa0\xa0\x35\x37\x9d\xf9\x8c\x08\xcc\x52\x73\xe0\xdf\
\xc7\xe9\x7e\x36\x78\x4c\x18\x5f\x62\xc1\xc1\xc8\x74\x09\x0a\x01\
\x9c\xc4\x66\x1c\x4a\xbe\x8f\xdc\xc5\x1b\xb0\x23\x31\xd8\xd1\x18\
\xda\x62\x31\xa4\x36\x84\x21\xd2\x05\xe1\x4e\x88\x30\x58\x04\x10\
\x81\x98\xea\xbb\x08\x43\x58\xc0\x5c\x82\x36\x79\x14\x73\xd3\x98\
\x4e\xe7\x30\x36\x95\xc3\xd5\x4c\x0e\xb9\xa9\x1c\x94\x9b\x42\xb2\
\x73\x2f\x52\x9d\x7b\x30\x59\x72\xe1\x95\xae\xc2\xb4\x31\x44\x08\
\x81\x6e\x1e\x54\x36\x4b\x30\xf0\xde\xaf\xe9\x9b\xcc\x78\x45\xb9\
\x1e\x45\xe3\x1d\x88\x26\x3e\x03\x2f\xde\x01\xd7\x4b\x01\xd4\x58\
\xa5\x29\x01\x02\x40\xb5\x6d\xd1\x52\xbb\x23\x02\x90\xda\xb8\x01\
\x9d\xf3\xf2\x4b\xc5\x32\xa6\x33\x39\x4c\x4d\x5d\xc6\xc4\xf0\x10\
\xf6\xaa\x41\x14\x27\x80\x6c\x38\x8c\x90\xe3\xd4\x7b\x93\x59\x13\
\x5a\x8c\x01\x63\xf0\x35\x6f\x63\x0f\x6d\xdd\xf9\xc8\x3c\xd4\xc1\
\x42\x7a\x2f\x0a\xa8\x55\x71\x43\x16\x36\x6e\x69\xc7\xc6\x2d\xed\
\xd8\xb1\xbb\x17\x95\xb2\x8f\x9b\x1f\x0e\xe0\x5f\xef\x5c\x86\x45\
\x3e\xda\xdb\x9d\x3a\x00\x23\x4b\x30\x60\x18\x0f\x7a\xc9\xce\x39\
\x85\x97\x13\x5a\x36\x63\x55\xe2\x38\x84\xdd\x07\x7a\x31\x34\x78\
\x07\x33\xf9\x51\xc4\xb5\xcc\x2e\xa2\x60\x61\xf0\x62\xcb\xa8\x31\
\xe8\x76\x22\x71\x98\x05\x00\xac\x58\x35\x6a\xb9\xc6\xa2\xe2\x79\
\x21\x64\xd3\x06\x81\x99\x73\xa4\xb5\x39\xb0\x08\x00\x86\x11\xd6\
\x60\xe3\xb7\xac\xc0\xf2\xd6\xd5\x3a\x20\x2f\x16\x42\xa9\xc2\xd0\
\x7a\x6e\x1d\x62\x16\x18\x03\xf5\x8b\xc7\x29\x7a\xec\x75\x29\xce\
\x07\xa0\x99\xf5\x3c\x13\x5a\x1f\xb3\xa8\xb7\x46\x2b\x6f\x2f\x1a\
\x75\xe0\x57\x04\xda\xcc\x01\x10\x53\x73\x6c\x36\x62\x00\xe6\x01\
\x30\x08\x98\xcd\x12\x73\x60\x7d\xc1\xd4\xdb\x5b\xa4\xd9\x48\xc4\
\x86\xd6\x82\xc0\x17\xd0\xfc\xe0\x8f\x8f\x18\x80\xf4\x7c\x00\x5a\
\x8c\x06\xb7\x6e\xf0\xf7\x04\x50\x24\x5a\x55\xad\x54\x66\xb8\xee\
\x5d\x7d\xd5\x8f\x82\x8d\x26\xe4\x57\xca\x45\x84\xc2\x91\x05\xf5\
\x5b\x5c\xdd\x7b\x03\xc4\x75\x08\x44\x84\x4a\x85\xa1\x2c\x85\xc6\
\x38\xac\x65\xa1\x6e\x26\x8d\x0c\x7c\x52\x9e\x99\xd9\xe5\x38\xf6\
\x72\x6d\x2f\xf1\x79\x7d\xc1\x44\x3d\x07\x15\x5f\xc3\x71\xab\xe9\
\x5a\x24\x07\x26\x40\x3d\x00\xd6\xc8\xc0\x95\xe2\xcc\xcc\x57\xbd\
\xb6\x16\x0e\xea\xcb\xea\x4b\xab\xab\x56\x93\x78\x5b\x08\xd9\x6c\
\x00\x6d\xaa\xbe\xa0\x1e\x7f\xe0\xea\x04\x6e\x02\xc0\x8c\x0f\xca\
\xc5\x12\xc4\xf8\xab\x59\xf8\x5b\x92\x05\x82\xf2\x0b\x96\x4b\xa5\
\xc2\x48\x8f\xe7\xa1\x6b\xce\x4c\x66\x5d\x42\x65\x21\x00\x06\x57\
\x4a\xc5\x32\x84\x97\x0b\xda\xae\xd1\x4c\x5a\xf0\x0d\xa9\x94\x0d\
\x36\x40\x60\xe6\x0e\x34\x00\xf8\xd8\x5b\x52\xbe\x0b\x40\xae\x8c\
\x8f\x60\xf9\x81\x18\x7f\x5e\xe0\x7f\xc5\xb3\x79\xdd\x81\xa7\xe2\
\x16\x44\x50\x3d\x5a\x52\xdd\x84\x8a\x8d\x65\xea\x00\x9e\x7a\x4e\
\x82\x13\x4f\xd3\xf5\xe2\x4c\xb1\x2f\x12\xb1\xd7\xa2\xe9\xea\x14\
\x5f\xa0\x58\x38\x0c\x84\x42\x0a\x22\x0c\x22\xcc\xda\x5e\x53\x04\
\xbb\x69\xc9\x31\x06\x6f\x4f\x4c\x14\xfb\xba\xb6\xb6\x78\x05\x76\
\x8f\x36\x76\x00\x21\x95\xb4\x31\x91\xf5\x61\xa9\x2a\x03\x02\x14\
\x89\x88\xa4\x16\x52\x6c\x06\xa0\xf1\xa7\xf1\x74\xe5\xc7\x9d\x1d\
\x56\x8b\x3a\xdc\x3b\xb6\x52\x09\x42\x7a\xb2\x76\xd6\x20\x40\x84\
\xfc\xfd\xfb\xf7\x25\xfb\xfa\xfa\x7c\x63\x4c\xd0\x04\xe0\xa9\x3f\
\xca\xc5\xdf\x1d\xa5\xcb\x23\x63\x95\xbe\x54\x52\x61\xd9\x65\xb0\
\x55\xeb\x58\x21\x53\x8d\xb9\xb1\xa8\x80\x35\x80\x50\x95\x01\x16\
\xf2\x89\x68\x73\xb9\x5c\x2e\x38\x8e\x93\xbb\xcb\x6b\x55\x58\xfd\
\x72\x70\x58\xbf\x14\x0e\xa9\x65\x14\xa4\x75\x06\xb3\x70\xc9\x48\
\x18\x55\xf3\xe1\xea\x53\x34\x4e\xd6\x18\xd3\x63\x59\xd6\x6d\xa5\
\x54\xb1\x09\x00\x11\x59\xbd\xbd\xbd\xff\xf8\xfe\xc1\xe1\x7f\x7a\
\x77\x82\x43\x1b\x36\xac\x4c\xa9\xd5\x48\x2b\xc0\x3b\x36\x03\xa3\
\xe3\xd5\xb2\xd9\x4a\xb4\x4c\x44\x9d\x8e\xe3\x8c\x17\x8b\x45\xd3\
\xb4\xcf\x3b\x70\xe0\x40\x38\x1e\x8f\x77\xbf\x39\xd0\xf3\xd6\xad\
\x11\x6b\xa6\x50\xb8\x77\x00\x66\x03\x96\xb5\x38\xc0\x92\xcf\xd6\
\x2d\x40\x34\x5c\xdd\x4e\xa7\x4b\x9e\x0b\x60\xbb\x31\x66\x93\xd6\
\xda\x6f\x62\x20\x93\xc9\x70\x32\x99\xcc\x4f\x69\x37\x77\x6e\xa0\
\xe7\xe4\x4c\x65\xe8\x1b\x89\x90\xdf\xa1\x6a\x30\x45\x00\xa2\x6a\
\xc7\x44\xcd\xa3\x48\xd2\x30\x9a\x8d\xe9\x45\xbe\x11\x01\x32\xef\
\xdb\xec\x52\xd9\xf8\x6d\xb6\x3f\xdb\x06\xf2\x15\x77\x6c\x78\x26\
\xf1\x36\x11\x7d\xe0\xfb\xfe\x8d\x81\x81\x01\xae\x5f\x70\x10\x11\
\xed\xdd\xbb\xd7\x53\x4a\x75\x31\x73\xb7\x52\x6a\xa3\x31\xa6\xad\
\x3d\x5c\xee\xb0\x2d\x71\x15\xc8\x66\x16\x9b\x88\x88\x14\x94\xb0\
\x28\x10\x55\x71\x48\x55\x05\x52\x42\x22\xa2\x2c\x52\x24\x22\x8a\
\x21\x6a\x76\x26\xd5\x40\x13\x11\x18\x00\x14\x20\x22\x22\x04\xc8\
\xdc\x85\xbe\x40\x11\xb1\x54\xc7\x9e\x2d\x82\x11\x11\x86\x88\x51\
\x4a\x38\x53\xf6\x6e\x4d\xf9\xee\x4d\x66\xfe\x24\x97\xcb\xdd\x1e\
\x19\x19\x29\x35\x32\x40\xe1\x70\x98\x0b\x85\xc2\xb4\xe3\x38\x83\
\x22\x32\x49\x44\xe1\x89\xa2\xfb\x1f\xa5\x94\xa5\x94\xb2\x98\xd9\
\x52\x4a\x29\x54\x6f\x76\xea\x63\x6a\x59\x16\x6a\x69\x12\x11\x25\
\x22\x64\x59\x16\x31\xf3\xec\x52\x26\x44\x24\xb5\x81\x12\x63\xcc\
\x6c\xba\xfe\xcb\xcc\xf5\x34\x33\x1b\x22\x62\x66\x36\x4a\x29\x63\
\x8c\x61\xc7\x71\x7c\xad\x75\xde\x98\x20\x5b\x28\x14\xb2\x23\x23\
\x23\x65\x11\x91\xa6\x2b\xa6\xea\x80\x42\xf5\xf7\xf7\xab\x5c\x2e\
\xa7\xca\xe5\xb2\x62\x66\xda\xb2\x65\x0b\x00\x20\x08\x02\x02\x00\
\x63\x4c\xd3\xd4\xd3\x5a\xd7\xd3\xc6\x18\x62\xae\x1e\x8b\xe2\xf1\
\x78\x3d\x7f\x7a\x7a\x5a\x00\x40\x29\x55\xef\xd0\xb2\xac\xfa\xbb\
\x6d\xdb\x4d\xf9\x8e\xe3\x08\x00\x8c\x8d\x8d\x89\x6d\xdb\xe2\x79\
\x1e\x5f\xbb\x76\xcd\x00\x60\x69\x50\xfa\xae\x3b\x32\x9a\x3b\xb8\
\x36\x2a\xb9\x1a\x4f\xd5\x58\x67\xb5\xff\xe9\x69\xac\x27\xb2\xc0\
\x85\xde\x7f\x01\x8b\xbf\xd2\xaa\x53\x46\x78\x75\x00\x00\x00\x25\
\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\x00\
\x32\x30\x31\x30\x2d\x30\x35\x2d\x32\x34\x54\x30\x37\x3a\x33\x38\
\x3a\x31\x35\x2d\x30\x36\x3a\x30\x30\xde\x18\xbd\x60\x00\x00\x00\
\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\x79\
\x00\x32\x30\x31\x30\x2d\x30\x35\x2d\x32\x34\x54\x30\x37\x3a\x33\
\x38\x3a\x31\x35\x2d\x30\x36\x3a\x30\x30\xaf\x45\x05\xdc\x00\x00\
\x00\x36\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\x74\
\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\x6d\
\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\x65\
\x73\x2f\x62\x79\x2d\x73\x61\x2f\x33\x2e\x30\x2f\x61\xec\xaf\x51\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\x2e\x6f\x72\
\x67\x9b\xee\x3c\x1a\x00\x00\x00\x16\x74\x45\x58\x74\x53\x6f\x75\
\x72\x63\x65\x00\x65\x63\x68\x6f\x2d\x69\x63\x6f\x6e\x2d\x74\x68\
\x65\x6d\x65\xa9\x4c\xb7\x53\x00\x00\x00\x34\x74\x45\x58\x74\x53\
\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x73\x3a\
\x2f\x2f\x66\x65\x64\x6f\x72\x61\x68\x6f\x73\x74\x65\x64\x2e\x6f\
\x72\x67\x2f\x65\x63\x68\x6f\x2d\x69\x63\x6f\x6e\x2d\x74\x68\x65\
\x6d\x65\x2f\x88\x32\x2e\x43\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x05\x5d\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xaf\xc8\x37\x05\x8a\xe9\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x04\xef\x49\x44\x41\x54\x78\xda\x62\
\xfc\xff\xff\x3f\xc3\x40\x02\x80\x00\x62\x62\x18\x60\x00\x10\x40\
\x03\xee\x00\x80\x00\x1a\x70\x07\x00\x04\xd0\x80\x3b\x00\x20\x80\
\x06\xdc\x01\x00\x01\x34\xe0\x0e\x00\x08\xa0\x01\x77\x00\x40\x00\
\x0d\xb8\x03\x00\x02\x88\x05\x44\x84\x31\x32\x32\xfc\x03\xd2\x7f\
\x81\xf8\x17\x03\x03\xc7\x4f\x06\x06\x3d\x20\xdb\x99\x87\x95\xd7\
\x8b\x47\x80\x5f\xe9\xd3\xdb\x0f\xd7\x7e\xfc\xfb\x72\x0a\xa8\xe6\
\x0c\x50\xc3\x15\x36\x06\x86\x07\xec\x0c\x0c\xbf\xf9\x80\xea\x19\
\xc9\xb0\xf4\x10\x10\xdf\x03\x62\x50\x21\x08\x10\x40\x2c\x50\x31\
\xee\x1f\x0c\x0c\xfe\xac\x0c\x6c\xce\x52\x72\x92\xe6\xca\xba\x32\
\x2a\x5a\x26\x52\xec\x5a\x86\x82\x0c\x82\xc2\xac\x0c\x6f\x5f\x7d\
\x93\x7a\xfa\xe8\x8b\xcb\x93\x7b\x1f\x19\x9e\xdc\xff\xfa\xf1\xc1\
\xa5\x47\x8f\x5e\x3d\x7a\x9c\x0e\xd4\x77\x9c\x1c\x5f\x3b\x00\x31\
\x3b\x94\x0d\x10\x40\x60\x07\xb0\xb3\xb0\x2c\x08\xca\x70\x0b\x31\
\x76\x90\x63\x90\x53\xe6\x60\x60\x17\x07\x4a\xf3\x70\x03\x25\x44\
\x18\x18\x98\x79\x19\x84\xff\x7d\x62\x50\xfb\xf7\x8e\x81\xe1\xcf\
\x27\xa0\xea\xe7\xfc\xe7\xe7\x7f\xd2\x6d\xcb\x7d\x6c\x4b\xae\x03\
\x40\xa1\x6d\x0b\x65\x03\x04\x10\xd8\x01\xdc\xac\x8c\x1a\xde\x1e\
\x7f\x19\x78\xdd\x78\x18\x18\x58\x85\x40\x22\x50\xa9\x3f\x40\x0c\
\xb4\x98\x99\x19\x48\x03\x1d\xc3\x2e\x0d\x8c\xa7\xaf\x0c\x7c\x2c\
\xb7\x41\xda\xac\xbf\x03\xa3\x89\x11\xa2\xe8\x0f\x8e\xd8\xf8\x05\
\x0a\x69\x18\x07\x68\xca\x6f\x60\xf4\x5d\x80\x49\x80\x00\x40\x00\
\x81\x1d\xc0\xcc\xc4\xc0\xf8\xeb\xd7\x17\xa0\xe1\xaf\x18\x18\x3e\
\xdc\x67\x60\x60\x03\x9a\xc5\xcb\xcb\xc0\xc0\xc4\x06\xd5\x0f\x33\
\x9b\x15\xa8\xf3\x21\x83\xa8\x22\x1f\x43\x70\x8a\xa6\xdf\xef\xdf\
\x7f\xfd\xfe\xff\x81\x9a\x0f\xb3\xe6\x3f\x23\x28\x72\x19\xfe\xfc\
\xfa\x0f\x8e\x63\x30\x1f\x64\x02\xd0\x92\x57\x8f\xbf\x32\x5c\x3c\
\x75\x6f\x0e\x3b\xc3\xff\x4c\xa8\xc3\x19\x00\x02\x08\xec\x00\x26\
\x16\x26\x26\x56\xb6\x3f\x0c\x77\x96\x1c\x62\xd8\xbd\xe6\x2d\x83\
\x81\xb5\x0e\x83\x65\x22\xd0\x72\xe9\x7f\x20\x9d\xa8\x99\x86\xe3\
\x1b\x03\x9f\x05\x37\x43\x84\xdb\x4f\xb0\x45\x0c\x7f\x19\x21\x61\
\x0a\x72\x08\x2c\x25\xff\x03\x8a\xfd\x65\x82\xd0\xbf\xff\x43\xc5\
\x80\x92\xcf\xd8\x19\xd6\xcd\xd3\x4d\x59\xb7\xf0\xa6\x38\xf3\xdf\
\x9f\xf1\x40\xd1\xf7\x00\x01\x04\x76\x00\x2b\x1b\x23\xdb\x8f\x6f\
\x9f\x19\x16\xf7\x3c\xfa\x7a\xe9\xe6\x3f\xef\x63\x3b\x2f\xe6\xca\
\xea\xbb\x04\xcb\x48\x9e\x00\x06\x0f\xcc\xf7\x8c\x0c\xbf\x7f\xfe\
\x67\xf8\x74\xf3\x3f\x38\x30\x19\x19\xbe\x43\xe2\xf3\xdf\x7f\x06\
\x26\xa0\x9a\x7f\x7f\x81\x34\x30\x80\x80\x5c\x06\xc6\xbf\x10\xb7\
\xfe\x63\x84\x8a\x01\x1d\xc1\x04\x12\x60\xfa\xc4\xe0\x1a\xc5\xc6\
\x20\xa5\x28\xef\x3b\xb7\xf5\xde\x7e\xa0\x2a\x03\x80\x00\x82\x84\
\x00\x33\x30\x96\x81\x21\xc0\xc6\xcc\x08\xb2\x0d\x68\xd4\xff\x9f\
\xff\xff\x03\x4d\xf9\xfd\x16\xe8\xcb\xbf\xf0\x58\xf8\x07\xb4\x93\
\xfd\x23\x28\xd1\x02\xb9\x4c\x90\x48\x05\x99\x0b\x0a\xa4\xff\xc0\
\x00\x63\x7e\x07\x11\xff\x27\x0a\x11\x67\x7a\x03\xa4\xbf\x01\xb1\
\x38\x50\x5e\x00\x28\x07\x32\xe7\xfd\x77\x86\x8f\x97\x3e\x31\xfc\
\xf9\xc3\xf0\x18\x64\x37\x40\x00\xb1\x40\xa2\xef\x3f\x2b\xb7\x00\
\x33\x43\x7c\x13\x2f\x97\xe4\xf2\xcf\x87\xd5\xf5\xe4\x18\x64\x75\
\xaf\x33\x30\x7c\xf9\x8b\x92\xa2\xd8\x81\x86\xb2\x1b\xc0\x03\x84\
\x01\x1a\x08\x10\x36\x30\x55\xfd\x03\x26\x9f\x4f\x40\x37\xf3\x8b\
\x42\xe4\xbe\x5f\x61\x60\xb8\x71\x89\x81\x41\x55\x13\x98\xa9\xb4\
\x80\x62\x4f\x18\x18\xd6\xcf\x67\x60\x58\xbd\xe7\xff\x12\x60\xc0\
\x24\x81\xb4\x02\x04\x10\x24\x11\x02\x43\xe0\x3f\x50\x87\x8c\xc9\
\x4f\x86\x24\x33\x2e\x60\x18\x3c\x05\xc6\x29\x30\x51\x7e\x44\xb2\
\x1d\x16\x13\xff\xa1\xe5\x27\x08\xbf\x67\x60\x78\x7a\x8c\x81\xe1\
\xf5\x73\xa0\x72\xa0\x03\x4e\x1f\x60\x60\xb8\x7c\x83\xe1\x69\x7c\
\x3c\x83\x34\x27\xd0\x86\x95\x2b\x19\x3e\xde\x7d\xca\xb0\x52\x9c\
\x8f\xc1\xc4\xd2\x98\xc1\xe8\x2f\x30\xd9\x6d\x3b\xcc\x30\x1f\x28\
\x95\xcc\x08\x4d\xb6\x00\x01\x04\x49\x03\xac\x0c\xac\xcc\x2c\x7f\
\xc0\xc1\xc3\xf0\x17\x87\xa5\x88\xa4\xc0\xf0\xfd\x05\x50\x29\xd0\
\xd2\xef\x40\x07\xce\xeb\x64\x60\xb8\xfd\x92\xa1\x0b\x68\xd0\x6b\
\xa0\xd4\x6d\xa0\xbb\x0e\x4d\x9d\xcc\x50\x07\x64\x4b\x00\x4d\xac\
\xe7\x64\x60\xb8\xf5\xee\x13\x03\xf3\x86\xfd\x0c\x2e\x40\x39\x45\
\x60\x4c\xcd\x40\x0e\x55\x80\x00\x82\x44\xc1\xff\xbf\xbc\x7f\xbf\
\x03\x6d\x16\x12\x06\x5a\x00\x4c\xdd\xbf\x80\x18\xc4\xff\xf5\x0f\
\x12\xcf\x6c\xd0\xf8\x66\x86\xe8\x58\xd9\xc5\xc0\xb0\xe7\x00\xc3\
\x76\x20\x17\x18\xe8\x0c\xa7\x81\xa5\xc6\x02\x64\x43\x81\xee\x2d\
\x64\x80\x6a\x83\x5a\xf2\x17\x88\x77\x22\xc9\x83\x32\x34\x18\x00\
\x04\x10\x23\x28\xaf\x26\x31\x31\xb6\x89\x8a\x31\xf9\xca\xa9\xb1\
\x28\x29\xe9\x32\x71\x29\xe8\x30\x30\x48\xa9\xfe\x61\xe0\x13\xfa\
\xcb\xf0\xeb\xeb\x7f\x86\xcf\xaf\x20\x3e\x7e\x03\x8c\xc3\x97\x0f\
\x19\x18\xf6\x6d\x61\xb8\xf7\xee\x0b\x83\x1a\x0b\x24\x13\x12\xac\
\xed\xfe\x61\x11\xdb\x03\xc4\x0f\x81\x76\x03\x04\x10\xd8\x01\x89\
\xc0\xc4\xff\x1b\xe8\x50\x60\x90\x29\x01\x5d\x67\x08\x74\xb9\x95\
\x00\x0f\x83\x99\xa8\x24\x83\xda\xf7\x4f\x0c\x9f\x3e\xbc\x63\x78\
\xf0\xed\x37\xc3\x5d\x60\x34\xdf\x02\x1a\x76\x9b\x83\x81\xe1\x22\
\x13\xa4\x3e\x21\x08\x80\xc9\x84\x41\x10\x4d\x0c\x94\xff\x1e\x42\
\x2b\x23\x80\x00\x62\x1c\xe8\x66\x39\x40\x00\x0d\x78\x7b\x00\x20\
\x80\x06\xdc\x01\x00\x01\x34\xe0\x0e\x00\x08\xa0\x01\x77\x00\x40\
\x00\x0d\xb8\x03\x00\x02\x68\xc0\x1d\x00\x10\x40\x03\xee\x00\x80\
\x00\x1a\x70\x07\x00\x04\x18\x00\xab\x94\x83\xf9\x01\xe4\xcd\xd5\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x04\x79\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x40\x49\x44\x41\x54\x78\xda\x95\x54\x5f\x4c\x53\x67\
\x14\xff\xdd\xdb\xaf\xff\x4b\x0b\x6b\x69\x29\x4c\xa5\x08\x28\xa4\
\x89\x86\x69\x13\x43\xc4\xd0\x07\xc3\x83\x43\x1f\xc6\xab\xf1\xc5\
\x38\xe3\xdb\x92\xbd\xec\x71\x3e\x2e\x59\x5c\xb2\x64\x09\x4f\x1a\
\xb3\x30\x97\x85\x2c\xf1\x11\xb0\x61\x18\x48\x48\x5c\x85\xe8\x56\
\x15\x03\x5d\xb5\xc0\x4c\x65\x4a\x69\x6f\x7b\x7b\xef\xdd\x39\xb7\
\xac\xb5\xcc\x07\x39\xc9\x97\x93\xf3\x7d\xe7\xfe\xee\xef\xfc\xce\
\xf9\x3e\xc9\x30\x0c\xec\xc7\xbe\x96\x24\xa9\x23\x16\xfb\x2e\xd0\
\xd3\x73\xde\xe6\xf1\x04\x35\x5d\x47\x7e\x6b\x6b\x23\x9b\x4e\xff\
\xf2\xc5\xe2\xe2\x97\xd8\xb5\x7d\x01\x8f\x47\xa3\x7d\xe1\x81\x81\
\x99\x63\x97\x2e\x85\xfd\x7d\x7d\x0d\x67\xd9\x85\x05\xcc\xde\xbc\
\xf9\xd7\x1f\x4f\x9f\xc6\xbf\x4d\xa5\x9e\x8b\xfd\x30\x3d\x32\x32\
\x32\x3d\x70\xf5\x6a\xd8\xdb\xd5\x85\xfc\xe6\x26\x2a\x6f\xde\x80\
\x4d\x6e\x6e\xc6\x47\x03\x03\x38\xe3\xf1\x1c\x7c\x7b\xfd\xfa\x14\
\x80\x2e\x19\x1f\x68\x1f\x9f\x3c\xf9\xbd\xcb\x6e\x6f\x17\x5e\x2f\
\x9a\x42\x21\xf8\x8f\x1e\x45\x7e\x7b\x1b\x79\x45\x41\xa8\xbf\x1f\
\xfe\xce\x4e\x58\x03\x01\x84\x0d\x23\xf2\x55\x2c\xf6\x8d\x20\x22\
\x0c\xde\xca\xb2\xe0\x3d\xe6\xf5\x7a\xe5\xee\xee\x6e\xdb\xe7\x86\
\x31\xba\xf3\xe2\x05\xd6\x1f\x3e\x44\x2b\xc9\x20\x6c\x36\x44\x86\
\x87\x61\xb1\x5a\x21\x5b\x2c\xd0\x2a\x15\x6c\x3c\x7a\x04\x75\x63\
\x03\x4e\x9f\x6f\x54\x44\x22\x91\xe5\x58\x2c\xd6\xeb\x76\xbb\x0d\
\x87\xc3\x01\xbb\xdd\x2e\x59\x2c\x16\xd6\x5e\xae\x54\x2a\x46\xa9\
\x54\x42\xb9\x5c\x86\x92\x48\x58\xca\x04\xbc\x7a\xfb\x36\xb6\x5f\
\xbf\xc6\xe0\xb5\x6b\xb0\x39\x9d\x60\xa3\x3c\xcc\xdd\xb8\x01\xed\
\xee\x5d\xc8\xab\xab\xd0\x3a\x3b\x0f\x8b\x40\x20\x70\x64\x62\x62\
\xe2\x7f\x5a\x73\x53\xa9\x9a\x5a\xfc\x03\xb1\xd4\x54\x15\x99\xe9\
\x69\x28\x6d\x6d\xd0\x34\x0d\xb2\x5c\x55\x52\xd9\xd9\x41\x66\x66\
\x06\xe1\xb9\x39\x34\xd3\x77\x82\x48\xc9\xc4\x0e\x1f\x62\x4d\xd4\
\x30\x50\xae\xe7\xdc\x39\x7c\x36\x3e\x0e\x2b\x49\xa0\x52\x25\x4c\
\xc0\xe3\xf3\xe1\xd3\x5b\xb7\x90\x3e\x71\x02\x3e\x92\x68\xc7\xe5\
\x82\xcc\xac\xf6\xda\x36\x37\x25\x9f\x6f\x60\x1f\x3c\x75\xca\x6c\
\x4e\xef\x85\x0b\xb0\xd2\xc7\xa5\x62\x11\x3f\x8e\x8e\x62\xf2\xf2\
\x65\xf3\xbc\x25\x18\x44\xdb\xc8\x08\x1c\x54\x4d\xb2\x50\xd0\xcc\
\xe6\xbd\xa5\xd1\x61\x2b\x6c\x6d\x21\xb3\xbc\x8c\x22\xfd\xcc\x20\
\xdd\x24\x2a\x5d\xd7\x34\xb3\x6c\xdd\xef\x47\x89\x26\x21\x33\x3b\
\x8b\x69\x2a\xfd\xf9\xe4\x24\x8e\xdd\xbb\x07\x0f\xe5\xfe\x4c\x79\
\xad\xa7\x4f\xc3\xbb\xbe\x8e\x45\x9a\x8e\xc4\xc2\x82\x2e\xa0\xeb\
\xd0\x08\x50\x22\xbd\x72\xf7\xef\x63\x27\x99\x44\x81\x18\x55\xa8\
\x41\x5a\x26\x03\x95\x98\xab\x85\x02\x34\x62\x68\xc4\xe3\xd5\xa9\
\xc8\x66\xf1\x09\xc9\xe2\x20\xdd\xbd\x24\xc7\xc8\x93\x27\x50\x69\
\xef\xd7\x5c\x0e\xff\x3c\x7e\x0c\x09\x90\x04\xb3\xd9\x4a\xa5\xa0\
\x10\x50\xe2\xca\x15\xae\x1b\xd6\x68\x14\x3a\xb1\x02\x75\x98\x3b\
\x20\x03\x9c\x6c\x8e\x95\xeb\xc1\x03\xfc\x4e\xac\xbc\x24\x8b\xcb\
\xe1\x30\x27\x43\x21\x52\x9b\xcf\x9e\xc1\x99\x4e\x83\xe7\x84\x1a\
\x20\x09\x95\x4a\x56\x5e\xbd\x02\xc8\x47\xa8\x1c\x99\x80\x2b\xe1\
\x30\x64\x2a\xcf\xd1\xd1\xc1\x80\xbc\xcc\x1f\xa6\xdc\x6e\x1c\x1e\
\x1c\x84\x01\x40\xa7\x58\xa3\xa5\x93\x14\x7f\xd3\x85\xe9\x05\xa0\
\xb5\xb7\x43\x21\xa2\x06\x55\xcd\xc0\x86\xfd\xf8\x71\x94\xa9\x5c\
\xd7\xc5\x8b\xa6\x9e\x25\x5a\xfc\x43\x9d\x65\xfa\x4f\x63\xae\x8c\
\x64\xc9\x9e\x3d\xcb\x73\x5b\xd5\x7e\xf7\x3c\x4b\x57\xdb\x38\x70\
\xc0\x8c\x4b\xb4\x90\x4c\x6a\x12\xdd\x2a\x35\x95\x4a\x09\xee\x2c\
\x03\xb1\x5f\xa7\x26\xb0\x0f\x06\x83\xec\xab\x8b\xce\x7e\xba\x73\
\x07\x63\x63\x63\xb5\x58\xdf\x3d\x4b\x24\x12\x38\x33\x34\x64\xc6\
\x45\xea\x45\x7f\x7f\x7f\x51\xd0\xcd\x32\xde\x01\xad\xb1\x24\xdf\
\xf0\x31\x2d\x9e\xdb\x5a\x9e\x51\xf5\x7c\xce\x15\xd4\xf6\xd9\xe8\
\x16\x43\xd0\xcc\x32\x50\x03\x33\x4e\x32\x93\xf7\x30\x2b\xab\x6a\
\x3d\xae\x83\x9b\xb9\x0c\xc9\x93\x25\xa8\xc1\x2d\x2d\x2d\x92\x20\
\xea\xf2\xd2\xd2\x12\x83\xd7\x56\x2e\x97\xe3\xf7\x81\x86\x62\xb5\
\xba\x47\x1f\x56\xc8\xaf\xad\xad\x61\x6a\x6a\x8a\xf7\x38\xae\x9d\
\xad\xd2\xbe\x10\x02\x36\x7e\x90\x08\xbc\xa9\xa9\x49\x98\xda\x46\
\xa3\xd1\x06\x26\xd9\x97\x2f\xa1\x28\x0a\x0e\x1e\x3a\xd4\xc0\x8c\
\x7a\x81\xe1\x78\xbc\x41\x06\x09\xc0\xfc\xfc\x3c\x86\x48\x63\x66\
\xcc\x4d\xf5\xf9\x7c\x86\x00\xc0\xa5\xd7\x93\xeb\xba\xed\x2d\x9b\
\xab\x68\xc8\x35\x8d\xc0\x2c\x42\xf0\x83\xc5\x6c\xd9\x33\x63\x49\
\x50\x22\xdd\x5c\x95\x37\xeb\xe0\xe4\xd5\x7a\x43\x6a\x5a\x53\xf3\
\xd8\xd7\x62\x06\x91\xaa\xaf\x60\xbd\xb2\xdd\xe6\x49\xa1\x50\xe8\
\x4f\xd2\xb4\xe7\x3d\x8f\x91\x6c\x90\xed\x79\x4a\xa5\x77\x03\x3b\
\xdd\x3c\x8f\xc7\xc3\x40\xbc\x0c\x97\xcb\x25\x39\xe9\x26\xae\xac\
\xac\xfc\xf6\x2f\x24\x1d\xf7\xc4\xbc\x92\x33\x7d\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x05\x32\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\
\x01\x42\x28\x9b\x78\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\xaf\x49\x44\
\x41\x54\x58\x85\xcd\x57\xdf\x6f\x53\x55\x1c\xff\x9c\x5f\xf7\xb6\
\xa5\x5d\xbb\x6e\x5d\x9a\xb5\x64\x60\xdc\x9c\x9a\xb9\x61\x14\x5d\
\x22\x99\xfa\x40\x8c\x89\x7b\xda\xc3\x5e\x20\x24\x06\x4d\x90\x27\
\xe3\x9b\xff\x07\x0f\x2e\x98\x65\x24\x46\x13\x9e\xd0\x84\x38\x35\
\x41\x47\xb2\x44\x10\x86\x9a\xa9\x80\x80\x30\xc1\x09\x6c\xc3\xf6\
\x76\xbd\xe7\xde\x73\xbe\x3e\x0c\x96\xb5\xeb\x1d\xdb\x90\xcc\x93\
\x7c\x1f\x9a\x7e\x7b\x3f\x9f\x73\x3e\x9f\xef\xe9\xe7\x32\x22\xc2\
\x56\x2e\xbe\xa5\xe8\xff\x07\x02\x72\x23\xcd\x23\xa7\xfb\xba\x38\
\x63\x83\x20\x0c\x31\x8e\xa2\x25\x64\x01\x80\x33\xcc\x91\xc5\x0c\
\x18\x8e\x5b\xa2\x13\x07\x5f\x99\xba\xb8\xde\x67\xb2\xf5\x78\x60\
\xf4\xcc\xee\xbc\xd1\xc1\x18\x01\xfd\x64\xad\x22\xc0\x05\x11\x1e\
\xfc\x92\x01\x00\x63\x60\x80\xcf\x38\x0f\x18\x30\x29\x1c\xb5\xff\
\xc0\x8b\xdf\xff\xf5\xc8\x04\x8e\x4e\xf4\x0e\x13\xe7\x47\xac\xb5\
\x49\x63\xac\x5a\xc7\xa6\x20\x04\x0f\x38\xe7\x65\x66\xed\xa1\xb7\
\xf7\x5c\xf8\x74\x53\x04\x46\x4f\xed\xca\x84\x92\x8e\x01\x34\xa0\
\x03\x93\xda\xe8\xb4\x30\xc6\xe0\x28\x51\x02\xd8\xb7\x32\x64\xfb\
\x0e\xbc\x7a\x7e\xa1\x51\x5f\xa4\x07\x42\x49\xc7\x42\x63\xf7\xea\
\x20\x74\x36\x84\xbc\xbc\x08\xa1\xb1\x29\x47\xc9\xbd\x90\xfc\x18\
\x80\xb7\x1a\x75\x35\x9c\x82\xa3\x13\xbd\xc3\x44\x34\x50\xd5\xda\
\xb1\x64\xf1\x28\x55\xd5\xda\x21\xa2\x81\xa3\x13\xbd\xc3\x8d\xb0\
\x56\x49\x30\x7a\x66\x77\x3e\xf4\xf5\xb4\xb7\xe8\x37\x1b\x6b\x37\
\xb7\x79\x00\x97\x7e\x08\xb1\xa3\x47\x42\x39\x80\xe0\x1c\xdb\xe2\
\xee\xbc\x74\x9d\x67\xea\x8d\xb9\xea\x04\x42\xad\xc7\xaa\x3a\x48\
\xea\x30\x84\xb1\x76\x53\x75\xe9\x9c\xc1\xf9\x2f\xb2\xf8\xe6\x63\
\x89\xd2\x82\x81\x0e\x43\x54\x75\x90\x0c\xb5\x1e\xab\xc7\xab\x21\
\x30\x72\xba\xaf\x8b\x08\xfd\xde\x62\x55\x59\x6b\xb1\x99\x9a\xbd\
\x46\x98\xfe\x3a\x0b\xc9\x5d\x54\x6e\x37\x63\xfa\x3b\x09\x6b\x2d\
\xbc\xc5\xaa\x22\x42\xff\xc8\xe9\xbe\xae\x48\x02\x9c\xb1\x41\xdf\
\x0f\x94\xb5\x84\xcd\x54\x69\x0e\xf8\xe9\x64\x2b\x98\x49\x40\x4a\
\x89\x74\x5e\xe3\xd9\xd7\xf4\xf2\xf7\xbe\x1f\x28\xce\xd8\x60\x24\
\x01\x6b\x69\xa8\xaa\xb5\x5b\x63\x22\x0f\x08\xcd\xc3\xcd\xa6\x7d\
\xc2\xf4\x97\x6d\x08\xbd\x6d\x10\x42\xc0\x4d\x10\x7a\xde\x98\x87\
\x70\x6a\x0c\xe9\x5a\x4b\x43\x2b\x31\x6b\xc7\x90\xa1\xa8\x43\x03\
\x63\x97\x8c\xa9\xcb\x0a\xbf\x8d\x17\x20\x63\x06\x9d\xaf\xdf\x82\
\x8c\x85\xab\xdd\x06\x80\x08\xb8\x7c\xaa\x00\xef\x76\x12\x52\x02\
\x8c\x01\x9d\x03\x77\x90\x68\xd5\x30\x2b\x7c\xac\x43\x03\x30\x14\
\x23\x09\x30\xb0\x6c\x10\x86\x78\x30\x19\x0b\xd7\xb2\xa8\xdc\x4d\
\x02\x00\x2e\x9e\x4c\x60\xe7\xc0\x75\xb8\x19\x6f\x15\x81\xd9\xf3\
\xdb\x31\x77\x35\x03\x79\xff\x69\x85\x9e\x7b\x68\xe9\x9c\x43\xfd\
\x10\x05\x44\x60\x60\xd9\x48\x09\x08\xa8\xd1\xb4\xa5\xfb\x26\x8a\
\x3d\x1e\x84\x10\xa8\xcc\xc7\xf0\xfb\x57\x4f\xc2\xbb\x99\xab\xd5\
\xfd\x6a\x3b\x6e\xfd\x9c\x83\x10\x02\x42\x08\xe4\x3a\x2c\xf2\xcf\
\xdf\x88\xf4\x49\xfd\x7d\x5a\x37\x86\x34\xc7\x19\x96\x1d\x6d\xac\
\x45\x6e\xd7\x65\x14\x9e\xd6\x90\x52\x22\xf4\x1d\xfc\x31\xb1\x13\
\xde\x95\x27\x60\xad\x85\xbe\xd3\x86\x3f\xcf\x16\xc1\x99\x80\x94\
\x12\xc9\x8c\x40\xe1\xa5\x2b\xb0\x08\x1a\x4e\x08\x67\x4b\x18\x91\
\x12\x10\xd1\x0c\xe7\xa2\x60\xec\x4a\xad\x0d\x9a\xfb\xa6\xc1\xd1\
\x87\xdb\x57\x63\x00\x01\x37\xce\xe6\x51\x5c\xcc\x60\x7e\x26\x0e\
\x6b\x08\x52\x02\x9c\x33\x74\xbc\x7c\x1d\xd6\xfd\x07\x88\xb8\xbf\
\x5c\x2e\x40\x44\x33\x91\x27\xc0\x38\x8e\x27\x62\x8e\x5f\xef\x70\
\x03\x1f\x4d\xcf\xfd\x88\xb6\x1d\x76\xf9\xa8\x6f\xfd\xba\x0d\xd5\
\x32\x5f\xfe\xbc\xe3\x85\x32\x6c\xf3\x95\x35\x27\x25\x11\x73\x7c\
\xc1\xf9\xf1\x48\x02\xa5\x7b\xfa\x84\xa3\x64\x40\x0d\xb4\x0b\x51\
\x41\xba\x77\x0a\xb9\xed\x1c\x52\xca\x9a\x6a\xef\x64\xa0\xf6\xa9\
\x35\xef\x08\xb2\x84\x64\x22\x1e\x58\xa2\x13\x91\x04\xde\x7f\xf3\
\x97\x8b\x15\xdf\x9f\x4c\x25\xe2\x41\x23\x0d\xab\x76\x01\xa9\x9e\
\x73\xc8\xe6\xc5\xf2\xce\xd3\x2d\x0a\xb1\xce\x29\x84\xc6\x5f\xf3\
\x86\xcc\xa6\x93\x01\xe7\x6c\xb2\x3e\x2d\xad\xfa\x2f\xa8\x7a\x76\
\x3f\x17\xac\xcc\x39\x87\xb1\xb4\xaa\x3c\xfb\x37\x52\x3d\x17\x90\
\x69\x75\x10\x8b\x39\x68\xed\xbd\x06\xcf\xce\x36\xec\x7d\x50\x4a\
\x4a\xb4\xa4\x53\x65\xe5\x3a\xfb\xeb\xf1\x1a\x06\x92\x0f\x3f\xcb\
\x0f\x0b\x21\x3e\xba\x57\xaa\xa4\xa2\x62\x48\x13\xeb\x46\x3c\xd8\
\x89\x59\x79\x32\xa2\xe3\x3e\x00\x63\x78\xaa\xa3\xbd\xa4\xa4\x78\
\xe7\x60\x83\x74\x14\x99\x88\x3e\xf8\xa4\xed\x73\x01\xb6\xd7\xab\
\x56\x37\x19\x48\x96\xc0\x0b\xb9\x16\xdd\x9c\x4e\x8e\xbf\xbb\xe7\
\xc2\xfa\x03\x09\x00\xdc\xd5\xc1\xbe\x20\x34\xe3\x89\x58\xac\xc4\
\x58\x63\x39\xd6\x2a\x47\x29\x74\x77\x14\x4a\xcd\xe9\xe4\xb8\x6b\
\xf8\xbe\x48\x92\x0f\xcb\x7a\x87\x47\xd3\xc3\x71\xe5\x1c\x09\x8d\
\x4d\x56\xaa\xfe\x43\x43\x29\x63\x0c\xed\x2d\xd9\x20\x9f\xcb\x94\
\x19\x70\xa8\xd1\xb1\x6f\x88\x00\x00\xbc\x37\x9a\xcc\x2b\xe6\x8e\
\xb9\x8e\xec\x37\x86\x94\x0e\x02\xd7\x58\x8b\xd0\x18\x00\x0c\x8e\
\x92\x70\x95\x44\xb6\x29\xe9\x67\xd3\xa9\x40\x30\x4c\xaa\x78\xec\
\xbf\x89\xe5\x2b\xd7\xe1\x91\xa6\xae\x44\xdc\x1d\x14\x52\x0e\xc5\
\x1d\x55\x74\x5d\x95\x75\x1c\x05\x57\xca\x39\x26\xf8\x8c\x23\xc4\
\xe3\x79\x31\x79\x9c\x6b\xcb\xdf\x0d\xb7\x9c\xc0\xbf\xbd\x57\xbd\
\x04\xb5\x69\x5e\x47\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x0a\x45\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0a\x61\x00\x00\
\x0a\x61\x01\xfc\xcc\x4a\x25\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x08\x47\
\x49\x44\x41\x54\x68\xde\xed\x59\x4d\x8c\x1c\x47\x15\xfe\x5e\x55\
\xcf\xec\x8f\x77\x17\xff\x44\x62\xc3\x22\x3b\x31\xc6\xc8\x09\x20\
\x41\x90\x85\x91\x20\x82\x43\xc4\x01\x45\x82\x0b\x0a\x47\x5f\x48\
\x0e\x9c\xf0\x95\x08\xc1\x19\x38\x07\x24\x24\x2e\xdc\x11\x07\x0e\
\xe4\x90\x0b\x21\x8a\x10\x87\x20\x01\xb1\x1d\xdb\x1b\xbc\x11\x5e\
\xec\x2c\xde\x9d\xdd\x99\xe9\xae\xf7\x1e\x87\xfa\x99\xea\x9e\xee\
\xde\xf5\x0a\x29\x41\xa2\xb5\xa3\xed\xae\xa9\xae\xfa\xbe\xf7\x7d\
\xaf\xfe\x06\xf8\xff\xf5\x21\xb9\x54\x15\xaa\xba\xa2\xaa\xe6\x83\
\xc6\xf2\x28\x17\x65\x04\xec\xcf\x5f\x79\xe5\xb7\xd7\xdf\xbe\xfe\
\xf5\xca\x55\x04\x10\x28\x7c\x7b\xee\x89\xf3\xf8\xfc\x95\xaf\x60\
\x79\x61\x08\x43\x06\x86\x00\x10\x81\x42\x05\x43\xc6\xdf\x87\x32\
\x32\x04\x63\x7c\x99\x31\x36\xb5\xa3\xaa\x80\xaa\xbf\x87\x00\xea\
\xef\x7c\x99\x2f\x77\xcc\xd8\x1f\x97\xf8\xc3\x6b\xbf\xc7\xbb\x9b\
\x77\xfc\x3b\xe1\xdd\x41\x31\x90\xa7\x3f\xf3\xe9\xdf\x5c\xbd\x7a\
\xf5\x5b\x11\x77\x91\x98\x10\xf1\x4b\xdf\x7d\xf1\xb9\xbd\xbd\x3d\
\x7a\xb8\xfb\x10\xd6\x58\xac\xaf\x3f\x0e\x00\x38\xb1\xb2\x82\x8d\
\xb3\x4f\x60\x75\x69\x11\xd6\xf4\x0b\x44\xbe\x31\xc0\xff\x85\x08\
\xf9\x60\x44\x22\x81\x3f\x40\x04\x13\x0a\x88\x08\x14\x08\xfc\x7b\
\x7f\x82\x95\x13\x2b\x98\x8c\xa7\xb5\xb6\xcb\x69\x65\xfe\xfe\xd7\
\xbf\x3d\xaf\xaa\x29\x78\x45\x5e\x41\x55\xec\xee\xde\x1e\xca\xb2\
\x42\xe5\x0e\xb0\x8e\x8f\xd6\x80\x19\x43\x87\x12\x48\xf8\xa9\x51\
\x06\x80\x02\xda\x44\xcc\x04\x02\xd9\x3b\x24\xf9\x8b\x32\xd7\xb6\
\x88\x58\xca\x1a\x2f\xea\x5f\x02\xc3\xe1\x10\xeb\x8f\xaf\xe3\x60\
\xb4\x0f\x89\xef\xab\x82\x08\x30\x44\x78\xed\x4f\x7f\x39\x8a\x23\
\x5b\x4b\x72\x52\x33\x35\x66\xb2\x10\x80\xaf\x5e\x7e\x1a\x86\x08\
\x0a\x9d\xf5\x5f\x0b\xb2\xd6\x9e\x8b\xfa\xd7\x02\xe7\x1c\xde\xbb\
\xbb\x05\xc7\x8c\xb3\xcb\x4b\xb5\x0e\xad\x01\x9e\xfb\xe2\x67\x0f\
\x09\xbf\xaf\x4c\xd9\xe3\xbc\x0a\x33\xf0\x14\xe4\x30\xa1\x66\xc9\
\xce\x57\xd4\x76\x05\x54\xeb\x65\x0d\x05\x14\x8f\x9d\x39\x53\x7b\
\x8e\xac\x7d\x42\x12\xac\x21\x28\xda\x2f\x4a\x28\xe7\xb5\xa0\x18\
\x6b\xd3\x78\xa6\x94\x32\xbe\x9c\x03\x50\x68\xea\xbf\x89\xb1\x93\
\x40\x53\x9e\x26\x38\x1b\x08\xf4\x47\x7f\x1e\x78\x4d\x89\x06\x60\
\x84\x60\x8b\xfa\xfe\x59\x3c\xc8\x30\xac\xcf\x13\xd0\x5e\x02\x2d\
\xa6\x0b\x5d\x18\x43\x30\x06\x30\x05\xf9\x1e\x9b\x6d\x67\xe0\xdb\
\xec\x93\x83\x85\x7a\x73\xa8\x2a\x14\x9a\x46\x52\x05\xc0\x22\x10\
\x55\xa8\x68\x2b\x1e\x95\x5e\x0b\x75\xc0\x57\x4d\x78\x73\xd9\x6b\
\xa0\x1a\x28\x13\xc7\x00\x52\xb3\x8a\x11\x6c\x8d\x40\x28\x67\x16\
\x40\x15\xa2\xc7\x4c\xe2\x76\x02\x9e\x39\xb3\xe0\xd7\xaf\xbe\xde\
\x6b\xb5\x26\x2b\x89\x0d\x74\x54\x49\x5f\x85\x9b\x6f\x3c\xfb\x8c\
\xb7\x50\x07\x9e\x5e\x0b\xf5\x29\x20\x0a\x38\x56\x7c\xf3\x6b\x97\
\x67\xc9\xda\x12\xf5\xf9\x32\xaf\x85\xe6\x75\xb2\xba\xaa\x92\x29\
\xe2\x27\x32\x81\xf7\x7f\xbb\x02\x3d\x16\xea\xca\x01\x09\xbe\x74\
\x22\x20\xee\x49\xe2\x16\xe2\x68\xda\x67\x8e\x88\xd4\x56\x14\xcc\
\x1e\xb8\x88\x74\xe4\xc0\x31\x46\x21\xef\x47\x05\xb3\x82\xd0\x95\
\xe8\x6d\x6a\x64\x04\xb2\xf2\xbc\x9b\xa8\x40\xac\xed\x44\xbc\x85\
\xa4\x63\x14\x92\x5e\x0b\x75\x10\x10\x09\x16\x3a\x02\x78\xcc\x92\
\xb7\x35\xfa\x19\x01\x0d\x93\x55\xae\x0a\xb3\x40\xa0\x7e\x34\x6a\
\xc1\xd3\x6b\xa1\xae\x24\x16\xf1\x23\x83\x63\x1f\xad\x2e\x13\x69\
\xed\x4e\xeb\x65\x6d\xfe\x07\x00\x6d\x10\x10\x81\x8a\x42\x54\x70\
\x8c\x99\xb8\x03\x58\xb4\x90\x08\x5e\x7d\xe3\xad\x23\xa9\xd0\xa7\
\x8e\xd6\x19\xd4\xbe\xfd\xf2\x33\x4f\x05\x0b\x49\x2b\x9e\x66\x59\
\x5d\x81\xbe\x24\x86\x82\x59\xf0\xec\x17\x9e\x42\xeb\x94\xdb\x16\
\xf5\x66\xf4\xd1\xf0\x7f\x1e\xd1\xa4\x80\xa6\x9c\xc3\x23\x4f\x64\
\x5d\x49\x2c\xbe\xc1\x0a\x32\xb7\x0c\x68\x52\x68\x7b\xd0\x66\x71\
\x63\x14\xca\x09\xf8\xc4\x25\xdf\x67\x0b\x1e\x45\x5f\x0e\x74\x8e\
\x42\x7e\x18\xed\xf4\x58\xcf\x55\x1f\x71\x9a\x44\xea\x33\x71\x2c\
\x37\x08\xcb\x88\x47\x1e\x85\xba\x2c\xe4\x04\xaa\x0a\x27\xa1\xa7\
\x23\x48\xa0\x5d\x5f\xd5\x46\xa0\xb4\xc8\xa8\x63\xb5\xc6\x4f\x68\
\xda\xb6\xa1\xe9\x9b\x07\x3a\x02\xfc\xe6\x1b\xaf\xe3\xbd\x7b\xdb\
\x28\x27\xe3\xa3\x45\xfd\x90\x52\xed\xae\x04\x10\x61\x61\x61\x01\
\x5b\x77\xde\xc1\xa0\x18\xb4\x34\xd3\x37\x13\x77\x0c\xa3\x45\x61\
\xf0\xcf\x7f\xdc\xca\x7b\x09\xfb\x16\x4a\xab\xbb\x7c\x73\x12\xeb\
\x74\x92\x48\xab\xcf\x99\x1c\xb3\x67\x0d\x7d\xda\x56\x3c\xd2\x4b\
\x40\xba\xc2\x32\x0f\xe4\xa8\x35\xff\xdb\xd7\xb1\x96\x12\x1f\xa6\
\xab\x7f\x35\xfa\x3f\x40\xa0\x7f\x29\x71\x64\x0b\x7d\x80\x04\x7a\
\x87\xd1\xa3\xac\x34\xc3\xe5\x93\xb6\xfd\x03\x20\xfd\x6f\x9d\xb0\
\x31\xb3\x6b\xdc\xfb\xce\x7d\xd0\x35\xa9\xf6\x2a\x70\x38\xf0\x6f\
\x7f\xe7\x05\x5c\xf9\xd2\x95\x88\xa2\x31\xfb\x3e\x5a\x72\xab\x2a\
\xde\xdd\xdc\xc4\xb5\xef\x5f\x43\x61\x6d\x9a\xdc\x9c\x08\x0a\x6b\
\xf1\xb1\x70\x32\xd8\x7c\xa7\x5b\x01\xe1\xde\x0e\x8b\xa2\xc0\xca\
\xea\x0a\xb6\xb7\xb7\x6b\xd1\x9b\x53\x87\x08\xf9\xf1\x5f\x4d\x91\
\xec\x3d\x22\xc2\x47\x4e\x9e\xc4\xd2\xd2\x22\x96\x97\x96\xd3\xac\
\xcc\x8e\xb1\x77\x30\x6a\xc5\x23\xdc\xa3\x80\xeb\x21\x50\xd8\x02\
\xa6\xb0\x35\x99\x8d\x31\xb0\xd6\x06\xf2\x92\x80\x47\x70\x91\x1c\
\x35\xce\x19\x4d\x38\x9e\x14\x11\x30\x33\xac\xb1\x30\xd6\xf8\xd3\
\x0a\x15\x98\xc2\xa2\xb0\x45\x2b\x1e\x23\xae\x4f\x81\x6e\x0f\x31\
\x18\xd3\xc9\x14\xce\xb9\x04\xf0\x67\x3f\xf9\x29\xc6\xe3\x49\x8c\
\x2b\xca\xaa\x02\x11\xf0\x83\x97\x5f\x0e\x07\x61\xfe\x84\xda\x6f\
\x0f\xb3\x99\x58\x15\xcc\x0c\x66\x86\x31\x26\xd8\x8e\xa0\xa4\x80\
\x12\xa0\x92\xde\x9b\x53\xa0\xff\x58\xa5\x9b\x00\x81\x60\x0b\x0b\
\x6b\xad\xef\x54\x15\x5b\x5b\x77\x67\x15\x14\xa8\x9c\xc3\x74\x3a\
\x4d\xc9\x9c\x2b\x20\x22\xe9\x13\x55\x72\xce\xa5\x53\xe9\xb4\xb3\
\xc7\xcc\xe7\xad\x04\xfa\x2c\x24\x3d\x5b\x46\x13\x96\x0f\xb9\xef\
\x6b\xf5\x15\x28\xcb\x12\x93\xc9\x24\x75\x4c\x44\x60\xe6\x64\x95\
\x9c\x40\xbc\x9f\xd9\x4e\xa0\x12\x37\xf9\x7e\xad\xd1\x86\x47\xcc\
\x31\x09\x38\x55\x60\xe2\xa5\x8f\x16\xaa\xad\x4b\xd4\x1f\xbf\x0f\
\x86\x83\x1a\xd8\x08\x3e\xbe\x97\x07\x80\xd9\x7b\x5c\x34\x10\x83\
\xdf\xb0\x68\x24\x19\xf0\x0c\x06\x05\x06\x83\x01\x9c\x73\x90\xe3\
\xe6\x00\xc8\xf8\x79\x2e\x1b\x5d\x6a\xf5\x15\x29\xb2\x79\x84\xe3\
\x73\x9e\xe0\x91\x94\x73\x2e\x10\x11\xb0\x08\x20\x33\x32\x12\xea\
\x05\x29\xe1\x02\x59\xc7\xc7\xcc\x01\x18\xbf\xd4\x98\xed\x9a\xe6\
\x09\x38\xe7\x41\x4d\xa7\xb3\x64\xcf\x41\x37\x3f\xb1\x8e\x30\x83\
\x5d\x5d\x21\x0d\x75\xa2\x52\xa2\x02\x43\xe6\xb0\x24\xee\x1e\x46\
\x8d\x10\x0a\x6b\xfd\x44\xe3\x9c\x07\xc1\x9c\xad\x90\x35\x59\xca\
\x39\x37\xab\x93\xa9\x10\xad\x14\xed\xc4\x29\xaa\xbe\x7e\x9c\x07\
\x44\x63\xce\x30\x40\x04\x6b\x2d\xca\x83\x29\x86\xc3\x85\x39\x5c\
\x47\x26\xc0\x4c\x98\x8c\xc7\x98\x4c\xa6\x28\xcb\x12\x22\x82\xfd\
\x83\x83\x00\xc6\x2f\xb2\xc8\xf8\x08\x8d\xc7\xe3\x39\xb0\x5d\x2a\
\x24\x62\x8e\xfd\xfe\xac\xa6\x80\xc7\x33\x9d\x8c\xd3\x88\x75\x88\
\x02\xfa\x26\xa0\x97\x5b\x15\x30\x8a\x62\x30\x80\x08\xa3\xaa\x2a\
\x30\x33\xd6\x56\xd7\x70\xff\xfd\x07\xe9\x1c\xc7\x88\xe0\xf4\x99\
\x33\xa8\xaa\x2a\x01\x8b\x7e\x6f\xcb\x8f\xa8\x12\x3b\x86\x33\x2e\
\x28\xe9\xcf\x9e\x58\x38\x81\x9d\x4c\x26\x58\x5e\x3e\x81\x83\x83\
\x31\xac\x35\xc1\xd0\x7e\xe1\x93\x13\x30\x0f\x76\x76\x9e\x3f\xb9\
\xb6\xf6\x3b\x22\x7c\x6e\x5e\x01\x86\xb0\x83\x73\x9e\x80\x73\x0e\
\x3f\xfc\xf1\x8f\x52\x72\x46\x70\xce\x39\xec\xee\xee\xd6\xa2\x1b\
\xa3\xda\x1c\x9d\x72\x8f\x33\xbb\xd9\x3e\x59\x35\x25\x73\xbc\x46\
\xa3\x3d\x7f\x43\x05\x00\x2c\x03\x18\x03\xe0\x9a\x02\xb7\x37\xef\
\x4c\x56\x57\x56\xbe\x77\x76\xe3\xe3\xbf\x2a\x8a\xe2\x13\x75\x05\
\x04\x00\x25\x7f\x3b\xe7\x50\x55\x55\x6d\xa8\xcc\x27\x2c\xe7\xdc\
\x9c\x02\x9a\x8f\x2c\x31\xf7\x03\x31\xc7\xf5\xe1\xd1\x9f\xc5\xb6\
\x0d\x2a\x0c\x00\xa7\x01\x6c\x03\x90\xa2\xf9\xf5\xde\x68\x34\xbe\
\x71\xeb\xd6\x2f\x9f\x3c\x77\xee\xda\xc2\x70\x78\x2a\x96\x3b\xc7\
\x18\x8d\xf6\x71\xff\xc1\x7d\xbf\x6e\x09\x91\x6b\x7a\x3b\xfa\x3e\
\x1f\x65\x9a\x6b\x21\x0a\x89\x19\xeb\x02\xf3\xbf\xbb\xc5\x49\xb3\
\xf9\x1e\x0b\x3f\x04\xb0\x0a\xe0\x7d\x00\x65\x4e\x40\x01\x4c\x01\
\xdc\x2f\xab\xf2\xad\xdb\x9b\x77\x7e\x71\xea\xe4\xa9\x4f\x06\xbf\
\x61\x79\x79\x19\xe7\xcf\x3f\xb9\x78\xfb\xd6\xad\x93\x5b\x77\xef\
\x0e\x8c\x31\xd6\x18\x53\x84\xff\xb6\x28\x8a\x82\x88\x2c\x88\x6c\
\xf8\x99\x9f\xc2\x50\x28\xea\xb7\x51\xc2\x22\x0c\x55\x16\x11\x27\
\x22\x32\x99\x4c\xa7\xa3\xfd\x51\xb5\xba\xb6\xb2\x77\xef\xde\xbd\
\x7d\x11\x69\x1e\xf9\xa5\x5d\x3e\x11\xa9\x31\x66\xa7\x2c\xab\x3f\
\x46\xfb\x00\xd0\x26\x81\x12\xc0\x7d\x00\x7f\x2e\xab\xea\x9d\x7b\
\xff\xda\x5e\x8c\x0d\x6e\x6c\x6c\x98\x4f\x5d\xba\xf4\xd8\xa5\x4b\
\x97\xd6\xd6\xd6\xd6\x8a\x85\x85\x85\xc1\x60\x30\xb0\xd6\xda\x22\
\x80\xa7\x60\x0f\xa3\xaa\x86\x88\x54\x55\xc9\x18\xa3\xaa\x2a\xe1\
\x59\x55\xd5\x39\xe7\xb8\x2c\xcb\x6a\x34\x1a\x1d\xec\xec\xec\x4c\
\x01\x3c\x7c\xfb\xc6\x8d\xdd\xf1\x78\xdc\xf7\x2b\xba\x02\xa8\x00\
\xec\x01\xd8\x09\xf7\xda\x76\xf6\x61\x00\x58\xf8\x04\xcf\x1b\xd4\
\x0b\x17\x2e\xe0\xe2\xc5\x8b\x38\x7d\xfa\x34\x16\x17\x17\x01\x20\
\xfd\x1f\x0e\x87\xa9\xad\xfc\x9e\x99\x35\x8e\xf7\xc1\x32\x9a\xe7\
\xd1\xf6\xf6\x36\xae\x5f\xbf\x8e\x9b\x37\x6f\x46\xe7\xf4\x5d\x1a\
\x22\xef\x10\x7e\x27\xfc\x0f\x0c\x53\x60\x43\x5f\x29\xe7\x29\x00\
\x00\x00\x25\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\x61\
\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x31\x2d\x31\x35\x54\x31\x37\
\x3a\x30\x32\x3a\x33\x35\x2d\x30\x37\x3a\x30\x30\x10\x90\x85\xa6\
\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\x65\
\x61\x74\x65\x00\x32\x30\x31\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\
\x33\x3a\x32\x36\x3a\x31\x35\x2d\x30\x37\x3a\x30\x30\x06\x3b\x5c\
\x81\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\
\x64\x69\x66\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\
\x30\x39\x3a\x33\x31\x3a\x32\x35\x2d\x30\x37\x3a\x30\x30\x5f\x2e\
\xc9\x50\x00\x00\x00\x67\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\
\x65\x00\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\
\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\
\x65\x6e\x73\x65\x73\x2f\x62\x79\x2d\x73\x61\x2f\x33\x2e\x30\x2f\
\x20\x6f\x72\x20\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\
\x69\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\
\x69\x63\x65\x6e\x73\x65\x73\x2f\x4c\x47\x50\x4c\x2f\x32\x2e\x31\
\x2f\x5b\x8f\x3c\x63\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\
\x69\x66\x79\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x30\x33\
\x2d\x31\x39\x54\x31\x30\x3a\x35\x33\x3a\x30\x35\x2d\x30\x36\x3a\
\x30\x30\x2c\x05\xbc\x4f\x00\x00\x00\x13\x74\x45\x58\x74\x53\x6f\
\x75\x72\x63\x65\x00\x4f\x78\x79\x67\x65\x6e\x20\x49\x63\x6f\x6e\
\x73\xec\x18\xae\xe8\x00\x00\x00\x27\x74\x45\x58\x74\x53\x6f\x75\
\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\x2f\x2f\x77\
\x77\x77\x2e\x6f\x78\x79\x67\x65\x6e\x2d\x69\x63\x6f\x6e\x73\x2e\
\x6f\x72\x67\x2f\xef\x37\xaa\xcb\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
\x00\x00\x02\x02\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x04\x00\x00\x00\x6e\xbd\xa4\xb0\
\x00\x00\x01\xc9\x49\x44\x41\x54\x78\x5e\x95\x93\x3f\x6b\x54\x51\
\x10\xc5\x7f\x73\xdf\x7d\x9b\xfd\x93\x18\x48\x25\xfe\x0b\x18\x0b\
\x0b\x0b\x41\x10\x4b\xb1\x09\x0a\x82\xa8\xc5\x82\x11\xfc\x08\x8a\
\x85\xd8\x0a\x86\x14\x36\x96\x7e\x00\x11\x6c\x14\xb1\x90\x80\xa0\
\x16\x42\x04\x09\x01\x0b\x49\x40\x11\x03\x6a\x8c\x31\x6c\x36\x59\
\xd6\xf7\xee\x8c\xef\xb2\xc5\x63\x59\x17\xcc\x1c\xe6\x70\x86\x39\
\x0c\x87\x0b\x57\x8c\xff\x2f\x31\x64\xbc\x31\x73\xe5\x62\x9b\x9d\
\xd0\x55\x23\x58\xd9\x3d\x5e\xfb\xf3\xb9\xcd\x3b\x1e\xd9\x2f\x61\
\xf2\xf6\xeb\xe6\xe4\x2b\x56\xd9\xa0\x43\x20\x90\xc7\x2e\xb0\xc3\
\x36\x1d\x5a\x7c\xc7\x00\x16\x99\x91\x43\xf7\x5e\xdc\xbc\xb0\xb2\
\xfc\x90\x4d\x86\xd7\x18\x97\xe4\xb8\xdd\xf7\xd7\x9b\x0f\x58\xbe\
\xf1\xec\xcd\xf6\x6c\xe5\x00\xa8\x15\x50\xb3\x60\x66\x4a\xd0\x82\
\x8d\xf5\xc9\xbb\xe7\xe6\xab\x6f\xc3\xb4\x1f\x6b\x2c\x64\xbc\xf7\
\x4f\x9b\x67\x20\xeb\x45\xe8\x71\x09\xbe\x9d\x0a\xa7\xab\x5b\x36\
\xe1\x73\x5b\x03\x26\xa6\x4a\x6b\xbf\x39\xea\xda\x41\xa8\x82\xb8\
\x96\x6d\x03\x48\xd6\xb7\xce\xfb\xa0\x06\x35\xa9\x89\x6f\x6b\xc7\
\x40\x2d\x1f\x7a\x37\x36\xd4\xc5\xc4\x6f\x69\x17\x08\x9a\x0f\xe6\
\x2d\xcd\x06\x55\x41\x7c\x4b\x33\x40\x6d\xf8\xdd\xc8\x31\x86\x88\
\xdf\x54\x05\xb4\xef\x6e\x46\x18\x34\x83\xf8\xf5\xa8\x50\x2b\xd7\
\xd9\x40\x76\xa5\x17\xc3\x7d\xca\x13\x20\x58\x69\xcd\x07\x10\x84\
\xde\x6b\xfc\x08\x09\x01\x2d\x57\x83\xd9\x09\x16\xcd\x38\x97\x59\
\x02\x74\x56\x72\x86\xc3\xbe\xe2\x47\xa9\xe2\x5d\x2b\xa9\xa4\x27\
\xdc\xd5\xa5\x3b\xb2\x57\x51\x33\x83\x60\x6a\x46\x6f\x52\xb1\x9f\
\xfb\x66\xa7\xce\x1e\x1d\xf9\xf8\x5b\x92\xb9\xc6\x2d\xf9\xa0\x8f\
\x2b\xad\xc4\x25\x92\x16\x1d\xd9\x89\x97\x24\x6a\x71\x91\xc7\x0f\
\x5f\x9e\xde\x3f\xff\x52\x38\x52\x7f\xb2\xe7\x58\x9d\x5a\x81\xc8\
\xff\x52\x11\x0b\x1b\xcf\xcf\x8b\x21\x13\xa3\xd7\x46\x4e\xa6\x95\
\xd4\x55\x24\x75\xa9\xf3\x92\x26\xa9\xf8\xa8\x0a\x4e\x8a\xc9\x69\
\x77\xe9\xcb\xdc\xe2\xea\xae\xfe\xa0\x63\x17\xf5\x17\x6a\xdd\x55\
\x45\x82\x15\xb0\x27\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x02\xcd\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x02\x94\x49\x44\x41\x54\x78\x5e\xed\x94\x0d\x48\x53\x51\
\x14\x80\x17\x67\x9b\xf6\x48\xb2\x4c\x20\xa9\x0c\xb0\x32\x13\x97\
\x7f\xcd\x7f\xf3\xe5\x26\x4e\xa9\x9c\x85\x49\x66\x7f\x50\x69\x59\
\x4c\xe7\xcc\xd4\x06\x69\xcc\xac\x0c\x4b\x20\x8a\x24\xd1\x70\x88\
\xa5\x11\x03\xa8\x16\x05\x8e\xca\xe1\x12\x61\xd3\x95\x85\x1a\x60\
\x25\x10\x96\x5a\x6e\x7b\xe7\xb4\x74\x40\x50\x66\x56\x41\x80\x17\
\x3e\xb8\x17\x2e\xdf\x05\xce\xe5\xe3\x11\xd1\x3f\xe1\xd7\x05\x73\
\x62\x90\xb6\x07\x08\x65\x8f\xd5\x61\x47\x2d\x9d\x49\xa5\x7d\x3d\
\x3b\x2a\x07\x5e\x89\x15\x2f\x3b\x20\xc5\x92\x03\xa9\x56\x9f\x59\
\x8b\x81\xd5\x89\x45\x07\x0c\xfd\xd5\x2d\xfd\x8e\xa1\xf7\x36\xa4\
\x6f\x16\x22\xd2\xe0\xb0\x8d\x2e\xeb\x86\x71\xe5\x5e\xeb\x33\x48\
\x31\x2f\x9b\x51\x0c\x71\x37\x40\xc0\x36\x9f\xde\xad\x31\xda\xba\
\x06\x3e\x93\x75\x18\xe9\xb9\x13\xab\x8b\xde\x77\x1c\xf5\xbc\xe5\
\xa8\xd7\x75\x7e\x68\x19\xa7\x38\xa5\xf5\x13\x24\x9b\x36\xfd\x54\
\xcc\x8f\xad\xab\x3c\x5c\xd3\x69\x6b\xe9\x9a\xa0\x56\x33\x52\x9b\
\x8b\x46\xc3\x08\xed\x3b\xd7\xcd\x45\x1d\x31\x38\x64\xc5\x46\x7b\
\xb6\xa6\x1b\x4b\x1a\x06\xb1\xc1\xf0\x81\xb4\xc6\x31\x62\x55\x66\
\x4e\x98\xd2\x91\xf7\x43\x31\x44\x5c\x90\x88\xb2\xb5\x13\x27\x75\
\xe3\x74\xea\x3e\x4e\xa1\x47\x52\xd4\x0f\x92\x8f\xbc\x75\x04\xe2\
\x9a\x24\x10\xdf\x3c\x6f\xf2\x6e\x42\x9b\x17\xb0\x77\xb2\x96\xc8\
\x1f\xbc\x48\x2e\xe9\xe2\x0a\x1a\x87\xc8\x7b\x5b\xbb\x03\x24\x8f\
\x44\xdf\x89\x05\xd1\xd5\x96\x44\x4d\x1f\xa5\xd5\xe3\x24\xf2\x49\
\x38\xf2\x4d\xd7\x3a\x20\xfa\x4a\xd4\xb4\xf3\x48\x68\xdd\xbc\x78\
\xcb\xdd\x37\xbe\x19\x7a\x72\x97\xe9\x07\x20\xf1\x9e\x80\x07\xc1\
\x05\x00\xc1\x2a\x3e\x84\x14\x7b\xf0\xc3\xd5\xdc\xd2\xb2\x31\x5a\
\x5e\x8e\xb4\xa2\x02\xc9\xd7\x89\x8f\xf2\x35\x09\x62\x6a\x47\x21\
\xb2\x86\x0f\x91\xb5\xc2\x69\xe5\xf1\xda\xf9\x42\xe9\xed\x9b\xb0\
\xf1\x16\x09\xa5\xba\x33\x3c\x08\x53\xe9\x41\x94\x47\xb0\xfe\x18\
\x09\xd8\x4b\xdc\xc2\x13\x48\x8b\x4a\x91\xbc\xca\x90\xbc\xd5\x48\
\x9e\x07\xcd\x04\xe1\x15\x04\x1b\x34\x04\xe2\x2a\x82\x88\xf3\xb1\
\xd3\xc9\x5d\xc3\xcf\x85\xf8\xa6\x8f\x3c\x08\xdc\xc3\x42\x50\x8e\
\x5d\xb8\xf3\x09\xb9\x2b\xed\xc4\x14\x21\x2d\x38\x8e\xe4\x51\x8c\
\xf4\xf5\x11\xcf\x12\x27\xaa\x51\x72\x4b\xba\x8e\xfc\xa8\xb3\x26\
\x08\x2f\x67\x66\xfc\xfb\x31\x75\xfc\xa9\x4d\x40\xa6\x53\xbe\xdf\
\x0e\x59\x9d\x24\x50\x22\xb9\x39\x71\x2f\x44\x62\x54\x4e\x0a\x6d\
\x24\x90\x5c\x45\x10\xab\x4d\x10\x52\xc4\xcc\xba\x15\xe0\x9f\xce\
\x42\xe0\x2e\x3b\x64\x1a\x09\x14\x48\x90\x8f\xc4\x57\xd8\x08\xd8\
\x8b\x08\xa1\x05\x26\x08\xca\x65\x7e\xbb\x15\xb0\x3a\x95\x85\xb5\
\x19\x76\xd8\xfe\x94\x20\xc7\x29\x8d\xad\x42\x10\x1d\x32\xc1\xba\
\x6c\xe6\x8f\x5b\x01\xab\xa4\x2c\xac\xd9\x6a\x87\xd0\x7c\x84\xc0\
\x2c\x13\xf8\xa7\x31\x7f\x2d\x42\xe0\xc7\x26\x80\xbf\xfc\x1a\xf8\
\x49\x98\xff\x37\x9b\x73\xe2\x2f\xa2\x1b\x1e\x1b\xcd\x61\xd4\x10\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0c\x75\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x49\xd2\x00\x00\
\x49\xd2\x01\xa8\x45\x8a\xf8\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x0a\x88\
\x49\x44\x41\x54\x68\xde\xed\x99\x69\x6c\x5c\x57\x15\xc7\x7f\xf7\
\xbe\x37\xf3\xc6\xe3\xf1\x78\xc6\xeb\x38\xa9\x1d\xdb\x49\xea\x38\
\x01\xda\xa6\xa4\x4d\x4b\xdb\x20\xa0\x69\x4b\x69\xa8\x00\x81\x40\
\xec\x4b\xa5\x7e\xa0\x80\x84\xc4\x22\xf8\x80\x58\xba\x7c\x43\x42\
\x2d\xb4\x65\x29\x48\x2c\x55\x09\xa5\xa4\x2d\xab\x04\x69\xc3\x52\
\x52\xc7\x71\x1c\x7b\xec\x7a\xbc\xc4\x76\xec\xb1\x3d\x63\x7b\xc6\
\x9e\xf5\xbd\x77\xf9\x30\x8b\xc7\x13\x3b\x71\xdc\xd2\x14\xd1\x23\
\x5d\xbf\xfb\xe6\x9d\x7b\xdf\xff\x7f\xee\x39\xe7\x9e\xfb\x0c\xaf\
\xcb\xeb\xf2\xff\x2d\xe2\xbe\x07\xbe\x0d\x80\xa6\x69\x68\x9a\x76\
\xa9\xf1\x6c\x48\x2c\xcb\xc2\xb2\x2c\x00\xf4\x96\x96\x16\x42\xa1\
\x90\x27\x95\x4a\x35\x2a\x65\x3b\x2f\x35\xb8\x8d\x88\x10\x32\xa3\
\x69\x5a\xb8\xbd\x7d\xfb\x92\x3e\x3c\x3c\x5c\xed\x76\xbb\xef\xae\
\xae\xf6\xbd\xdf\x70\x1a\x15\x80\xba\xd4\x00\x2f\x84\x3f\x9d\x49\
\x25\x17\x17\x17\x1f\x1f\x19\x19\x7e\x48\x37\x4d\xb3\xd9\xe7\xf3\
\xdf\x79\xfd\xfe\xeb\xaf\xaa\xad\xad\xc7\x56\x36\xe2\x52\x43\x5c\
\x47\x14\x20\x85\x60\x2e\x32\xc7\xdf\xff\x71\x2c\x13\x8f\xc7\x8f\
\xe8\x4a\xd9\x4e\x97\xe1\x32\x6a\x6b\xeb\xf0\x78\x2a\x31\x4d\xf3\
\x52\xe3\x3c\xaf\xe8\xba\x8e\x52\x0a\x97\x61\x18\x4a\x29\xa7\x5e\
\xe0\x66\xdb\x36\xa6\x99\x7d\xcd\x13\x00\x85\xad\x56\xbc\x5c\xbf\
\x98\xa1\x42\xac\x76\x2e\xa5\xd4\x05\xf5\xd6\xd3\xd9\xbc\xac\xc6\
\xb0\x61\x02\xa6\x69\x12\x9e\x99\x25\x99\x4c\xe6\x06\xea\x3a\x81\
\x40\x23\x15\x2e\x17\x05\x8c\x42\xe4\xf4\x16\x16\x63\x98\xa6\x89\
\x43\xd7\xa9\xae\xae\x46\xd7\xcf\x4d\xcf\xb9\x31\x2f\x9f\xdc\x86\
\x08\x48\x29\x19\x9f\x98\xe4\xa1\x87\x1f\xe5\xcc\xf8\x04\x42\x0a\
\x2a\xdd\x6e\x3e\xf3\x89\x8f\x73\xdd\xfe\x6b\x4a\xf4\x04\x73\x91\
\x28\x0f\xfe\xe0\x11\xa6\xa7\xc3\x5c\xb6\x75\x0b\x77\xdf\xf5\x69\
\x1a\x1b\x1b\x50\x4a\xad\x22\xba\x9e\x5c\x2c\xb1\xf3\x10\x10\x80\
\x42\x08\x81\x52\x8a\xbe\xfe\x20\xbd\xa7\xfb\x88\x2f\x2f\x23\x85\
\x40\x08\xc1\xbf\xbb\xba\xb8\x7a\xef\x55\x18\x86\x81\x52\x39\xdd\
\x4c\x26\x43\x68\x78\x84\xd1\xb1\x31\xd2\x99\x34\x99\x6c\x16\x21\
\x24\x42\x28\x40\xe4\x5d\x4a\xe5\x1c\x41\x88\x22\x58\xa5\xc4\x1a\
\xe4\x54\xd1\x05\xd7\x73\x45\x7d\x35\x64\x51\xe2\xbf\xb9\xbe\x10\
\x82\x58\x7c\x89\x9e\xde\xd3\x2c\x27\x12\xe8\x9a\x86\x10\x02\xd3\
\x34\x39\xdd\x17\x24\x3c\x33\x43\x5b\xeb\x36\x6c\xdb\x2e\xea\xaf\
\x34\x89\xa6\x69\x64\xb3\x59\xa2\xf3\x51\xb2\x19\x93\x2a\xaf\x07\
\x6f\x95\x17\x21\x59\x05\x5c\x4a\x41\x36\x9b\x25\x16\x8f\xb1\xbc\
\x9c\x40\x29\x85\xbb\xa2\x02\x8f\xa7\x12\xa7\xd3\x59\xc4\x55\xbe\
\x7a\x45\x02\x42\xe4\xfe\x94\x06\xa0\x10\x02\x29\x25\x93\x93\x67\
\x09\x0e\x0c\x60\xdb\x36\x2d\xcd\xcd\x54\x55\x79\xe8\xeb\x0f\x32\
\x3e\x31\x41\x70\x60\x90\xb6\x6d\xdb\x8a\xba\x39\xe0\x2b\x16\x1c\
\x19\x1d\xe3\xc8\x33\xcf\x72\xbc\xeb\x04\xa9\x54\x8a\x96\xe6\x66\
\x6e\xbf\xed\x16\xae\xdd\xb7\xaf\x18\x1b\x4a\x29\x46\xc6\xc6\xf8\
\xeb\xdf\x8e\xd2\xdd\x73\x8a\x48\x34\x8a\x52\x0a\x6f\x55\x15\x7b\
\xaf\xbc\x82\xf7\xbc\xfb\x10\x35\x35\xfe\xfc\x2a\x9c\x27\x88\x73\
\x2f\x5e\x01\x20\x84\xc0\xb6\x6d\x4e\xf7\xf7\x33\x35\x1d\x46\xd3\
\x34\xf6\x5d\xbd\x97\xad\x5b\xb7\x30\x3a\x3a\x46\x3c\x1e\xa7\xa7\
\xb7\x97\x9b\x6e\xbc\x01\x4f\x65\x65\x71\x4c\xe1\x1a\x9d\x5f\xe0\
\xc7\x8f\xfd\x8c\xc9\xa9\xb3\x64\xb3\x26\xa9\x54\x8a\xe1\x91\x51\
\xce\x8c\x8f\xe3\x32\x0c\xde\x7c\xf5\x5e\x84\x10\x04\x07\x06\x79\
\xf8\x87\x3f\xe2\x78\xd7\x09\x32\x99\x0c\x4e\xa7\x13\xc3\x30\x98\
\x98\x98\x60\x79\x39\xc1\xdb\xde\x7a\x80\xba\xba\x5a\x2c\x2b\xbf\
\xca\x6b\x13\x28\x5d\xfa\x95\xfb\x78\x3c\xc6\x89\xee\x93\xa4\x52\
\x29\xbc\x5e\x2f\x6f\xbe\x7a\x2f\x5b\x9a\x02\x3c\xfd\xec\xef\x19\
\x18\x1c\xa2\xaf\x3f\xc8\xd4\xf4\x34\x1d\x3b\x77\x16\xe3\x00\x04\
\x08\x41\x2c\x16\x63\x4b\x53\x80\xbb\x3e\xf5\x49\xdc\x15\x15\xfc\
\xe1\xcf\x7f\xe1\xc5\x17\xbb\x18\x1e\x19\xe5\xd9\x3f\xfe\x89\x5d\
\xbb\x76\xa1\x69\x1a\xbf\x3d\x72\x84\x7f\xfd\xfb\x38\xb6\x6d\xd3\
\x71\xf9\x4e\x6e\x3d\x78\x33\x5b\x9a\x9a\x98\x9d\x9b\x65\x76\x76\
\x0e\x97\x61\xac\xc2\x77\x9e\x20\x16\xab\x56\x41\x08\xc1\xe8\xd8\
\x19\x06\x06\x5f\x02\xa0\xb5\xa5\x85\xdd\x9d\xbb\xf0\xfb\x7c\xec\
\xe9\xec\x24\x34\x3c\xc2\xc4\xe4\x24\x7d\x7d\x41\x2e\xdf\xb1\x23\
\xef\x42\x45\xe7\xa6\xb2\xb2\x92\x0f\xbc\xef\xbd\xdc\x7a\xcb\x41\
\xa4\x10\xf8\xfd\x7e\x46\x47\x47\x99\x9a\x0e\x13\x1c\x18\x24\x1c\
\x0e\x23\xa5\x46\xd7\x89\x6e\x4c\xcb\xa2\xb6\xc6\xcf\x47\x3f\xfc\
\x21\xde\x76\xe0\x00\x9a\x26\xb1\x2c\x8b\x44\x32\x89\xc3\xe1\x80\
\xa2\x71\x0a\x09\x26\x27\xb2\x3c\xef\x94\x06\xa1\x65\x59\x74\xf7\
\xf4\x10\x8d\x46\x91\x52\x52\x5f\x5f\xc7\xdc\x5c\x84\x33\xe3\xe3\
\xf8\x6b\xfc\x38\x9d\x4e\x12\x89\x24\x5d\xdd\xdd\x2c\x27\x12\x79\
\x02\x05\xfc\x8a\x6a\xaf\x97\x1d\x3b\xb6\xa3\x49\x89\x94\x92\x6d\
\xcd\xcd\xd4\xd7\xd5\xa3\x94\x22\xbe\xb4\xc4\xc2\xc2\x22\x91\x68\
\x94\xc5\x58\x1c\x14\x04\x1a\x1b\xd9\xd3\xd9\x89\xa6\x69\x28\x05\
\x52\x6a\x54\xba\x2b\x71\x3a\x9c\xf9\xf8\xcc\xbb\xa8\x58\x6f\x05\
\xf2\xcb\x9f\x0b\xc8\x5c\x4e\x3f\xd9\x73\x2a\x9f\x0a\x05\xdd\x27\
\x7b\x18\x1d\x1d\x03\x01\x89\x44\xb2\x58\x93\xf7\x05\x83\x4c\x4c\
\x4c\xe2\xdb\xe3\x5b\x95\x26\xa4\x94\xe8\x9a\x5e\x34\x88\xa6\x6b\
\x48\x2d\x67\x33\x65\xe7\x52\xa4\xad\xf2\xa9\x52\xe4\x36\x47\x5d\
\xd7\x8b\xa9\xbb\x10\x4b\x05\xd7\x5c\x2b\x93\xca\x72\xfc\x2b\x41\
\x28\x19\x0a\x85\x08\x0d\x8f\xe4\x37\x21\x45\x24\x3a\xcf\xd0\xc8\
\x08\x43\xa1\x11\xa6\xa6\xa7\xb1\x2c\x0b\x21\x04\x33\x33\x33\x74\
\xf7\xf4\x60\xdb\x36\x52\xc8\xe2\x3c\xf1\xa5\x25\xa6\xa6\xa7\xf3\
\x87\x25\x9d\xd9\xb9\x08\xd1\xf9\x79\x84\x10\xb8\xdd\x6e\xbc\x5e\
\x2f\x35\x7e\x3f\x95\x6e\x37\x02\x98\x99\x9d\xe5\xcc\xf8\x78\x8e\
\xb8\xae\xa3\x69\x1a\x96\x65\xa1\x94\x5d\x24\x73\xc1\x18\x28\xe4\
\xe4\x74\x3a\x4d\xcf\xa9\x5e\xa2\xf3\xf3\x48\x4d\x63\xf7\xae\x0e\
\x76\x75\x74\x20\x8b\x41\x0a\x67\xcf\x9e\x2d\xa6\xc7\xae\x13\x27\
\xb9\xfd\xb6\xdb\x90\x72\xc5\x26\xb1\x58\x8c\x27\x9f\x3a\x82\xae\
\xeb\xb8\x0c\x17\xbf\x7b\xfa\x19\x66\x66\x66\x91\x52\xd2\xd6\xba\
\x8d\xa6\xa6\x26\x34\x4d\xa3\xb3\xa3\x83\xa9\xe9\x69\xe6\xe6\x22\
\xfc\xf2\xf1\x27\x48\xa7\xd3\x34\x36\x34\x12\x89\x46\x09\x87\xc3\
\x5c\xbb\x6f\x1f\x8d\x8d\x0d\xd8\xb6\x5d\x0e\x75\xed\x9d\x58\x08\
\xc9\xcc\xec\x2c\xdd\x27\x7b\x48\x24\x93\xf8\x7d\x3e\xee\xbc\xe3\
\x0e\x6e\xbb\xe5\xe6\xe2\x68\x4d\x4a\x4e\xf7\xf7\x33\x3e\x31\xc9\
\x50\x28\x44\x70\x60\x80\x50\x68\x98\xfa\xfa\x3a\x6c\x3b\x57\xdd\
\x3a\x1c\x0e\x06\x5e\x7a\x89\x6f\xde\x7b\x7f\xbe\x8e\x8f\x90\x4e\
\xa7\xa9\xaf\xaf\xe3\xe0\x3b\xde\x4e\x8d\xdf\x8f\x10\xf0\xee\x43\
\xef\x62\x6c\x7c\x9c\xa1\x50\x88\xe7\xff\xfe\x0f\xfa\x83\x03\x78\
\xaa\x3c\xc4\xe3\x4b\xd4\xd7\xd5\xb2\xbb\xb3\x93\xa6\xa6\xc6\x35\
\x5d\x48\x3f\x17\xbc\xc8\xbb\x4b\x14\xa9\x69\x74\xec\xdc\x41\x4b\
\x73\x33\x57\xbc\xe9\x8d\xb8\xdd\x95\xf9\xe5\xcc\x11\xd8\xde\xde\
\xce\x5b\xae\xdb\x9f\xb7\xb0\x41\x78\x66\x86\xa6\x40\x23\xed\x6d\
\xad\x38\x1c\x0e\x9a\x2f\xbb\x8c\xb7\x1e\xb8\x89\xa3\xcf\x3d\xcf\
\xe9\xbe\x3e\xaa\x3c\x1e\x76\x6c\x6f\xe7\x8e\xdb\xdf\xc9\x81\x9b\
\x6e\xcc\xaf\x96\x62\xff\x35\xfb\xd0\x35\x9d\xa7\x9e\x79\x9a\x60\
\x70\x90\x58\x3c\xc6\xc2\xc2\x02\x2e\x97\x8b\xf6\xb6\x36\x3c\x9e\
\xca\x95\x3a\xea\x42\x04\x0a\x19\xa4\x6d\x5b\x2b\x5f\xfc\xfc\x3d\
\x28\x5b\x51\x51\x51\x41\x20\xd0\x98\xf7\x79\x00\x85\x65\x2b\xaa\
\xaa\xaa\xf8\xd8\x47\x3e\xcc\x9d\x87\x0e\x21\x04\xf8\x7d\x3e\xbc\
\x5e\x2f\x5f\xb8\xe7\xb3\x64\x32\x19\x0c\xc3\xa0\x29\x10\xe0\x86\
\xeb\xf6\x33\x32\x3a\x46\x32\x99\x24\x10\x68\xa4\xa5\xa5\x05\xc3\
\xe9\x2c\x16\x78\xba\xae\x73\xed\x35\xfb\xd8\xd5\x71\x39\x13\x93\
\x93\x44\xe7\xe7\xb1\x6d\x9b\x6a\xaf\x97\x40\xa0\x91\xda\x9a\x9a\
\x62\x1c\x5c\x70\x05\x72\xc5\x95\xa0\xba\xda\x8b\xdf\xef\xa3\x50\
\x6e\x15\x8a\xb0\x52\x1b\x08\x21\x68\x6c\x68\xa0\x29\x10\x28\x30\
\x47\x01\x6d\xad\xad\xab\x8c\xd1\xd0\xd0\x40\x43\x43\x43\xf1\xde\
\xb6\xed\x92\xf9\x56\xc4\xe7\xab\xc6\xef\xf7\xad\x2a\xdc\x6c\xdb\
\x2e\xd1\xdf\x00\x01\xa5\x72\xd9\x48\x29\x1b\xcb\x5a\x49\x65\x2b\
\xee\x55\x78\x0e\x42\xa8\xe2\x0b\x4a\x8b\xad\xc2\xb8\xc2\x7d\x69\
\xec\x9d\x5b\x5d\xaa\x62\x09\x9d\xd3\xb3\x8b\xf7\xe5\xa0\x95\x3a\
\xb7\xd0\xd6\x0b\x16\x15\x42\xa0\xc9\xc2\xc1\xa3\xb4\x20\x5b\x4d\
\xe0\xdc\xe7\xab\xfb\x17\x92\xf2\xaa\x72\xc5\x20\xa2\xa4\xe4\x3e\
\x97\x40\xa1\xaf\x49\x6d\x55\x2a\xd5\x85\x10\x99\x54\x3a\x9d\x89\
\x44\x23\x20\x04\xca\x2e\xe1\x28\x56\x5d\xd6\x83\x74\x41\xd0\xe7\
\x17\x75\xe1\x27\x25\x2a\x52\x0a\x22\xd1\x39\x52\xa9\x74\x46\x08\
\x91\xd1\x75\x5d\x1f\x5f\x58\x98\x3f\x7c\xf4\xb9\xbf\x49\xa7\xc3\
\x61\xa8\xd7\xf8\x77\x21\x01\x22\x93\xcd\xa6\x97\x96\xe2\x87\x75\
\x5d\x1f\xd7\x53\xa9\xe4\xa2\x94\xf2\xa1\x64\x32\xf9\x94\x52\xca\
\xf9\x9a\xfd\x28\x54\x10\x05\x42\x88\x8c\x94\x72\x32\x95\x4a\xc5\
\x04\xc0\xbd\xf7\x7f\x6b\xf5\x2e\xf7\x3f\x20\x52\x4a\xbe\xf2\xa5\
\xaf\x6d\xde\xde\x4b\x5f\x5e\xb1\x08\x9b\xe5\x2e\x29\x86\x90\xe7\
\xbe\xcd\x4d\x71\x51\xdf\x85\xca\xc4\x01\xb4\x00\x9e\x97\x19\x35\
\x4b\xc0\x19\x20\xfb\x6a\x13\xa8\x46\xf1\x45\x8c\xca\x1b\x64\x55\
\x40\x21\xf5\x75\x36\xfb\x72\xc9\xab\xd9\x26\x76\x7c\x5a\x92\x5e\
\x7e\x1e\xc1\xd7\x81\xb9\x57\x9b\xc0\xa2\x6d\x73\x0c\x87\xe7\xa0\
\xbe\xeb\xd6\x76\xbd\xf5\x1a\xc8\xc6\xc1\x4a\x9f\x7f\x94\x66\x80\
\xa3\x0a\x73\xf4\x05\xcc\xee\x27\x86\x49\x2e\x1f\x93\x1a\x8b\x9b\
\x05\xb1\x69\x02\xc7\xcf\x92\xbd\xa2\x8e\x5f\x5b\x0b\x11\xc3\x1a\
\x3c\xf6\xb5\x8a\xda\xf6\x56\x87\xc7\x01\x8b\xfd\xeb\x93\xd0\x0c\
\xa8\x7d\x13\xd9\xf8\x1c\x89\xc1\x63\xa3\xf6\x42\xe4\x3b\x9a\xe2\
\xd7\x93\x4b\x9b\x73\x1f\xd8\xfc\x2e\x54\x1c\x77\xf4\x83\x78\x5a\
\xfc\xf2\xe3\xae\xd6\x2b\xbf\x5a\xbd\xff\x3d\x01\x67\x45\x16\xb5\
\x30\x04\xca\x2c\x51\x53\x20\x74\x84\x6f\x07\x99\xa4\x83\xd8\x3f\
\x0f\x4f\xa5\xcf\x74\x7f\x3b\x9b\xb1\x7f\xd2\xfe\x39\x96\xc5\x9e\
\xcd\xc2\x87\x8d\xfe\x4f\x49\x90\xcb\x19\x5a\xbe\xe9\xf9\xe6\xfc\
\x71\x2f\x4a\x98\x6a\xa8\x4d\x0b\x9b\x24\xe3\x6f\x30\xb6\x5e\x55\
\xe9\xa8\xd9\x0a\x42\x43\x38\xaa\x10\x4e\x2f\xc2\xf0\x21\xfd\x97\
\x93\x4a\x38\x98\x3b\xf6\x9b\x99\xb9\x60\xd7\x77\x0f\x9f\xb6\x7f\
\x7a\xe8\x49\x92\xdf\x78\x10\x49\xd9\xc9\xf0\x95\x24\x50\x00\xad\
\x97\x34\x27\xb9\x0c\x64\x14\xae\xff\x9c\x46\x2d\x25\xd5\x70\xbb\
\x9c\x15\x32\x15\xdb\xed\xda\xba\xbb\xc2\x51\x55\x8b\x50\x36\x42\
\x33\x10\x95\x4d\x24\x97\x2c\xc2\x47\x0f\x47\xc7\x7b\xbb\x1e\x79\
\xf4\x84\xf9\xd3\x07\x8e\x93\xc8\xcf\xa7\x95\x34\xc1\x45\x7a\xc5\
\xf9\x08\xac\x05\xde\x91\x6f\xa5\x7d\x27\xe0\x3c\x15\xc1\x8e\x2c\
\x5b\x23\x6d\x4c\x3b\x8c\x6c\xbc\xb3\x22\xd0\xee\xd4\xdd\x1e\xd0\
\x5d\xa4\xe2\x29\xa6\x8e\x3e\x19\x0f\x75\xbd\xf0\xb3\x87\xbb\xb2\
\x8f\x3d\xd6\x4f\x2c\x3f\x87\x2c\x69\x82\x57\x90\x40\xb9\xcb\x94\
\xf6\x4b\x5b\x81\x98\x06\x38\x06\x17\xc8\x46\x96\xed\xd0\x76\x31\
\xed\x72\x99\x4b\x3b\xdd\x81\x76\xa7\x95\x31\x99\x7a\xee\x77\x4b\
\xa1\xae\x17\x7e\xf5\xfd\x17\xb3\x3f\x7a\x62\x88\x79\x56\x5c\xe6\
\x7c\x60\xcf\x3d\x30\x5c\xe4\x0a\x14\x48\x94\x5b\xa6\xf0\xfb\x9a\
\x2f\x1d\x5a\x24\xa1\x2c\x6b\xb0\x4d\xce\xb8\xf5\x44\x64\x67\x7c\
\xb4\x3f\x3b\x76\xaa\xfb\x89\x9f\xf7\xa4\x1f\xf9\xc5\x4b\x84\xf3\
\xa0\x2c\x72\xfb\x77\x69\x53\xeb\xfc\xb6\x69\x02\x8a\xd5\x56\x50\
\x65\xad\xfc\x65\x66\x1e\x98\xd9\x1b\x61\xa1\xc1\x69\x06\x03\x66\
\xd8\x11\x0b\x4f\x9d\xfa\xfd\x50\xf6\xfb\xdf\xeb\x61\xbc\xf0\xbc\
\xac\x59\x6b\x5c\x37\x4c\x60\xa3\xfe\x56\xb0\x7a\xa9\xbf\x96\xfb\
\x6e\x49\x65\x93\x3b\x89\x7e\x7a\x0f\x55\x52\xc0\xc3\xbd\xc4\xca\
\x8c\xb0\x9e\xd5\xcb\x8d\xb6\x21\x60\x17\x2b\xe5\xee\x54\xe8\xcb\
\x32\x9d\x02\xe0\xb5\x56\x15\x56\x4a\xc0\x8b\x02\xfc\x4a\x10\xb8\
\xd8\x79\xff\xab\x07\xa4\xff\x00\x98\x4f\xc9\x02\x32\xee\xf8\x5f\
\x00\x00\x00\x25\x74\x45\x58\x74\x63\x72\x65\x61\x74\x65\x2d\x64\
\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\
\x32\x3a\x35\x31\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\x82\x80\x0a\
\xca\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x63\x72\
\x65\x61\x74\x65\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\
\x30\x39\x3a\x31\x31\x3a\x33\x39\x2d\x30\x37\x3a\x30\x30\x7d\x15\
\xa2\xc7\x00\x00\x00\x25\x74\x45\x58\x74\x64\x61\x74\x65\x3a\x6d\
\x6f\x64\x69\x66\x79\x00\x32\x30\x31\x30\x2d\x30\x31\x2d\x31\x31\
\x54\x30\x39\x3a\x31\x31\x3a\x33\x39\x2d\x30\x37\x3a\x30\x30\x0c\
\x48\x1a\x7b\x00\x00\x00\x34\x74\x45\x58\x74\x4c\x69\x63\x65\x6e\
\x73\x65\x00\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\
\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\x73\x2e\x6f\x72\x67\x2f\x6c\x69\
\x63\x65\x6e\x73\x65\x73\x2f\x47\x50\x4c\x2f\x32\x2e\x30\x2f\x6c\
\x6a\x06\xa8\x00\x00\x00\x25\x74\x45\x58\x74\x6d\x6f\x64\x69\x66\
\x79\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\x2d\x31\x32\x2d\x30\
\x38\x54\x31\x32\x3a\x35\x31\x3a\x32\x31\x2d\x30\x37\x3a\x30\x30\
\xdd\x31\x7c\xfe\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\
\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\
\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\x17\x74\x45\x58\
\x74\x53\x6f\x75\x72\x63\x65\x00\x47\x4e\x4f\x4d\x45\x20\x49\x63\
\x6f\x6e\x20\x54\x68\x65\x6d\x65\xc1\xf9\x26\x69\x00\x00\x00\x20\
\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x5f\x55\x52\x4c\x00\x68\
\x74\x74\x70\x3a\x2f\x2f\x61\x72\x74\x2e\x67\x6e\x6f\x6d\x65\x2e\
\x6f\x72\x67\x2f\x32\xe4\x91\x79\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
\x00\x00\x12\xdd\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x06\x62\x4b\x47\x44\x00\x00\x00\x00\x00\x00\xf9\x43\
\xbb\x7f\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x49\xd2\x00\x00\
\x49\xd2\x01\xa8\x45\x8a\xf8\x00\x00\x00\x09\x76\x70\x41\x67\x00\
\x00\x00\x30\x00\x00\x00\x30\x00\xce\xee\x8c\x57\x00\x00\x10\xf0\
\x49\x44\x41\x54\x68\xde\xbd\x5a\x6b\x90\x5c\x47\x75\xfe\x4e\x77\
\xdf\xc7\xdc\x79\xec\xcc\xec\xce\xec\x43\xab\xd5\x4a\xd6\xc3\x96\
\x79\xc8\x2f\xa0\xf2\x2e\x62\x62\x1b\xd9\x18\x52\x84\xc0\x8f\xe4\
\x6f\xaa\x28\xfe\x50\x95\x90\x4a\x48\xa8\x14\xf0\x23\xa9\x54\x25\
\x24\x54\x41\xa5\x2a\x50\x21\x09\x50\x04\xbf\x28\xfc\x90\x1f\x38\
\x38\xa1\xc0\x36\x36\xb2\x2c\x5b\x42\x92\x65\x4b\x5a\x69\x77\xf6\
\x3d\x77\x1e\xf7\xd9\xdd\x27\x3f\x66\x47\x5a\x0b\xdb\x5a\x01\xe1\
\xd6\x9e\x3d\x3d\x7d\x7b\x7a\xce\xd7\xe7\xeb\x73\x4e\xdf\x19\xc2\
\x2f\x78\x3d\xfa\xc4\x43\x60\xe6\xb7\x1c\x43\x44\xb8\xed\xd6\x83\
\xbf\xe8\x47\xbd\xf1\xdc\x57\xfb\x86\xc7\xbe\xf7\x30\xac\xb5\x00\
\x00\xcf\xf3\xd0\xe9\x76\x84\xa3\x1c\x9f\x88\x2a\x00\x4a\x00\xbc\
\x8d\xa1\x29\x80\x1e\x33\x77\xb4\xd6\x49\xb9\x54\xb6\x49\x9a\x5c\
\x9c\xe7\x8e\xdf\xbb\xeb\x57\x0f\xe0\xd0\xe3\x0f\x01\xb0\x48\x92\
\x54\x48\x25\xeb\x52\xc8\xfd\x52\xca\x1b\xa4\x94\xfb\xa5\x54\x33\
\x52\x8a\xaa\x20\xe1\x01\x80\xb5\x36\x35\xc6\xb4\x8d\x35\xe7\x8c\
\x31\xc7\xac\xb5\x87\x8d\xd1\xc7\x8c\xb1\x6b\x52\x4a\x4b\x44\x38\
\x78\xfb\xdd\xbf\x3a\x00\x87\x1e\x7f\x10\x44\x42\x18\x93\xcf\x0a\
\x21\xdf\xeb\xb9\xde\xc1\x42\x21\xb8\xa9\x18\x14\xc7\xfc\x42\xc1\
\x73\x1d\x57\x48\x29\x41\x44\x00\x18\xd6\x5a\x68\x6d\x90\x65\xa9\
\x8d\x93\x38\x8d\xa2\x68\x25\x4e\xa2\xe7\xb3\x2c\x7b\x48\x6b\xfd\
\xa4\x94\xf2\x8c\xb5\xd6\xde\x79\xc7\x07\xff\x7f\x01\x1c\x7a\xfc\
\x41\x08\x21\x60\x8c\xa9\x13\xd1\xed\xbe\xef\xff\xf1\x48\xa5\xfa\
\xee\xea\x48\xad\x5a\x28\x14\xc0\x60\xa4\x59\x8a\x24\x8e\x90\xa4\
\x29\xb4\xd6\x00\x00\xa5\x14\x3c\xcf\x83\xef\xf9\x70\x1c\x07\x6c\
\x19\x51\x1c\x21\x0c\xc3\x76\xa7\x13\x3e\x93\xa4\xe9\xbf\x33\xdb\
\x43\x00\xd6\x8c\x31\xf8\xe0\x5d\x1f\xfe\xe5\x03\x78\xe4\xb1\xef\
\x42\x79\x2e\xf2\x24\xdd\xed\x38\xce\xc7\x47\x2a\xd5\x3f\x6c\x36\
\xc7\xa7\x82\x20\x40\x92\xc4\x58\x5d\x5d\xc1\xd2\xf2\x32\xd6\xd6\
\xdb\xb6\xd7\x8f\x75\x92\x19\x6d\x0c\x2c\x00\x28\x49\xc2\x73\xa5\
\x2a\x17\x0b\x6a\x74\xb4\x2a\xc6\xc6\x1a\xa8\x55\xab\x50\xd2\x45\
\xaf\xd7\xc5\xf2\xca\xf2\x7c\xa7\x1b\x7e\x2b\xcf\xf3\x2f\x65\x3a\
\x7f\xc5\x51\x0a\x1f\xba\xeb\x0f\x7e\x79\x00\x1e\x7d\xe2\x21\x10\
\x91\xd0\x5a\xdf\xe0\xfb\xfe\x5f\x37\x1b\x13\xb7\x35\x9b\xe3\x7e\
\x96\xa7\x98\x9f\x3f\x8f\x73\xe7\xce\xf3\xfc\x62\x3b\x5a\x8f\x28\
\xec\x9b\x20\x4c\x51\xec\x69\xf6\x52\x0b\x69\x00\x40\x40\x4b\x85\
\xd4\xf3\x28\x2a\x95\x54\x34\x52\x2f\xd2\xc8\xb6\x89\x5a\xb0\x7d\
\xfb\x34\x35\xc7\x9a\x60\x00\x4b\x4b\x8b\xc9\xca\xca\xf2\xa3\x49\
\x9a\x7c\x4e\x4a\x79\x98\xb5\xb6\x77\xdf\xfd\x91\x5f\x1c\xc0\x03\
\xdf\xbd\x07\x41\x10\x90\xd6\xfa\x66\xdf\x2f\x7c\x76\x7a\x6a\xfa\
\xd6\x7a\x7d\x4c\xad\xb5\x57\x70\xf2\xd4\x49\x9c\x39\xb7\x14\xb5\
\x3a\x6a\xb1\x8b\xb1\xc5\x5c\xd6\x7a\x90\x9e\x21\x12\x4c\x00\x31\
\xc0\xcc\x0c\xcb\x60\x6b\x19\xcc\x16\x64\x33\xe5\x23\x2c\x57\xc5\
\xea\xf8\x54\xd5\x8e\xef\xda\x31\x11\xec\x9c\xdd\x89\x82\x5f\xc0\
\xf2\xf2\xb2\x5e\x68\xcd\x3f\x91\xa4\xc9\x67\x14\xe8\xb9\x7e\x9a\
\xf0\xc7\x3e\xf2\x47\x5b\x06\xa0\xde\xa8\x53\x4a\x89\x34\x4d\x77\
\x17\xfc\xc2\x5f\x4c\x4d\x4e\xdf\x3a\x3a\xda\x50\xf3\xad\xf3\x78\
\xf9\xd8\x31\x7b\xfa\x7c\x77\x75\x45\x8f\x9f\xcd\x9d\xf1\xb6\x74\
\x7c\x53\x90\x24\x04\x41\x02\x20\xe6\x41\x46\xb0\x96\xd9\x32\xb3\
\xb5\xc4\xc6\x12\x1b\xeb\xeb\x98\x0b\x6b\x29\xd7\x3b\xbd\xf5\xe5\
\xd5\x4e\xbc\xb0\x23\x8a\xe2\xd1\x7d\x7b\xf7\x8a\xe6\xf8\xb8\xb2\
\x6c\x6f\xbd\x30\x7f\x21\x4e\x92\xe4\xcf\x05\x89\x53\x57\xe3\x01\
\x79\x79\xc7\x77\x1e\xbc\x17\xcc\x3c\xe2\x38\xce\x9f\x4d\x4e\x4c\
\x7d\x6c\x62\x7c\xc2\x9d\x6f\x9d\xc7\x0b\x47\x5e\x32\x27\x2f\x24\
\x0b\x2b\xb8\xe6\x14\x05\x13\xbd\xc0\xf7\x84\xef\x90\x54\x8a\xa4\
\x92\x24\xa4\x20\x48\x49\x24\x05\x91\x20\x22\x21\x04\x09\x02\x11\
\x81\x06\x5d\x00\x20\x6d\x46\xe5\xa8\xa7\x0b\xed\xb8\xbb\xea\xd8\
\xac\x53\xac\x8e\x94\xc5\x68\x7d\x54\x68\xad\x77\x46\x51\x9f\xb4\
\xd6\x4f\x7f\xf8\xc3\xbf\x9f\xde\x7b\xcf\xfd\x3f\xb7\x07\x24\x11\
\xdd\x51\x1d\xa9\x7e\x74\xbc\x39\xe1\xaf\xad\xaf\xe2\xe5\x63\x3f\
\xb5\xaf\xb6\xf2\x85\xb6\xdc\x7d\xda\x2b\x54\x73\xcf\x15\x4a\x12\
\x11\x11\x30\xf8\x3f\xb8\x98\x87\xf4\x61\xb6\x16\x6c\x2c\xb1\xb0\
\xcc\xc6\x5a\x26\x03\x61\x89\xd9\x32\xb1\xb6\x95\xa8\x65\xe4\x2b\
\x72\xfe\x02\x3c\xf7\xf4\xd4\xf5\xfb\xaf\x13\x93\x13\x93\x7e\xbf\
\xdf\xff\xe8\x6a\xbe\xf2\x8c\x35\xf6\xdb\x00\xcc\x55\x7b\xe0\xde\
\x07\xbe\x05\x22\x9a\xf5\xbd\xc2\xa7\x67\x66\x66\xdf\x29\x84\xa0\
\xe3\xc7\x8f\xe1\xa7\x67\xd6\x56\x56\x69\xd7\x69\x37\xa8\x67\x81\
\x2f\x95\x23\x85\x70\x94\x14\x4a\x0a\xe1\x48\x41\x4a\x0a\x92\x1b\
\x5a\x88\xa1\xd0\x45\xd9\xb8\x40\x00\x68\xc3\x2b\x06\x6e\x9e\x58\
\x37\xe2\x64\xa5\x58\xf4\x50\x1c\x1b\x6b\x40\x49\x59\x0c\x3b\xed\
\x52\xae\xf3\x1f\xdc\xfd\xa1\x0f\xb4\xef\xbf\xef\x3b\x57\xe7\x01\
\x22\x92\x00\xde\x57\xad\x56\xdf\x53\x2a\x95\xe8\xec\xb9\xd7\x70\
\xe6\xfc\x52\xbc\x6e\x27\xcf\xaa\xa0\x9e\x04\xbe\x50\x8e\x94\x42\
\x4a\x31\xa0\x8a\xd8\xf0\x02\x08\x8c\xc1\xee\xb5\x0c\xb6\x0c\xb2\
\x96\xd9\x58\x66\x63\xac\x15\x52\x90\xd0\x16\x5a\x08\x6b\xac\x85\
\xb5\x0c\x32\x56\xa4\xb6\xd2\x6f\x25\xe9\xd9\x33\xe7\x17\x4b\xa3\
\xa3\xa3\x85\x5a\xad\x4e\xd5\x91\xda\x7b\xe2\x38\x79\x1f\x88\xbe\
\xb2\x15\x2f\x88\x61\xe3\xab\x5f\xfb\x0a\x8c\xd1\x0d\xd7\x71\x6f\
\x1b\x1d\x1d\xab\xc6\x71\x84\xf3\x17\xe6\x79\x25\xf2\x16\xad\x3f\
\xde\x09\x7c\xa5\x5c\xa5\x84\xeb\xc8\xcb\x44\x09\x67\x53\x7b\xa3\
\x9f\x5c\x47\x92\xe3\x48\xe1\x38\x4a\xb8\x4a\x92\xb3\x31\xce\x71\
\x14\x29\x25\x07\x22\x25\xf5\xb8\xbe\xde\xea\xc8\xc5\x56\x6b\x91\
\x41\xc0\xd8\xe8\x58\xd5\x75\x9c\xdb\xac\xd6\x8d\x2f\x7e\xe9\x0b\
\x5b\xf7\x80\xd1\x12\xcc\xd8\x17\x04\xc5\x03\x41\x50\xc4\xe2\xd2\
\x3c\x96\xd7\x7a\x71\x9f\x26\x96\x3d\xbf\xc0\xae\xab\x84\x23\x85\
\x50\x4a\x90\x23\x05\x49\x49\x62\x83\x1e\x60\x00\x60\x0c\x22\x10\
\x33\x0d\xf8\xcf\x4c\x96\x59\x08\x2b\x48\x90\x85\x60\x10\x11\x91\
\xb1\x10\x43\x1e\x91\x45\x4e\x9e\x5d\xd7\xb5\xa5\xc5\xb5\xb0\x39\
\xd3\xef\x05\x95\xca\x08\x82\x20\x38\xd0\xed\x75\xf7\x59\x50\x6b\
\xcb\x1e\x50\x8e\x96\x42\x88\x03\xa5\x52\x69\x0a\x60\xac\xad\xad\
\x21\x4c\x64\x87\xbd\x7a\xe4\xb9\x4a\x3a\x52\x90\x52\x02\x8e\x23\
\xc9\x71\x25\xb9\x8e\x82\xe7\x28\x72\x1d\x49\x9e\x23\xc9\x75\x07\
\xab\xee\x3a\x6a\xd0\x76\x37\xb4\xa3\xe0\x0e\xc6\xc1\x71\x24\x5c\
\x57\xc1\x71\x06\x1e\x90\x4a\x92\x52\x02\x29\x55\x7a\x6b\x3d\x84\
\x61\xa7\x03\xd7\x75\x51\x2a\x95\xa7\x84\x90\x07\x04\xac\xbc\x12\
\x80\x8b\x1e\x20\x82\xa7\xa4\xda\x5f\x28\x04\x5e\x9e\x67\x08\x3b\
\x3d\x93\x72\xb1\xa3\xdc\x82\x71\x94\x90\x52\x0a\x80\x48\x74\xa3\
\xd4\x23\xb0\x94\x72\x18\x26\x07\x41\x88\x87\x81\xc8\x02\x96\x99\
\xcd\x20\x91\x6d\xec\x03\x66\x6d\xac\xd5\xc6\xb2\xb1\xcc\x00\x19\
\xd7\x75\x52\x05\x69\x00\x22\x03\x4f\xf7\x4d\xa1\xd3\xe9\xf6\x9a\
\xd3\x80\x2c\x06\x25\x4f\x49\xb5\x9f\x88\x3c\x00\xd1\x16\x01\x50\
\x51\x4a\x35\xe3\xba\x2e\xa5\x69\x82\x28\xc9\xb4\x91\xa3\x91\xe3\
\x38\x90\x42\x90\x90\x92\x92\x34\x75\x4e\x9e\x59\x98\x2c\x78\xd2\
\xf5\x94\x04\x68\xe3\x6f\x08\x62\xc0\x25\x66\x06\x86\x19\xf9\x52\
\x68\x1d\xe8\x2c\x37\xe8\xa7\x36\x99\x99\x1a\x9f\xf3\x5c\x37\xc9\
\x0d\x73\x9c\x53\xde\xb5\x6e\xb7\x17\xa5\xda\x58\x23\x0b\xbe\x4f\
\x52\xca\x19\x22\x51\xdc\x32\x00\x00\x81\x10\xa2\x2e\xa5\x44\x14\
\xc7\xc8\x35\x6b\x96\x41\x26\xc5\x20\x4b\x29\x29\x88\x19\xa2\xe4\
\x2b\xf7\x03\xbf\xbe\xd3\x1f\xaf\x15\xd8\x32\xe8\x4d\x8a\xa9\xe1\
\xb6\xd8\x00\x35\x38\xb4\x11\x11\x16\xd7\x23\xdc\xff\xbf\xaf\x22\
\xce\x0c\xaf\x45\x59\x7c\xea\x42\xaf\x3f\xbf\x9a\x24\x7b\xea\x09\
\xf6\x37\xcd\x5e\x6b\xad\xe7\xb8\x2e\xa4\x10\x75\x00\xc1\x96\x29\
\xc4\xcc\x2e\x80\x02\x81\x60\x8c\x81\x65\x62\x21\x1d\x4b\x82\x90\
\xe4\x56\x27\x1a\x9c\xe6\xac\x1c\x25\x31\x5e\x2b\xf0\x78\xd5\x83\
\xb1\x16\x83\x20\xfa\x26\x08\x06\x00\x18\x00\x2c\x03\x52\x08\x6b\
\x2c\x23\x33\xc8\x5e\x7c\xb5\xbb\xda\x0a\x79\xad\xdd\xcb\x74\x9a\
\x59\xae\x28\x1b\x67\x1a\x39\x33\x43\x08\x01\x10\x15\x36\x6c\xda\
\x1a\x00\x6b\x99\x2c\xdb\x8b\xe7\x5b\x21\x04\x48\x08\xac\x74\x75\
\x7c\x6a\x21\xea\xc5\x39\x1b\x57\xe8\xca\xb6\x92\xde\x96\x1b\x28\
\x0b\x22\xc6\xa0\x6c\x18\x30\xf0\x75\xd6\xd3\x60\x4d\x88\x19\x83\
\xdc\x60\x0c\x5b\x6d\xd9\xc6\xb9\xe5\x76\xa4\xb3\xd7\x96\x74\x94\
\xb3\x93\x0b\x29\x49\x2a\x82\x94\x02\x42\x30\x09\x31\xa4\x23\x83\
\xad\xbd\xe2\x79\x65\x13\x00\x93\x1a\x6d\x62\x6b\x2d\xa4\x94\x70\
\x94\x10\x79\xac\x71\xf4\x5c\x3f\x3c\xbf\x9a\x26\xca\x51\x90\x9c\
\x3b\x05\x9b\xe5\x67\x16\x7b\x3a\xd5\x0c\x30\x0f\x32\x2c\x81\xc4\
\x26\x47\x30\x83\x2d\xc0\x1b\x15\x29\x5b\x66\x66\x0b\x26\x01\xb4\
\x56\x23\x4a\x33\x03\x29\x5d\x30\x14\xac\x35\x10\x16\x08\x3c\xa1\
\x7c\x8f\xa4\x14\x12\xc6\x24\xd0\x5a\xc7\xc6\x98\x74\xcb\x00\xb4\
\x36\x51\x9e\xe7\x6b\x79\x9e\xc1\x51\x0e\x7c\x57\xaa\x28\x8e\x78\
\xbe\x2d\x92\x41\x10\x17\x44\x42\x9a\xc5\x8e\xee\x7d\xfd\xc9\x57\
\x8d\xe7\xca\x01\x79\x08\x18\x56\xe5\xbc\x09\xc0\x60\x23\xf3\x70\
\x23\x0f\x77\x38\xd2\x5c\xd3\x62\x47\x47\xd2\x29\x5a\x6b\x25\x01\
\x0c\x29\x81\xd1\x12\x0a\xe5\xc0\x75\x94\x72\x90\xa5\x29\xf2\x3c\
\x5f\xd3\xc6\x44\x5b\x07\x90\x67\xfd\x2c\x4b\xe7\xe2\x38\x46\xad\
\x5e\x45\x50\x70\x15\xeb\xbe\x9b\xe4\x81\x15\x52\xc2\x82\x60\xa5\
\x97\xc4\x72\xec\xf8\x6b\x3d\x16\x24\xc4\x90\xab\x18\x24\x33\x02\
\x00\xb6\x00\x86\x89\xcc\x5a\x86\xb6\xcc\xd6\xda\xa1\x3b\x36\x28\
\x5a\xb2\x50\x2a\x11\xc6\x82\x21\xe1\x12\xc4\xb6\x11\x1e\xa9\x55\
\x8a\xae\x90\x12\xfd\xa8\x8f\x34\x4b\xe7\xf2\x3c\xef\x6f\x19\x80\
\x31\x26\x4d\xd3\xf4\xa5\x6e\xb7\x93\x8c\x8e\x8d\xf9\x95\x72\x49\
\xd4\xfd\x95\x6a\x41\xe5\x4e\xdf\x3a\xa9\x82\x10\x16\x52\x1b\xe5\
\x77\x95\x12\x10\x52\x42\x0c\xaa\x35\x26\x1a\x00\xb1\x20\xa6\x8d\
\x74\xcc\x16\xcc\xd6\xb2\xb4\x0c\x61\x2d\xac\xb5\xb0\xc6\xc2\x5a\
\x03\x6b\x0c\xc8\x18\x12\x30\xb0\x16\x5c\x0b\xb4\xbf\xb3\x41\x8d\
\x7a\x75\x44\x59\x6b\x11\x86\x61\x92\xa6\xe9\x4b\x46\xe7\x57\xa4\
\xd0\xc5\x4c\x2c\xa5\x34\x59\x9e\x1f\x69\x87\xe1\xbc\xd6\x1a\x95\
\x4a\x05\x33\xa3\xb2\x31\x3b\x92\xd6\x2c\x0b\x36\x4c\xd6\x32\xb1\
\x05\xc1\xb0\x80\x65\x1a\x78\x05\xe2\xa2\x30\x09\x30\x09\x86\x90\
\x80\x10\x10\x52\x92\x94\x92\x84\x1c\x84\xe2\x41\x11\x38\xac\x56\
\xe5\x20\x50\x48\x81\xdd\x63\x79\x6d\xf7\x44\xa1\x51\xa9\x54\x10\
\xf5\x23\xac\xb7\xd7\xe7\xb3\x2c\x3b\x42\xca\xd9\x7a\x31\xf7\x89\
\x8f\x7f\x12\xd6\xda\x13\x61\x18\xbe\x10\xb6\x43\x94\x4a\x65\x4c\
\x8e\x15\x4b\x37\x4c\xc6\xb3\x05\xc7\x2a\xcd\xc4\x06\xc4\x86\xc9\
\x1a\x90\x35\x10\x6c\x20\xad\x85\x64\x4b\xd2\x5a\x21\x2d\x93\x64\
\x16\x8a\x49\x2a\x96\x4a\x41\x2a\x05\xa1\x24\xa4\x92\x90\x52\x0d\
\xbc\xb6\x21\x24\x05\x20\x04\x4a\x1e\x3b\xef\xda\x9e\xcf\xce\x4c\
\xd4\x4a\x9e\x57\xc0\xf2\xca\x32\xda\xed\xf6\x0b\xc6\x98\x13\x9f\
\xfe\xd4\x5f\x5d\xc9\xfe\x4b\x00\x00\x40\x90\x5c\x8e\xe3\xe8\xd0\
\xc2\xc2\xfc\xba\x20\x89\xc6\xd8\xa8\x78\xfb\x36\xcc\x1e\x18\xef\
\x4e\x12\x09\x58\x08\xb6\x20\x1e\x68\x61\x2d\x04\x5b\x22\x3b\x58\
\xf5\x81\xe1\x42\x29\x88\x0d\xe3\xa5\x1c\x88\x10\x43\xc3\x07\xa1\
\x59\x08\x01\x41\x03\x7d\xcb\xb6\x78\xf2\xa6\x9d\xfe\xec\x44\xa3\
\x29\xd2\x24\xc1\xdc\xdc\xb9\xf5\x7e\xd4\x3f\xa4\x84\x58\xbe\xa2\
\xf5\x97\x03\x30\xac\x8d\x36\xe6\x7b\xcb\x2b\xcb\xcf\xae\x2c\xaf\
\x70\xb5\x52\xc3\xcc\x44\xb5\xf4\x5b\x3b\x7a\x6f\xdb\x55\x8d\xaa\
\x4c\x97\xf8\x0e\x12\x80\x18\xd0\x85\xa4\x1c\x18\x39\x34\x7c\xd3\
\xea\x5f\x14\x71\xc9\x78\x12\x02\x4c\xc4\x7b\xea\x69\xf5\xd6\x3d\
\xf9\xdb\xf6\xce\x4c\x94\x7c\xbf\x80\xb9\xf3\x73\xdc\x5a\x6c\x3d\
\x6b\xb4\xf9\x5e\xae\xed\xd5\x9f\xc8\x1e\x7e\xf0\x11\x1c\x3c\x78\
\x7b\x27\xcb\xb2\x5c\x1b\xf3\x9b\x8d\xb1\x46\xa9\x54\x2e\x91\x8b\
\xb8\x14\x50\xdf\x6d\x45\x85\xd5\xae\xf1\x53\x39\xa8\xa5\x21\xa4\
\x84\x94\x12\x42\xaa\xd7\xd3\x64\xc3\xc8\xcd\xd7\xb0\x40\xb2\x60\
\x18\x0b\x9e\x2e\xc5\xe5\xbb\xf7\xb5\x6f\xf8\xb5\x7d\xa3\x3b\xb6\
\x4d\x4e\x89\xb5\xb5\x35\x1c\x39\x7a\x64\x69\x65\x65\xf9\x6f\x89\
\xf8\x87\x9f\xfa\xd3\xbf\xe4\xab\x06\x00\x00\x07\xef\xbc\x83\xf3\
\x3c\x9b\xcb\xb2\x74\x8c\x99\x0f\x34\x9b\xe3\x2a\x08\x0a\xa2\x2c\
\xe3\x6a\x55\xf5\xfc\xb5\xd4\x6d\x77\x74\x21\x25\x21\xa1\xe4\x10\
\x84\xd8\x00\x32\x04\x21\x70\xe9\x89\xcd\x20\x29\x6c\x3c\xad\x00\
\x2c\x63\x67\xa5\x57\xfd\xe0\xde\xf5\x1b\x7f\x63\xef\xc8\x35\x3b\
\x67\xb6\xab\x38\x8e\xf1\xe2\xd1\x23\xd1\xdc\xb9\x73\x5f\x35\xd6\
\xfc\xeb\xc9\x93\xa7\x92\xd9\x9d\xb3\x38\x7e\xec\xa7\x57\x0f\xe0\
\xe1\x87\x0e\xe1\xce\xbb\x0e\xa6\x79\x9e\xbf\x16\x45\xd1\x2c\x91\
\xd8\x3d\xde\x1c\x97\x41\xe0\x8b\x8a\x93\xd4\x9a\x5e\x77\x84\xc0\
\x59\x3b\xf7\xa3\x1c\x8e\x11\xe2\x92\x37\x2e\x6e\xd0\x8d\xe7\xa3\
\xcc\x83\xe3\xe3\x86\x70\x20\x73\xf7\xe6\xc6\xda\xf4\xc1\x6b\xc2\
\x1b\xdf\xbd\xbb\x36\x3b\x33\x3d\xad\xb2\x2c\xc7\x4f\x0e\xff\x04\
\xcf\x3d\xff\xdc\x6b\xc7\x4f\x9c\xf8\xe6\xd1\xa3\x47\x5b\xfd\x7e\
\x64\xb4\xd6\xfa\x6d\x6f\xbf\x1e\x37\xde\x74\x03\x8e\xbe\xf8\xd2\
\xd6\x01\x00\xc0\x23\x0f\x1f\xc2\xc1\x83\x77\xae\x25\x69\x7c\xba\
\xdb\xeb\xee\x22\x60\x67\xa3\xd1\xa0\x4a\xb9\x2c\xaa\x05\x53\x99\
\x2a\x74\xc7\xc7\xbd\x5e\x11\x80\x4e\xd8\xc9\x34\x94\xb5\x24\x19\
\x20\x30\x13\x2c\x0f\x56\xdb\x1a\x0b\x62\x23\x8a\x22\x71\xf7\x96\
\xd7\x9b\xbf\xbb\x6d\xe9\xfa\xdf\xd9\x99\xbf\xfd\x1d\xbb\x9a\x8d\
\xc9\x89\x09\x91\x26\x29\x0e\xbf\x70\x18\xcf\x3d\xff\x1c\x5a\xad\
\x96\x1f\x27\xc9\x01\xbf\x50\x78\xaf\xa3\xd4\x2d\x42\x08\x58\x6b\
\xcf\x58\x6b\xcd\x5b\x79\xe2\x4d\x8b\xa5\x7f\xfa\xe2\x3f\x22\x49\
\x32\x12\x82\x0f\x04\x41\xf0\x99\x1d\x3b\x76\xdc\xbe\x77\xcf\x5e\
\x3f\x28\x16\x11\xc5\x3d\xb4\xc3\x8e\x5d\x09\xd3\xfe\x42\x4f\x2d\
\x5d\x88\x82\xa5\xa5\x34\x08\x7b\xc6\x8f\x73\x96\x06\x20\x38\x94\
\xcb\xb2\x4c\x0b\x4d\x3f\x1a\xd9\x56\x4c\x9a\xd3\x23\xdc\x9c\xaa\
\x97\x8a\x8d\xd1\x31\xe1\x79\x3e\x56\x57\x57\x71\xec\xf8\xcb\xd1\
\x8f\x9f\x7b\xee\xdc\xd9\xb9\xb9\x1d\xd7\x5d\xbb\xaf\x50\x2e\x97\
\xe1\x38\x0a\x51\x1c\xdb\x53\x27\x4e\xbe\xb2\xb0\xd0\xfa\x2c\x33\
\xdf\x43\x44\xe9\x7d\xf7\x3c\x70\x75\x00\x00\xe0\x1f\xbe\xf0\xf7\
\xa0\x9c\x90\x8b\x7c\x9f\xeb\xb8\x7f\xd2\x68\x34\x3e\x7a\xcd\xae\
\xdd\x93\x93\x93\x13\x50\x8e\x42\x92\x26\x88\xa3\x08\x51\x92\x99\
\x28\x35\x59\xa2\x39\xd3\x16\x1a\x00\x1c\x41\xaa\xe0\x0a\xb7\x5c\
\x70\xdc\x52\x31\x90\xa5\x62\x09\x9e\xe7\x23\x89\x13\x9c\x9b\x3b\
\x87\x53\xa7\x4e\x2e\x2c\x2d\x2f\x7d\xe3\x99\x67\x9f\x7f\x26\xec\
\x74\x3f\xff\xee\x5b\x6e\xdc\x3b\x3a\x3a\x8a\x7a\xbd\x8e\xfa\x68\
\x0d\xab\xab\xab\x78\xe6\x99\x67\x4f\xb4\x16\x5a\x9f\xb3\xd6\xde\
\xcb\xcc\x49\x10\x28\x7c\xe3\x3f\xef\xbb\x32\x85\x86\xd7\xa3\x87\
\x1e\xc7\xc1\x3b\xef\x40\x9a\xe7\xab\x46\xeb\x1f\x77\xba\xdd\xd3\
\x2b\x2b\x2b\x95\x30\x6c\x8f\x81\xe1\x17\x83\x12\x2a\xe5\x0a\x46\
\x2a\x15\x51\x1f\x29\x3b\x8d\x6a\xd1\x9f\xa8\x97\x82\xc9\x7a\x39\
\x98\x18\x1d\xf1\x1b\xa3\x35\x67\xa4\x32\x22\x3c\xcf\x47\x92\x24\
\x38\x77\xf6\x2c\x5e\x7a\xf9\x68\x78\xf2\xd4\x89\x1f\x2c\x2d\x2f\
\xfd\x5d\x9e\xe7\xff\xf6\xc8\x63\xff\x7d\xbe\xe0\xfb\xb7\xd6\x6a\
\x23\xbb\x84\x10\xe8\x74\xba\xe8\xf7\xfa\x18\x1f\x6f\xa2\xd1\x18\
\x1b\x0b\xdb\xe1\xf5\xbd\x5e\x6f\x59\x6b\x7d\x82\x59\xfc\x0c\x9d\
\xae\x78\x68\x7e\xe4\xd0\xa3\x78\xe2\xb1\x27\xb0\xba\xb6\x14\xbf\
\x70\xf8\x85\x63\x42\x8a\xa7\xc2\x30\x3c\xbd\xb8\xb8\x68\x96\x16\
\x17\xfd\x76\x3b\x74\xe3\x38\x71\x75\x9e\xc3\x18\x0b\x63\x2c\x74\
\x6e\x10\xc7\x09\xda\x61\x88\x85\xd6\x02\x5e\x79\xe5\x54\x74\xec\
\xf8\xb1\x0b\x27\x4f\x9d\x7c\x6a\x7e\x7e\xfe\xcb\xad\x85\xd6\x3f\
\x7f\xf3\x1b\xff\xf5\xf4\xbd\xf7\xdc\x1f\x7b\x85\x00\x41\x31\xb8\
\xb9\x54\x2a\xdd\x54\x2c\xf8\xb4\xb4\xb4\x88\x6e\xb7\x87\x3c\x37\
\x98\x9a\x9a\x42\xb3\xd9\x18\x0b\xc3\xf0\x1d\x51\x14\x2d\x33\xf3\
\xc9\xfd\xd7\x5f\xf7\x3a\x10\x5b\xfd\x86\xe6\x75\xe3\x6e\xbb\xed\
\x7d\xf2\xe6\x5b\x6e\x6a\x38\xae\x73\xbd\xe3\x38\xef\x74\x5d\xf7\
\x5a\xcf\xf3\xa6\x1d\xc7\xad\x2a\x29\x7d\x00\xd0\x46\xa7\x59\x9a\
\x85\x49\x9a\x5c\x88\xa2\xe8\x64\xbf\xdf\x3f\x7a\xfe\xfc\x85\xe3\
\x4f\x3c\xfe\xe4\xea\xca\xf2\x8a\x19\xce\xe9\x7a\x1e\xef\xbe\xf6\
\xba\xf7\x37\x9b\xcd\xcf\x5f\xbb\xef\x9a\x3d\x81\xef\xa2\xd3\xe9\
\xa0\x58\x2c\x63\xfb\xf6\x69\xec\xde\x73\x0d\xba\xdd\x2e\x9e\xfe\
\xd1\xd3\x27\x5a\xad\xc5\xcf\x5b\x6b\xef\x61\xe6\xa4\x5c\x2e\xe3\
\x3f\xbe\xf6\xf5\x2d\x01\xa0\x4d\x7a\xb3\x30\x00\xcc\xee\x9c\x75\
\x6f\x79\xd7\x4d\xc5\x62\x10\x54\xa4\x52\x45\x29\x85\x67\x2d\x53\
\x9a\xa6\x79\xd4\xef\xc7\x8b\x4b\xcb\xfd\xa3\x2f\xbe\x14\x87\xed\
\xd0\x60\x90\xf9\xc5\xe5\x0b\x52\xaa\x54\xfc\xe9\x1d\x3b\xef\x9e\
\x98\x68\x7e\x72\xff\xb5\x7b\x76\xfa\x9e\x8b\x30\x0c\x51\x2a\x95\
\xb0\x7d\xfb\x76\xec\xdd\xb7\x07\x61\x18\xe2\xe9\x1f\x3d\x7d\x62\
\x7e\x7e\xe1\x73\x5a\xeb\x6f\x3b\x8e\x93\xdd\x77\xcf\x03\x57\x04\
\xf0\x66\xc6\x8b\xcb\x34\xde\xe2\xfe\x66\x79\xb3\x31\xf0\x0a\x85\
\xc2\xf6\x1d\xb3\xef\x9f\x9e\xde\xf6\x89\xfd\xd7\xed\xdd\x51\xf0\
\x5d\xb4\xdb\x21\x8a\xc5\x01\x88\x7d\xd7\x5e\x04\xf1\xca\xfc\x7c\
\xeb\x6f\x88\x70\x2f\x80\xe4\x4a\x7b\x60\xb3\x71\xe2\x2d\xb4\xd8\
\xd8\x4f\x12\x83\x33\xc6\x66\x2d\x37\xdd\xdf\x3c\x6e\x38\xc6\x01\
\xe0\x1a\xad\x65\xaf\xdb\x9d\x87\x90\x9d\x2c\xd7\xbb\x6a\xd5\x5a\
\xb5\x5c\x2a\xa2\xdb\xed\x20\x8e\x13\x68\xad\x31\x35\x35\x85\x46\
\xb3\x51\x5f\x6f\xb7\xaf\x8f\xfa\xfd\xb3\x00\x5e\xb9\x1a\x00\x6f\
\x64\x3c\xe1\xca\xe0\x36\x83\x7c\x33\x0f\x29\x00\x8e\x31\x86\xfa\
\xdd\xce\x1c\x0b\xd9\xce\xb2\xfc\x9a\x7a\xbd\x3e\x52\x2e\x17\xd1\
\xe9\x5c\x02\x31\xb3\x63\x06\x8e\xab\xc6\x16\xe6\xe7\x7b\x71\x9c\
\x7c\xff\x6a\x01\xe0\xb2\xd7\x6f\x74\x9f\xde\xe4\xfd\x43\xcd\xb8\
\x74\x7c\xfe\x19\xea\x19\x63\x4c\xaf\xdb\x39\x03\x21\x97\xb3\x3c\
\xdf\x53\xab\x57\xab\xe5\x52\x09\x9d\x4e\x07\x00\x50\xaf\xd7\xb0\
\xbe\xde\xd6\x73\xe7\xe6\xbe\x1f\x86\xe1\x55\x01\x78\xa3\xfe\xcd\
\x6d\xbe\x4c\x03\x18\x7c\x63\xb9\xc9\x68\xbb\x49\x0f\xc5\x6c\xea\
\x1f\x3c\x43\x32\x46\xf7\x7b\xbd\xd7\x48\xca\xf5\x2c\xd3\xbb\x6b\
\xb5\x6a\xb5\x5e\xaf\x61\xa4\x3a\x82\xb0\xd3\xc1\x8b\x47\x8e\x1e\
\x6d\x2d\x2e\xfe\xcb\x53\x4f\x3e\xf5\xda\x15\xf3\xc0\x65\xc6\xf2\
\x65\x06\x6d\x96\xcb\x0d\x1d\x1a\x36\x6c\x1b\x00\xfa\x32\xc9\x37\
\xb5\xcd\x26\x61\x63\xb4\xe9\x75\x7b\x67\x21\x44\x37\xcd\xf2\xdd\
\xbe\xe7\x55\x3a\xdd\xae\x3d\x7e\xfc\xc4\xe9\x33\x67\xce\x7c\xf9\
\xc8\xe1\x23\x3f\x4c\xd3\xec\xe7\xcb\x03\x78\x73\xea\xbc\x15\x8d\
\xde\x6a\xee\xe1\xe6\x76\x36\x89\x02\xe0\xb8\xbe\x5f\x9c\x9e\xd9\
\xf1\xdb\x95\x91\x91\xdf\x26\xf0\x7a\xa7\xdd\xfe\x9f\xb9\xb3\x67\
\x0f\x67\x59\xd6\x05\x90\x5c\xed\x8f\x3d\x86\x1c\xde\x0a\xa5\xae\
\x76\xde\xcd\xd1\x4c\xe1\x52\x84\x72\xa4\x94\x9e\x5f\x28\x94\x74\
\x9e\xdb\x34\x4d\x87\x5e\x4b\x7f\x1e\x00\x6f\x65\xc0\x2f\x63\x8e\
\xcd\x51\x6a\x18\x76\x87\x60\x86\xaf\x87\x8b\x98\x03\xc8\xff\x0f\
\xa2\xa6\x1d\x4e\xc6\x2f\xed\x25\x00\x00\x00\x25\x74\x45\x58\x74\
\x63\x72\x65\x61\x74\x65\x2d\x64\x61\x74\x65\x00\x32\x30\x30\x39\
\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\x3a\x35\x31\x3a\x32\x31\x2d\
\x30\x37\x3a\x30\x30\x82\x80\x0a\xca\x00\x00\x00\x25\x74\x45\x58\
\x74\x64\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\x00\x32\x30\x31\
\x30\x2d\x30\x32\x2d\x32\x30\x54\x32\x33\x3a\x32\x36\x3a\x31\x38\
\x2d\x30\x37\x3a\x30\x30\x67\xec\x3d\x41\x00\x00\x00\x25\x74\x45\
\x58\x74\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\x79\x00\x32\x30\
\x31\x30\x2d\x30\x31\x2d\x31\x31\x54\x30\x39\x3a\x31\x31\x3a\x34\
\x30\x2d\x30\x37\x3a\x30\x30\x93\x15\x56\xb1\x00\x00\x00\x34\x74\
\x45\x58\x74\x4c\x69\x63\x65\x6e\x73\x65\x00\x68\x74\x74\x70\x3a\
\x2f\x2f\x63\x72\x65\x61\x74\x69\x76\x65\x63\x6f\x6d\x6d\x6f\x6e\
\x73\x2e\x6f\x72\x67\x2f\x6c\x69\x63\x65\x6e\x73\x65\x73\x2f\x47\
\x50\x4c\x2f\x32\x2e\x30\x2f\x6c\x6a\x06\xa8\x00\x00\x00\x25\x74\
\x45\x58\x74\x6d\x6f\x64\x69\x66\x79\x2d\x64\x61\x74\x65\x00\x32\
\x30\x30\x39\x2d\x31\x32\x2d\x30\x38\x54\x31\x32\x3a\x35\x31\x3a\
\x32\x31\x2d\x30\x37\x3a\x30\x30\xdd\x31\x7c\xfe\x00\x00\x00\x19\
\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\x00\x77\x77\x77\
\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\
\x1a\x00\x00\x00\x17\x74\x45\x58\x74\x53\x6f\x75\x72\x63\x65\x00\
\x47\x4e\x4f\x4d\x45\x20\x49\x63\x6f\x6e\x20\x54\x68\x65\x6d\x65\
\xc1\xf9\x26\x69\x00\x00\x00\x20\x74\x45\x58\x74\x53\x6f\x75\x72\
\x63\x65\x5f\x55\x52\x4c\x00\x68\x74\x74\x70\x3a\x2f\x2f\x61\x72\
\x74\x2e\x67\x6e\x6f\x6d\x65\x2e\x6f\x72\x67\x2f\x32\xe4\x91\x79\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x03\x0e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x02\x8b\x49\x44\
\x41\x54\x58\x85\xed\x97\xcb\x6b\x13\x51\x14\x87\xbf\x99\x49\x6d\
\x4b\x1b\x8a\x2d\x2a\xa2\xa8\x1b\xa1\xa1\x8b\xd2\x9d\xd0\x4d\x40\
\x70\x2d\x14\xdc\xb8\xb3\x0b\x57\x12\x5a\xff\x80\x6c\x5c\x08\x8a\
\xa5\x2b\x57\x5d\xbb\x55\xdc\x37\x20\xa4\x08\x29\xd4\x62\x4b\x8a\
\x0f\x50\x29\x28\x2d\x1a\x75\xa2\xe4\x31\xf7\x1e\x17\x9d\x4c\xa6\
\xc9\x9d\x9a\xa6\x63\x40\xe8\x0f\xee\xbc\xef\x39\xdf\x9c\x73\xee\
\x61\xc6\x12\x11\x4c\xb2\x2c\xcb\x36\xde\xe8\x52\x22\xa2\x8d\x7e\
\x4c\x00\x8b\x8b\x8b\xe7\x53\xa9\xd4\x9c\x88\xc4\x02\x61\x59\x96\
\x2e\x16\x8b\x0b\x99\x4c\x66\xdb\x44\xb6\x6f\xa4\xd3\xe9\x44\xa1\
\x50\x58\xa9\xd5\x6a\x12\xe7\x28\x14\x0a\x2b\xe9\x74\x3a\xd1\xea\
\xaf\xed\x0d\x5d\xd7\xb5\x1c\xc7\x19\x88\xe3\xcd\xc3\x72\x1c\x67\
\xc0\x75\x5d\xab\xf5\x7a\xac\x79\xee\x46\xc7\x00\xc7\x00\xff\x04\
\xa0\xf4\xfb\x1d\x60\x6e\x70\x3d\x01\x78\xbb\xfb\x94\xe5\x37\xf3\
\xb8\x95\xf6\xbe\xd3\x13\x00\x80\xdd\xf2\x6b\x9e\x6f\xde\xa4\xf8\
\xe5\x09\x82\xb1\x0b\x03\x90\x38\x8c\x51\x2d\x75\xaa\x9e\x8b\x88\
\x87\x16\x15\xec\xb5\x78\x08\xfe\x5e\x14\x15\xef\x3b\x00\x4a\x55\
\x29\x7c\x5a\xe0\xe3\xb7\x65\xc6\xf4\x4c\x7f\xc7\x00\x8d\x36\xd9\
\xaa\x6a\xfd\x27\x3b\xe5\x75\x6a\xaa\x4c\x5d\x95\xa9\x79\x6e\xf3\
\xd8\x3f\xaf\xab\x5f\xd4\x94\xbb\x6f\xde\x4e\x79\x9d\x5d\x36\xc7\
\x6f\x3f\x52\xf3\x4b\xf9\xa9\x07\xb3\xd3\x6b\x41\x48\x22\x53\xd0\
\xda\xb3\x9b\x03\x68\x1c\x07\xcf\x12\xaa\x39\x09\x6d\x43\xf6\xf0\
\x6c\xdb\xe1\x3e\x90\x5f\xca\x4f\x8d\x77\x15\x01\xf1\x3d\x05\x0e\
\x45\x7c\x4f\x4d\x82\x0e\x6a\xff\x0a\xf0\x6a\x29\x3f\x95\x05\x1e\
\x1a\x01\xb4\xd6\x68\xdd\x5e\x38\x5a\x34\x5a\x0b\x22\xda\x18\x19\
\x69\x00\x05\x60\x91\xaa\x03\x3f\x00\xdd\x5d\x04\xfc\x6d\xf3\x0c\
\xc2\x1e\xff\x12\x85\x1c\x70\x6b\x76\x7a\xed\x03\x44\xd4\x40\x74\
\xfe\x7d\xb0\x50\x2d\x20\xe1\x04\x44\xbb\xb7\xe9\xd3\xca\x23\x03\
\x5c\x6d\x38\x87\x03\x6a\xc0\x94\x82\x84\x35\xc4\xe8\xe0\x04\x22\
\x6a\x6f\x19\xd2\x58\x8e\xca\xbf\xb6\xb7\x1c\xdf\x7f\x7d\xc6\x67\
\xf7\x65\x30\xef\xd4\xd0\x24\x23\x95\xeb\x5b\x77\x33\xf7\x1e\xaf\
\xae\xae\xee\x23\x8c\xec\x03\xa6\x14\x58\x24\xe8\x77\x4e\x46\x4d\
\x09\xb4\x9d\x78\x01\x80\x63\xf7\x33\x71\x66\x96\xcb\x63\x33\x14\
\x8b\x5b\x55\xd3\xb3\x91\x45\x18\xf5\xb1\xda\xa9\x46\x07\x53\x4c\
\x9e\xbd\xc3\xf0\x89\x73\x88\x60\x8c\x68\x24\x40\x54\x11\x76\xaa\
\x0b\x23\xd7\x48\x9e\xbe\x84\x85\x15\xd8\x89\xb2\x77\xa8\x1a\xe8\
\x54\xc3\x7d\x17\x11\x2d\xa1\x15\xd2\x05\xc0\x51\x53\x60\xb2\xd9\
\x31\xc0\x41\x13\xe2\xd6\xa1\x3a\xe1\x51\xd4\xd3\x22\x8c\xb2\xf9\
\x7f\x00\x24\x93\x49\x51\x4a\x55\xe2\x4e\x81\x52\xaa\x92\x4c\x26\
\xdb\x28\xda\x00\x72\xb9\x9c\x97\xcd\x66\x6f\x94\x4a\xa5\x39\xad\
\x75\x2c\x9f\x6c\xb6\x6d\xeb\x8d\x8d\x8d\x85\x5c\x2e\xe7\xb5\xde\
\x33\xfe\x1d\x43\xef\x7e\xcf\xff\x00\x9e\xfb\x3e\x13\x97\xc1\x3f\
\xbe\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x01\x62\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x03\x00\x00\x00\xf3\x6a\x9c\x09\
\x00\x00\x00\x75\x50\x4c\x54\x45\xff\xff\xff\xee\xee\xf2\xf5\xf5\
\xf7\xd4\xd4\xdc\xfe\xfe\xfe\xa3\xa3\xaf\xe9\xe9\xed\xf0\xf0\xf4\
\xe8\xe8\xec\xfb\xfb\xfd\xf1\xf1\xf5\xed\xed\xf1\xff\xff\xff\xf2\
\xf2\xf6\xf7\xf7\xfb\xf3\xf3\xf7\xe3\xe3\xe9\xe4\xe4\xea\xea\xea\
\xee\xf4\xf4\xf8\xe0\xe0\xe6\xce\xce\xd6\xd0\xd0\xd8\xdb\xdb\xe1\
\xf9\xf9\xfb\xec\xec\xf0\xd7\xd7\xdd\xfa\xfa\xfc\xeb\xeb\xef\xf6\
\xf6\xf8\xfc\xfc\xfe\xd2\xd2\xda\xde\xde\xe4\xd6\xd6\xdc\xdf\xdf\
\xe5\xd9\xd9\xe1\xe2\xe2\xe8\xdb\xdb\xe3\xe6\xe6\xec\x7f\xfb\x8f\
\x57\x00\x00\x00\x01\x74\x52\x4e\x53\x00\x40\xe6\xd8\x66\x00\x00\
\x00\x9b\x49\x44\x41\x54\x78\x5e\x65\xce\x45\x0e\xc4\x30\x10\x44\
\x51\xb7\x31\xcc\xc3\x8c\xf7\x3f\xe2\x24\x3d\x29\xa9\x2d\xd7\xf2\
\x2d\x4a\x5f\x29\xb3\xce\xa9\x68\xa6\xaa\xaa\xbc\x39\x10\x5c\xb0\
\x3d\x11\x99\xa3\x4b\x38\x2f\xc8\xcd\x4b\xb8\x25\xbf\xdb\xc4\xbc\
\xf8\x18\xee\xb7\x6d\xca\x9a\xa2\x22\x94\x0c\x5d\x54\xc4\x6c\xf7\
\xc1\x67\x51\x11\x73\x5e\x87\xf2\x2c\x8b\x98\xed\xa5\x2d\xa8\x94\
\x45\xcc\x57\x0d\x46\x11\x73\xa3\xdb\xf9\x05\x45\xaf\x87\xf9\xb3\
\x1e\xeb\xf9\x04\x45\xd3\xf3\xc3\x6c\x35\x9f\xa0\xa8\x7b\x4f\x0b\
\xbb\x75\x28\xca\xfa\x6e\x61\x0c\x45\xfe\x1b\x31\x8a\x86\xac\x97\
\x8c\x22\xc9\xa2\xc8\x0b\x46\x51\x7a\xe2\xc4\xd4\x0f\x03\x81\x0c\
\xa5\xab\x5d\xa7\x60\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x04\x8c\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x04\x53\x49\x44\x41\x54\x78\xda\xa5\x54\x5b\x6b\x5c\x55\
\x14\xfe\xf6\x3e\x67\x6e\x49\x3c\x33\xe9\x68\x92\x4e\x4d\x9a\xea\
\x18\xad\xa6\x52\x43\xa3\x62\xa5\x41\x2a\xa9\x4f\x15\xd2\xc7\x0a\
\x02\x82\xbe\x28\x46\x10\x81\xbc\xf6\x45\xa4\x82\x50\x7d\xf1\x17\
\xa8\x16\x4a\x23\xa9\x48\x14\xd5\x68\x42\x42\x42\x85\xe6\x56\x2c\
\xb9\xb4\x13\x3b\xd3\xc9\x65\x32\x97\x73\x99\x73\xd9\xee\xb5\x73\
\x18\x02\x05\xc1\xba\x0e\x8b\x75\x66\xf6\xb7\xbf\xb5\xd6\xb7\xd7\
\x3e\x4c\x08\x81\x07\xb1\xd3\x3f\xbf\xf2\xe9\xf9\xec\x1b\xef\x78\
\xf0\x61\x79\xa6\x7f\xe9\xb7\xcf\xce\xde\x7a\x73\xed\x57\x84\xa6\
\xe3\x01\xed\x48\xcb\x91\x27\x7a\x93\xbd\xcd\x26\x2c\x98\xa2\x86\
\x54\x22\xf5\x0c\x80\xff\x4f\x5c\xaf\xbb\x41\xb9\x5e\x86\x49\x8f\
\x30\x01\x9f\x81\xec\x3f\x13\x37\x7d\x1e\x6f\x7e\xf1\xd0\x0b\x9f\
\x18\xf1\x64\xcc\x63\xbe\xe8\x32\xba\xb2\x15\x67\x8f\xb8\x2a\xaa\
\x28\x9a\xc5\x33\xc6\x97\x4d\x9d\x3c\x60\x94\x64\x5d\x69\xcc\x18\
\x6b\x07\xc0\xf0\x2f\xd6\xf1\xf1\xc3\xef\x7d\x75\xfe\xdb\x11\x2f\
\x70\xa5\xa6\x16\x2c\x61\xa1\x16\x3e\x97\x37\xbf\xc1\x6c\x7d\x0e\
\x41\x22\x90\x2e\xc0\xd7\xd8\x86\x9e\xcd\x66\x7f\x1f\x1e\x1e\x7e\
\x5e\xd7\xf5\x40\x9a\x6c\xb1\x0e\xc7\x71\x28\xea\xb6\x63\x0b\xa7\
\xee\xc0\xb6\x6c\x6c\xac\xe5\xb8\x2d\x09\x4d\xcf\x54\xc4\x3b\xce\
\x36\x26\x37\xff\xc0\xe4\xee\x24\x76\xf4\x1d\xb0\x04\x03\x67\x1c\
\x40\x00\xb6\xcd\xda\x58\x7f\x7f\xbf\x3d\x3d\x3d\x1d\xc3\x3e\xa3\
\x04\xb7\x8a\x7f\x21\x92\x88\x60\xbd\xbc\x8e\xeb\xc5\x39\x8c\x2e\
\x5e\x85\x17\x75\x91\x8c\x26\xb1\x5e\x59\x43\xc1\x2c\x80\x4c\xc4\
\x85\xaa\x32\x08\xa3\x90\x8e\x65\x21\x74\x4d\xd3\xee\x6b\x9b\xe4\
\xe1\x5c\x43\xae\x96\xc3\x2f\xb9\x9f\x70\xa7\x72\x07\x81\x1e\xc0\
\x29\xb8\x68\xef\xec\x40\xdb\x43\xed\x58\x0d\x56\xb1\x60\xdf\x00\
\xb3\x19\x78\x00\xbc\xe4\x9c\x44\x5a\xa4\x11\xd8\x02\x57\xbe\xbf\
\x22\xd4\xe1\x85\x3a\x23\x34\x25\xc7\x77\xf3\xa3\x18\x73\x47\xf1\
\xe7\xbd\xeb\xe0\x16\x03\x04\x70\x36\x32\x84\x4b\x83\x5f\x28\xfc\
\xc8\x8f\x1f\x61\x21\x7f\x03\x31\x2d\x86\xc3\xf1\x6e\x0c\x75\x9e\
\xc3\xeb\x47\x87\xd4\xda\xd7\xe7\x2e\xfb\x44\xcc\x6d\xdb\x56\xc4\
\x14\xf3\xf9\x3c\x4c\xd3\x44\x7d\xab\x0e\xc3\x4d\xe1\x59\xe7\x38\
\x44\x3d\x90\x95\x04\x88\xd4\x23\x98\x9a\x9a\x82\xef\xfb\xb8\xfb\
\x77\x1e\xd4\xed\xf1\x47\x9e\xc3\x53\xa9\xa7\xb1\xb4\xb0\x84\xf8\
\xed\x1f\x68\x8d\xc8\xb9\x4e\x19\x62\xb1\x18\x38\xe7\x2a\x1a\x86\
\x81\x72\xb9\x8c\xad\xad\x2d\xcc\xea\x33\xa8\x98\x15\x70\x93\x41\
\x2b\x73\x74\x55\xbb\xd1\x7f\xe2\x04\x15\x8f\xb1\xea\x55\x64\xac\
\x43\x78\x2c\xf9\x38\x8e\xa5\x8f\x81\xf5\x72\xbc\x9a\x3d\xad\x2a\
\x26\xd3\xc3\x0c\xe4\xea\xd0\x54\xf4\x7d\x35\x9b\x56\xcc\x46\x40\
\x40\x1f\xe0\x51\x01\xcf\xf3\x40\x78\xea\xee\xdd\xfe\xf7\x71\x70\
\x31\x03\xad\xae\x61\x61\x76\x01\x1f\xbc\xf6\xa1\xc2\x8a\x90\x43\
\x27\x30\x11\x12\xb8\x41\x2c\xdd\x12\x26\x6c\x49\x4c\xc6\x5c\x8e\
\x20\x2a\x24\xa9\x24\x96\x18\x2e\xb1\x07\x12\x07\xf0\x56\xdf\xdb\
\x0a\x3f\x51\x99\x00\x13\x90\xfb\x02\x45\x4c\xa6\x88\x73\xb9\x9c\
\x02\x14\x0a\x05\x55\x51\xad\x56\x03\x6e\x33\x3c\x59\x3a\x8a\xc0\
\xf1\x21\xaa\x42\xb9\x77\x37\xc0\xf8\xf8\x38\x61\x09\xd7\xf0\x9b\
\x37\x6f\xe2\x9e\xdc\x4b\x85\x79\x7b\x1d\x09\x5d\x5e\x06\xbf\xa3\
\xa3\x23\x42\x07\x91\xc9\x64\xd4\xe2\xee\xee\x2e\x2e\xb2\x8b\x98\
\xef\x99\x07\xaf\x31\xe8\x25\x0d\xfa\x96\xd4\xb8\xde\x85\x81\x81\
\x01\xc8\xcb\x04\xb1\xaf\xbb\x78\x3c\x8e\x81\x53\xa7\x1a\xa3\x3a\
\x32\x32\x22\x74\x1a\x2d\xca\xda\x90\x42\x3a\xc5\x1a\xaa\x6a\xe0\
\x99\xcb\x20\x74\x01\xa1\x01\x5e\xe0\x29\xfd\x03\xce\x15\x81\x08\
\x25\x24\x62\x4e\xf7\x21\x3c\xb8\x74\x3a\x0d\xbd\x5a\xad\x0a\xcf\
\x75\x09\x40\xe0\xc6\x06\x8b\xdb\xea\x56\x09\x6b\x8f\x54\x70\xd5\
\xbe\x3a\x40\xea\x8e\x28\x18\xe7\x6a\x5f\x53\x22\xa1\xfe\x0b\x4b\
\x26\x62\xa6\x4b\x3d\xf5\xe9\x99\x19\x68\x12\xe4\x85\x9a\xc9\x64\
\xe8\xdc\x78\x14\x46\xc9\x80\xa8\x09\xa0\x2a\xbb\xa8\x04\x70\x57\
\x3d\x8c\x5d\xbb\x86\x84\x24\x8a\x45\xa3\x88\xca\xf1\x8c\xca\xb8\
\x59\x2c\x92\x3c\x54\xb5\x4a\xd4\xda\xda\xca\x75\xca\xd1\xd7\xd7\
\x47\xc0\x86\x66\xa5\x52\x09\x17\x96\x2f\x60\xf9\xe5\x65\xe8\xdb\
\x52\xdf\xa2\x86\x83\xa5\x76\x64\xab\x3d\x18\x1c\x1c\x44\x4b\x73\
\x33\xcd\x3d\xb9\xaa\x7a\x65\x65\x05\x3d\x3d\x3d\x8a\xb4\x21\x45\
\x38\xbf\xfb\x67\x50\xfd\xc6\x26\x10\x5b\x8f\xa8\x6f\x41\xb2\x6a\
\xe0\x30\xeb\x46\x4c\xc4\x14\x06\x21\x01\x11\x51\xa7\x89\x50\x0a\
\x7a\xc7\x5e\xc5\xd0\x09\xe0\xd8\x36\x22\x91\x48\x43\x5f\xf2\x54\
\xde\x40\x6a\xc9\x00\x3c\x20\xc3\x33\xc8\x24\x32\x70\x03\x5f\x61\
\x20\xdd\x27\xa7\x99\xf6\x7d\x92\x41\x55\xaf\x85\x31\x99\x4c\x32\
\xd6\xd6\xd6\x36\x51\x2c\x16\x4f\xd2\xec\xed\xfb\xba\x31\xdc\x6f\
\x6a\x53\xb3\x94\xa1\xa5\xa5\x85\x9c\xde\xc9\xa9\x62\x8a\x34\x1d\
\x2a\xc9\xdc\xdc\xdc\xe2\x3f\x90\x6c\xae\x58\x53\x15\x54\x13\x00\
\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x90\xe2\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x01\xa3\x00\x00\x01\x9b\x08\x06\x00\x00\x00\x69\xbc\xff\x34\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x2e\x23\x00\x00\x2e\x23\
\x01\x78\xa5\x3f\x76\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x20\x00\x49\x44\
\x41\x54\x78\x9c\xec\xbd\x77\xbc\x6c\x47\x75\xe7\xfb\x3d\xe1\xea\
\x5e\x65\x09\x24\xa1\x04\xba\x12\x20\x89\x20\x84\x10\x12\x39\x19\
\x3c\xd8\xc6\x60\xc0\x78\xc6\x01\xc6\x69\x1c\xc6\xf6\xd8\x9e\x99\
\xe7\x34\x4e\x8f\xe7\x3c\x4e\x98\x37\xc3\xf8\xe1\x88\x03\x98\x28\
\x0c\x26\x1a\x21\x91\x93\x89\x0a\x20\x84\x84\x02\x92\x50\x46\x42\
\xe9\x86\x73\xce\xfb\x63\x75\xa9\x57\xaf\x5e\xab\xaa\x76\x77\x9f\
\xd3\xdd\xa7\xeb\xf7\xf9\xd4\x67\xd7\xde\xdd\xbd\x7b\xef\xdd\xbb\
\xeb\x5b\x2b\x54\xed\xa5\x8d\x8d\x0d\x9a\x9a\x9a\x9a\x9a\x9a\xa6\
\xa9\xe5\x69\x1f\x40\x53\x53\x53\x53\x53\x53\x83\x51\x53\x53\x53\
\x53\xd3\xd4\xd5\x60\xd4\xd4\xd4\xd4\xd4\x34\x75\x35\x18\x35\x35\
\x35\x35\x35\x4d\x5d\x0d\x46\x4d\x4d\x4d\x4d\x4d\x53\x57\x83\x51\
\x53\x53\x53\x53\xd3\xd4\xd5\x60\xd4\xd4\xd4\xd4\xd4\x34\x75\x35\
\x18\x35\x35\x35\x35\x35\x4d\x5d\x0d\x46\x4d\x4d\x4d\x4d\x4d\x53\
\x57\x83\x51\x53\x53\x53\x53\xd3\xd4\xd5\x60\xd4\xd4\xd4\xd4\xd4\
\x34\x75\x35\x18\x35\x35\x35\x35\x35\x4d\x5d\x0d\x46\x4d\x4d\x4d\
\x4d\x4d\x53\x57\x83\x51\x53\x53\x53\x53\xd3\xd4\xd5\x60\xd4\xd4\
\xd4\xd4\xd4\x34\x75\x35\x18\x35\x35\x35\x35\x35\x4d\x5d\x0d\x46\
\x4d\x4d\x4d\x4d\x4d\x53\x57\x83\x51\x53\x53\x53\x53\xd3\xd4\xb5\
\x3a\xed\x03\x68\x6a\x6a\xda\x9e\x5a\x5a\x5a\x5a\xea\xf2\xfe\x8d\
\x8d\x8d\x8d\xcd\x3a\x96\xa6\xd9\xd7\x52\xfb\xfd\x9b\x9a\x9a\x46\
\x55\x57\xe0\x8c\xa3\x06\xab\xed\xad\x06\xa3\xa6\xa6\xa6\x6a\x6d\
\x25\x7c\x4a\x6a\x70\xda\x5e\x6a\x30\x6a\x6a\x6a\x2a\xaa\x03\x84\
\x26\x05\xab\x4e\x0d\x53\x03\xd3\xfc\xab\xc1\xa8\x69\x66\x34\x4b\
\xbd\xee\x48\x8b\xd6\xe8\x55\xfc\x26\xe3\xbe\xae\x55\xba\xb6\xc5\
\x6b\xbf\x68\xbf\xcf\x76\x52\x83\x51\xd3\xa6\x6b\x1e\x20\xb3\x59\
\x9a\xd7\xc6\xb1\xf0\x9b\x45\xaf\x79\xdb\x6b\x7f\xfb\xe8\x3a\x75\
\xdd\x2e\x2f\xce\xe9\x75\x5f\x64\x35\x18\x35\x4d\x4c\x13\x84\xce\
\x2c\xc2\x6b\xe2\x7f\x94\x59\x6d\x30\x33\xbf\xa3\xdd\x5e\x5a\x8f\
\xb6\x45\xf2\xae\x87\xdd\x56\x5a\x1f\x7c\x71\x46\xaf\x71\xd3\xb0\
\x1a\x8c\x9a\x3a\x6b\x0c\xe8\x8c\x03\x99\xad\x02\xd4\xa4\xfe\x10\
\x63\xed\x67\x1a\x8d\xe8\x88\x10\xaa\xa9\x47\x9f\xad\xb1\x7a\x6a\
\xea\xa5\xfd\x35\x28\xcd\x81\x1a\x8c\x9a\xb2\x1a\x01\x3c\x9b\x15\
\xe8\x9e\x75\x18\x75\xfd\x5c\xe7\xef\xd9\xcc\x06\x35\xf8\x9d\x23\
\x08\x79\xd0\xe9\x0a\x25\x4f\x25\xf0\x8c\x0a\x29\x79\xa1\x35\x76\
\x33\xad\x06\xa3\xa6\x01\x75\x84\xcf\x38\xc1\xeb\x9a\xef\x99\x05\
\x77\x5d\xed\x1f\xa4\xe6\x7d\x93\x7a\x8f\xbc\x71\x02\x7f\xde\x4a\
\x6b\xc8\x02\xa7\x76\x69\xeb\x25\xe5\xa0\x53\x5a\xe6\xea\xfd\x8d\
\xad\xc1\x9b\x59\x35\x18\x2d\xb8\x26\x94\xb2\xdb\x25\xa0\x3d\xea\
\xbe\x46\x7d\x5f\x49\x93\xb6\x68\x72\xaf\x6f\xc6\x6b\x83\x6f\xac\
\xfc\x43\x4f\x10\x42\x51\x3d\xda\x97\xa7\x08\x3e\x1e\x78\xba\xc0\
\xc9\x5b\x97\x8d\xad\xe1\x9b\x39\x35\x18\x2d\xa0\x2a\x01\x34\x6e\
\xc6\xd4\x38\xdb\x72\xdb\xbb\xbe\x27\xd2\x24\x21\xd4\x25\xe3\x6b\
\x12\xef\x2d\xbd\x36\x8a\x72\x6e\xb6\x08\x42\xa5\xf5\xdc\x7e\x93\
\x6a\x40\x54\x5a\xcf\x2d\x6d\xbd\xbf\xb1\x35\x7e\x33\xa5\x06\xa3\
\x05\xd1\x18\xe3\x45\xba\x66\x50\x8d\xbb\x9e\x3b\x96\xd2\x6b\xe3\
\x68\x54\x8b\xa7\x16\x22\x35\x3d\xf6\x51\xde\x53\xfb\x5a\xa4\x52\
\x5c\x28\x82\x4e\x0e\x48\x25\x2b\x29\x3a\x6e\x0f\x38\x11\x88\xa2\
\xd7\xbc\xfd\xd9\x7a\x7f\x63\x6b\x00\x67\x46\x0d\x46\xdb\x58\x23\
\x02\xa8\x0b\x3c\x6a\x83\xd6\xa3\xbc\x2f\xb7\xad\xcb\xeb\x91\x46\
\x8d\xdf\x4c\x22\xfd\x38\xb7\xde\xf5\xb3\xd1\xb6\xe8\xf5\x52\xa7\
\xa3\x0b\x84\x6a\x8a\xdd\x57\x74\x6c\x25\xe0\xd4\x96\x68\x9f\xf6\
\xfb\xfa\x1b\x5a\x23\x38\x13\x6a\x30\xda\x66\xda\x04\x00\xe5\x62\
\x08\x93\x78\x3d\xf7\x7e\x6f\xbd\xf6\xb5\x1a\x4d\xc2\xf5\x56\x0b\
\x92\x49\xd5\x4b\xaf\x95\xb6\x6b\x95\xe2\x43\xa5\xb2\x5c\x58\x8f\
\xdc\x75\xde\xb1\x46\x30\x5a\x2f\xac\x77\x05\x93\xad\xcb\x86\xd6\
\x10\x4e\x5d\x0d\x46\xdb\x40\x13\x00\xd0\x28\x70\x29\x2d\xbb\xbe\
\xe6\x1d\x67\x17\x30\x95\x5e\xdf\x2c\x4b\x68\xd4\xfa\x38\xdb\x72\
\x75\x6f\x3d\x52\xf4\x7b\xd4\x42\xe8\x48\xe0\x21\xa6\x2c\x03\x5f\
\x03\xae\x01\x3e\x06\xdc\x8d\xff\x5b\xdb\x63\xf5\x60\xb2\x6e\x96\
\xa5\x6d\xb5\xee\x3b\x5b\x97\x0d\xad\x31\x9c\xaa\xda\xf3\x8c\xe6\
\x58\x23\x40\x68\x52\xd0\xa9\x05\x52\xd7\x65\xae\xee\xad\x97\xb6\
\x7b\xea\xe2\xd2\x2a\xad\x77\x05\x4a\xcd\x6b\xb5\x9f\x59\x52\xeb\
\x4b\xe6\x7d\x76\x3d\x52\xe9\xb7\xf5\x2c\x9f\x43\x81\x97\x01\x3f\
\x06\xec\x2e\xec\x7f\x0f\xf0\x3e\xe0\xcd\xc0\x87\xcd\x77\xd9\xf3\
\xc9\x81\x48\xd7\xd3\xb9\x2d\xa9\xed\x76\x1f\xeb\xce\xb1\x94\xae\
\x19\x4b\x4b\x4b\x4b\x0d\x48\xd3\x53\xb3\x8c\xe6\x50\x1d\xe7\x0d\
\xab\x05\x50\x57\xf8\xd4\xd4\x73\xdb\x72\xcb\x5c\xdd\x5b\x1f\x57\
\x35\x16\x51\xad\xa5\x32\x89\xe5\xa8\x9f\xcd\x1d\xb7\x56\xce\x22\
\xd2\xf5\x65\xb5\x3c\x0e\xf8\x59\xe0\x07\x10\x20\x75\xd5\x07\x80\
\xdf\x06\x6e\x60\x10\x04\xf6\xbc\x2d\x84\xbc\x75\x5b\x22\x8b\xa9\
\x64\x29\x81\x73\x7d\x1a\x90\xa6\xa3\x06\xa3\x39\xd1\x84\xac\xa0\
\xae\xe0\xf1\x5c\x37\xb9\xf5\xda\xd7\xba\x1c\x53\xae\x9e\xdb\x16\
\x29\xba\xe1\xbb\x5a\x40\xba\x3e\x2a\x60\x26\xf9\x7a\xe9\x58\x3d\
\xd5\xb8\xe6\x96\x81\x73\x80\xbf\x07\x8e\x29\xec\xaf\xa4\x7b\x81\
\x3f\x07\x5e\x4b\xdf\x7a\xf1\x2c\x22\x0d\x99\x35\x7c\x00\xd9\xed\
\x9e\x15\xd5\x80\x34\x47\x6a\x30\x9a\x71\x4d\xc0\x0a\xaa\x05\x50\
\xcd\x7a\xcd\x6b\xde\xf6\xdc\x7e\x6b\x8e\x31\x57\xa7\x62\x7b\xd2\
\xa4\x40\x34\x29\xf8\x74\x79\xad\x0b\xa4\xa2\xf3\xb2\xca\xfd\x8e\
\xc9\x2a\xfa\x3e\xe0\x4f\x80\x03\x0a\xfb\xea\xa2\x2f\x03\xbf\x0f\
\x7c\x51\x1d\x67\xce\xfa\x59\x73\xea\xde\xb6\x5a\x4b\x09\x53\x07\
\xe7\x5a\x35\x20\x6d\xad\x1a\x8c\x66\x54\x9b\x04\xa1\xae\xc0\x19\
\xe5\x7d\x51\x39\x18\x78\x50\xaf\x1c\x03\x3c\x10\xd8\xa5\xca\x4e\
\xa7\xec\x42\x1a\xc1\xb4\xbe\x01\xec\x05\xf6\xf5\xca\x5e\xb3\x4c\
\xf5\xbd\xc0\x7e\x55\xb7\xef\xff\x26\x70\x1b\x70\x7b\xaf\xdc\x41\
\xdc\x38\xd5\xc2\x28\xda\x56\x02\xce\x28\xdb\x6b\xf6\x6f\x8f\xd9\
\xca\xbb\x3f\x74\x8c\x68\x19\x71\xcb\xfd\x7a\xf0\xf9\x71\xb5\x0e\
\xbc\x1e\x78\x35\xb1\x2b\x4e\x83\xc7\xd6\x2d\x94\x22\x0b\x4a\x83\
\xae\x01\x69\x86\xd5\x60\x34\x63\x9a\x10\x84\xba\x58\x3f\xb5\x25\
\x4a\xdb\x5d\x02\x0e\x07\x4e\x03\x4e\x44\x40\x73\x0c\x7d\xe8\x1c\
\x03\x1c\x0d\x1c\x54\x38\xf5\x69\x6a\x1d\xf8\x46\xaf\xdc\x9e\x29\
\x37\x23\x99\x62\xfb\xa8\xb3\x54\x4a\xa0\xe9\xfa\x9e\x1a\xb7\x53\
\x04\x25\x4f\xf6\x9e\xd0\x31\xa2\xff\x00\xbc\xb2\xf0\xf9\x49\xe8\
\x03\xc0\xff\x44\x3a\x0a\x09\x1a\x1e\x78\x4a\x25\x02\x53\xce\x4a\
\x22\xb3\xbc\x5f\x0d\x48\x5b\xa3\x06\xa3\x19\xd2\x08\x53\xf8\x77\
\xb5\x82\x46\x81\x8e\x5e\xdf\x05\x9c\x0a\x9c\x8e\xc0\xe7\xb4\xde\
\xfa\xb1\x9d\x4e\x74\xbe\xb5\x8e\x04\xe1\xaf\xe9\x95\x6b\x81\xab\
\x7b\xe5\xeb\x48\x43\x38\x2e\x60\x6c\xa9\x0d\xca\xe7\x1a\x59\x4f\
\xd1\xef\xff\x6c\xe0\x6f\xd9\xba\x6c\xdb\x2f\x00\xbf\x83\xa4\x81\
\xe7\x40\xb4\xdf\x2c\x6d\xbd\xc6\x4a\x6a\x16\xd2\x8c\xaa\xc1\x68\
\x06\xd4\xc1\x1a\xaa\x85\x50\x04\x23\xcf\xba\x89\xe0\x73\x28\x70\
\x2e\x70\x16\x02\x9f\x53\x81\x93\x80\x95\xae\xe7\xb7\x40\xda\x87\
\x58\x4e\xd7\x22\xa0\xfa\x12\x70\x31\x70\x3d\xdd\x20\xd3\x75\x7b\
\x8d\xb5\xa4\x95\x73\xd1\x9d\x05\xbc\x81\xad\xb7\x64\xaf\x42\xb2\
\xed\x6e\x65\x10\x46\x1a\x40\x51\xbd\x0b\x94\x1a\x90\x66\x54\x0d\
\x46\x53\xd4\x08\x10\x4a\xf5\x12\x84\x6a\xac\x1e\x5b\xdf\x89\x64\
\x4d\x3d\x05\x78\x32\xf0\x58\xda\x38\xb4\x49\xe9\x36\x24\x58\x7f\
\x49\xaf\x5c\x8a\xc4\xad\x72\xb3\x0b\xe4\xe2\x1d\x5d\xa1\xa4\x97\
\x10\xdf\x37\x27\x03\x6f\x41\xe2\x79\xd3\xd0\xcd\x48\x62\xc3\xd7\
\x18\x84\x51\x4d\xf1\x80\xa4\xc1\xd4\x80\x34\xe3\x6a\x30\x9a\x92\
\x3a\x4e\xe1\xaf\xeb\x5d\x5c\x70\x1e\x7c\xd2\xf2\x00\xe0\x4c\xe0\
\xa9\x08\x80\x1e\x8f\x00\xa9\x69\xf3\xb5\x81\x58\x4e\x97\x02\x9f\
\x06\x3e\x81\x58\x04\x5e\x7c\xa3\x76\x16\x82\x1a\x20\x69\xd9\x7b\
\xe8\x68\xe0\x8d\x88\xf5\x3b\x4d\xdd\x05\xfc\x31\x70\x39\xc3\x30\
\xda\x57\x51\x8f\xa0\x54\x03\xa4\xa2\x8b\xb3\xc1\x68\xf3\xd4\x60\
\xb4\xc5\x1a\xd3\x25\x57\x03\xa1\x1c\x80\x76\x02\xdf\x02\xbc\x08\
\x89\x0b\x1c\x3c\xde\xd9\x34\x4d\x48\x1b\xc0\x15\xc0\x27\x7b\xe5\
\x0b\x48\x40\x3f\x17\x84\xaf\x99\x16\x07\x53\xd7\xd2\xf7\xd2\x29\
\xc0\x5f\x20\xd3\xf9\xcc\x82\xee\xa6\x6f\x21\x59\xe0\xec\xcb\xd4\
\x4b\x96\x52\x03\xd2\x0c\xab\xc1\x68\x0b\x35\x81\x07\x9a\x75\x81\
\x50\x5a\x5f\x01\x9e\x84\x00\xe8\x3b\x81\x23\x26\x70\x2a\x4d\x9b\
\xab\xfb\x80\xcf\x01\x9f\x42\xe0\x74\x35\xfd\x86\xb3\x34\xc0\xb3\
\x94\x31\x66\xef\xb5\x73\x81\x3f\x43\x32\x22\x67\x49\xb7\x03\x7f\
\x88\xb8\xee\x34\x78\xa2\x62\x81\x65\x63\x4b\x11\x90\x4a\x83\x63\
\xf5\xf2\x7e\x35\x20\x4d\x5e\x0d\x46\x5b\xa0\x11\xb3\xe4\xba\x42\
\x48\x2f\x97\x81\x47\x03\x2f\x06\x5e\x08\x1c\x3f\x89\xf3\x68\x9a\
\x9a\x6e\x44\xc0\xf4\x29\xc4\xad\xa7\xe3\x4d\x35\xb3\x0e\x78\x7f\
\xf2\x23\x90\xa9\x7d\x7e\x18\xd8\xb1\xb9\x87\x3f\xb2\x6e\x00\x5e\
\x01\xdc\xc9\x30\x7c\xbc\xf1\x63\x91\x95\xd4\x80\x34\x07\x6a\x30\
\xda\x64\x8d\x61\x0d\x45\x30\x8a\x2c\xa0\x65\xe0\x10\xe0\xa5\xbd\
\x72\xea\x64\xce\xa0\x69\xc6\xb4\x86\xb8\xf4\x2e\x41\x32\xf5\x2e\
\x41\x52\xca\x6b\xa6\xc1\x01\x89\x0d\xbd\x14\xe9\xa4\x1c\xb8\x65\
\x47\x3d\xba\xbe\x0a\xbc\x0a\x99\x4a\xc8\x0e\x6c\x8e\x06\x3e\x6b\
\x30\xe5\x80\x94\x96\xa5\xeb\xe6\x02\xa9\xc1\x68\xb2\x6a\x30\xda\
\x44\x8d\x00\xa2\x92\x35\x14\x59\x41\x47\x03\xff\x09\xe9\xe5\x36\
\x37\xdc\xe2\xe9\x66\x24\x35\xfa\x36\x53\xf6\x21\x63\xc0\x8e\x43\
\xac\xe3\xe3\x80\x13\x98\xbf\xf4\xfc\x4b\x80\xd7\x20\xb3\x80\x6b\
\xf8\xd8\xe2\x41\x29\x07\x24\x6f\x1a\xa1\x04\x26\xf0\x61\xde\x80\
\xb4\x49\x6a\x30\xda\x24\x05\x20\xaa\xb1\x86\x6a\x40\x94\xea\x27\
\x03\x3f\x05\x7c\x2f\x32\x20\xb5\xa9\x69\xbb\xea\x53\xc0\x9b\xf0\
\x21\x54\x82\x92\x76\xdd\xe9\xc4\x86\xd2\xbc\x76\x5e\x12\x48\x73\
\xd7\x6d\x92\xda\x38\x92\x4d\xd0\x04\x41\x14\x59\x42\x67\x01\x3f\
\x03\x3c\x8f\xf9\xeb\xe5\x36\x35\x8d\xa2\x73\x80\x5b\x80\x0f\x32\
\xd8\x21\xd3\x1e\x85\x9c\x22\xeb\xc6\x82\x64\xdd\xec\x2f\xbd\xbe\
\x44\x3f\x01\xa4\xc1\x67\x13\xd4\x60\x34\x61\x75\x04\x91\xe7\x9a\
\xcb\xc5\x84\x4e\x03\x7e\x0b\x49\xcf\x6e\x6a\x5a\x34\x3d\x17\x99\
\xcd\xe2\x4a\x7c\x18\xd9\xff\x5e\x17\x68\x24\xd0\xa4\xff\xda\x7a\
\xf0\xfa\x10\x90\xda\x43\xf9\x26\xa3\x06\xa3\x09\xaa\x00\xa2\x51\
\xac\xa1\x54\x3f\x1c\xf8\x05\x24\x2e\x34\xab\x99\x4f\x4d\x4d\x9b\
\xad\x65\xe0\x7b\x90\x99\xbe\xbf\xd1\xdb\x56\x63\x19\x95\x06\x06\
\x97\xac\x23\xbd\x9f\xa4\x06\xa4\x09\xab\xc1\x68\x42\x9a\x00\x88\
\x3c\x08\xad\x20\xcf\x93\xf9\x35\xc6\x7f\xb0\x59\x53\xd3\x76\xd0\
\x61\xc8\x90\x85\xd7\x12\x83\xc8\xc6\x7a\x4a\x03\x80\xbd\xcf\x79\
\xd6\x91\x7d\xdf\x80\x1a\x90\xc6\x53\x83\xd1\x04\xe4\x80\xa8\x36\
\x5b\x2e\x9a\x2d\x61\x19\x78\x1c\x32\x0a\xfd\xec\xcd\x39\xea\xa6\
\xa6\xb9\xd5\x29\xc0\x33\x90\xc7\x4f\xe4\x64\xc1\x60\x63\x45\x51\
\x49\x20\x5a\x72\x3e\x07\x2d\x7e\xb4\x29\x6a\x30\x1a\x53\x1d\x41\
\x54\x63\x11\x1d\x81\xc4\x85\xbe\x1f\xbf\xd7\xd7\xd4\xd4\x24\x73\
\x2a\x5e\x0f\x7c\xc5\x79\x2d\xb2\x88\x4a\x6e\x3a\x0f\x2c\x9e\xcb\
\xae\xc5\x8f\x36\x41\x0d\x46\x63\x68\x4c\x10\x59\x08\x2d\x23\x56\
\xd0\x5f\x32\x3b\x73\x84\x35\x35\xcd\xaa\x96\x80\xe7\x23\xe3\x8f\
\x6e\x55\xdb\x3d\x57\x5c\x6d\xac\xc8\x1b\xe4\x9a\x4b\x68\x68\x9a\
\xa0\x96\xa7\x7d\x00\xf3\xaa\x4d\x00\xd1\x4f\x03\xef\xa0\x81\xa8\
\xa9\xa9\x56\x07\x01\x2f\x40\x66\x92\xb0\x8f\xac\x3f\xc0\x29\x3b\
\x54\x59\xed\x95\x15\x53\x6c\x06\x6b\xee\x09\xc7\x6e\x16\x5f\x61\
\x32\xe4\xa6\x40\xcd\x32\x1a\x41\x63\x80\xc8\x83\xd0\x03\x81\xff\
\x85\xa4\xad\x36\x35\x35\x75\xd3\x09\xc0\xd3\x81\x0b\x7b\xeb\x35\
\x2e\xb9\xc8\x45\x17\x59\x4b\xda\x3a\xaa\x8a\x1f\x35\x77\x5d\x77\
\x35\x18\x75\x54\xe5\x23\x20\x6a\x41\xf4\x24\x64\xea\xfe\x36\x91\
\x69\x53\xd3\xe8\x3a\x07\x89\x1f\x5d\x46\x0c\x9c\xdc\x84\xa8\x76\
\xd6\x05\x0f\x56\x29\x76\xd4\xe2\x47\x9b\xa4\x06\xa3\xf1\x35\x4a\
\xda\xf6\x32\xf0\x73\xc0\xaf\xd2\x7e\x83\xa6\xa6\x49\xe8\xb9\x48\
\xec\xe8\x16\xca\xb0\xa9\x7d\x52\xae\xb5\x9c\x5a\xfc\x68\x13\xd5\
\x1a\xc2\x0e\xca\xb8\xe7\x4a\x20\xd2\x30\x5a\x05\x7e\x07\xf8\x89\
\xcd\x3e\xde\xa6\xa6\x05\xd2\x2e\x64\x7a\xac\xd7\x53\xff\x98\xf6\
\x92\xb5\x84\xb3\xf4\x52\xbe\xf5\x7a\xb3\x8e\x46\x54\x83\x51\xa5\
\xc6\x00\x91\x5e\x1e\x00\xbc\x12\x99\xd8\xb4\xa9\xa9\x69\xb2\x7a\
\x10\xf0\x4c\xe0\x7c\x7c\xd8\x78\xcf\x80\x2a\x01\x2b\xcd\xfd\x68\
\x2d\x24\xf0\xa1\x34\x04\xa4\xa6\x3a\x35\x18\x55\x68\x42\x16\xd1\
\x81\x48\x7c\xe8\x79\x9b\x7d\xbc\x4d\x4d\x0b\xac\xc7\x00\xd7\x32\
\x1c\x3f\x8a\x1e\xa6\xd7\xd5\x65\x97\x32\x90\xab\xc7\x1f\xa5\xf6\
\xa3\x59\x48\x79\x35\x18\x15\x34\x21\x10\x1d\x0a\xfc\x23\xf0\xb4\
\xcd\x3e\xde\xa6\xa6\x26\xbe\x85\xfe\x03\x07\x73\x10\xaa\x79\x8c\
\xbb\xcd\xb6\x4b\xf5\x9a\xf8\x51\x73\xd9\x75\x50\x83\x51\x37\x79\
\x60\x8a\x5c\x73\xa9\x7e\x14\xf0\x06\x64\x7a\x9f\xa6\xa6\xa6\xcd\
\xd7\x81\xc0\x73\x80\xb7\x51\x1f\x2b\x8a\xdc\x79\xda\x5d\xd7\x35\
\x7e\x34\xa4\x06\xa4\x58\x0d\x46\x19\x15\x9e\xd4\x6a\xc7\x16\x79\
\x96\xd1\xa1\xc0\x9b\x81\x33\x37\xf1\x30\x9b\x9a\x9a\x86\x75\x12\
\xf2\xbf\xfb\x2c\xbe\x85\x54\x2a\xa5\xf8\x51\xb2\x8e\x5a\xfc\x68\
\x42\x6a\x30\x0a\x54\xe1\x9e\x4b\x75\x0f\x42\x29\x6b\xee\x2f\x68\
\x20\x6a\x6a\x9a\x96\x9e\x0c\x7c\x0d\xb8\x91\x3c\x74\x4a\x10\xca\
\x65\xdb\x41\x9b\xbf\x6e\x22\x6a\xd3\x01\x39\x1a\x33\x4e\x94\xca\
\xef\x01\xdf\xb6\xe9\x07\xdb\xd4\xd4\x14\x69\x15\xf8\x56\x24\xed\
\xdb\x9b\x1e\x28\x4d\x11\xa4\xa7\x0a\x5a\x25\x9e\x2a\x48\x4f\x17\
\x54\x9a\x26\x28\x37\x38\xbe\x4d\x19\xe4\xa8\x59\x46\xdd\x95\x8b\
\x11\xa5\xf5\x9f\x00\x7e\x6c\x5a\x07\xd8\xd4\xd4\x74\xbf\x8e\x06\
\x9e\x00\x7c\x14\x3f\xab\xae\xd6\x45\x57\xb2\x8e\xa0\x9f\xcc\xe0\
\x25\x31\x34\x77\x5d\x41\x0d\x46\x46\x05\xab\x28\x72\xd1\xe9\xde\
\xd2\xb7\x23\x83\x5a\x9b\x9a\x9a\x66\x43\x67\x01\xd7\xf4\x4a\x2d\
\x88\x6a\xe1\x04\x71\xfc\x48\xbf\xd6\xdc\x75\x05\x35\x37\x5d\x5e\
\x35\x71\x22\x0d\xa4\xc7\x22\x71\xa2\x76\x5d\x9b\x9a\x66\x47\x4b\
\x48\xba\xf7\xc1\xc4\xee\x3a\x3b\xab\xf7\x24\x5d\x76\xf1\x81\x35\
\x77\xdd\xfd\x6a\x96\x91\x52\xc5\x24\xa8\xb9\x38\xd1\xa1\xc8\xb3\
\x55\x0e\xda\xe4\xc3\x6c\x6a\x6a\xea\xae\xc3\x90\x71\x7e\xef\x63\
\xb4\xac\xba\xc8\x42\xc2\xd4\x6d\x32\x83\x9e\xb1\xa1\xb9\xeb\x32\
\x6a\x30\x8a\x95\x4b\x56\xf0\x80\xf4\x72\xda\xb3\x88\x9a\x9a\x66\
\x59\xa7\x02\xd7\x01\x97\x30\x7a\xba\xb7\x5e\x2e\x13\xbb\xec\x74\
\x3d\x9b\xee\xdd\xdc\x75\xa2\x06\xa3\x9e\x8c\x55\xe4\xb9\xe7\xd2\
\xba\xb5\x88\x96\x90\xf9\xb0\x7e\x68\x73\x8f\xb0\xa9\xa9\x69\x02\
\x7a\x2a\x92\xea\x7d\x13\xb0\xc6\x20\x6c\xec\x7a\x04\xa1\x9c\xa5\
\x54\x9a\x2e\x28\xa9\x01\xc9\xa8\xc5\x36\xe8\xe4\x9e\xb3\xeb\xcb\
\x88\xf9\xff\x4a\x86\x6f\xbc\xa6\xa6\xa6\xd9\xd3\x0e\x64\x76\x86\
\xd2\xd3\x60\x6d\xba\xb7\x8d\x21\xe9\x38\x92\x1d\xd6\x31\x72\xca\
\xf7\x22\xab\xc1\x68\x58\x5e\xf6\x5c\xe4\x9e\x5b\x02\x7e\x1b\x38\
\x71\x8b\x8f\xb1\xa9\xa9\x69\x74\x1d\x85\x0c\x88\x2d\x25\x33\x8c\
\x32\xfe\xc8\xf3\x9c\xd4\x0c\xa0\x5f\xf8\x64\x86\x85\x77\xd3\x05\
\x37\x40\xe4\xb2\xb3\x37\xd9\xb3\x81\x97\x6d\xea\x01\x36\x35\x35\
\x6d\x86\xce\x40\xe2\x47\x97\x93\x77\xd3\xe9\x6d\xd1\xbc\x76\x36\
\x66\x94\x96\x2d\xdd\xbb\x83\x16\x1e\x46\x46\x35\x29\xdc\xa9\x1c\
\x08\xfc\xe9\x56\x1f\x60\x53\x53\xd3\xc4\xf4\x4c\xe0\x66\xe0\x36\
\xf2\x31\xa3\x2e\x19\x76\xde\xf3\x8f\x20\x1f\x3f\x6a\xa2\xc1\xc8\
\x53\x94\xb4\x60\x5d\x74\x3f\x4c\x73\xcf\x6d\x07\xe5\x7a\xc3\x69\
\x09\xc3\x71\x81\x54\x6c\xcc\xa0\x69\x7e\xb4\x0b\x89\x1f\xfd\x33\
\x3e\x8c\xd6\x9c\x6d\xb9\xe4\x86\x28\xa1\xa1\x34\xbb\x77\xb3\x8e\
\x58\x70\x18\x05\x19\x74\xa9\x9e\x4b\x5a\x38\x04\xf8\xf9\xad\x38\
\xc6\xa6\x89\x6a\x0d\xd8\x07\xec\xed\x95\x3d\xc0\x7e\xf2\x99\x52\
\xb6\xa1\xc1\xa9\x27\x2d\x21\x71\x86\x5d\xbd\xb2\x53\xd5\x57\x68\
\x9a\x45\x1d\x07\x3c\x1e\xf8\x38\x83\xe0\xc9\x81\xc8\xba\xeb\x4a\
\xb3\x34\x78\xee\xba\x6c\xba\xf7\x22\x6a\xa1\x61\xe4\xa8\x64\x15\
\xa5\xde\xef\x8f\x23\x73\x5e\x35\xcd\xbe\xf6\x02\xf7\x20\xe0\xa9\
\x71\xc3\xd4\xa4\xef\x46\x30\xda\x00\xee\x05\xee\xe8\xad\xeb\xfb\
\xe9\x00\xc4\xb5\x7b\x20\x02\xa7\x03\x91\x4e\x4d\x83\xd4\xf4\x75\
\x36\x12\x3f\xba\x9a\x72\x9a\x77\xc9\x5d\x17\x8d\x3f\x82\x72\xba\
\xf7\xfd\x5a\x44\xeb\x68\x69\xc1\xce\xf7\x7e\x65\xc6\x15\x79\x19\
\x73\xda\x1d\x73\x04\xf2\x8c\x94\x23\xb6\xec\x60\x9b\xba\x6a\x0d\
\xb8\x0f\x01\x43\xb2\x7c\x6a\xc7\x94\x74\x81\x12\x0c\xc3\x28\x29\
\x97\x41\xa5\xcb\x21\xc8\xbd\x74\x38\x32\x4c\xa0\xb9\xfa\xa6\xa3\
\xbb\x80\x37\x22\x1d\x89\x74\xef\xdc\x17\x94\x3d\xbd\xb2\x57\x95\
\x7d\xaa\xec\xef\x95\x35\x7c\x0b\x4b\x83\x0b\xe2\xfb\x69\xa1\x1e\
\x55\xde\x2c\xa3\x58\x36\x8b\x2e\x2d\x7f\x8a\x06\xa2\x59\xd5\x7e\
\xe0\x6e\xa4\x71\xb0\x2e\x97\xdc\x32\x82\x53\x09\x48\x38\x4b\x2b\
\xeb\x9e\xb1\x2e\x9b\xfb\x80\x5b\x7b\xf5\x15\x04\x48\x47\x22\xf7\
\xd8\xa1\x34\x38\x6d\x95\x0e\x41\x12\x1a\xde\x45\x7d\xe7\x65\xc3\
\xd9\x96\xeb\xb8\x24\xa5\xf7\x14\x67\x67\x58\x24\x2d\x24\x8c\x2a\
\xad\x22\xcf\x4a\x7a\x20\xf0\x93\x5b\x77\xa4\x4d\x95\xda\x40\x5c\
\x71\xf7\x32\x0c\x1b\x5b\xf7\xb6\x45\x60\x2a\xc5\x06\x70\x96\x56\
\x11\x8c\xa2\x72\x1f\x92\xe1\xb5\x84\xfc\x3f\x0f\x47\xee\xbb\xa3\
\x11\xd7\x5e\xd3\xe6\xe9\x64\xe0\x11\xc0\xc5\xc4\xf1\xa3\x9c\x45\
\x9d\x73\xe9\xea\xd8\x91\x37\xf6\x68\xe1\xdd\x75\x0b\x09\xa3\x0a\
\x45\x0d\xc7\x0f\x23\xbd\xd5\xa6\xd9\xd1\x5e\xc4\x1a\xd2\xee\x38\
\x0f\x40\xd6\x6d\x12\xc1\xa9\xc6\x4a\xca\xb9\xea\x3c\x75\xe9\xf0\
\xd8\xfa\xbd\xc8\xd4\x35\x5f\x42\xc0\x74\x2c\xf0\x20\x24\xee\xd4\
\x34\x79\x3d\x05\x89\x1f\xdd\x4a\x7d\x46\x5d\x94\xd8\x10\xdd\x2b\
\x16\x46\x1b\x6a\x7d\x61\xad\xa3\x06\x23\x51\xa9\x81\x48\xe5\x7b\
\xa7\x75\x80\x4d\xae\xee\x46\x2c\x09\xcf\xf2\xf1\x20\xb4\xdf\xd9\
\x56\x02\x53\x4d\xd6\x14\x8c\x67\x19\x79\x10\xf2\x46\xf4\xef\x45\
\x1a\xc9\x2f\x22\x6e\xbc\xe3\x68\x60\x9a\xb4\x0e\x00\x9e\x05\xbc\
\x8d\xb2\x25\x54\xba\x47\x52\x32\xc3\x0a\xfe\x7d\x52\xe5\xae\x5b\
\x14\xeb\x68\xe1\x60\x94\x49\xe7\xb6\xdb\x6c\x83\xf1\x24\xc4\x8c\
\x6f\x9a\x0d\x45\x20\xb2\xc0\xd9\xef\xd4\xbd\xf7\x94\x60\x54\xd3\
\xe3\xf5\x14\xc5\x8a\xba\x82\xc8\x96\x3d\x88\x3b\x2f\xb9\x8f\x8f\
\x43\xac\xa6\x9d\x35\x17\xaf\x29\xab\x13\x80\x33\x91\x44\xa5\x68\
\xec\x51\xc9\x5d\x67\xef\x15\x3d\x18\xd6\xba\xec\xb4\x16\xd6\x5d\
\xb7\x70\x30\x72\x94\x8b\x1f\xe9\x06\xe1\xfb\xb7\xf8\xb8\x9a\x62\
\xdd\xc3\x30\x88\x3c\xe0\xd4\x96\x2e\x40\xca\xa5\x79\x47\x8a\x40\
\x54\x82\x91\x85\x92\x37\x29\xe7\x0a\x70\x03\x32\x13\xf5\x2a\x70\
\x0c\xb0\x1b\x99\x7f\xcd\xeb\x6c\x35\xd5\xe9\x5c\xe4\xc9\xb0\x37\
\xe1\xc7\x8e\x4a\x65\x95\xf2\xf0\x00\x0f\x46\x49\x0b\xe7\xae\x5b\
\xb8\xd4\x6e\x65\x19\xe5\x1a\x07\xfd\x47\x5f\x41\xe2\x44\x97\x20\
\x4f\x8a\x6c\x9a\xae\xee\xed\x95\xc8\x1a\xda\xcf\x60\x7a\xed\xbe\
\x60\x19\x41\xa9\xc6\x5d\x97\x83\x91\x76\xb7\x60\xea\x5d\x5d\x74\
\xb9\xb2\xe2\xd4\xf5\xf2\x10\x04\x4a\x0f\xa6\x59\x4b\xa3\xea\x26\
\xe0\x3c\xfa\x69\xde\xb5\xe9\xde\x7b\xe8\x0f\xae\xb6\xf7\x5b\xce\
\xb2\xf2\xac\xed\x85\x49\xf5\x5e\x28\xcb\xa8\x62\x56\xdc\x28\x6e\
\xf4\x5d\x34\x10\xcd\x82\xd6\xc8\x83\xc8\x03\x8f\x1d\xff\x61\xeb\
\x39\x0b\x29\x07\xa3\x54\xc7\x59\x26\xd5\x66\xd2\x2d\x3b\xcb\x1a\
\x10\xe5\x96\x7b\x91\x31\x33\x97\x20\x6e\xa7\x93\x11\x77\x5e\x53\
\xbd\x8e\x41\x06\xc4\x7e\x12\x3f\xe3\xb2\x04\x16\x7b\xbf\xac\x10\
\x5b\x47\x91\xbb\x6e\xc0\x3a\xda\xce\xee\xba\x85\x82\x91\xa3\x52\
\x76\x53\x2a\xdf\x37\xad\x03\x6c\x1a\xd0\xdd\xf8\xfe\xfb\x1c\x80\
\x74\x0f\x35\x82\x53\x17\xeb\x68\x14\x18\xa5\xfa\x66\xc2\xc8\xd6\
\x75\xb9\x02\xb8\x0a\x49\x7a\x38\x05\xb1\x96\x76\x84\x57\xb9\x49\
\xeb\x71\x88\xbb\xee\x3a\xfc\x21\x01\x5d\xca\x06\xc3\xb3\x33\x24\
\x20\xa5\x39\xec\xac\x16\xc6\x5d\xb7\xa8\x30\xca\x25\x2e\xa4\x7a\
\xba\x41\x8e\x07\x9e\xb0\x15\x07\xd5\x94\x55\x72\x7d\x78\x3d\x53\
\xed\x92\xb3\x00\xda\x6b\xea\x25\x20\x79\xd6\x51\x6d\x12\x03\x0c\
\xf6\x68\x31\xf5\xcd\x86\x51\x0e\x48\xc9\x5a\xba\x0d\xf8\x02\xf0\
\x50\xe0\x61\xb4\xb1\x4b\x25\x2d\x23\xd9\x75\x6f\x22\xce\xa2\xab\
\x49\x68\xc8\x15\x7a\xef\x4b\xf7\x89\xbe\x9f\x86\x40\xb4\x5d\xad\
\xa3\x45\x85\x91\x55\xae\xb1\x78\x1a\x3e\xbc\x9a\xb6\x56\xf7\x90\
\x07\x91\x06\xd2\x5e\x86\xa7\x6a\xf1\xa6\x6e\xd9\x4b\xbd\x75\x94\
\xcb\x94\x82\xb8\xe7\x9a\xcb\xa6\xd3\xf1\xa2\xda\x2c\xba\x12\x8c\
\x4a\x65\xb5\x77\xde\x17\x03\x97\x21\xee\xbb\xd3\x90\x18\x53\x93\
\xaf\x23\x91\x0e\xe9\x47\x88\xdd\x75\x5d\xac\xa3\x52\x32\x83\x6e\
\x6f\x16\xc6\x5d\xb7\x30\x30\x72\xe2\x45\xd6\x57\x1b\xf5\x56\x9f\
\xb6\x55\xc7\xd8\x14\x6a\x1f\xf1\x40\x56\x0b\x22\x0d\x1a\x5d\xf4\
\x5c\x62\xd6\x4a\xf2\xac\xa3\xad\x80\x51\xce\x32\x8a\x80\x64\x13\
\x17\x6a\x81\xb4\xea\xd4\xf7\x22\x83\x69\xbf\x02\x9c\x04\x9c\x4e\
\x9b\xea\x2a\xd2\x19\x88\xbb\xee\x2a\x7c\x77\x5d\xc9\x5a\xda\x30\
\x4b\x1b\x3f\x82\x41\xf0\x58\x6d\x7b\x77\xdd\xc2\xc0\x48\xa9\xd6\
\x45\x97\x1a\x83\xa7\x6c\xc5\x41\x35\x65\xb5\x97\xe1\x1e\xa6\x85\
\x52\xe4\xa2\xdb\xc3\x30\x8c\xa2\xc9\x2d\xf7\xa9\xfd\xd5\xc4\x8c\
\x60\xb0\x31\x01\xbf\x41\x29\xb9\xe9\x46\x71\xd7\xd5\xc6\x8b\x22\
\x10\xd9\xe5\xe5\xc0\x95\xc8\x33\xba\x1e\x41\x9b\x95\xde\x6a\x09\
\x78\x06\xc3\xa9\xde\x11\x94\x3c\x6b\xc9\xa6\x7b\xdb\xf8\x51\x8a\
\x1b\x2d\xa4\xbb\x6e\x11\x61\x14\xc9\x6b\x1c\x4e\xa6\x3d\x40\x6f\
\x16\xb4\x87\xfe\x9f\x38\x67\x1d\x79\xb1\xa2\x04\x22\x0f\x4a\x5e\
\xfc\xa8\x8b\x65\x04\xa3\xc1\x48\xd7\x23\x77\x5d\x2d\x8c\x72\x31\
\xa3\x55\x7c\x28\x79\xcb\x54\xff\x2a\x70\x2d\x32\xb3\xc3\xa3\x91\
\x81\xb4\x4d\xa2\x43\x91\xce\xe9\x05\x94\xc7\xa3\xe5\x32\xec\x9a\
\xbb\xce\xd1\xa2\xc2\xa8\xb6\xa7\xfa\xd4\xa9\x1c\x5d\x93\x96\x05\
\x42\xe4\xae\xd3\xd6\x8d\x07\xa2\xc8\x42\xea\x62\x19\x45\x83\x18\
\xc1\xf4\x5a\x95\x6c\xc3\x52\xba\xe7\x3c\x18\x79\x60\x8a\xc6\x19\
\x75\xb5\x8e\x56\x83\xf5\x6b\x91\xc1\xb4\xc7\x03\x67\x01\x0f\x08\
\xce\x6f\xd1\x74\x1a\xe2\xaa\xfb\x0a\xf9\x7b\x32\x8a\x23\x25\xeb\
\x28\xdd\x4b\xd6\x3a\x4a\xd2\x16\x92\xd6\xb6\x75\xd7\x2d\x04\x8c\
\x82\xf1\x45\xd1\x36\x9b\xbc\xd0\x34\x5d\x79\x7f\xe8\x9c\x65\xa4\
\x5d\x76\x5e\xdc\xa8\xeb\x73\x68\x22\xbf\x7f\x2e\x93\x2e\xa9\xe4\
\xaa\xb3\xeb\x93\x48\x68\xa8\x8d\x1d\x45\x10\xb2\xdb\xae\x46\xd2\
\x9a\x1f\x0a\x3c\x96\x36\xde\x0e\xa4\x5d\xf8\x3a\x75\x00\x1a\x25\
\xd3\x4e\xdf\x03\xde\x3d\xb5\x2d\xdd\x75\x0b\x01\x23\xa5\x12\x80\
\xf4\xb6\x65\xe0\xc9\x5b\x71\x50\x4d\x59\xad\x31\xd8\x93\xd4\xc5\
\x4e\x82\x6a\x41\x54\x9b\xcc\x50\x7a\x28\xda\x1a\x83\x20\xf2\xe2\
\x45\x5d\x2c\xa3\xb4\x9c\x54\x0c\x29\x72\xd9\xd5\x02\x29\x82\x92\
\x2e\x5f\x42\x62\x4a\x8f\x44\x82\xf9\x07\x04\xe7\xbb\x08\x3a\x08\
\xc9\xae\xbb\x10\xff\x5e\xa9\x1d\x10\x5b\xe3\xae\xb3\x6d\xd6\xb6\
\x75\xd7\x2d\x1a\x8c\xac\xa2\xc4\x85\x25\x24\x80\x7b\xd4\x34\x0e\
\xaa\x69\x40\x39\xcb\x28\xd5\xbd\x79\xe9\xbc\x31\x46\x5e\x19\x05\
\x46\x91\x65\x84\x59\x8f\x2c\xa3\xb4\x8c\xac\xa4\x52\x0c\xc9\x82\
\x69\x54\x97\x5d\x0d\x84\x74\xd9\x87\x4c\x1e\xfa\x65\x64\x22\xd1\
\xd3\x7a\x9f\x5f\x44\x9d\x86\x24\x7d\x5c\x4b\xde\x8d\x1c\xc5\x92\
\xac\xbb\x2e\xca\xae\xd3\x83\x61\x13\xa4\x74\x7d\xae\x01\xa4\xb5\
\x88\x30\x8a\x1a\x05\x5d\x5f\x42\xdc\x12\x4d\xd3\x97\xed\x49\x76\
\x71\xd7\x45\xe9\xde\xb6\xae\x61\x94\x1b\xf4\x5a\x9b\xbc\x90\x54\
\x82\x51\x5a\x6e\x56\x1c\x29\x02\x53\x2e\x81\xc1\x02\x68\x87\xb3\
\x6d\x3f\xf0\x51\x64\xaa\xa1\xb3\x91\x44\x1f\xcf\xeb\xb0\x9d\x95\
\x62\xca\xe7\x51\x4e\xf5\x2e\x59\x47\x35\xd9\x75\x45\xf8\xcc\xbb\
\x75\xb4\xed\x61\x34\x46\xbc\xa8\xc1\x68\x36\x64\xff\xa0\x1e\x88\
\x6a\x63\x48\xa5\x52\x9a\xcc\x32\xb2\x8a\x4a\x0d\x40\x2e\x76\x14\
\xd5\xa3\x58\x52\x17\x28\xd5\xa6\x7c\xe7\x2c\xa4\x7d\x0c\x43\x69\
\xbf\x7a\xed\xfd\xc8\x1c\x6e\xe7\x20\x8f\xb1\x58\x24\x1d\x09\x3c\
\x06\xf8\x34\x75\xae\x3a\x7b\x4f\xad\x92\xbf\xb7\x72\xee\x3a\xd8\
\x66\xd6\xd1\xb6\x87\x51\x41\xb9\x9e\x68\x83\xd1\x6c\xc8\xba\x33\
\x6c\x8f\xd2\x82\x28\x1a\x10\x5b\xb2\x9c\x74\x36\xdd\x56\xc1\x28\
\x2d\x6b\xa0\xb4\x59\xc9\x0d\xb5\x2e\xbb\x7d\xf4\x81\xa4\xeb\xfb\
\x91\x04\x87\x9b\x80\x87\x20\x50\x3a\xb2\x70\x3d\xb6\x93\x1e\x8b\
\xc4\xd2\x6a\x32\xea\x3c\x6b\x29\x01\x29\xca\xae\xb3\xe9\xde\xde\
\xd8\xa3\xfb\x81\x34\xcf\xd6\xd1\x22\xc1\xc8\xf6\x2c\x22\xb7\x42\
\xfa\xe1\x4f\xd9\xdc\xc3\x69\xaa\x94\xf5\xa5\xaf\x9b\x7a\x29\xbd\
\x76\x12\xcf\x35\x8a\x32\xe9\x60\x18\x44\x3a\xc0\x6c\x65\x41\x94\
\xea\xe3\x24\x37\x58\x18\x2d\xf5\xae\x59\x5a\x8e\xe3\xb6\xf3\xdc\
\x73\xb6\xae\x97\x57\x20\x31\x94\x53\x11\xf7\xdd\x41\xce\x35\xd8\
\x6e\x5a\x45\xc6\x1e\xbd\x8b\xb2\x75\x14\x41\xaa\xf4\xec\x23\xf0\
\xef\xab\xb9\x84\x4e\xa4\x45\x82\x91\xa7\xdc\x9f\xbd\xc1\x68\x36\
\x94\x1a\x56\xcf\x55\x97\xb3\x92\x4a\xc5\xba\xe4\x2c\x90\x3c\x5f\
\xff\x28\x56\x91\x56\x6d\x0c\x29\x2d\xad\x8b\x26\x67\x25\x69\x28\
\xad\x31\x0c\xa3\x9c\x95\xb4\x9f\x41\x30\x45\x50\x2a\xc1\x28\x2d\
\x2f\x41\xc6\xe1\x3c\x86\xc5\xc8\xbc\x3b\x01\x99\x74\xf6\x32\x86\
\xef\xc3\x9c\xb5\x14\xa5\x7c\x27\xeb\x28\xc5\x8b\xd2\x6f\x9b\xd6\
\xad\xb6\x85\x75\xb4\x68\x30\x8a\xfc\xaf\xf6\x8f\xbf\x0a\xec\xde\
\xd2\x23\x6b\xca\xe9\x20\xe4\x01\x66\x16\x06\x5e\x9a\x6c\x34\x9e\
\x23\xd7\x20\xd4\x64\x43\x45\x3e\xfd\xa4\x51\x5c\x75\xba\xde\x15\
\x4a\x39\x20\xa5\xe5\x1a\xdd\xe2\x49\x09\x26\x11\x94\x34\x8c\x92\
\xab\x2e\x2d\x35\x8c\x92\xcb\xf3\x53\xc0\x17\x91\xc7\x30\x9c\xde\
\xfb\xbe\xed\xaa\x27\xd0\xcf\xac\xab\xb1\x8a\xa2\x6c\x3b\x7d\xaf\
\x25\x28\x41\xde\x5d\x37\xa4\x79\x04\xd2\xa2\xc1\x48\x2b\xe7\x32\
\x39\x8e\xf6\xbc\x97\x59\xd2\x61\xc8\xa3\x0f\x20\x86\x42\x14\x53\
\xca\x65\x30\x45\x69\xb7\xb9\x06\x42\xa7\xd9\x76\x81\x11\x94\x81\
\xa4\xeb\xa5\x38\xd2\x3a\xc3\xa0\xf2\x80\x64\xdd\x78\xb9\x34\x70\
\x0d\x22\x0b\x25\x0b\x23\x0f\x40\x51\xfd\x83\x08\x94\x9e\xc2\xf6\
\x9d\x5e\xe8\x40\xe4\x51\xe5\x1f\xa2\x1e\x46\xa5\xfb\x54\xc7\x8f\
\xf4\xef\xac\x53\xbc\x93\xe6\x3e\x99\x61\x5b\xc3\xa8\xf2\xc9\xae\
\x69\xa9\xdf\x7b\xe8\xe6\x1c\x51\xd3\x88\xda\x81\x8c\xfc\xdf\xa3\
\xb6\xe5\xa0\x94\x83\x94\xe7\xea\x8b\x40\x16\xc5\xaa\x22\x37\x5d\
\xae\x21\xb0\x0d\x45\x2e\x86\x59\x03\x24\x5d\x8f\xe2\x48\x91\x0b\
\xaf\x64\x25\x25\x98\xe8\x7a\xe4\xb2\x4b\x50\xca\xc1\x68\x07\x32\
\xb5\xd0\x3f\x23\xf1\xa4\x27\xb0\x3d\xe3\x49\xa7\x22\xee\xc9\xaf\
\x51\x06\xd2\x0e\xb3\x9e\xae\x7d\xba\xf7\x6c\xac\xb4\x36\x99\xa1\
\xbf\x61\xce\xac\xa3\x6d\x0d\xa3\x11\x94\x7e\xe8\x36\xe5\xc9\xec\
\xe9\x01\xf4\xad\xa3\x9c\x2c\x1c\x36\x4c\x7d\xd2\xc5\xfb\xde\xd2\
\x71\x79\x60\xf2\x40\x55\x72\xdd\xe9\xba\xb5\x96\x72\xe9\xe0\x16\
\x4c\x9e\xcb\x4e\x37\x90\x1a\x48\xda\x5a\xb2\xd6\x51\x04\x23\xbd\
\x7e\x29\x32\xb7\xdb\xe3\x81\x47\xb1\xbd\x5c\x77\x4b\xc8\xac\x2d\
\x6f\xa5\xce\x5d\xa7\x81\x14\xc5\x8e\x74\xfc\x28\xd5\x3d\xaf\x8e\
\x4e\x70\x98\x1b\x00\x69\x2d\x0a\x8c\x4a\xbd\x50\x5b\xda\x83\xc6\
\x66\x4f\xbb\x90\x59\x31\xae\xdb\xc2\xef\xf4\xac\xa0\xc8\x32\xea\
\xd2\x00\xe8\x86\xa3\x66\xdd\xbb\x5f\xa3\xba\x05\xd3\xb2\xa9\x7b\
\x60\x4a\xe0\x49\x4b\x2f\xc9\x21\x25\x76\x58\xf0\xec\x70\xb6\x79\
\x30\xda\x61\xd6\x3f\x84\x4c\x31\xf4\x54\xb6\xd7\xf8\xa4\x34\xf6\
\xe8\x33\xf8\x49\x33\x36\x63\x73\x07\x83\x6e\x62\x3d\xf6\x48\x03\
\xc8\x2e\x3d\xb7\xdc\x5c\x5b\x47\x8b\x02\x23\x4f\x5e\x22\x43\xd2\
\x76\x74\x21\x6c\x07\x1d\x03\xdc\x89\xb8\xeb\xec\xef\xd7\xa5\xe1\
\xf6\xd6\x4b\xf2\xfe\xd0\x5d\x5d\x75\xb5\xdf\xa1\xa1\xb4\x84\xdf\
\xeb\x1d\x15\x4a\x39\xf7\x5d\x82\x4e\x04\x23\x6d\x25\xe9\x0c\x44\
\x3d\x28\x36\x82\x91\xb7\xed\x06\xc4\x8a\x38\x0d\x78\x22\xdb\xe7\
\x7f\x77\x26\x32\xf6\xe8\x56\x7c\x00\xd9\xe1\x03\x36\x9e\xa4\xdd\
\x75\xc9\x3d\xac\x21\xa4\x13\x1b\xb6\x8d\x75\xb4\x88\x30\x8a\xac\
\x24\xfd\x07\x6e\x6e\xba\xd9\xd4\x12\x32\xf5\xcc\x37\xe9\xc7\x8f\
\xbc\x86\xd8\x66\x9a\xd9\xb8\x4a\xee\xf5\x5c\x23\xdf\xc5\x15\xe7\
\xad\xdb\x73\x89\x5e\xd7\xae\x98\x08\x44\x9e\xbb\x26\x3a\xfe\x04\
\x25\x6b\x25\x59\x0b\x49\xbb\x86\xb4\x9b\x4e\xc3\x49\x83\x28\xd5\
\x53\xd1\xf1\x24\x6b\x09\x45\x80\x4a\xa9\xe0\x5f\x45\x12\x00\xb6\
\x83\xeb\x6e\x15\x78\x12\xf0\x1e\x7c\xab\x28\x07\xa3\x74\xdd\xd7\
\x55\x3d\x01\xc8\x26\xad\xcc\x7d\xd2\x82\xd6\x22\xc1\x28\xd7\x13\
\xb6\x3d\xe6\xe6\xa6\x9b\x5d\xad\x22\x3d\xe9\xcf\x21\x73\xcb\xd9\
\x06\xd5\x42\xc7\x16\x0f\x4e\x11\xb4\xbc\xc6\xbf\xf6\x8f\xdf\x15\
\x5c\x5a\xa5\xef\xd1\xc7\xe2\x2d\x23\x2b\x49\xbf\xae\xe1\x14\xb9\
\xef\x74\x83\x68\x97\xa9\xae\xc1\xa4\xcb\x1a\xc3\x16\xd4\x0e\xb3\
\x6e\xcb\x07\x90\xac\xbb\xa7\x31\xff\xae\xbb\x13\x91\xf1\x47\xd7\
\x90\x1f\xcf\xa6\xaf\x97\x05\x7c\x82\x92\xfe\x6d\xbc\x44\x06\xdb\
\xae\x0d\xdc\xab\xf3\xe2\xaa\xdb\xb6\x30\xaa\xc8\xa4\x83\xd8\x6d\
\xb3\x5d\xdc\x05\xdb\x55\x07\x23\x0f\x7c\xfb\x34\x7d\x97\x9d\x97\
\xba\x1c\xa5\x33\xaf\x38\xef\xd3\x7f\x7c\x9b\x08\x90\xe4\x0d\x3a\
\xf4\x80\x00\xdd\xc0\x65\xd5\x35\xfe\xe4\x01\x29\x1d\x43\x04\x26\
\xfd\x5e\xdb\xe0\x59\x4b\xc9\xeb\xad\x6b\x18\xd9\x98\x92\xb5\x8e\
\xac\x95\xe4\x59\x4d\xa9\x5c\x0f\xbc\x05\x19\x97\xf4\x24\xe6\xfb\
\xbf\x78\x16\xe2\x8a\xb4\x56\x91\x75\xdd\xa5\xa5\x85\x78\xba\xde\
\x36\x91\xc1\x03\xd3\xcc\xc3\xa6\xa4\x6d\x0b\xa3\x82\x4a\x56\xd2\
\xce\x2d\x3c\x96\xa6\xd1\x74\x10\x32\x0f\xda\x27\x10\x20\x59\xb0\
\xd4\x16\xed\xa3\xd7\x9f\xb7\x49\x0a\x1a\x4e\x69\xac\x91\x55\x17\
\x20\xd5\x34\x1e\x5e\x3c\x20\xa7\x9c\xa5\xa4\xeb\xde\x36\xfd\x19\
\x7d\x2d\x3c\x2b\xc9\x5a\x4c\xab\x66\xdd\xba\xee\x22\x20\xe5\xdc\
\x56\xc9\x75\xf7\x04\xe6\xd7\x75\xf7\x20\xc4\x42\xba\x0a\xff\x1a\
\xe8\xac\x44\x7d\x1d\xad\x15\x6a\xad\x58\x6b\x1d\x59\xb7\xee\x5c\
\xc2\x69\x51\x61\xa4\xe5\x99\xbb\xdf\x9c\xd2\xb1\x34\x75\xd3\x2e\
\x24\x95\xf6\x63\x48\x96\x5d\x69\x22\x50\x3d\x98\x33\x6d\xd3\x30\
\xf2\xb2\xe4\xac\x72\x99\x75\xde\x7b\x6d\xec\x27\x69\x94\x18\x54\
\xfa\x5c\xee\xf8\xec\x77\x7b\x96\x92\x5d\xd7\x29\xc3\x9e\xfb\x2e\
\x07\x25\x9d\x05\xe6\xc1\xc8\x82\xc9\x5a\x08\x3a\xbd\xd9\xb3\x94\
\x2e\x44\xd2\xc1\x9f\xce\x7c\xba\xee\xce\x42\xc6\x1d\xe9\x34\xf8\
\x08\x4a\xf6\xfe\xd4\x09\x25\xfa\xfa\x47\x56\x2e\x99\xfa\xcc\xab\
\xc1\xa8\x2f\xfd\x07\xbd\x73\x9a\x07\xd2\xd4\x49\x3b\x90\xf4\xe0\
\x8b\x91\x38\x92\x9d\x35\xc0\x9b\x63\xcd\x1b\xdb\x11\xa5\x6c\x6b\
\xa5\xc6\x3a\xbd\x1e\x59\x48\x56\x11\x94\x6a\xc1\x62\xf7\x65\x8f\
\x69\x14\xb7\x5e\x64\x41\x79\xee\xbb\x08\x4a\x16\x4c\xa3\xc6\x92\
\x4a\xe5\x7a\xe0\xcd\xc0\x23\x98\x3f\xd7\xdd\x51\xc0\x49\xc8\x24\
\xb2\x76\x80\xb0\xbd\x4f\xed\xec\x17\xa3\x02\x69\x48\xf3\x10\x37\
\x6a\x30\xf2\xd5\x2c\xa3\xf9\xd2\x32\x32\xb6\xe3\x38\xe4\xf9\x3a\
\x37\x31\xec\x02\xd1\xbd\xf0\x68\xaa\x9f\x52\x52\x81\x2e\xeb\x6a\
\x59\x63\x25\x41\x1e\x4a\x93\x88\x2f\x45\xfb\x19\xd7\x7d\x97\xb3\
\x92\xac\xb5\xa4\x1b\x50\x9b\x6d\x67\x2d\xa4\x5a\x28\xa5\xcf\x5d\
\x8c\xa4\x4c\x3f\x01\x78\x34\xf3\xe3\xba\x3b\x1d\xb8\x1a\x7f\x26\
\x0b\x6f\x66\x0b\x1b\xd3\x4c\xd7\xd3\x03\x90\x17\x1f\x9c\x4b\x57\
\xdd\x22\xc0\xa8\x26\x91\xc1\xbe\xb7\xc1\x68\x3e\x75\x34\xf0\x62\
\xe0\x23\xc8\xe3\xb1\x2d\x88\xbc\x39\xc1\x4a\x10\x49\x7f\x72\xaf\
\x31\xc8\x01\x29\xd7\x20\x44\xa9\xdb\x98\x6d\x5d\x65\xf7\x55\x72\
\xd7\x44\x96\x91\x07\xa6\x5a\x28\xd9\x92\x73\xdd\x59\x28\x79\xd9\
\x66\x9e\x0b\xef\x42\x24\xeb\x6e\x5e\x5c\x77\x0f\x42\xe2\xd0\x9e\
\x45\xa4\xad\x77\xcf\xcd\x9c\xb3\x4c\x35\x88\xa2\x4e\xc9\xdc\x40\
\x69\x11\x60\x64\xb5\xe4\xd4\xed\xb6\x3b\xb6\xee\x70\x9a\x26\xac\
\x1d\xc0\x33\x81\xdd\xc0\xfb\x80\xaf\x33\x3a\x80\x3c\xf8\x58\x28\
\xa5\x46\x21\x35\xd6\x9e\x95\x64\x1b\xf5\x48\x11\x4c\xba\x6a\x14\
\x6b\x49\x6f\x8b\xa0\xa4\x33\xba\x6a\x5c\x77\x36\x51\xa4\x26\x96\
\xa4\x63\x48\x5e\x2a\x78\x7a\x6d\x9e\x5c\x77\x2b\x48\x9a\xf7\x15\
\xf8\x6e\x63\x0f\x44\xd6\x2a\xaa\x1d\x1f\x37\x17\xe0\xf1\xb4\x88\
\x30\xb2\xf2\x80\xd4\x62\x46\xf3\xaf\xdd\xc0\x0f\x03\xff\x06\x5c\
\x80\x0f\x22\x2f\xfe\xe2\x15\x3d\x10\x74\x09\xdf\x02\xd0\x50\xb2\
\x60\x02\x1f\x4e\x5a\x39\x6b\x69\x9c\x06\xa6\xd6\x5a\xaa\x81\x52\
\xda\xae\x33\xba\x2c\x98\xbc\x19\x04\x72\x56\x92\x06\x90\x67\x21\
\x79\x20\xd2\xdb\x2e\x62\x3e\x5c\x77\xc7\x21\x59\x75\x5d\x32\x3d\
\xad\x65\x94\x73\xd3\x25\x85\x40\x9a\xf5\xb8\x51\x83\x91\xaf\x06\
\xa3\xed\xa1\x15\xa4\x91\x3a\x03\x38\x1f\xf8\x28\xf5\x30\xd2\xe3\
\x6e\xf6\x33\xd8\x28\xe8\x31\x20\xe9\x3d\x1a\x76\x16\x4c\x39\x17\
\x5e\x8d\xb5\x34\x49\x17\x5e\x3a\xcf\x12\x94\x6a\x5d\x77\x9e\x0b\
\xcf\x02\xc9\x5a\x4a\xda\x4a\x4a\x80\xb2\xb3\x58\x47\xf1\x26\x0f\
\x4e\x6b\xf4\xb3\xee\x9e\xc1\x6c\xba\xee\x3c\x6b\xb1\xd6\x2d\x67\
\x3b\x45\x25\xcb\x68\x12\xf7\xcb\x96\xab\xc1\xc8\xd7\xbd\xf4\xfd\
\xbb\x4d\xf3\xaf\x83\x80\xe7\x23\xe3\x92\xde\x89\xf4\xa6\x93\x22\
\x00\xa5\xb2\x9f\x18\x48\x3a\x78\xaf\xa1\x14\x59\x48\xb9\x98\xd2\
\xb4\xac\xa5\xd2\x7e\xba\x42\x49\x97\x5c\x3c\x49\x27\x39\xa4\x6b\
\xa8\x81\x34\x8a\x95\x74\x03\xb3\xeb\xba\xbb\x87\x38\xfe\x13\x0d\
\xd0\xb6\xf7\x63\xce\x22\x9a\x7b\xb5\xc6\x36\xd6\x9d\xc8\x63\x0b\
\x9a\xb6\x8f\x8e\x05\x7e\x04\x69\xb4\xce\x07\x3e\x4e\x19\x46\x16\
\x40\x1a\x4a\x7a\x84\xbc\xe7\x96\x8a\x1a\xe9\x5a\x6b\xa9\x14\xef\
\xd1\xeb\xa3\xa8\x2b\xe0\x72\xee\xbb\x52\x3c\x29\xbd\xa6\x2d\x25\
\x0d\x22\x5d\x8f\x62\x4a\x35\x56\x52\x72\xdd\x5d\x81\x4c\xbe\x3a\
\x2b\xae\xbb\x7b\xc8\xdf\x5b\x91\x45\x54\x13\x27\xd2\x70\xf2\xee\
\x99\xb9\x88\x25\x35\x18\xc5\xba\x91\x06\xa3\xed\xaa\xe3\x80\x97\
\x02\xcf\x43\xe2\x49\x17\x20\x19\x94\xba\x77\xba\x4f\xd5\xad\x35\
\xa4\x1b\x44\x0d\x25\x0f\x48\xe9\xf5\x1a\x4b\x09\x86\xc1\x54\xd2\
\x24\xc0\x54\x03\xa5\x52\x4c\xa9\x14\x4f\xd2\xae\x3b\xed\xc2\xeb\
\x92\xe0\xd0\xc5\x4a\xd2\xae\xbb\xa7\x21\x09\x04\xd3\x54\x82\x91\
\x75\xb9\x45\x00\xaa\x05\x92\xd6\x5c\x40\x27\x52\x83\x51\xac\x4b\
\x10\x73\xbf\x69\xfb\xea\x48\x24\x15\xfc\xdb\x91\x86\xeb\xbd\xc0\
\xcd\xf8\x6e\x93\xf4\xf8\x84\xb4\xb4\x0d\x66\x72\x3b\x45\xc9\x0d\
\xe3\x58\x4a\xb5\x70\x1a\x17\x4c\x1e\x94\xba\x26\x3a\x68\x2b\x29\
\xe7\xba\xf3\x92\x1c\x4a\x50\x1a\xc5\x4a\x4a\x73\xdd\xed\x46\x2c\
\xa5\xa3\x3b\x5e\x93\x49\x68\x0d\xb8\x8f\x7a\x0b\xa7\xd6\x0a\xc2\
\x59\x4f\xdb\xe6\x0e\x4a\x0d\x46\x83\x3d\x52\xad\x4b\xb7\xfa\x40\
\x9a\xa6\xa6\x03\x11\x20\x7d\x2b\x32\xb5\xd0\x3b\x90\xd9\x96\x93\
\x85\xa4\x97\x39\x20\x95\xac\xa4\x0d\x53\x2f\x59\x4a\x11\x90\xba\
\xc6\x97\xf4\xb6\x1a\x79\x31\xa5\x2e\x50\x4a\xd0\xb1\x30\xd2\x96\
\x92\x06\x53\x2d\x94\xd6\xcd\xb2\x4b\xb9\x02\xf9\x4d\x1f\x8e\x3c\
\xaa\xe2\x88\x0e\xd7\x63\x5c\x5d\x4d\xff\x77\xd6\xea\xea\x7e\xcb\
\x41\x68\xee\x63\x48\x8b\x08\x23\xef\x4f\x6b\xff\x64\x20\xa3\xbd\
\x9b\x16\x4b\xab\x88\x4b\xe7\xa9\xc0\xe7\x81\xb7\x23\x16\xb2\x06\
\x51\x2a\x7a\xa6\xea\x51\xad\x24\xcf\x8d\xd7\x35\xae\x94\x94\x8b\
\x2f\xa5\xd7\xed\xb6\x92\x22\xc0\x45\x50\xd2\xeb\x1e\x90\x2c\x9c\
\xbc\x78\x92\x07\x25\x5d\xd2\x35\xb6\xd9\x77\x25\xb7\x5d\xda\xfe\
\x25\x24\x15\xfc\x91\xc0\xd9\x6c\xfe\xb3\xcb\x12\x08\x73\x6d\x8d\
\x96\x67\xe5\x94\x2c\xa1\xe8\xb3\x73\xa5\x45\x80\x91\xfd\xb3\x94\
\xde\x9b\x96\x5f\xa6\x65\xd4\x2d\xaa\x96\x80\xc7\xf6\xca\x57\x80\
\x7f\x41\x92\x1d\xf6\x31\xdc\xc0\xe5\x66\x18\xf0\xac\xa4\x35\x86\
\x1b\x5f\xdd\x20\xe7\x2c\x26\xcc\xfa\x92\x79\xad\xa4\x51\xc0\x14\
\xc5\x93\x3c\x28\xda\xff\x5a\xca\x2c\xb4\xef\xed\x62\x25\xd5\xc6\
\x92\xac\xfb\xae\x14\x57\xfa\x3c\x70\x19\x32\x55\xcf\xa3\x11\x97\
\xed\x66\xe8\x5a\x24\x3b\xd7\xfb\x4d\xa1\xfe\xb7\x8b\xe4\xc1\xaa\
\x64\x45\xcf\xa4\x5a\x43\x1b\x6b\x2f\xd2\x10\x9d\x3e\xed\x03\x69\
\x9a\xaa\x1e\x06\xfc\x3c\xf2\x08\xe9\x0f\x22\x73\xdf\x5d\x4f\xbe\
\xb1\xb3\x30\xd2\x40\xd2\x2e\x28\x0f\x4a\xa9\xc1\xaa\xb1\x98\x30\
\xeb\x5d\x1a\xa0\xae\x60\xf2\x2c\xa0\xd2\x7b\xbd\x52\xb2\x92\x72\
\xd6\x64\x2d\x98\xa2\xe2\x25\x3f\x7c\x1e\x71\xc9\xef\x46\xc6\xa3\
\x1d\x9f\x39\xaf\xae\x4a\x6d\x48\xe4\xba\x8d\x7e\xcf\x85\x54\x83\
\x51\x5f\x2b\x77\x6c\xbb\x00\x00\x20\x00\x49\x44\x41\x54\xde\x9f\
\xfb\x52\x1a\x8c\x9a\x44\x0f\x04\x5e\x04\xbc\x10\x99\x17\xed\x02\
\x64\x0e\xbc\xbb\x19\x9c\x4b\x6d\x95\x61\xd7\x9d\x8d\x75\x44\x2e\
\x28\xcf\x85\x17\x59\x49\x25\x38\x8d\x0b\x26\xbd\x3d\xf7\xbe\xd2\
\x77\x78\x60\x4a\xf0\xd1\xc7\x6e\x2d\x25\x0b\x20\xfb\xb8\x0f\x0b\
\xfa\x12\x74\x4a\x59\x78\x5f\x41\x62\x3b\x47\x23\x50\x3a\x09\x71\
\x05\x8e\xaa\x7d\xc8\xb3\xb6\xf4\xfd\x11\x01\x29\xfa\x7d\x31\xf5\
\x6d\xad\x06\xa3\x7c\xaf\xe4\x12\x24\xdb\xaa\xa9\x29\x69\x09\x89\
\x37\x3c\x12\x19\xb3\xf4\x51\x64\x0e\xbc\x2f\x32\xf8\x78\x80\x92\
\x95\x54\x8a\x29\x8d\x03\xa5\x49\x80\x29\x9d\x6b\x8d\xac\xeb\x4e\
\x6f\xf7\xc0\xb5\x64\xde\x1f\x59\x4a\xd6\x9a\x8c\xc6\x26\x59\x18\
\xd9\x78\x52\xc9\x6d\xb7\xaa\xb6\xdf\x80\x64\x54\xee\x42\x1e\x8c\
\xb7\xbb\xb7\x3c\xa0\xf2\x5a\x80\xcc\x1a\x7f\x11\x32\x5c\x20\x82\
\xa0\x67\x35\x97\xa0\x84\xd9\xe6\xad\xcf\xad\x16\x15\x46\xb9\x1f\
\xd0\x5a\x46\x4d\x4d\x91\x0e\x04\x9e\xdd\x2b\xd7\x21\x2e\xbc\xf7\
\x03\xb7\x30\x08\xa5\x52\x3c\x29\x07\xa6\x8d\xcc\x72\xc3\x59\x87\
\xb8\x31\x1b\x07\x4c\x35\xb2\x50\xea\x12\x4f\xb2\x96\x92\x3d\xbf\
\x15\x53\xcf\x0d\x92\xb5\x40\xb2\x13\xb0\x5a\x40\x79\x0f\xbb\x4b\
\xd6\xd2\x55\xbd\xd7\x8f\xef\x95\x43\x90\xa4\x87\x83\x10\x60\xd1\
\x7b\xef\xbd\x08\x84\x6e\x40\x7e\xff\x75\x7c\x08\x7a\x40\x2c\xfd\
\xee\x5e\x67\xd9\xfb\x6d\x22\x78\xcd\x85\x96\x66\x78\xde\xbc\xb1\
\xb4\xb4\xb4\xe4\x65\xa0\xe8\xa2\xc7\x91\xe8\x07\x5b\xed\x50\xe5\
\x10\xe0\x43\xcc\xd6\xb4\x22\x4d\xb3\xad\x35\xe4\xf1\x15\xe7\x23\
\x49\x0f\x7b\xf1\x33\xee\x72\x40\xd2\x75\xeb\xb2\xaa\x85\x52\x0d\
\x9c\x6a\x96\x04\xeb\x25\x79\x69\xc7\x36\x4d\xd9\xfb\x4f\xda\xa5\
\x37\xde\x4b\xff\x6f\xed\x23\x18\xec\x6c\xd8\x3b\x18\xfc\x5f\xdb\
\xff\xb8\xb7\x5d\x7f\xce\x9b\x59\xdb\x7e\xff\x9a\xb9\x4e\xe9\xb7\
\xb0\xd0\xdb\x8b\xb8\xef\xf6\x02\x7b\x4c\xb9\xaf\x57\xf6\xa8\x65\
\x2a\xe9\xfd\xfb\x54\xf1\xe6\xe7\x2b\x82\xac\x4d\x94\x3a\x05\x6d\
\x6c\x6c\x6c\x18\x20\x79\xfe\x6e\xfb\x5a\xaa\xa7\xf5\xbd\xc8\x60\
\xc8\xef\x98\xf8\x01\x36\x6d\x57\xad\x00\x8f\xef\x95\x3b\x90\xa4\
\x87\xf7\x02\x5f\x25\x1f\x5c\xaf\xb5\x94\x72\x50\xaa\x71\xe7\x61\
\xd6\xa3\xec\xab\x9c\x55\x53\xd3\xa0\xe9\xcf\xe4\xbc\x10\x51\x2c\
\xc9\xb3\x94\xf4\x80\x59\x0d\x69\x3b\xb3\x43\xce\x4a\x8a\x1e\xe8\
\x67\x9f\xc2\x9a\x96\xd1\x63\x1e\xec\x2c\x09\xf6\xbc\xbc\x38\x96\
\x07\x93\x1c\x54\x6a\xdd\x77\xe3\x76\x1c\x66\x42\xdb\x16\x46\x19\
\x45\x7f\xac\xe8\xcf\xfb\x1e\x1a\x8c\x9a\x46\xd3\xe1\xc8\x04\xad\
\xcf\x47\xc6\x9a\x7c\x10\xf8\x00\x12\x93\x88\x92\x1c\x4a\x96\x92\
\x67\x31\x59\x30\xd5\xc6\x98\x30\xeb\x91\xeb\x2e\x07\x26\x88\x1b\
\x3f\xdb\x01\xac\x71\x0f\xae\x33\x0c\x44\x7d\x5e\xd6\x5d\xa7\xaf\
\x49\x0e\x4a\xf6\x31\x15\x1e\x94\x56\x9d\x65\x2d\x8c\x6c\x9b\xa2\
\x8f\x4b\x7f\xc7\x3e\x62\x28\x45\x9d\x94\x5c\xa2\xc3\xb6\xd1\xb6\
\x75\xd3\xc1\x80\xab\xce\xba\x07\xb4\x1b\xc0\x4e\xe1\xae\x4d\xf7\
\x03\x10\x17\xdd\xf9\xc0\x61\x5b\x76\xe0\x4d\xdb\x59\x1b\x48\x2c\
\xf2\x03\x88\x0b\xf8\x1b\xd4\x41\xa9\x64\x2d\x45\x70\xaa\x81\x52\
\xd4\xd3\xf6\xdc\x7a\x04\xdb\xec\x6b\x56\xde\x60\x4e\xbb\xec\xea\
\xba\xf3\xdc\x76\x9e\xfb\x4e\xd7\xb5\xfb\xcd\xab\x47\x6e\x3a\xfb\
\x34\x56\x7b\x1c\xfa\x5c\x3c\x57\x9d\xb5\x8e\xf6\xaa\xa2\x5d\x71\
\x7b\xcc\xb6\x54\x6a\x5d\x74\x39\x57\xed\x4c\xbb\xe9\x16\x05\x46\
\x10\xc7\x8c\xac\xff\x57\xfb\x8e\x0f\xe8\x95\x97\x03\xdf\xb5\x65\
\x07\xde\xb4\x28\x4a\xf1\xa5\x0f\x20\x59\x79\x77\x93\x07\x53\xad\
\x0b\x2f\x17\x5b\x9a\x24\x98\x3c\x40\x79\xf2\xac\x29\xf0\x81\x94\
\x96\x1e\x90\x3c\x18\x75\x81\x92\x8d\x29\x59\xe0\x44\xeb\x16\x6a\
\x1e\x8c\xac\x65\x94\x4a\xfa\xbd\x12\x3c\xac\x65\x64\x81\x54\x0b\
\xa2\x52\xba\xb8\x6b\x41\x35\x18\x4d\x49\x23\xc0\xc8\x26\x31\x24\
\x18\x3d\x15\xf8\xdf\x5b\x76\xe0\x4d\x8b\xa8\x3d\xc0\xa7\x90\x18\
\xe5\x27\x7b\xeb\x16\x48\x91\x95\xd4\xd5\x8d\xd7\x05\x4a\xb5\x40\
\xaa\x05\x93\x55\x94\xe8\x90\x2b\xde\x0c\xd7\xf6\x51\xdd\x5e\xb1\
\x56\x8e\x57\x22\x8b\x28\xf7\x68\x70\x7d\x6c\xfa\x1a\xd8\xdf\xc8\
\x73\xd7\xed\x65\x18\x3c\x11\x88\x12\x8c\xd6\x88\x61\x94\xbe\x37\
\x1d\x43\x83\xd1\xac\xc8\xb8\xea\xbc\xde\x96\x97\x1d\xa3\x5d\x75\
\x3b\x91\x14\xce\x77\xd3\x1e\x29\xd1\xb4\x35\xba\x1b\x99\xb0\xf5\
\x02\x64\x86\x80\xbd\x94\xa1\xb4\x15\x6e\xbc\xcd\x04\x93\xd7\x71\
\xd4\xf5\x9c\xfb\xae\xd6\x4a\x8a\x5c\x78\x25\x40\x59\x17\x9d\xde\
\xbf\xb5\xdc\xf4\x79\xeb\x6b\x6e\x33\xeb\x12\x58\x34\x80\xbc\xa5\
\x86\xd0\x3e\x7c\x10\xad\x31\xfc\xfb\xba\x2e\xd6\x06\xa3\x29\x2a\
\x03\x23\xaf\x57\x65\x7b\x48\xc9\x3a\xda\x09\xfc\x0a\xf0\x92\xad\
\x3c\xf6\xa6\x26\x24\xa6\xf4\x61\xc4\x62\xba\x84\x72\x06\xde\x38\
\x6e\xbc\x08\x4a\x7a\x3b\xce\xeb\x54\x2c\x09\xd6\xb5\x72\x56\x92\
\xae\xd7\xba\xee\x34\x90\xbc\x74\xf0\x5c\x6c\xc9\x73\xef\x45\x09\
\x0c\x39\x18\x45\xb1\x23\x2f\x99\x21\x2a\x11\x88\x6a\x5c\x74\xe9\
\x58\x66\x1a\x44\xb0\x78\x30\x4a\xcb\x68\x1c\x43\x2e\x6e\x74\x0e\
\xf0\xea\x2d\x3b\xf0\xa6\xa6\x61\xdd\x88\x24\x3d\x5c\x80\x64\xe7\
\x75\x4d\x78\x48\xdb\xac\x0b\xc9\xeb\x55\xdb\x86\x2d\x17\x8b\xc8\
\x81\x29\x67\x25\xd9\xf5\x51\x93\x1c\x6a\x12\x1c\x6a\x2c\xa5\x28\
\xc6\xe4\x7d\xa6\x06\x46\x30\x7c\xfd\x23\x0b\xc9\x83\x8f\x17\x23\
\x1a\x25\x56\xd4\x60\x34\x0b\xaa\xcc\xa8\xcb\xc1\x28\xb9\xea\x0e\
\x00\xfe\x01\x38\x75\xab\x8e\xbd\xa9\x29\xa3\x6b\x90\x54\xf1\x0b\
\x90\xd9\x1f\x6a\xc7\x2c\x95\xe2\x4b\xe3\x26\x3f\x50\xa8\xe3\xd4\
\x4b\x1a\x25\xf3\xae\x8b\xa5\xe4\x41\x29\xda\x66\x01\x17\xc1\x48\
\x9f\xbb\x07\x24\x6f\x46\x86\x7d\x41\x5d\x83\xc8\x4b\x6a\xf1\x7e\
\x2b\x4c\xbd\xc1\x68\xda\xea\x90\xc4\x90\x6e\x32\xeb\xaa\x4b\x96\
\xd1\x4e\x64\xda\x97\xdf\xdf\xaa\x63\x6f\x6a\xaa\xd4\xe5\x48\x46\
\xde\x85\xc8\x18\xa6\x92\x0b\x6f\xd4\xf8\xd2\xa4\xb2\xf2\xf4\xd2\
\xd6\x23\x45\x40\xd2\x75\xeb\xba\xab\xb5\x94\x72\x56\x53\x04\xa2\
\x15\xf3\x1d\x1e\x8c\xc0\x87\xbd\xb6\x70\xf4\x32\x37\x6d\x90\x9d\
\xd3\x2e\x07\xa2\xb9\x8b\x17\x41\x83\x91\x67\x19\x45\xae\xba\x9d\
\xbd\xf2\x1a\xe4\x69\x91\x4d\x4d\xb3\xa6\x0d\xe4\xa1\x90\x1f\x40\
\xac\xa6\x3b\x18\x6f\xec\xd2\x66\x26\x3f\x78\x4b\x5b\xb7\xea\x9a\
\x79\x67\x81\x94\xea\x16\x48\x5e\xd2\x83\x6d\x13\x22\x8b\x48\xef\
\xd7\x1e\xa3\x3d\x77\x7b\xed\xb5\x95\xa4\x81\xe4\xc1\x2a\xf7\x9b\
\xd9\xdf\x42\x7f\x77\xff\x60\x66\xbc\xb1\xdf\xf6\x30\x82\xea\x24\
\x86\x9a\xb8\xd1\x4e\xe0\x59\xc0\xef\x6d\xe1\xe1\x37\x35\x8d\xa2\
\x35\xe0\x33\x88\xb5\xf4\x51\xe0\x1e\xba\x8d\x5f\xf2\x46\xff\x8f\
\x1b\x63\x22\x58\xf7\x96\x04\xeb\x11\x90\xd2\x32\x07\xa4\x9c\x0b\
\xaf\x04\x28\x0f\x46\xd6\x2a\x2a\xb9\xea\x72\x40\xf2\x92\x13\x22\
\xb7\x9c\x8d\xfd\x95\xa0\x3f\xf3\x20\x82\xc5\x84\x51\x5a\xd6\xc4\
\x8d\x3c\x57\xdd\x4e\xe0\xaf\x69\xd6\x51\xd3\xfc\x68\x0f\x32\x76\
\xe9\x42\xfa\x63\x98\x6a\xac\xa5\x9c\xe5\x34\x29\x57\x1e\x4e\x1d\
\xa7\x9e\x53\xd7\xcc\xbb\x9a\xb8\x52\xcd\x36\x0f\x46\x56\x9e\x75\
\x64\xaf\xaf\x85\x52\xae\xd3\xd0\xc5\x22\x6a\x30\x9a\x35\x65\x60\
\x54\x1b\x37\xb2\xae\xba\x67\x02\xbf\xb3\x35\x47\xdf\xd4\x34\x51\
\xdd\x8d\x58\x4a\x17\x02\x9f\xa3\x9f\x32\x3c\x6e\xaa\x78\x04\xa5\
\x49\xb8\xf1\x6c\xdd\xd3\xa8\x99\x77\x25\x30\x45\x00\x8a\xe2\x45\
\x9e\x65\x94\x96\x51\xfc\xa8\x6b\x7c\xaf\x74\x5d\x87\xae\x57\x83\
\xd1\x8c\xa8\x43\xdc\x48\xc3\x28\x9a\x8d\x21\x0d\x82\x7d\x35\x2d\
\xb3\xae\x69\xbe\xf5\x0d\x24\xb6\xf4\x3e\xe0\xcb\x74\x8b\x2f\xe5\
\x7a\xeb\xe3\x58\x4c\x38\x75\xbd\xb4\x75\xad\x71\x62\x4a\x1e\x64\
\x4a\xeb\xde\x3e\xf5\x77\x7b\xae\xc9\x12\x94\x6a\xae\x6d\xc9\x0d\
\x3a\x70\x8d\xe6\x01\x44\xb0\xd8\x30\x82\xb8\x67\xe4\xc1\xc8\x5a\
\x47\x4f\xa7\x59\x47\x4d\xdb\x47\x57\x23\x13\x02\xbf\x1f\x79\x38\
\x5c\xe4\x2a\xda\x6a\x8b\x09\xa7\xae\x35\x6e\x4c\xa9\xe4\xc6\x8b\
\xa0\x15\xed\x4b\x7f\xb7\x07\x88\x08\x46\x39\xa8\x97\xae\x5d\xf6\
\x1a\x35\x18\xcd\x98\x3a\xb8\xea\x4a\xb3\x31\x68\xeb\xe8\x0f\x81\
\xb3\xb7\xe6\x0c\x9a\x9a\xb6\x44\xeb\x88\xfb\xee\x7d\x88\x3b\xef\
\x5e\x86\xe3\x1a\x9b\x15\x63\x2a\x35\xb4\x39\x6b\x29\xa7\x52\x4c\
\xa9\x04\xa6\x5c\x3d\xb2\x8a\xb4\xec\xb1\x7b\x56\x62\xcd\xb5\xaa\
\x8d\x11\x35\x18\xcd\xb2\x0a\x30\xb2\x49\x0c\x91\x75\x64\x13\x19\
\x4e\x04\xfe\x82\xf6\x24\xd8\xa6\xed\xa9\x7b\x90\xa9\x88\xde\x87\
\xa4\x8c\x47\x01\xf6\x5a\x77\x5e\x4d\x6f\xbf\xc6\x62\xc2\xd4\xa1\
\x0c\xa6\xc8\x3b\x92\x73\xe3\x95\xac\xa0\x2e\x30\xd2\xc7\x1c\xc1\
\xb7\x06\xd4\xde\x7e\xec\x77\xf4\xbf\x78\x8e\x1a\xf8\x45\x84\x11\
\xe4\x6f\x3a\x9d\xc6\x19\x65\xd5\x69\x20\xbd\x10\xf8\x2f\x5b\x72\
\x12\x4d\x4d\xd3\xd3\x0d\xc8\x6c\x0f\xe7\x03\xd7\x93\xcf\xfa\xaa\
\xb5\x96\xba\x5a\x02\xb5\xae\xa9\x5c\xa3\xe6\x75\x4a\xd3\xd2\x03\
\xcb\xb8\x20\xb2\xc7\x94\x83\xac\x77\x9e\x5d\x2c\xc5\x81\xfa\x3c\
\x81\x08\x16\x1b\x46\x69\xe9\xf9\x89\x6d\x22\x83\x7e\xe0\x96\x85\
\xd1\x2e\xe0\x0f\x80\x33\x37\xfd\x24\x9a\x9a\xa6\xaf\x0d\x64\xc2\
\xd6\xf7\x23\xc9\x0f\x77\xe1\xa7\x28\xd7\x58\x4d\x93\x8c\x2f\x91\
\x59\x7a\x2a\x41\x49\xd7\xa3\x6d\xde\xfb\x23\x79\xc7\x36\x4a\xc1\
\xa9\xdb\xef\x90\x95\x39\x6b\xdc\x17\x06\x46\xd0\xc9\x55\x57\x33\
\xe6\x48\xc7\x8e\x1e\x0c\xbc\xaa\x57\x6f\x6a\x5a\x14\xed\x01\x3e\
\x8e\xb8\xf1\x3e\x43\x79\xbc\x4c\x57\xab\x29\x02\x52\x04\x27\x9c\
\x3a\x4e\x5d\xab\x26\xe1\xa1\x54\x8f\xf6\xe3\x7d\x77\xce\xba\x29\
\x9d\x53\x0e\xb6\x43\xe7\xd7\x60\x34\xc3\xaa\x70\xd5\xd9\xd8\x51\
\xcd\x8c\x0c\x09\x48\x2f\x04\x7e\x62\x2b\xce\xa3\xa9\x69\x06\x75\
\x2b\x32\x76\xe9\x5f\x91\x49\x5c\x27\x09\xa6\x92\x1b\xaf\x8b\xb5\
\x64\xeb\x49\x11\x4c\x72\x16\x94\xb7\xb4\x9f\xb3\xdf\x15\x59\x48\
\x51\xbd\xc6\xea\x9b\x7b\x10\x41\x83\x51\x5a\x7a\x96\x91\xb5\x8e\
\x92\xbb\xce\x4b\xf3\xde\x09\x1c\x08\xfc\x2e\xf0\xe8\xcd\x3e\x8f\
\xa6\xa6\x19\xd6\x06\xf0\x05\xe0\x1d\x88\xd5\xa4\x07\xd5\x8e\x92\
\x00\x51\x02\x53\x0d\x9c\x70\x96\xb6\xae\x15\x81\x25\x07\xa9\xe8\
\xb3\xde\x77\xd9\x7a\x0e\x38\xa5\xe3\xde\x16\x20\x82\x06\xa3\xb4\
\xcc\xb9\xea\x6a\xd2\xbc\x53\x39\x09\xf8\x53\x04\x4c\x4d\x4d\x8b\
\xae\x5b\x90\x27\x24\xbf\x07\xb8\x0d\x7f\xd2\xcf\x9a\x24\x88\x49\
\x80\x09\xa7\x8e\x53\xf7\x94\x03\x4e\x04\x9f\xc8\x32\x8a\xbe\x3b\
\x77\x5c\xde\x6b\xee\xbe\xe7\x15\x44\xb0\x60\x30\x82\xd0\x55\x97\
\xea\x51\x22\x43\x6d\x66\xdd\x2e\xe0\x49\xc0\x2f\xd3\x9f\xc5\xb7\
\xa9\x69\xd1\xb5\x1f\x19\xb3\xf4\x0e\x86\x9f\x56\x5b\x03\x24\x2f\
\x5d\x7c\x83\x18\x4e\x1a\x42\xb9\x6c\x34\xe8\x06\x25\xad\x5c\xb2\
\x42\x2e\x66\xe4\x6d\x1b\xa7\x3e\xb8\xd3\x39\x6e\xd0\x1b\x8c\xfa\
\xcb\x28\xb3\xae\x26\x76\xa4\x93\x19\x76\x01\x2f\x06\x5e\xb6\xc9\
\xa7\xd2\xd4\x34\x8f\xfa\x2a\xf0\x2e\x24\x1b\xef\x5e\x62\x30\x8d\
\xe2\xca\x9b\x44\x6c\xc9\xd6\xbd\x75\xc8\xc3\x28\xa7\x2e\x60\xaa\
\x3d\x16\x79\x61\xce\x1b\xf3\x06\xa3\xfe\x32\x97\xc8\xd0\x65\xdc\
\x51\x82\xd2\xcf\x20\x13\xaa\x36\x35\x35\x0d\xeb\x6e\x04\x48\xef\
\x04\xbe\x46\xff\x91\x09\xe3\x58\x4c\xb5\xd9\x78\x93\x8a\x2d\x75\
\x51\xb4\x8f\x12\x9c\xaa\x8e\x61\xde\x41\x04\x0d\x46\x30\x19\xeb\
\x28\x3d\x9a\x5c\xc3\xe8\x60\xe0\x37\x80\xd3\x36\xef\x6c\x9a\x9a\
\xe6\x5e\x1b\xc0\xe7\x11\x28\x7d\x92\xe1\x84\x87\x9a\x38\x53\x2e\
\x23\x6f\x14\x6b\x89\xcc\x92\x60\xbd\xe6\x3c\x27\xfd\xda\xb6\x80\
\x50\xd2\xc2\xc1\x08\x26\x6e\x1d\x45\xc9\x0c\xbb\x80\xa3\x81\xdf\
\x06\x8e\xda\xd4\x13\x6a\x6a\xda\x1e\xba\x19\x49\x76\x78\x0f\x32\
\xa3\x78\x64\x29\xd5\xa6\x8b\x8f\x6b\x2d\xe1\xd4\x71\xea\xb9\x6d\
\x5d\xdf\x53\xdd\x20\x6f\x27\x10\x41\x83\xd1\xfd\x9b\x28\xcf\xca\
\xe0\x59\x47\x35\xee\xba\x87\x02\xbf\x49\x1b\x10\xdb\xd4\x54\xab\
\x7d\xc0\x47\x10\x6b\xe9\x4b\xe4\x5d\x78\xa3\x82\x69\x12\x2e\xbc\
\xad\x80\xd3\xf0\x07\xb6\x69\xa3\xdd\x60\xd4\xdb\xa4\x96\xa3\x5a\
\x47\x7a\xec\xd1\x01\x08\x7c\x12\x90\xce\x05\x7e\x8e\x96\x61\xd7\
\xd4\xd4\x55\x97\x03\x6f\x04\x3e\x81\xef\xba\xab\x75\xe3\x95\x92\
\x1e\x46\x4d\x78\xe8\x9a\xf1\x36\x52\x83\xbb\x5d\x01\xa4\xb5\x90\
\x30\x82\xac\xab\x2e\x2d\x23\xeb\xc8\x9b\xd1\x7b\x95\xc1\xd8\x91\
\x4d\xf7\xde\x05\x3c\x19\x99\xa1\x61\x65\xb3\xce\xa9\xa9\x69\x1b\
\xeb\x4a\xfa\x50\x4a\x71\xa5\x08\x4a\xb9\xe4\x07\x2f\xbe\x94\x8b\
\x2b\xe5\x52\xc3\x37\xc3\x52\x5a\x08\xf0\x78\x6a\x30\x52\x9b\xd4\
\xb2\x66\xce\x3a\x9b\xcc\x90\x80\xe4\xa5\x7b\xa7\xe5\x13\x69\x40\
\x6a\x6a\x1a\x47\x57\x03\x6f\x42\xc6\x2d\x59\x28\xd5\xb8\xf2\xa2\
\x71\x4b\x39\x28\x75\x1d\x48\x3b\x52\xd2\xc3\xa2\x42\x28\x69\x61\
\x61\x04\x23\x5b\x47\xd1\x40\xd8\x9a\xf8\xd1\x4e\xc4\x65\xd7\x80\
\xd4\xd4\x34\x9e\xbe\x06\xbc\x19\xf8\x10\x31\x94\xba\x58\x4b\x91\
\xa5\x54\x3b\xed\x10\x4e\x5d\x2f\x09\xd6\x65\xe3\x22\x37\xc4\x3d\
\x35\x18\x99\x4d\x6a\x99\xb3\x8e\x72\x33\x33\xd4\x00\xe9\x1c\xe0\
\xc7\x69\x40\x6a\x6a\x1a\x57\x37\x00\x6f\x01\x3e\x00\xec\x25\x0f\
\xa4\x28\xbe\x94\x4b\x11\x1f\x27\x35\xbc\x53\x3c\x69\xd1\x81\xb4\
\xd0\x30\x82\x4e\x40\xd2\x16\x92\x4d\x66\xb0\x4f\x84\xad\x01\xd2\
\xd9\xc0\x8f\xf5\x3e\xd7\xd4\xd4\x34\x9e\x6e\x04\xde\x8a\x3c\x00\
\x70\x0f\x02\x9e\x5a\x4b\xa9\x36\xe1\x21\x72\xdd\xe9\x3a\xf8\x60\
\xd2\x4b\x5b\xef\x6f\x5c\xe0\x06\xb9\xc1\xa8\x0c\x23\x18\x7c\xf4\
\x70\x2e\x99\xc1\xba\xeb\xbc\xd9\xbd\x35\x94\xce\xa2\x01\xa9\xa9\
\x69\x92\xba\x05\x81\xd2\xf9\xc0\x7d\xf4\x21\xa4\xe1\x54\x0b\xa6\
\xda\x2c\xbc\x9a\xb8\x92\xb7\xb4\x75\xd9\xb0\xa0\x8d\xf2\xc2\xc3\
\x08\xc6\x4e\x66\xa8\x49\xf7\x8e\x2c\xa4\x5d\xc0\x19\xc0\x8f\xd0\
\x66\xfa\x6e\x6a\x9a\xa4\x6e\x03\xfe\x19\x79\xf0\xdf\xbd\x0c\x03\
\x69\x14\x6b\x29\x37\x66\x69\xd4\x98\x92\xad\xf7\x37\x2e\x58\xe3\
\xdc\x60\xd4\x53\x65\x32\x83\x17\x3b\xaa\x89\x1f\x95\x2c\xa4\x07\
\x23\x31\xa4\x36\x53\x43\x53\xd3\x64\xf5\x0d\xe0\x6d\xc0\x7b\x81\
\x7b\x18\x06\x52\x04\xa5\xfd\xf8\xe3\x96\x3c\x38\x75\x1d\xab\x84\
\xb3\xb4\xf5\xfe\xc6\x05\x69\xa4\x1b\x8c\x7a\xea\x68\x1d\x45\x83\
\x61\x6b\x12\x1a\x3c\x28\xed\x02\x8e\x44\x2c\xa4\x87\x6e\xc6\xf9\
\x35\x35\x2d\xb8\xee\x00\xfe\x05\x99\x31\xdc\x5a\x4a\xb5\x16\xd3\
\xa4\x06\xd1\x62\xea\x64\xea\xfd\x8d\xdb\xbc\xb1\x6e\x30\x52\x9a\
\x50\x76\xdd\x38\x40\x3a\x10\xf8\x1e\xe0\x09\x9b\x71\x7e\x4d\x4d\
\x4d\xdc\x02\xbc\x0e\xf8\x30\x3e\x90\x72\xd6\x52\x0d\x98\xba\x66\
\xdf\xe1\x2c\x6d\xbd\xbf\x71\x1b\x37\xd8\x0d\x46\x46\x1d\xdd\x75\
\xd1\xdc\x75\xde\x80\xd8\x1a\x20\x25\x28\x3d\x13\xf8\x4e\xf5\xbd\
\x4d\x4d\x4d\x93\xd5\x97\x81\xbf\xef\x2d\xf7\x23\x63\x95\xac\xfb\
\xae\x94\xf4\x10\xcd\xee\x50\x93\xe8\x00\x0d\x4a\x03\x6a\x30\x72\
\x34\xe6\x60\x58\x2f\xa1\xa1\x8b\x85\x94\xca\xa3\x81\xef\xef\xd5\
\x9b\x9a\x9a\x26\xaf\x0d\x64\x42\xd6\x7f\x42\x66\x0c\x4f\x40\x8a\
\xac\xa4\x51\x93\x1d\x46\x71\xdd\x2d\x1c\x90\x1a\x8c\x02\x75\x7c\
\xcc\x84\x37\xfe\xa8\x04\x24\x3d\x8f\x5d\x04\xa5\x07\x03\x3f\x80\
\x3c\x8a\xa2\xa9\xa9\x69\x73\xb4\x07\x89\x27\xfd\x0b\xf2\xd0\xbf\
\x9c\xfb\xae\x76\x76\x87\x9a\x69\x86\x9a\xeb\x4e\xa9\xc1\x28\xd0\
\x88\x83\x61\x6b\x5c\x76\xb9\xb4\x6f\x0f\x4a\x87\x00\xcf\x07\x1e\
\x3f\xf9\xb3\x6c\x6a\x6a\x52\xba\x0d\x78\x3d\x32\xc5\x50\x02\x4f\
\x64\x2d\x75\x81\x52\x8d\xfb\x6e\xe1\xad\xa4\x06\xa3\x8c\xc6\x8c\
\x1f\x75\xb1\x90\x34\x8c\x22\x2b\xe9\x4c\xe0\xbb\x68\xcf\x45\x6a\
\x6a\xda\x6c\x5d\x06\xfc\x25\x70\x1d\x83\x30\xca\xb9\xf1\x6a\x32\
\xf0\xba\x00\xa9\xb3\x95\x34\xef\x40\x6a\x30\x2a\xa8\xe0\xae\x83\
\xe1\xd9\x19\x96\x18\x86\x51\x17\x0b\x29\x67\x25\x1d\x05\x7c\x37\
\x70\xd2\xc4\x4f\xb4\xa9\xa9\x49\x6b\x1f\x32\x68\xf6\x1d\xc8\x4c\
\x0e\x1a\x46\xa5\xd8\x52\x57\x4b\xa9\x76\xc0\xac\x5e\xda\xba\x6c\
\x98\xe3\x06\xbd\xc1\xa8\x42\x1d\xe2\x47\x35\x29\xdf\x2b\x0c\x66\
\xd8\x45\x40\xd2\x30\xb2\xcf\x47\x7a\x06\xf0\x74\xda\xc3\xfa\x9a\
\x9a\x36\x5b\xd7\x00\x7f\x0d\x5c\x81\x40\xa8\xc6\x52\xaa\x9d\x6a\
\xa8\x76\x26\x07\x9c\x3a\x4e\xbd\xbf\x71\x0e\x1b\xf6\x06\xa3\x0a\
\x8d\x30\xfe\x68\x14\x97\x5d\x94\xd8\x10\x41\xe9\x64\xe0\x45\xc0\
\xe1\x13\x3e\xdd\xa6\xa6\xa6\x41\xad\x03\xff\x8a\x3c\xb2\xe2\x1e\
\x06\xa1\x14\xc1\x29\x37\x80\x76\x12\x56\xd2\xb6\x03\x52\x83\x51\
\xa5\x3a\xc4\x8f\x72\x19\x76\xb9\x89\x55\xbd\x38\x92\xe7\xb6\xd3\
\x40\x3a\x04\x78\x2e\x12\x4f\x6a\x6a\x6a\xda\x5c\xdd\x0c\xbc\x06\
\xb8\x88\x41\x18\x95\xdc\x77\xa5\xc1\xb3\xa3\x26\x38\x78\xcb\x01\
\xcd\x13\x90\x1a\x8c\x2a\x55\x39\xbb\x77\x2e\xc3\x2e\x17\x43\xaa\
\x89\x23\xe5\xc0\x74\x0a\xf0\xed\xc0\x03\x26\x77\xc6\x4d\x4d\x4d\
\x81\x3e\x0a\xbc\x16\xb8\x93\x3e\x8c\x6a\xa0\x94\x4b\x72\x88\x66\
\x72\x18\xdb\x6d\x37\x2f\x40\x6a\x30\xaa\x54\x06\x46\xa9\x5e\x7a\
\xe4\x44\x2d\x90\xd2\xe3\xcb\x4b\xb1\x24\x5b\x3f\x08\x78\x2a\xf2\
\x24\xd9\xf6\xd0\xbe\xa6\xa6\xcd\xd5\xad\xc0\x5f\x20\x99\x77\x39\
\x20\x79\x60\xf2\xb2\xef\x6a\x06\xcc\xd6\x24\x38\xd8\xba\x6c\x98\
\x83\x86\xbe\xc1\xa8\x20\x07\x42\x03\x2f\x3b\xcb\x71\xc6\x21\xd5\
\xba\xed\x72\x50\x3a\x16\xf8\x36\xe0\xf8\x71\xce\xbb\xa9\xa9\xa9\
\xa8\x75\x64\xa0\xec\xdb\x91\xa7\xcc\x46\x50\xaa\x49\x09\x2f\x4d\
\x2d\xd4\x65\x5c\x12\xcc\x21\x90\x1a\x8c\x28\x02\x27\xfb\x51\xa7\
\x3e\x49\x20\xd5\x58\x49\x11\x9c\xce\x46\x2c\xa5\x36\x9d\x50\x53\
\xd3\xe6\xea\x72\x64\x5c\x52\x9a\x52\xc8\x2b\x35\xe3\x94\x72\x49\
\x0e\x39\xb7\x5d\x75\x1c\x69\x96\x81\xb4\x50\x30\x1a\x03\x3a\xee\
\xee\x82\xf5\x71\x66\x6a\x28\xc5\x91\xba\x58\x4a\x07\x20\x8f\xa5\
\x78\x36\xf0\xb0\x49\x9d\x74\x53\x53\x93\xab\xbb\x91\x89\x57\x3f\
\x4d\x1f\x40\xd6\x5a\x8a\xdc\x77\xa5\xf1\x49\xb5\x56\x12\x99\xe5\
\xfd\x9a\x55\x20\x6d\x6b\x18\x4d\x00\x3e\x5d\x3e\xef\xc5\x90\x74\
\xbd\x04\xa4\x28\xd3\x2e\x07\xa5\x5c\xe6\x9d\x7e\xfd\x21\xc0\xd3\
\x68\xae\xbb\xa6\xa6\xcd\xd6\x07\x81\x37\x22\x29\xe0\x9e\xeb\xae\
\x64\x29\x8d\x63\x25\xe1\xd4\xf5\xf2\x7e\xcd\x22\x90\x56\xa7\x7d\
\x00\x9b\xa1\x0e\x10\x9a\x94\xa5\xe4\xed\x67\x43\x6d\x4f\x3f\xfc\
\x3a\x02\x9d\xf5\xe0\xfd\x76\x59\x2a\x76\xb0\x5c\xda\x66\x6f\xe6\
\xab\x80\xeb\x81\x87\x03\x4f\xa6\x65\xdd\x35\x35\x6d\x96\x9e\x8e\
\xfc\xcf\xfe\x0a\xb8\x9a\x7e\x47\xd3\x2b\xba\x83\x6a\x8b\x96\xed\
\xd8\xa6\xf6\x23\xb5\x27\xd6\x3a\x82\x7e\xfb\xe3\xb5\x43\xf7\xb7\
\x91\xb3\x04\xa5\x6d\x65\x19\x55\x40\x68\xdc\xd7\xab\x0f\xc5\xd4\
\xf5\xcd\xd4\x25\xd3\x2e\xca\xb6\xcb\xb9\xed\x22\x17\x9e\x9e\x03\
\xef\x91\xc8\x03\xfc\x0e\x99\xd0\xf9\x36\x35\x35\x0d\x6a\x0f\xf0\
\xb7\xc0\x67\xe9\x5b\x48\x5d\x2c\xa5\xda\xc1\xb2\xb5\x83\x64\x71\
\xea\xb2\x61\x46\x20\xb0\x2d\x60\x54\x99\xf1\x56\xbb\xbd\xf4\x5a\
\xcd\x05\x1b\x77\xfa\x20\x3b\x63\x43\xf4\xb0\xbe\x08\x4a\x39\x38\
\xa5\xf5\x03\x91\xc1\xb2\x67\xd1\x26\x5f\x6d\x6a\xda\x0c\x6d\x20\
\x99\x76\xef\x66\x10\x46\x1e\x9c\xba\x24\x38\xe4\x1e\x4f\x31\xb7\
\x40\x9a\x6b\x37\x5d\x47\x08\x95\xd6\x4b\xdb\x61\xd0\xe4\xad\x95\
\x36\x97\x3d\xad\x9b\xf7\xea\xa5\xb7\xdd\xfa\x8b\xbd\xe2\x0d\xa4\
\xf3\x7c\xd1\x9f\x04\x2e\x05\x1e\x07\x9c\xc1\x9c\xdf\x0f\x4d\x4d\
\x33\xa6\x25\xe0\x05\xc8\x70\x8b\xd7\x12\xbb\xeb\xb4\xdb\x2e\x57\
\xf4\x7e\xd3\xd2\xb6\x1f\x51\x08\x40\xb7\x41\x43\xed\xd1\xd2\xd2\
\xd2\xd2\xb4\x81\x34\x97\x8d\xcf\x18\x10\x8a\xea\xb9\x6d\xde\xeb\
\xd1\x8f\x56\xfa\x31\x4b\x40\xb2\xfb\xaf\x89\x19\xd9\xf8\x91\x05\
\x51\xf4\x98\x64\x5d\x3e\x02\x5c\x0c\x9c\x03\x9c\x46\x77\xe0\x36\
\x35\x35\xc5\x3a\x17\x99\x71\xff\x2f\x81\xdb\xc9\xc7\x91\x2c\x98\
\x70\xea\x6b\xc1\xf7\x94\x62\xd2\x33\x0d\xa4\xb9\x73\xd3\x65\x40\
\x54\x03\x9d\x2e\x60\x2a\x29\xb2\x5e\x4a\xf2\x6e\xb0\x52\x1c\x29\
\xe7\xb6\xb3\x19\x77\xde\xf3\x92\x22\x37\x9e\x7d\xcf\x0e\xe0\x81\
\xc0\x13\x81\xdd\x95\xe7\xd3\xd4\xd4\x54\xa7\xdb\x90\x59\x1b\xae\
\x45\x5c\x74\xba\x44\x31\xa5\x52\x2c\xa9\x6b\x1c\x09\x06\xdb\xaa\
\x81\x76\xab\xc1\xa8\x52\x01\x88\x4a\x80\xc9\x6d\xab\x75\xdd\x69\
\xe5\x7c\xaf\x59\xbf\x6c\xe1\x38\x6c\xea\x77\x5a\xda\x89\x56\x2d\
\x90\xd2\x72\x87\xb3\xf4\x62\x4a\x39\x10\xe9\xf5\xe3\x90\x24\x87\
\xe3\x32\xe7\xd1\xd4\xd4\xd4\x4d\xf7\x21\xe3\x91\x2e\x62\x18\x48\
\x11\x94\xbc\x78\xd2\x38\x71\x24\x98\x41\x20\xcd\x05\x8c\x3a\x5a\
\x43\xa3\x2e\x6d\xdd\x53\xf4\x03\xd6\x04\x09\xf5\x7a\x29\xc1\x21\
\x37\xd1\xaa\x05\x52\x6e\xf6\x06\x6f\x7c\x92\x07\x1e\x6f\x3d\x95\
\xdd\x88\x9b\xa1\xa5\x83\x37\x35\x4d\x46\xeb\xc0\x5b\x91\x31\x49\
\x7b\x18\x06\x51\x0e\x4a\xb9\xe4\x06\xed\x9e\x9f\x3b\x20\xcd\x7c\
\xcc\x68\x0c\x6b\x28\xaa\x47\xdb\x6c\xdd\x53\x04\xa0\x25\xb3\xf4\
\x3e\x13\xed\xdb\xfb\xdc\xba\x79\xbf\x77\x03\x79\xa6\x78\x2e\xa1\
\xc1\x2b\xf6\x66\xf6\x6e\xf0\x2b\x90\xf1\x12\xa7\x21\x89\x0e\x87\
\x05\xe7\xd1\xd4\xd4\x54\xa7\x65\xe0\xc5\x48\x67\xef\xfd\x74\x4b\
\x62\xa8\x8d\x89\xaf\xd1\x7f\xf8\x66\x4d\x0c\x69\x70\xa7\x53\x88\
\x1f\xcd\x3c\x8c\x1c\xd5\x5a\x43\x1e\x90\x4a\x80\xf2\xbe\x03\xf2\
\x56\x90\x4d\x36\xa8\x01\x93\x55\xf4\x7e\x9b\xd8\xa0\xbf\x67\x85\
\x41\x08\xe5\xb2\xec\x72\xc9\x0b\x1a\x42\xd6\x2f\x9d\xca\x0e\x24\
\xeb\xee\x2b\xc8\x43\xfd\xce\x00\x8e\x09\xce\xa5\xa9\xa9\xa9\x4e\
\xcf\x47\xfe\xc7\xe7\xd3\x1d\x46\xde\xd2\x26\x36\xac\x07\xf5\xa4\
\x6c\x7b\xb5\xd5\x40\x9a\x69\x18\x55\x3c\xb6\xc1\x2e\x23\x00\x45\
\x3f\x66\x64\x21\x45\x8a\x00\x94\xab\xd7\x42\x29\x07\xa4\x25\xf5\
\x1e\xef\x7b\xac\x65\xb4\xaa\xd6\x3d\x9f\x72\x8d\xa5\x14\x3d\x24\
\xec\x32\xe0\x4a\x64\x6a\xa1\x33\x80\x07\x53\x77\xed\x9a\x9a\x9a\
\x86\xf5\x1d\x48\x67\xef\xbd\x0c\x27\x31\xe5\x2c\xa2\xa4\x2e\xff\
\xbd\xce\x40\xda\x4a\xcd\x2c\x8c\x3a\x80\xa8\x06\x3e\xb5\x60\x2a\
\x29\x07\x1e\x5d\x96\x18\x06\x87\xde\x87\x86\x8b\xf7\x9a\x77\x43\
\x58\xd7\x5d\xf4\xdd\x1a\x4c\xab\xf8\xee\xba\x1d\x66\x5d\x5b\x40\
\x39\x10\xa5\xf7\xec\x07\xae\x01\x6e\x40\x26\x63\x7d\x34\xf0\x50\
\x66\xf8\x7e\x6a\x6a\x9a\x61\x7d\x2b\x62\x21\xbd\x9b\xfc\xf4\x40\
\x25\x97\x5d\x4e\x1b\xd4\xa5\x7d\x0f\xb4\x3f\x5b\x69\x1d\xcd\x64\
\xe3\xd1\x11\x44\xd1\x0f\xa5\x7f\xd4\x47\x20\xbd\xf8\x07\xf6\xca\
\x11\xc8\x74\xef\x57\xa9\xf2\x4d\xe7\xbb\x92\x22\x8b\x28\x07\xa4\
\x28\x68\xa8\x41\x15\x41\xc9\x6e\x4b\x37\x12\x94\x1f\xb4\x65\x03\
\x97\xb9\x38\x52\x82\xcf\x2a\x65\x8b\x28\x95\x7d\xf4\x81\x94\xca\
\x87\x90\x69\x4f\x1e\x81\xc4\x96\xda\x8c\x0e\x4d\x4d\xdd\xf4\x2d\
\xc8\xff\xf0\x9d\x74\xf7\xe2\xd4\x76\xa4\x6b\xc7\x21\x4d\x05\x48\
\x33\x09\xa3\x8c\x22\xf0\xc0\x70\x8f\xe2\x0c\xe0\xfb\x80\xe7\x21\
\x8f\xe5\xce\x69\x03\x99\x8d\xe0\x9f\x91\x9b\xe1\xd6\xe0\x3d\x69\
\x39\x6e\xb1\xfb\x8d\x6e\x26\x0d\xb0\x64\x19\x25\xd0\xae\xab\xf7\
\xd8\xa2\x27\x4f\x2c\x25\x33\xec\x30\xeb\x25\x30\xad\x66\xb6\x7d\
\x0a\xf8\x02\x32\x51\xe4\x23\x80\xc3\x83\xf3\x6a\x6a\x6a\x1a\xd6\
\xd3\x11\x0b\xe9\x5f\xa8\xf3\xe8\x94\x64\x3b\xb4\x50\x37\x59\x33\
\x4c\x01\x48\x33\x97\xda\x9d\xb1\x8a\x6a\xdd\x71\x0f\x06\x7e\x0d\
\x01\xd1\x32\xdd\xb5\x06\x7c\x18\xf8\x47\xe0\x5f\x7b\xdb\x72\x96\
\x51\x6a\xf0\xbb\xac\x47\xee\x3e\x4f\xb9\xf3\xf7\xc6\x25\x45\x63\
\x93\x4a\xe9\xe0\x51\x6a\xb8\x4d\x11\xcf\xad\xdb\xcf\x3c\x04\x99\
\x94\xf5\x41\xc1\xb9\x35\x35\x35\x0d\xeb\xa3\x08\x90\xf6\xd0\x4f\
\xfd\xb6\x4b\x2f\x05\x3c\x37\x40\x36\xf7\x18\x8a\x54\x87\x42\x9b\
\xb4\x99\x40\x9a\x75\x18\x45\x0d\x71\xaa\xdb\x99\x0b\x7e\x08\xf8\
\x43\x26\xe7\x26\xfa\x34\xf0\x07\xc0\x67\x7a\xeb\x25\xd7\x98\xad\
\x7b\xdb\x22\x4b\x29\x07\xa5\x12\x90\x73\x83\x65\xbb\x40\x69\x85\
\x3e\x4c\x22\x28\x75\x81\x51\x5a\x1e\x0d\x3c\x0a\x81\x53\x4b\x76\
\x68\x6a\x2a\xeb\xdd\x88\xfb\x7b\x0f\xc3\x50\xea\x02\xa4\x68\x2c\
\x52\x04\x25\x9c\xfa\xfd\x5a\x18\x18\x15\xac\xa2\x9c\x65\xb0\x0a\
\xfc\x2e\xf0\xd3\x9b\x74\x68\x6f\x03\x5e\x0e\xdc\x45\x3d\x84\xbc\
\x74\xeb\x1a\xf7\x5d\xe9\x07\xc9\x59\x88\xd6\x42\x5a\x22\x86\x92\
\x06\x92\x86\x92\x05\x52\xc9\x5a\xaa\xd9\x96\xf6\x71\x18\x02\xa5\
\x53\x7a\xdb\x9b\x9a\x9a\x7c\x6d\x00\x6f\x40\xdc\xde\x16\x44\x9e\
\x95\xe4\xcd\x02\x3e\x2a\x90\xb2\x1d\xe4\xcd\x02\xd2\xcc\xc0\x68\
\x04\xf7\x9c\x6e\x78\xff\x18\xf8\xf1\x8e\x5f\x79\x1d\xf0\x0e\x24\
\x46\xb4\x07\x79\x34\xf7\xe3\x80\x97\xe2\x37\x94\xd7\x02\xff\x1d\
\x99\x50\x34\x02\x51\x04\xa3\x1a\x4b\x09\x53\x07\x1f\x4c\xb5\x6e\
\x4b\xfb\x00\x2f\xcf\x42\x8a\xe6\xbc\xcb\xcd\xea\x50\x63\x31\x45\
\x30\x4a\xf5\x03\x91\x44\x87\x53\x81\x83\x9c\x73\x6c\x6a\x6a\x12\
\xa8\xbc\x06\x49\xb0\xda\xe3\x94\x12\x90\xac\xcb\xae\x34\x7d\x50\
\xb5\xc7\x66\x33\x80\x34\xab\x30\xb2\xf5\x9c\x15\xf0\x5c\xe0\xcd\
\x1d\xbf\xee\xf5\x88\x25\xe5\xed\xff\x34\xc4\xd5\x77\x82\xf3\xb9\
\xfd\x88\xdb\xee\x9f\xf0\xad\x1e\xaf\xb7\x91\xeb\x81\x94\x80\xd4\
\xd5\x4a\x4a\x75\xeb\xbe\xd4\x40\xca\xc5\x94\x4a\x93\xb1\x8e\x03\
\x27\xfb\x99\xb4\xfe\x60\x24\xe1\xe1\x38\x06\x7f\xf7\xa6\xa6\x26\
\xf1\xc6\xfc\x15\x92\xfd\x5b\x03\xa4\x68\xb2\x55\x0b\xa5\x68\x82\
\xd5\xc8\x63\x83\xae\x2f\x22\x8c\x4a\x8d\xec\x31\xc0\xc7\xe8\x16\
\x20\x7f\x15\xf0\x6a\x86\xe3\x2c\xfa\x7b\xce\xea\xbd\x2f\x6a\x1c\
\x5f\x0e\x9c\x47\x3d\x84\x22\x20\xd5\xcc\x1b\x15\x59\x4a\x9e\x25\
\x99\x73\x65\x5a\x20\x45\xd6\x52\xf4\xa4\xd9\x92\xb5\x54\x82\x52\
\xe9\x33\x87\x22\x50\x3a\x05\xb1\x9c\x9a\x9a\x9a\x44\x37\x23\x4f\
\x8d\xbd\x13\x99\x68\xb5\x06\x48\xd1\x83\xfb\x3c\x0b\xc9\x03\x52\
\x31\xa1\x61\xd2\x40\x9a\x09\x18\x55\xc4\x8a\x22\xf7\xdc\xeb\x91\
\x11\xcc\xb5\xfa\x73\xfa\x20\xca\x3d\x3b\x04\xe0\xcf\x10\xb7\x9d\
\xa7\x75\xc4\x65\xf7\x01\xca\xf0\x89\x60\x34\x8a\x85\x94\xfb\xb1\
\xba\x58\x93\xb5\xd9\x77\xa5\x64\x87\x1c\x5c\x4a\xd6\x53\xc9\x5a\
\x7a\x18\xd2\xc9\x68\xd6\x52\x53\x13\x7c\x15\x78\x1d\x70\x2f\x3e\
\x90\x22\xb7\x5d\x57\x0b\x69\x6a\xf1\xa3\x59\x1c\x67\x54\x4a\x5a\
\x48\x8d\xe8\xf7\xd0\x0d\x44\x57\x23\xfe\xd7\x1d\xe4\x61\x94\x74\
\x43\x66\x5f\xcb\x88\x9b\xef\x3b\x91\xde\x4a\x0e\x3e\x6b\xe6\xd8\
\x37\x4c\x7d\x5d\xd5\xbd\x1e\xc9\x86\xf9\x5c\x7a\xad\x24\x7d\xf3\
\xd8\xef\xd6\xcb\x54\xd2\xd8\x83\x15\xe7\x1c\x12\x8c\xf4\xf8\x23\
\x3d\x1e\x49\x27\x3d\xa4\xd7\xa2\xfa\x3e\x06\x01\xe4\xad\xa7\xc9\
\x59\x0f\x43\xa0\x74\x32\x6d\x20\x6d\xd3\x62\xeb\x64\x64\xcc\xe4\
\xdb\xc9\xff\xff\x3d\x78\xe4\x5c\x6f\x98\xf5\xd4\x1e\xd9\xd7\x6d\
\xbb\x31\x71\xcd\x22\x8c\x60\xb8\x97\x9f\x96\xba\xfc\x40\xc7\x7d\
\xfe\x31\x72\x11\x53\xaf\xde\x06\xf8\xed\xf7\xde\x5c\xd8\xdf\x81\
\xc0\x53\x81\xf7\xa8\x7d\x78\xf0\x59\x62\xb8\x71\xd7\xdb\x35\x94\
\x3c\x48\x78\x96\x92\xbd\x21\xbc\x9b\x2b\xba\x69\xec\x3e\xd2\x77\
\xa7\xeb\xa1\x81\x94\x40\xa3\xcb\x9a\x5a\x6a\xd8\xac\x31\x68\xe1\
\x58\x18\x69\xe8\x94\x80\xa4\xb7\x7f\x03\xf8\x3c\x92\x16\xfe\x50\
\xda\x98\xa5\xa6\xc5\xd5\x99\xc0\x4d\xc0\x27\xcc\xf6\x1c\x70\x4a\
\x21\x00\xdb\xe9\xd5\x6d\x99\xfd\x8e\x21\x4d\x72\x30\xec\xac\xc2\
\x48\xcb\xb3\x90\x1e\x00\x3c\xa3\xc3\x3e\x2e\x44\x66\x07\xd0\x2e\
\xa7\x68\xda\xf6\x24\x6f\x16\x06\xad\x0d\x04\x58\xab\xf8\x90\x89\
\x2c\x23\x6b\xe1\xe5\x20\x94\xbb\xc1\xba\xf4\x50\xec\xe7\xf4\xb1\
\xda\xef\x4e\xc7\xa3\xe1\xa4\xcf\x45\x43\x29\x41\x48\x43\x27\x17\
\x5f\xb2\x70\xd2\x6e\xba\x7d\xe6\xbd\x16\x6a\x5f\x41\xb2\x8a\x0e\
\x47\xac\xa5\xdd\xc0\xce\xca\xf3\x6f\x6a\xda\x2e\x7a\x16\x32\x2f\
\xe4\xf5\xbd\xf5\x08\x3c\x76\xbd\x16\x54\x30\x68\x1d\xe9\xce\x6b\
\x5a\x1f\x68\x7b\x26\x05\xa4\xa9\xc3\xa8\x22\x8b\xce\xae\x2f\x01\
\xdf\x46\xb7\x63\x7f\x0d\x83\x0d\xa5\x8e\x8f\x44\x96\x91\xed\x19\
\x58\xbd\x0a\xf8\x12\x83\x30\x8a\x00\x64\xb7\xe9\x46\x3e\x72\x9b\
\x45\x03\xd1\xbc\x6d\x4b\x66\x9b\x27\x6b\x49\x59\x30\xda\x7d\x69\
\x58\xa7\x63\xd5\xd6\x9f\xb6\x92\xb4\xcb\x4e\x4f\x0f\x14\x59\x49\
\xa5\xed\xfb\x82\xf7\x46\xd6\xd2\xd1\xc1\x39\x37\x35\x6d\x37\xad\
\x22\x8f\x9e\xf8\xbb\xde\x7a\x0e\x3c\x35\x63\x1b\x3d\x6b\xc9\x8b\
\xa1\x5b\x8f\xca\xc4\xdd\x75\x53\x87\x51\x85\x3c\x8b\xe2\xe4\x0e\
\x9f\xbf\x11\xe9\x55\x6b\x18\x45\x96\x91\xd6\x21\x99\x7d\xfe\x23\
\x32\x10\x76\x25\x38\x3e\x6d\x1d\xad\x39\xdb\xb4\x65\x92\x1a\x78\
\x6d\x25\x6d\x38\xeb\x93\x02\x93\xf7\x1e\x0d\x24\x3b\xaf\x9d\x06\
\x92\x5d\xa6\xf3\xb3\x70\x8a\x80\xe4\x59\x4c\xd6\x42\xaa\x2d\x7b\
\x81\xcb\x91\xc0\xee\x11\x08\x94\x76\x23\x4f\xac\x6d\x6a\xda\xce\
\x3a\x06\x99\xc7\xee\x42\xea\xac\xa0\x9a\xb2\xa2\xf6\x93\x14\xc5\
\x8f\x86\x34\x09\xeb\x68\x16\x61\xe4\x51\xd9\x36\xf4\xc7\x75\xd8\
\xdf\x87\x19\x6e\x0c\xed\x74\x39\x5e\x2f\xe0\xe0\x60\x7f\x6f\x47\
\xb2\x5a\x72\x20\xd2\x65\x27\x32\xb8\xf3\x48\xc4\xc5\xb4\x0b\x49\
\x8e\xb8\xba\x57\xee\x62\xd0\xf2\xb0\xae\x32\xdb\xd3\x81\xf2\x8d\
\xe5\xf5\x5a\xac\x65\x64\xa5\x3f\x17\xb9\xef\xa2\x98\x92\x85\xd2\
\x2a\x7e\x6c\x29\xca\xc8\x2b\xb9\xe9\x6c\xb1\xfb\xd9\x07\xdc\x86\
\x58\x4b\x27\x22\x9d\x95\x96\x89\xd7\xb4\x9d\x75\x0e\xe2\xb6\xfe\
\x2a\xf5\xc0\xa9\xb5\x94\xac\xe7\x24\x69\x53\xad\xa3\x59\x82\x91\
\x6d\x38\x2c\x20\x52\x7d\x89\x6e\x4f\x19\xfd\x08\x7e\x9a\x72\x02\
\x52\x74\xd1\xed\xb5\x59\x07\xde\x84\x80\x48\xbb\xf5\xbc\x72\x00\
\xf0\xef\x80\xa7\x00\x67\x93\xcf\x04\xbb\x08\x99\x09\xe2\x5d\x08\
\xa4\x3c\x28\x69\x6b\xa9\xf6\xe6\x4a\xc7\x57\x0b\x28\x2b\x9b\xe5\
\x67\xdd\x88\xda\x62\x8a\xa0\x94\xb3\x96\x3c\x2b\x29\x6d\xcb\xb9\
\xe9\x72\x80\x4a\x99\x78\x57\x21\x96\xed\xc9\x88\xb5\x94\xb3\x72\
\x9b\x9a\xe6\x51\x29\x5c\xf1\x0f\xd4\x83\xa7\x34\xbe\xd1\xf3\xb6\
\xd8\x58\x11\x04\xed\xc6\xb8\xd6\xd1\x2c\xc1\xc8\x93\xb5\x8c\x52\
\xfd\xf6\xca\xcf\xdf\x85\x4c\xdf\x13\x0d\xe8\x8c\x92\x17\x36\x90\
\x46\x2d\xe9\x66\xe0\x95\xc0\x17\x7b\xef\x4b\x10\x5b\x37\x9f\x5f\
\x45\x1e\x94\xf5\x32\xea\xe3\x18\x67\xf4\xca\x2f\x21\x03\x78\xff\
\x08\xb8\x04\xff\xa6\xf1\xe0\x54\x7a\x0f\x0c\x83\xa8\x64\x35\x79\
\xf1\xa4\xb4\xd4\xae\xbb\x2e\x71\x25\x0b\xa4\x68\x40\x6d\x69\xe6\
\x87\x92\x95\xa4\xc1\xf4\xcd\xde\xb5\x3c\x06\x01\xd3\x89\xcc\xfe\
\x3d\xdf\xd4\x54\xab\xc3\x90\xe7\x20\xbd\x8b\xc1\xff\xbf\x1d\xc3\
\xe8\x0d\x6a\xb5\xef\x4d\x1e\x0f\xdb\xbe\x80\xef\xae\x83\x09\x5b\
\x47\xf3\xf4\xc7\xd4\x8d\xe3\xd7\x2a\x3f\x93\x26\x36\xd5\x16\x51\
\x64\x19\x69\x6d\x00\x5f\x06\x7e\x1f\xb8\x03\x99\x97\x6e\x1f\xfd\
\x1f\xc7\x6b\xd8\x1f\x08\xfc\x0f\xe4\x39\x3e\xa3\x68\x09\x78\x32\
\x32\xb5\xd1\xdb\x81\x3f\x45\x2c\xa5\x08\x34\xda\x95\xa7\xb7\x5b\
\xd7\x9a\x86\x92\x95\x07\xa5\x28\x9e\x54\x8a\x29\xe9\x78\x92\xb5\
\x94\xbc\xd4\x70\x0d\xa7\x9a\xb9\xf1\x6a\x21\xe5\xb9\x02\xaf\x03\
\xbe\x8e\xb8\x4c\x1f\x8c\x80\xe9\xa8\xe0\x9a\x34\x35\xcd\x93\x4e\
\x47\x3c\x01\xa9\x03\x9b\x83\x4d\x34\x08\xdf\xb6\x27\x39\x77\x9d\
\x6e\x33\x86\xdc\x75\xe3\x58\x47\xb3\x06\xa3\xc8\x12\xb2\x2e\xbb\
\x6b\x2a\xf7\xb7\x8b\xe1\x64\x05\x9b\xc0\x10\xc1\x68\x03\xb8\x94\
\xe1\x46\x5f\x2f\xd3\x7b\x4f\x07\x7e\x05\x89\x0b\xe5\x74\x07\x32\
\x8d\xd0\xd7\x81\xe3\x11\x57\xde\xb1\xe6\x3d\x4b\xc0\x0b\x90\xd4\
\xf5\xff\x0e\x7c\x9c\xc1\x1b\xca\x33\xb9\xbd\x14\x71\x6f\x0c\x53\
\x04\xa6\x9c\xd5\xe4\xbd\xaf\xc6\x5a\xf2\xac\x23\x6f\xda\x21\x6d\
\x25\xe5\xa6\x20\x8a\x60\x94\x83\x94\xfd\xfc\x3e\x24\xe9\xe1\x4a\
\x64\xfa\xa1\x53\x90\x8c\xbc\x36\x59\x6b\xd3\x3c\xeb\x59\x48\x07\
\xfd\x1b\xc4\xd0\xb1\x00\x8a\xea\x25\x77\x9d\x17\x43\x1a\xd0\xa8\
\x40\x9a\xfa\x74\x40\x2a\xb5\xdb\x8b\xbd\xe8\xd4\x6b\xdd\x98\x1d\
\x8d\xc4\x5a\x4a\x30\xdd\x03\xbc\x08\xbf\x91\x8a\x60\x54\xf2\xb3\
\xda\xe5\x89\xc0\xef\x51\x6e\xd0\x3e\x81\xcc\x69\x77\xaf\xfa\xfc\
\x41\xc0\x2f\x22\xa6\xb6\xa7\x35\x64\xd2\xd6\xd7\x55\x1c\x87\x77\
\xb3\x79\xcb\xe8\x66\xd3\x4b\xcc\x35\xc9\xfd\x46\xfa\xb7\xf2\x26\
\x65\xcd\xcd\x83\x97\x9b\xa4\xb5\x64\x2d\x75\xb1\x9e\xa2\xcf\xa6\
\xe5\xb1\x48\x6c\xe9\x78\xfa\x59\x45\x4d\x4d\xf3\xa4\x8b\x81\xf7\
\x23\x53\x05\x45\x65\x8f\x5a\xea\xa9\x83\x6a\xa6\x0c\xf2\xda\x17\
\xf0\xdb\x91\x91\xa6\x09\x9a\x35\xcb\xc8\x93\x67\x25\xdd\x8e\x24\
\x26\x3c\xa3\xf0\xd9\x9d\xc4\x53\xff\xd8\x92\xfb\xfe\x68\x79\x04\
\xf2\x54\xd9\x12\x88\x3e\x0d\xfc\x16\x7d\xb7\x54\xfa\x01\xf7\x00\
\xbf\x8d\x58\x54\x67\x39\x9f\x5b\x01\x7e\x19\x09\xc0\xff\x35\x31\
\x80\x3c\x33\x5c\x5b\x2f\xeb\x6a\x19\x01\x29\x27\xcf\x37\xec\xb9\
\xf0\xf4\xf7\x45\x71\x25\xed\xc6\xf3\x00\xa5\x2d\xa5\xfd\xf8\x60\
\x1a\xd5\x6a\x8a\xd6\xd3\x20\xc2\x9d\xc0\x49\xbd\xf2\x80\x8a\xeb\
\xd2\xd4\x34\x2b\x7a\x24\xd2\x41\xbf\x89\x3a\xeb\x28\xb2\x94\xf4\
\x7f\x37\xe7\xae\xcb\xc6\x8a\x46\xb1\x8e\xa6\x0a\x23\x63\x15\x75\
\xfa\x28\xf0\x5a\xea\x66\x61\x38\x0b\xe9\x35\x44\x56\x57\x0e\x46\
\xba\x11\xf6\x96\x3f\x4a\x39\x51\x61\x2f\xf0\xbf\xe9\xc7\xae\x3c\
\xab\xeb\x77\x11\xd8\x1c\x1a\xec\xe3\xa7\x11\xd7\xde\x7b\x28\x43\
\xc8\x83\x92\x05\x93\x07\xa4\x9c\xfb\xae\x64\x9a\xdb\xeb\xa2\xb3\
\x01\x23\x8b\x69\x8d\xbc\xb5\x64\x41\x34\x8e\x3b\x2f\x07\x25\x5d\
\xdf\x8b\x0c\x64\xbe\x1c\xe9\x68\x9c\x8c\xc4\x98\xda\xbc\x78\x4d\
\xb3\xae\x65\x24\xe6\xfc\x4e\xca\x6d\x82\x67\xed\xac\x32\xd8\xae\
\x78\xc5\xb6\x25\x5a\x5e\x87\xb5\x93\xe6\xc1\x32\x4a\xb2\xe0\x7a\
\x27\x12\x4f\x79\x62\xe1\x73\x2f\x45\xe2\x39\x9e\x25\x94\x0b\xce\
\xa5\xd7\x23\x10\x3d\x12\x78\x52\xc5\x71\x7f\x18\x99\x5a\x48\x0f\
\x2a\xb3\xe5\x9b\xc0\x07\x91\x89\x10\x3d\x2d\x01\xbf\x89\x0c\xe0\
\xbd\x08\x1f\x48\xde\x0d\x96\x03\x53\x8d\xdb\xae\xa4\x08\x4c\x11\
\x94\xac\xc5\xa4\xad\x28\x0d\xa7\xc8\x5a\x2a\xb9\xf2\x4a\x60\xaa\
\x81\x52\x5a\xee\xa5\x3f\x76\xe9\x78\xc4\x8d\x77\x2c\xfd\x58\x61\
\x53\xd3\xac\xe9\x24\xa4\xf3\x74\x35\xc3\xed\x41\xee\xd1\x11\x69\
\x3d\x01\x49\xff\x67\x6d\xbd\x94\xcc\x30\xb2\xe6\x09\x46\x30\x4c\
\xe3\xdf\x40\xa0\x94\x3b\x8f\xd3\x80\xc7\x03\x9f\x1b\xe1\xfb\x72\
\x8d\xf3\xbf\xaf\xdc\xc7\x17\x18\x04\x51\x5a\xda\x92\x83\x11\xc8\
\x40\xd0\x5f\x42\xac\x31\x0f\x3c\x76\x56\x04\x7b\xb3\x69\x8b\x50\
\xbb\xf1\x2c\x98\xf4\xf1\x45\x90\xd6\xf2\x5c\x77\x76\x1f\x1a\x3a\
\x69\xb9\x84\x0f\xa8\x9c\x0b\xaf\x04\xa7\x28\xc6\x34\x0e\x94\x56\
\x90\x6c\xa5\x6b\x91\xc9\x71\x77\x23\x7f\xfa\xc3\x33\xd7\xa4\xa9\
\x69\x5a\x7a\x22\xe2\x72\xd6\x6d\x40\x14\xfb\xf1\xb6\x27\x20\xe9\
\x34\xef\x65\xb3\xf4\xac\x23\xed\x45\xd9\x80\xee\xae\xba\x79\x83\
\x91\xd5\xe5\x48\x52\xc0\x6f\x15\xde\xf7\x1f\x91\xc6\xe4\x8e\xe0\
\xf5\x9c\x8b\xca\xd3\xc1\x08\xe4\x6a\x94\xc6\x39\xd9\xfd\x5a\x18\
\x5d\x06\xdc\x42\x3e\xe5\xf8\x61\xc0\x8b\x81\xb7\x92\x37\xc1\x53\
\xa3\xae\x2d\x22\x6b\x21\x79\x19\x78\x9e\x85\x14\x99\xdf\xde\xba\
\x8d\x1d\xe9\xed\xd6\x55\xe8\x81\x29\x72\xe1\x59\x20\xe9\xf5\x5c\
\x6c\xa9\x4b\x12\x44\xa9\x9e\xb2\xf1\x2e\x41\x5c\x79\x0f\xa4\x3f\
\x76\xa9\x4d\x41\xd4\x34\x2b\x3a\x0a\x69\x9b\xbe\xc8\x70\xe7\xd4\
\x5a\x47\x16\x58\xa9\xbe\xc2\x70\x27\x31\x8a\x1d\x4d\xcc\x3a\x9a\
\x77\x18\x81\x3c\x02\xfc\x38\xe0\xa7\x32\xef\x39\x11\xc9\x4a\x7b\
\x35\xf0\x59\x86\x1b\x5d\x7d\x11\xf5\xf6\x83\x90\xe4\x81\x1b\xcc\
\xf6\x47\x53\xe7\xae\xb9\x06\x19\xeb\xe4\x65\x68\x79\x8d\xfe\x47\
\x80\xef\x2a\xec\xf3\x47\x80\xf3\x81\x7b\x88\x41\xa4\x1b\x7b\x0f\
\x4e\xd6\x9a\xf2\x06\xcf\x7a\xc7\x07\xf5\x37\x9b\x05\x99\x75\x8f\
\x6a\x28\xda\xa5\x07\xa5\xc8\x8d\x67\xad\xa4\xda\x8c\xbc\x12\xa0\
\x72\x70\x5a\x41\x62\x78\x37\x23\x16\xf7\x09\x88\xc5\x74\x0c\x83\
\xbd\xc5\xa6\xa6\x69\xe8\x6c\xc4\x9a\x8f\x00\x14\x95\xf4\xfe\xc8\
\x5d\xe7\xb5\x03\x13\xb3\x8e\xe6\x0d\x46\xfa\x62\x68\xfd\x2f\x24\
\x13\xea\x47\x33\x9f\x3d\x04\xf8\x6f\xc0\xfb\x80\x37\x22\x99\x6c\
\xd6\xc5\x04\x32\xaa\xf9\x89\xc8\xb3\x8a\x4e\xe8\x6d\x7b\x0d\xf0\
\x5e\xf5\xde\xc7\x56\x1e\xef\xc5\xf4\x1b\x59\x4f\xb6\xb1\xff\x24\
\x65\x18\x1d\xda\x3b\xb6\x0b\x88\xe1\xa2\x01\x64\x97\xe3\x02\xc9\
\x03\x14\xc4\x90\xd2\xef\xf7\x62\x75\xda\x5a\x8a\x52\xc4\x23\x28\
\x79\x2e\xbc\x2e\x31\xa6\x2e\x96\x51\x64\x69\xe9\x87\x01\x1e\x4c\
\xdf\x8d\xd7\xa6\x20\x6a\x9a\x96\x0e\x41\x3a\xcc\x9f\xa1\x1b\x8c\
\x34\x88\x56\xcc\x32\x81\xc9\xfb\xef\x8e\x15\x2b\x4a\x9a\x27\x18\
\xd9\x86\xcf\x96\x3f\x43\xdc\x27\x2f\x27\x9f\x6a\xfd\x1c\xe0\x99\
\x88\xbb\xe5\x72\x24\x79\x60\x17\xfd\x79\xcc\xbc\x09\x36\x4f\x34\
\xdf\x75\x66\xe5\x31\xeb\xc4\x85\x5c\x8f\x39\xed\x37\x72\x23\x5a\
\x3d\x1b\x49\x8c\x28\x81\xc5\xa6\x53\xdb\xb8\xd2\x86\x5a\xb7\xb1\
\x23\xbd\x0e\xfe\x35\xf7\xac\xa5\x1c\xa0\x3c\x7f\xb3\x4d\x2c\xb1\
\xae\x3b\x0f\x4a\x16\x46\xa5\xb1\x4b\x11\x90\x6a\x2d\xa6\x5a\x38\
\xed\x45\xee\xa7\x4b\x91\x2c\xcb\xdd\xb4\x29\x88\x9a\xa6\x23\xde\
\xba\xde\x00\x00\x20\x00\x49\x44\x41\x54\xa3\x33\x10\x57\x5d\x57\
\x18\xe9\x19\x52\xb4\xdb\x4e\xc7\x8c\x3c\x4f\x87\xd6\x00\xa4\x6a\
\xad\xa3\x59\xf9\x93\xd8\x60\x58\xed\x67\x6c\x43\xf9\x3e\xc4\x3c\
\xfd\x25\x24\x69\x21\xd2\x2a\x02\x94\x1a\xa8\xdc\x85\xb8\xc5\xd2\
\x77\x9c\x48\xfd\x18\x14\xdd\xa0\xe2\x2c\x6d\x63\xbe\xaf\x72\xbf\
\x8f\x45\x02\xe8\x7a\xc6\xef\x12\x8c\xb4\xd5\x64\x13\x1e\x2c\x94\
\x2c\x8c\xba\x94\xa4\x52\xac\x49\x9b\xf4\x16\x4c\xfa\xf8\xac\xeb\
\x2e\xad\xeb\xd9\x1d\x72\x70\x8a\xac\x25\xcf\xca\x19\x05\x4a\xd1\
\xb6\xeb\x90\xec\xc7\xcf\x22\x19\x4e\x27\xd1\x9e\xbb\xd4\xb4\x75\
\x3a\x00\x89\x31\x5f\xca\x20\x68\xf6\x3b\xcb\x55\x24\x41\xca\xba\
\xeb\x6c\xdb\x62\xff\x93\xd6\x15\x3f\x96\xa6\x0a\xa3\x8d\x8d\x8d\
\x0d\xf3\x70\x3d\xf7\x6d\x94\x5d\x45\xba\xe1\xbc\x0a\xf8\x59\xc4\
\x95\xf5\x9f\xe9\xf6\xec\x23\xab\x2f\x20\x2e\xba\xeb\xd5\x77\x76\
\x19\x0c\x99\x7a\x13\x5e\x2f\xc2\xfe\x80\x1b\xf4\xad\x95\xd2\x35\
\x59\x41\xa6\xb1\xf9\x32\x83\x20\x49\xdf\xf5\xf0\xde\xeb\x0f\x41\
\x7a\xe7\xc7\x11\x37\xa2\xff\x08\xfc\x01\x83\xd7\xb0\x64\x29\xd5\
\xc0\x2a\x9d\x93\x8d\xc7\x79\xd7\x28\xe7\xbe\xf3\xac\x25\x2f\xf3\
\xce\x5a\x4d\x25\x38\xd5\xba\xf0\x6a\x93\x20\x22\x28\xa5\xe7\x2e\
\x5d\x89\xb8\x80\x4f\x46\xc0\xd4\xc6\x2e\x35\x6d\xb6\x4e\x43\xee\
\x3d\xcf\xfa\xb1\x50\x4a\x2e\x3a\xeb\xae\xd3\xff\x2b\x9b\xcc\x90\
\xea\xe0\x5b\x47\xf7\xab\xc6\x3a\x9a\x15\xcb\x48\x4b\x37\x4e\xb6\
\x9e\x96\x51\x83\xa8\x49\xfe\x51\xe0\xdf\x80\x73\x11\xb7\xd6\x93\
\x89\x9f\x51\x64\x75\x35\xd2\x48\xa7\x31\x3d\xf6\xfb\x6b\xa5\xd3\
\xa9\x73\x66\xad\xde\xef\x7d\x48\x0a\x71\x49\xc7\x23\xcf\x32\xd1\
\xe7\xff\x24\xe0\x7b\xe9\xf6\xbc\xa7\xa7\x20\xbd\xa2\x1c\x8c\xa2\
\xe5\xb2\xb3\xad\xab\x2b\x2f\xad\xd7\xba\xef\x2c\x98\x6c\xd6\x8f\
\x85\x54\xd7\xf8\xd2\x28\x50\x2a\xc5\x95\x74\x7c\xe9\x1b\x48\x2c\
\xf1\x44\x64\x6e\xbc\x66\x2d\x35\x6d\x96\x8e\x44\xc6\xc6\x5d\xc7\
\x20\x7c\x74\xd9\xc1\xe0\x43\x30\x73\xee\x3a\x6b\x1d\x95\x62\x47\
\x9d\x2c\xa6\x59\x83\x91\x3d\x29\x9d\x2a\x0c\xc3\x0d\x9a\x85\x90\
\x05\xd2\x1a\xf0\x29\xc4\x55\x72\x20\x02\xa6\x47\x21\x0d\xf9\xb1\
\x48\x1a\xe4\x1e\x24\x33\xed\x0e\xc4\xc7\x7a\x11\x92\x66\x6d\xe3\
\x25\xa8\xfd\x77\x39\x1f\x0d\x22\xcf\x65\xa7\xdf\x0b\xf5\x30\x3a\
\x16\xf9\xfd\xd2\x31\x9d\x04\xfc\xd7\x0e\xc7\x96\x74\x19\x62\xd2\
\x7b\xb1\xa3\x68\x9b\xb5\xc6\xd2\xcd\x69\x5f\xf7\x14\x41\xc9\xfb\
\xed\x35\xc0\xf5\x18\x87\x08\x4c\x5e\x26\xde\xb8\xf1\xa5\x51\xa0\
\xd4\x25\xe9\xe1\x70\xe4\x29\xb5\x0f\xa1\xa5\x88\x37\x4d\x5e\xa7\
\x21\x53\x04\x45\x30\x8a\x5c\x77\xfa\xfe\xcf\x59\x47\x16\x48\x5a\
\x9d\x5c\x77\xb3\x06\xa3\x9c\x2c\x7c\x96\x19\x86\x91\x4d\x71\xd6\
\x83\x3d\xef\x43\x52\xa7\x3f\x4e\xbf\x21\x4a\x8d\x18\xf8\x29\x8a\
\x5e\xc3\xf9\xb5\x0e\xc7\xbc\x93\x61\x10\xd9\x46\xd6\x9e\x63\x6d\
\xec\x6c\x99\x3e\x8c\x36\xe8\xdf\x5c\x5d\x7f\xd3\x37\x20\xbd\xa3\
\x13\x90\x31\x4c\x0f\x45\x40\xf7\x75\x64\x4e\xbd\xb7\x23\x63\xb4\
\x22\xe0\xdb\xf8\xd3\x92\x59\x46\x60\x8a\x5c\x76\xba\xae\xaf\x93\
\x5e\xf7\x80\xa4\x7b\x6e\xb9\x14\xf1\x71\xe3\x4b\xa3\x40\xa9\x94\
\xf4\x70\x3b\xe2\x12\x7e\x08\x72\xfd\x4b\xb3\xbf\x37\x35\xd5\xea\
\x44\x24\xbb\x2e\x82\x91\xb6\x8a\x52\xdc\x48\x5b\x48\xd6\x3a\xd2\
\x1e\x09\xaf\x3d\x0b\xad\xa3\x92\xab\x6e\xd6\x61\xa4\x7b\xcb\x9e\
\x7b\xce\x36\x46\x6b\xa6\x1e\x35\xfe\xc9\x62\xb1\x17\xd5\xfb\x7e\
\xab\x5b\x90\xc6\xa3\xa6\xc1\x38\x1d\x49\xaa\xb0\xd9\x61\xd1\xf7\
\x3d\x00\x99\x13\xad\x46\x77\x31\x08\xa3\x5b\x80\x57\x01\xff\x25\
\xd8\xb7\xa7\x4f\x23\xae\xcb\xdf\x45\x62\x6c\xcb\xea\xb5\x13\x91\
\x24\x90\xef\x47\x9e\xd3\xf4\x11\x62\x18\x79\xd7\x3a\x01\x28\x5d\
\x43\xbb\x0e\xc3\x96\xaf\x27\xeb\xc2\xf3\xdc\x03\x25\x4b\x29\x4a\
\x7a\x88\x80\xe4\x01\x2a\xb2\x96\x26\x65\x39\xed\x45\xac\xd4\x2b\
\x90\xfb\xe0\xe1\xb4\x4c\xbc\xa6\xf1\xb5\x8c\xdc\x4b\x9f\x23\x86\
\x91\x85\xd2\x2a\x79\xeb\xc8\xfe\xdf\xec\x7f\xb4\x93\x45\x94\x34\
\x4b\x37\xba\xb5\x0a\xa2\x13\xb4\x40\xb2\x3d\x71\xaf\x61\x5c\x32\
\x9f\x5d\x51\xf5\x1c\x1c\x22\x5d\x82\x34\xde\x25\x9d\x4e\xbf\xb7\
\x11\x1d\x93\xfe\xde\x87\x77\x38\x86\x7b\x18\x84\xd1\x3a\xe2\x62\
\x3c\x1f\x49\x5f\xaf\xd1\xc3\x90\x31\x5a\x39\x1d\x8a\xa4\xcd\xff\
\x19\xfd\x47\x59\xd8\x6c\x9b\x65\xb3\xae\xcf\x57\x5b\x45\xfa\x26\
\x86\x61\x77\xac\x55\xb4\xcd\xbb\x96\xf6\x7e\x89\x2c\x25\x1b\x63\
\xf2\xb2\xf2\x3c\x20\xd5\x5a\x4b\xe3\xc0\x29\x2d\x6f\x44\x3a\x17\
\x3b\x91\xb8\xd2\x29\x48\xf2\x43\x53\xd3\x28\x3a\x19\xc9\xaa\xd3\
\x99\x73\x39\x20\xa5\xfb\x30\x59\x47\xe9\xbf\xe0\x01\xc9\xfe\x1f\
\x73\xed\x78\x56\xb3\x04\xa3\x24\xdb\x40\xd9\x65\x64\x25\xa5\x06\
\xc8\x03\x92\xdd\xbf\xb6\x8c\x72\x70\xb0\x4a\xef\xfb\x67\xea\x60\
\x74\x00\x70\x2a\x32\xfe\x49\xef\x3f\x3a\xb6\x2e\x30\xba\x09\xb9\
\x41\x60\x30\x56\xb3\xa7\xc3\x3e\x6a\xe7\x57\x5b\x46\x2c\xae\x0f\
\x22\xee\xbb\x75\xfa\x37\xa7\x75\x8b\xa6\xdf\x42\xff\x06\x5a\x5e\
\xfc\xcd\xbb\x61\x6b\x40\x95\x83\x92\x8e\x61\x69\x18\x45\xf1\xa5\
\x15\xa7\x5e\x8a\x2d\xe5\x06\xd7\xd6\x42\x29\x07\xa7\x34\xfd\xd0\
\x65\xc8\xec\x0e\x0f\x43\xdc\xa9\xda\x82\x6d\x6a\x2a\xe9\x40\x64\
\x78\xc1\x95\xf8\x56\x90\x57\x3c\xcb\xc8\x03\x52\xf4\x1f\x74\x95\
\x73\xd5\xcd\x22\x8c\xac\x3c\x8b\x48\x37\x32\xba\xac\x39\x75\xbb\
\xaf\x65\x86\x61\x64\xe3\x46\xf6\x73\x16\x24\x97\x21\xb3\x39\xd7\
\x8c\x53\x3a\x03\x81\x91\xb7\x1f\xfb\x5d\x0f\xab\xd8\x1f\xc8\xf4\
\x44\xb7\x31\x08\xa3\x74\x5e\x5d\x32\xe9\xba\x68\x15\x99\x01\xfd\
\x95\x0c\x8f\x55\xd2\xf1\x39\xfd\xbb\xe8\xdf\xc0\x5a\x4a\x9e\x95\
\xa4\x6f\x64\xdd\xf9\x88\xfc\xd1\xa8\xed\xb5\x60\x8a\x32\xf0\xf4\
\x36\xfd\xc7\x2b\xc5\x97\xec\x36\x0b\x24\x0f\x3e\xb5\xae\x3b\xbd\
\xed\x6b\x48\x47\xe0\x20\x24\xae\x74\x32\xf5\xd9\xa1\x4d\x4d\xa7\
\x20\xd3\x93\x79\x96\xd1\x3e\xba\x01\x29\x8a\x1d\x25\xe9\xff\x6b\
\xb5\xdb\x6e\xea\x30\x32\x63\x8d\xa2\x86\x27\xb2\x8a\x72\x40\x1a\
\xfa\x2a\xea\x60\xe4\x41\xc2\xb3\x6a\xfe\x06\xf8\x9f\x94\x33\xa0\
\x1e\x8b\x3c\x6a\x7c\xcd\x79\x4d\xef\xf7\x01\xd4\x8f\x61\xfa\x02\
\x83\xbd\xe3\x74\x6e\x07\x21\xd3\x80\xd4\xe8\x1b\xc8\x2c\x0e\x3b\
\x10\xeb\xed\xe4\x8a\xcf\x3c\x0f\xf8\x07\x24\xf3\xd0\xeb\x29\xd9\
\xa4\x91\xf4\x7b\x80\xff\x9b\xd8\x44\x14\x2f\x81\xc1\x53\xee\x26\
\xaf\x75\xe3\x69\x38\x79\x45\x43\xd6\xf6\x0c\x73\x96\x93\xe7\xce\
\xeb\xea\xca\xcb\xa5\x8c\xef\x43\x3a\x42\x97\x22\xbd\xdd\x47\x50\
\x1f\x67\x6c\x5a\x5c\x1d\x85\x8c\x6d\xf3\x2c\xa3\x04\xa7\x7d\xc4\
\x1d\xaa\xe8\x3f\xe2\xfd\xd7\x20\xee\x5c\x86\x9a\x3a\x8c\x02\x79\
\x7e\xc7\xb4\xd4\x10\xca\x01\xc9\xee\x2f\x07\xa3\xe8\x82\x7a\x96\
\x4c\xfa\xcc\xe5\xc8\x43\xf3\x4a\xe9\xd4\x0f\x00\xbe\x1b\xc9\x5a\
\xf3\x1a\xd8\xb4\xfe\xfc\xc2\x7e\x92\xd6\x91\xc6\xc8\xba\x6a\x36\
\x80\xa7\x53\x97\x1e\xfc\x35\xe4\x51\xe9\xf7\xd1\x77\xef\xbd\x18\
\x78\x41\xe1\x73\xbb\x10\x57\xe2\x17\x18\xf4\x27\xe7\xae\x65\x52\
\x0e\x2c\xa5\x74\x79\x7b\x13\xdb\x7b\x23\x77\xa3\x7b\x3e\x6d\x1b\
\x74\xcd\x41\xc9\x0b\xd8\x96\x66\x7d\x88\xdc\x7a\x35\x60\xca\xd5\
\x2d\x94\xae\x40\x06\x79\x9f\x80\x3c\x5f\x2b\x37\xe3\x7b\xd3\x62\
\x6b\x09\xf1\x9a\x7c\x95\x3e\x80\x22\x8b\xa8\x36\x91\x21\x15\x1b\
\x7f\xcf\xfe\x27\x23\x57\xdd\xac\xc2\x48\xcb\x5a\x4b\xe9\x24\x52\
\x03\xa6\x5d\x43\xa5\xfd\x58\x18\x2d\x91\x6f\x44\xbd\xf5\x0d\xf5\
\xb9\xf7\x21\xe6\x6f\x69\x72\xd3\x67\x22\x01\xe9\x0b\xcc\x39\xa4\
\x7d\xfe\x3b\xe0\x31\x85\x7d\x24\x7d\x12\x99\xf3\x2e\x1d\x77\x3a\
\xb7\x55\x64\x00\x6b\x49\xfb\x91\xd9\xcb\xd7\x19\x1c\xec\xfa\x36\
\x24\x7b\xee\xf8\xc2\xe7\x4f\x44\xc6\x63\x79\x8d\xb6\xbd\x9e\x49\
\xb6\x83\xa0\xaf\xab\x76\xd3\xe9\x52\x6b\xde\x77\x01\x53\x92\xee\
\xc0\xe8\x7b\x42\x77\x76\x72\x50\xf2\xac\xa7\x08\x4e\x5d\xc0\xd4\
\x05\x4a\x7a\xdb\x55\x48\x07\xe3\x41\xc8\x38\xba\x63\x8b\x57\xad\
\x69\x11\x75\x2c\x32\x4c\x43\x5b\x44\x1e\x90\x6a\xad\xa3\xa8\x23\
\xaf\xdb\xc9\xa4\xb9\x4d\x60\xc8\xf9\x1c\x3d\x2b\x09\x06\x81\x61\
\xf7\xb7\x81\x5c\x4c\xdb\x2b\xae\xb5\x8e\x22\x77\xcf\x06\xf0\xff\
\x21\x70\xf8\x21\xf2\x81\xe5\x97\x20\xd9\x75\x17\x20\x0d\xc7\x01\
\x08\xc8\x9e\x8d\x8c\x2f\xa9\xd1\x3d\xc8\xec\xe1\x5e\x63\xff\x78\
\xea\x66\x8a\xfe\x18\xe2\x66\x4b\x20\xd2\xd7\xf1\x62\xca\x30\x3a\
\xa1\x77\xec\x76\x6a\x91\x1c\xdc\xad\x3c\xeb\x30\x59\x68\x1e\x90\
\xf4\xfd\x90\x93\xf7\xdb\x7b\xf7\x8f\x3e\x36\xed\x6e\x48\xaf\x5b\
\x38\x45\xa0\xf2\x32\xf3\x52\x7d\xc5\xa9\x4f\x02\x4a\xb9\x6d\x5f\
\x43\xe2\x89\x47\x21\x50\x3a\xd1\xb9\x26\x4d\x8b\xab\xa3\x19\xbe\
\x67\x4a\x40\x4a\xd6\x91\xbe\x7f\xad\x75\x14\xc5\x8d\x3c\x8f\x46\
\xf8\x1f\x9e\x09\x18\x05\x73\xd4\x79\x64\xd5\x27\xe3\x35\x12\xee\
\xee\xd5\x32\x5d\xd0\x5a\x18\x59\xd7\x5c\x6a\x34\x6d\x63\xf5\x26\
\x64\x34\xfd\x2f\x92\x0f\x2a\x3f\xba\x57\x72\xf1\x90\x48\x1b\xc8\
\x00\xd4\x7b\xcc\xb1\xa5\xfa\xd3\x2a\xf6\xb1\x0e\x7c\x80\x61\x10\
\xa5\xeb\x77\x53\xc5\x3e\x8e\xea\x7d\xbe\xd6\x22\xd2\xf5\x54\xd6\
\xcc\x36\x3b\x48\x56\x5b\x8f\x7a\x59\xdb\xd3\xf2\xae\xed\x86\x79\
\x4d\x5b\xd8\xcb\xaa\xee\x75\x6a\x3c\x40\x5a\x30\xe9\xfb\xc9\x82\
\x29\x07\xa5\xb4\x5e\x8a\x27\x45\x00\xf2\x1a\x91\x1b\x90\x67\x2d\
\x1d\x89\x40\xe9\x24\x75\x8e\x4d\x8b\xab\x9d\xc8\x3d\xa1\xe1\x93\
\xbb\xa7\x72\x96\x51\xce\xab\x54\x74\xd5\x79\x9a\x09\x18\x15\x14\
\x05\xc0\x6a\x62\x0d\xfa\xf3\x36\x6e\x54\x0b\x23\xdd\x58\xa6\xcf\
\xd8\x86\x1c\x64\xda\xa1\x9f\x42\x9e\x2a\xfb\x2d\xe4\x61\x33\x0a\
\x88\xce\x43\xa6\x35\xf2\x40\xf4\x08\xea\xe2\x05\x17\x31\x3c\x58\
\x56\x97\xda\xe9\x68\x4a\x30\xf2\xac\x22\xcf\x1a\xd2\xc9\x0e\xb6\
\xa1\x8f\xa0\x84\x7a\xaf\x95\x05\x8e\xfd\xbe\xe8\xf3\xf6\x0f\xa3\
\xbf\xd3\x66\xfd\xe9\x63\x5c\x72\xde\x63\xaf\x87\xe7\xee\xcb\xc5\
\x98\x6c\x23\x50\x8a\x1d\xe5\xca\x3e\x24\xeb\xf2\xf3\x48\x4c\xe9\
\x14\xe6\xe3\x3f\xdf\xb4\x79\x7a\x10\xfd\x4c\xdc\xe8\x1e\xca\x59\
\xef\xde\xff\xde\x5a\x47\x45\x57\x9d\x17\x37\x9a\xd5\x1b\xb3\xe4\
\xa2\xf1\x2c\xa4\x68\xca\x19\xef\x7d\xd6\xcd\x52\x82\x91\x6e\x5c\
\xf4\x3e\x56\x18\x3c\xae\x9b\x81\x57\x20\x16\xcc\x0f\x53\xff\xdc\
\xa3\x9c\xf6\x03\x6f\x41\x26\x7d\xf5\x40\x54\x6b\x15\x81\xcc\xa2\
\xb0\xd2\xab\x7b\x90\xae\x81\xd1\x1a\x3e\x8c\x6a\x01\xab\xad\x23\
\xbd\xac\x81\x91\xe7\xae\xd5\xf5\xd2\x31\x78\x56\x8f\x27\xcf\x0a\
\x07\x3f\xa5\x35\xbd\x77\x9d\xe1\x3f\x65\x09\x4c\xb9\xd8\x52\x8d\
\xa5\x54\x5b\xf6\x21\xee\xd9\x2f\x20\x1d\x97\x87\xd3\xe6\xc1\x5b\
\x54\x1d\x8d\xcc\xf6\x9f\x8b\x13\x59\x20\x59\xb7\x73\x4d\xdc\x08\
\xb6\xa1\x65\x04\xf9\x9e\xac\x86\x43\xc9\x5d\x17\xf5\x66\x6b\x40\
\x64\x07\x4f\xa6\xfd\xad\x30\xdc\x78\x5e\x01\xfc\x26\x92\x32\x7d\
\x2e\x70\x0e\xe2\x2a\xe9\xaa\x4b\x80\xb7\x22\xd3\x0f\x25\x37\x8b\
\x85\xf2\x83\xa9\x8b\x39\x7d\x15\x19\xa7\xe2\xc1\x28\x2d\x77\x54\
\xec\xc7\xc2\x28\x77\x33\x5a\x59\x4b\x49\x8f\x4d\xd2\xbf\x47\xc9\
\x3a\x8a\x96\x5a\xde\x36\xfb\xfd\xb5\x00\xf5\x5c\x7c\xe9\x5e\xf2\
\x7a\x82\x9e\x45\x3d\x2a\x94\x4a\x30\xca\xc1\x69\x07\xc3\x50\xfa\
\x14\x12\x1b\x3c\x0d\x89\x61\xb6\x47\x59\x2c\x96\x0e\x47\x7e\x73\
\xcf\x55\x17\xb9\x86\x3d\x4b\x3e\x07\x24\x18\xee\x60\x62\xb6\x0f\
\x69\x5e\x60\xa4\x15\xf9\xfe\x4b\x50\xb2\x30\xf2\x1a\x8f\xa8\x68\
\x10\x79\x96\xd1\x0a\xbe\xbe\x8c\x8c\x7a\x7e\x23\x62\x1e\x9f\x83\
\x3c\x9f\xfe\xb4\xcc\x67\x6e\x42\x20\x74\x11\x02\x10\x7d\x0c\x09\
\x48\xfa\xdc\x6b\x66\x82\x00\x79\xa4\x86\x17\x37\xe8\x0a\xa3\x74\
\x13\xd7\xc0\xc7\x4a\xdf\xa8\xda\xb2\x38\x18\x79\x42\xea\x3e\x06\
\xaf\xb1\x67\xbd\xd9\x63\xf6\x96\xb6\x9e\x3b\x0e\x10\x2b\xe1\x04\
\xc4\xa7\x6e\xcb\x2e\x64\x72\xdd\x7b\xcd\x7e\xbd\xfb\xcf\xee\xb7\
\x64\x65\x47\x2e\xbc\x1a\x4b\xa9\xc6\x4a\x4a\xbf\x95\x07\xa5\xcf\
\x22\x59\x91\x67\x20\xd6\x52\x74\x3f\x36\x6d\x2f\x2d\x21\xb3\x79\
\xdc\x43\xbe\xb3\x53\x72\xd1\x69\x08\xd5\xc6\x8e\x06\x40\x64\x5d\
\x75\xf3\x06\xa3\x5a\xb7\x9d\xf5\xf3\xc3\x60\x03\xb1\x41\xbf\xd1\
\xcb\xf5\xec\xed\x45\xd6\x2e\xbe\x9c\x65\xa4\x8f\x37\x2d\xbf\x0e\
\xbc\x13\x78\x0f\x32\x3d\xc7\x03\x91\xc1\x8a\x87\xd1\x7f\x5c\xf5\
\x9d\x0c\x26\x28\xd8\x1f\xdc\xc6\x26\x8e\x43\x1a\x92\x92\x6e\x06\
\xbe\x42\x1c\xc4\x4e\xc7\xbd\xb3\x62\x5f\xb7\x33\x08\xa3\x2e\xda\
\x89\xc0\xf8\x69\x88\x0b\xf3\x08\xa4\xa7\x96\x02\xfe\xd7\x21\xa3\
\xc4\xaf\x42\x5c\x8a\xef\x47\xa6\x37\x9a\x34\x94\x8e\xa7\x9f\x4e\
\xff\x18\xfa\x73\x08\x46\xba\x98\x7e\xfa\xbe\x77\xde\x16\x48\xf6\
\xde\xd4\x9f\x1b\xc7\x52\x8a\x5c\x77\x35\x6e\xba\x9c\xa5\x74\x19\
\xf0\x38\xc6\x7b\x10\x65\xd3\xfc\xe8\x28\x24\xf3\x32\x67\x7d\xd7\
\xc4\x8c\x6c\xec\xc8\xcb\xaa\x4b\x2a\xba\xec\xe6\x0d\x46\x91\x74\
\x6f\xd5\x6b\x98\x6c\x96\x54\xad\x55\xa4\x2d\x22\xfd\xb9\xb4\x4f\
\x6d\x19\x79\x20\xf2\x1a\xd1\x0d\x04\x38\xf7\x21\x59\x4f\x2b\x0c\
\x37\x4c\xda\x0a\x4b\xeb\xa8\xe5\x32\x32\xdb\xc2\xcb\xf0\x7f\x78\
\xab\x8f\x39\xfb\xd0\x4a\xe7\x55\xf3\xa0\xb7\x5b\x19\xee\x45\xe7\
\x8e\x61\x03\x01\xce\x4b\x81\x6f\x23\x76\x0b\xad\xd0\x7f\x3a\xed\
\x53\x7b\xef\xbf\x0b\x49\x65\x7f\x3b\x32\x5b\x44\x7a\x12\xae\x77\
\x6d\xc9\x2c\x53\xfd\x30\x64\x8e\xbd\x1f\xa3\x0e\xbc\x49\x07\x32\
\xec\x82\x88\x64\xef\x03\xfb\xfe\x9c\xb5\x54\x4a\x74\x88\xe6\xc2\
\x8b\xdc\x76\x1e\x7c\xec\xb6\x34\xf2\xfe\x02\x64\x56\x87\x73\x69\
\x0f\xfc\xdb\xee\x3a\x94\xfe\x7d\xe5\x75\x70\x72\x10\xf2\x92\x18\
\x3c\x17\x9d\xb5\x8e\xb4\x5c\x30\xcd\x04\x8c\x2a\x1e\x3d\x5e\xab\
\x1c\x94\xa0\x2e\x3e\x84\xb3\x6d\xc3\xd4\xb5\x3b\xd0\x73\xd5\x45\
\x0d\xa6\x2e\xda\xcd\xb7\x6c\xf6\x19\x99\xb7\xbb\x91\xde\xeb\x89\
\x48\x3c\xaa\x66\xa2\xd3\xbb\x90\xc0\x75\x3a\x2f\xbd\xd4\x5a\x42\
\x5c\x89\x25\xe9\x39\xf1\xb4\xbc\x5e\xcf\x32\x32\xbe\xea\x25\x08\
\x3c\xbb\xea\x10\x64\x66\x88\x17\x23\x8f\x7e\x7f\x05\x12\x43\xd3\
\x71\x25\xf0\xaf\xb7\xb7\x7c\x09\xf0\x33\x23\x1c\xc7\x79\x0c\x76\
\x0a\x3c\xd5\x00\x11\x86\x7f\x83\x5a\xd7\x5d\x97\x58\x52\xaa\xeb\
\xb8\xc0\x0e\x7c\x2b\x49\x03\xea\x3a\x04\xfc\x0f\x45\x2c\xd8\x9a\
\x71\x6b\x4d\xf3\xa7\x83\x28\x43\xa8\xc6\x55\xb7\x84\x0f\x25\x18\
\xfc\xaf\x14\xad\x22\x98\x01\x18\x05\x20\x8a\xfe\xf4\xb5\xd0\x8a\
\xdc\x79\xa5\xf7\xdb\x06\x42\xd7\x3d\x1f\x68\xce\x55\x57\x03\xa3\
\x64\x5d\x79\x0d\x91\x85\xd3\x59\xc0\x8f\x74\xb8\x06\x49\x9f\x60\
\x38\x63\x2d\x49\xd7\x57\x29\xcf\x8d\x77\x37\xe2\x36\x8b\xdc\x7d\
\xd0\x3f\xbf\x03\x81\x9f\xa3\x7e\x66\x89\x92\x8e\x47\xe6\x02\xfc\
\x11\x64\x2a\xa3\x8f\x13\x5f\x67\x5b\x4f\xeb\xd7\x8e\xf0\xbd\xf7\
\x20\x53\x39\x25\x00\x7b\xf7\x55\xe4\xa6\xf3\x00\xa9\xe5\xdd\x63\
\x35\xae\x3b\x6b\x29\xd5\xc4\x93\xbc\xe7\xd5\xd8\x7a\x5a\x5e\x86\
\xb8\x4a\xcf\x42\xc6\xc5\xe5\x7e\xef\xa6\xf9\xd3\x32\xd2\xd1\xd8\
\x8b\xdf\xc9\xa9\x71\xcd\xd5\x66\xd3\x45\x1d\xeb\x21\x4d\x15\x46\
\x15\x20\x8a\x28\x9b\xf3\x4b\x46\xaf\x59\x79\x17\xc4\x5e\x34\xbb\
\xcf\xf4\x9a\x8e\x19\xd5\x00\x29\x65\x8b\xe9\x7a\xfa\x91\x6b\x26\
\xeb\x5c\x46\xe6\x8d\xeb\x0a\xa2\x75\x64\xfa\x20\xcf\x62\xb4\xe7\
\xf9\xa0\x8a\xfd\xa7\x69\x88\x22\xa5\x7d\x1f\x09\xfc\x02\xdd\x67\
\x10\x5f\x47\x52\xd8\xaf\xa7\xff\x1c\x1f\xdb\x3b\x3f\x1d\xf8\x5b\
\x64\xa2\xda\x57\x20\x0d\xa8\x37\xa5\x10\xa6\x0e\xe2\xea\xfb\x6b\
\x04\x68\xb5\x7a\x13\xfd\x60\xaf\x05\x91\xfd\x1e\x9d\x74\xa1\x15\
\x59\x6e\x10\xdf\x67\x5e\xef\x33\xb2\x90\xb4\xfb\x2e\x72\xdd\x59\
\x18\x69\x8b\xc8\xc2\x28\xb9\xee\x3e\x8e\x64\x86\x3e\x1d\x89\x71\
\x36\x6d\x1f\x1d\x82\xcc\xc4\x12\xdd\x53\xde\xfd\x56\x63\x15\x95\
\xda\xe7\x81\xff\x87\x4e\x62\x98\xba\x65\x64\x94\x03\x91\x77\x92\
\xa5\x93\x8f\x54\x63\x39\x59\x30\xd5\x02\x09\x67\xbb\x07\x2d\x9d\
\x91\x97\x0b\x0a\xa6\x72\x39\xdd\x7d\xf9\x37\x32\x98\x10\xe1\x5d\
\xbf\x74\xfe\x35\x2e\x3a\x0f\x46\xde\xf9\xff\x04\xdd\x40\xb4\x1f\
\xf8\x2b\x24\xc1\xe3\x16\xb5\xbf\xd5\xde\xbe\xbe\xdf\x7c\xef\x12\
\x02\x94\x73\x91\x59\x2f\xae\xc5\xbf\xd6\x38\xcb\x57\x22\x93\xd2\
\xd6\x5c\xcb\x75\xe0\xb5\xf8\xff\x93\xdc\xf7\x45\x99\x80\xf6\xbd\
\x56\x1e\x90\xf4\x7d\xe0\xcd\x81\x17\x81\xc9\x42\xc9\x7b\x86\x4d\
\xda\x96\xc0\x94\x96\x1a\x4a\xd7\x23\xe3\xdc\x1e\x8b\x24\x39\x78\
\x2e\xda\xa6\xf9\xd3\x21\x94\xad\x22\xdb\x3e\x45\xf1\xa2\x12\x94\
\x66\xdb\x4d\xe7\x58\x45\x5d\x40\x94\x3b\x69\xfd\x27\x2e\x7d\xde\
\xfb\x6e\x0b\x2a\xeb\x76\xb1\xfb\xb1\x2a\x41\x49\x8f\xa9\x59\x21\
\x6f\x19\xe9\xf2\x6a\x24\x15\xf7\x3b\xa8\x6f\xe8\xaf\xa7\xdf\x80\
\xa5\xeb\x62\x8f\x35\x9d\xc3\x09\x15\xfb\xbb\xa5\xb7\xb4\xd7\x5a\
\x9f\xdf\x73\x90\xd4\xf5\x5a\xdd\x0b\xbc\x1c\xc9\xea\xda\x60\x70\
\xaa\xa2\x75\xe0\xff\x20\x99\x3f\xbf\xec\x7c\xf6\xd1\xc0\x3f\x21\
\x60\xfa\x0a\x79\x40\x24\xed\x45\x20\x5d\x03\xa3\x7f\x45\x32\x11\
\xed\xff\x24\xfa\x5d\x61\x78\x12\xd6\xdc\x67\xec\xb1\x95\xac\x24\
\x0b\xa5\x5c\x63\x62\xad\x1d\x6b\x2d\xe5\x5c\x75\x1e\x94\x3e\x85\
\x0c\x53\x78\x06\x6d\x22\xd6\xed\xa0\x83\x19\xbe\x87\x72\x16\x52\
\xce\x5d\x97\xeb\xec\xea\xba\xbd\xd7\x07\x00\x35\x15\x18\x8d\x01\
\x22\x7d\xb2\x25\x12\x47\x9f\xcb\x81\xc4\x53\x44\x74\x3d\x4e\x26\
\x2a\xba\xa1\xd6\xee\x39\xbd\xac\x01\x51\x2a\x1f\x40\x5c\x4d\x67\
\x02\xdf\x4e\xb9\xd1\x3f\x1d\xc9\x1a\xbb\x4f\x1d\x8b\xbd\x6e\x09\
\x48\xbb\x2b\xae\xc5\x6d\xf8\xbf\x4b\xda\xf7\xf1\x94\x1f\x43\xa1\
\x75\x27\xf0\xeb\x88\xd5\xa7\x67\x10\xb7\x6e\xaf\x77\x21\x10\xf6\
\xe2\x4f\x87\x01\xaf\x42\x66\xbc\xf8\x3a\x75\x0d\xfe\x29\x95\xc7\
\x97\xac\x22\x7b\xaf\x58\x08\x6d\x38\xef\x41\x6d\xaf\x81\x92\x96\
\xbd\xc6\xcb\xce\x32\x35\x12\xde\xf3\x95\x4a\x56\x52\x4d\xdc\x68\
\xbf\x53\xbf\x11\x49\xe6\x38\x13\x78\x02\xcd\x4a\x9a\x67\x1d\x44\
\x9c\x29\x57\x0b\xa1\x52\x1b\x0c\xc3\xed\x4c\x68\x21\x6d\x39\x8c\
\x26\x00\xa2\x9c\x15\xd4\x05\x46\x5d\x65\x1b\x14\xbb\xdf\x9c\x4b\
\x4e\x83\xc9\x7b\xda\x68\x8a\x47\x2c\x67\xb6\x25\x78\xad\x01\x9f\
\x46\x06\x2d\x9e\x82\x40\xe9\xf1\xf8\xb1\x9c\x83\x81\x17\x21\x0f\
\xc4\xb3\x6e\xc7\xf4\xfe\x25\x24\x1e\x70\x58\xc5\x35\xb8\x4d\xd5\
\xed\xb5\xdd\x89\xcc\xcb\xd7\xa5\x81\xfa\x4b\x64\x82\xd9\x55\x86\
\x1b\x77\x5b\xff\x34\x71\x32\xc4\x31\xc8\xb3\xa5\x7e\x08\x71\x4b\
\xe6\x60\xf4\x28\xea\x32\xfb\x3e\x8b\x58\x5b\x3b\x18\xb6\x9c\x3d\
\x4b\xd7\xde\x5f\xfa\x37\xb7\x96\x92\xb5\xa6\x2c\x94\xec\xfd\x6f\
\xa7\x18\x4a\xf7\xbc\x7d\xc0\x61\x0e\x4a\x16\x3e\x1a\x4e\xd6\x0a\
\x8a\x60\x94\xca\xa7\x11\xab\xfb\xb9\x48\x9a\x70\xd3\xfc\xe9\x40\
\xca\x20\x8a\xdc\x73\x5d\x5c\x74\x56\xfa\xff\x31\xa0\x59\x8a\x19\
\xd9\x3f\xa0\xae\xe7\xe0\x63\x2f\x4c\x17\x10\x79\xa4\xb6\xd0\xb1\
\xf2\x08\x6f\x1f\x41\xe0\x59\x47\x1a\x40\xd6\x2a\xb2\x53\x0d\x59\
\x57\x8c\x85\x57\x2a\x5f\x41\x1a\xe1\xa3\x91\x86\xe1\x69\x0c\x8f\
\xe3\x39\x99\xfe\xf8\x1c\xdb\x43\x49\xd7\xe6\x74\xe7\x3c\x3d\xdd\
\x6e\xd6\xf5\xf5\x7d\x2c\xdd\xdc\x37\x97\x22\x01\xf2\x08\x44\x7a\
\x7d\x1d\x89\x57\xe5\xb4\x1b\x79\x12\xed\x79\x66\x1f\x30\xf8\x5b\
\xbd\xac\xf2\xf8\x5e\x4f\x1f\x44\x1e\x8c\xf4\xb1\xd9\xa7\x0b\xeb\
\xef\x8f\xfe\x94\xe9\x98\x6c\x7c\x49\x2b\xb2\x42\xf5\xbd\xa2\xef\
\x0b\xfb\x34\x5a\xdd\xb0\xa4\x6d\x39\x6b\x28\x41\x49\x3f\x96\xda\
\x83\xd1\x7e\x24\x4e\xf7\x7a\x64\xf0\x70\xed\x23\x50\x9a\x66\x47\
\x4b\x48\x67\x75\x0f\x3e\x80\x72\x20\xaa\xb1\x8c\xf4\xf7\xa4\x65\
\x68\x15\xc1\x16\xc3\x28\x63\x15\x95\x40\x14\x01\x28\x5a\xd6\x52\
\x5a\xcb\x36\x08\x91\x8b\xa5\xf4\x5a\x0e\x4a\x5e\x03\x92\xc0\x64\
\x61\xe4\xc5\x09\xec\x8d\x91\xf6\xf3\x75\xc4\xfa\x39\x0f\x99\x31\
\xfc\x39\xf4\x1f\x45\x7d\x25\xfd\xe7\x91\xa4\xcf\x1c\x87\x58\x13\
\x07\x23\x63\x95\x9e\x55\xb8\x36\x20\xb1\x9d\xfb\xf0\x1b\xcc\x25\
\xba\x4d\x0a\xbb\x06\xfc\x1d\xf5\x20\xda\xa0\x0c\x23\x10\x18\xea\
\x7d\xda\xdf\xf4\x58\xe4\xda\x94\x74\x0d\xd2\xfb\xb7\x30\xd2\xfb\
\x5b\x67\xd0\x2a\xf2\x1e\x2b\x5f\x82\x92\xb5\x94\xf4\xb6\xa4\xc8\
\x4a\xd2\x8d\x81\x77\x9f\x58\xf7\x9d\x06\x54\x7a\x06\x95\xe7\xaa\
\xb3\x56\x92\x06\x53\x2a\xfa\x59\x56\xe7\x01\x4f\x44\x92\x49\x46\
\xf5\x3a\x34\x4d\x47\x07\x03\xdf\xc0\x07\xd0\xb8\x2e\x3a\xdb\x96\
\x87\x20\x4a\x19\x75\x5b\x06\xa3\x11\x41\xe4\x59\x3d\xe7\x22\x8d\
\xe7\x83\x91\x46\xf5\x0e\x64\x5c\xc4\x97\x7b\xe5\x3a\xb3\x8f\x9c\
\x65\x94\x64\x1b\x03\x6f\x3d\x92\x67\x21\x69\x8b\x48\x37\xae\xde\
\x0f\x6a\x1f\x3b\xd0\x05\x48\x7a\x7d\x1d\x89\xc1\xbc\x1d\x78\x37\
\x32\x70\xf1\x60\xe0\x4b\xbd\x63\x4b\xef\x7b\x2a\x32\xf8\xb3\x6b\
\xc3\x71\x3b\x71\x83\x79\x10\x32\x13\x74\xad\x2e\x44\x00\xba\x83\
\x18\x42\x16\x48\x77\x16\xf6\x79\x07\xf2\xe4\xdd\xe4\x1a\xc5\x59\
\x7e\x1f\xbe\x3b\xd3\xea\xcd\xf4\x63\x45\x16\x46\xd6\x3d\x67\x07\
\x52\xa3\xde\xbb\x6c\xde\x0f\xc3\xd7\xdd\x3b\xd6\x1a\x0b\x29\x77\
\xdf\xa4\xd7\x3c\x4b\xc9\xb3\x92\x2c\x9c\x74\xca\x77\x5a\xd7\x0f\
\x52\x5c\x63\x10\x4e\x1f\x41\x66\x13\x79\x2e\xe2\xfe\x69\x9a\x0f\
\x1d\x48\x77\x4b\xa8\xe4\xa2\x4b\xf2\xda\x5c\x0b\xa5\x81\xf5\x69\
\xb9\xe9\x3c\x30\xe5\x40\xb4\x02\xfc\x67\x64\xf4\xfc\x89\x85\x7d\
\xdf\x8a\x64\x58\xbd\x16\xc9\x84\xf2\xa0\x07\xc3\x56\x4d\x4d\x59\
\xc2\x6f\x2c\x3c\x58\xd9\x04\x87\x54\xd7\x50\xb2\x0d\x49\x2d\x90\
\xf4\x4d\x63\x63\x50\xc9\x6d\xf4\x25\xe7\x7d\x2b\xc0\xf7\xf8\x97\
\xad\xa8\xdb\x89\x67\x44\x3f\x91\x6e\xb1\xa2\x4f\x20\xf7\x9e\x1e\
\xd8\x9b\xb3\x8a\xd6\xc9\xc7\x79\xee\x01\x7e\x15\x69\x10\xb5\x65\
\x84\x5a\x1e\x02\x7c\x67\xc5\xb1\xdd\x0e\x7c\x88\x41\xab\x28\x07\
\xa3\xb5\xe0\x3d\x2b\xe6\xbd\xcb\xaa\x5e\xb2\x90\xa2\xfb\xcb\xeb\
\x6d\xda\xfb\xca\xde\x43\x16\x4c\xe9\x7e\x48\x71\x23\x0d\x22\x6d\
\xf1\xac\x32\x08\x2a\x0b\x26\x6b\x25\x5d\xde\xbb\x76\x2f\xa1\xc5\
\x91\xe6\x45\xba\xc3\x55\x6a\x77\xba\x5a\x46\x98\xe5\x6c\xb8\xe9\
\x32\xd3\xfd\x78\x34\xb5\x6e\xb7\x13\x80\x3f\x07\x9e\x59\xf9\x75\
\x0f\x04\x7e\x1a\xf8\x49\xa4\xa7\xfc\x5a\xe0\x33\x6a\xff\x49\x5e\
\x8f\xd4\x7b\x7c\x41\xf4\x48\x03\xcf\x4a\xb0\x6e\x3c\xfd\x23\xe8\
\xa5\xd7\x70\xd8\xf3\xae\xb5\x92\xa2\xa5\x85\x54\xda\x76\x05\x62\
\x35\x75\xd5\x6d\xf8\x0d\x29\xd4\x25\x3f\x24\xdd\x81\xc4\x1b\x52\
\xa3\xe8\x5d\x57\x3b\x40\x78\x99\x78\x6a\x9a\xbd\xc0\xff\x83\xb8\
\x23\x35\x00\x30\xcb\x17\x52\xd7\x6b\x7f\x67\x6f\x59\x82\xd1\x1a\
\xc3\x13\x43\x5a\xa8\x58\x28\xe4\xac\xf4\xd2\xbd\xa5\x3f\x63\xef\
\x2b\xaf\x43\x62\x61\xa4\x3b\x2a\xfa\xfe\x48\x89\x0c\xda\xf2\xd1\
\x19\x77\x6b\xf8\x50\xb2\xee\xba\x35\x24\xdb\xee\x75\xc0\xbf\xa7\
\xef\x26\x6e\x9a\x5d\x45\x89\x09\xe3\xba\xe6\x72\xf7\x79\x08\xa5\
\x69\x58\x46\x91\xf9\xe6\x81\xe8\x7b\x80\x3f\x61\xb4\x1b\x7b\x05\
\x71\x1b\x3c\x17\x79\x24\xc3\x1f\x21\x73\xb4\xd9\x8b\x91\x73\x11\
\xe9\x3f\x77\x04\x26\xbd\x1f\x9c\x6d\x1e\x94\x6c\x03\xe2\x81\xc8\
\xb3\x9a\xa2\x98\x91\x07\xa0\xa8\x81\xfa\x23\x64\x06\xea\x67\xd0\
\xcd\xa5\x72\x20\xc3\x0d\x6a\x52\x17\x18\x5d\xa4\xce\x27\x82\xbc\
\x3d\xee\x75\xfc\xc7\xb9\xef\x45\xa6\x08\xba\x94\x41\x10\xd9\xdf\
\x62\x95\xfe\xac\xdb\x39\xed\x41\x3a\x30\x16\x44\xfa\x9e\xd1\x56\
\x88\xb5\x8a\x50\xef\xb1\x56\x91\x3d\x27\xef\x73\xde\x3e\xec\x36\
\x7b\x1f\x95\xc0\x54\xb2\x92\x12\x54\x6d\x87\xc6\x5a\x49\x7a\x99\
\x2b\x37\x23\x1d\xc0\xef\xa5\x3c\xbd\x54\xd3\x74\xb5\x4a\xec\x7a\
\x8b\x40\x14\x6d\xcb\xb9\xea\xac\x3c\xef\xd4\xe6\xc3\xa8\x30\x09\
\x6a\x8e\xaa\xbf\x00\xfc\xc6\x84\x0e\xe3\x51\xc8\x34\x30\xef\x42\
\xc6\xa4\xdc\xc6\x70\x2f\xd6\x73\x0d\xd9\x92\x03\x13\x6a\x7f\x76\
\x69\x7b\xb4\x1a\x48\xe9\xc7\xf4\xa0\x14\xb9\x5c\xac\x75\x64\x7b\
\xbd\xba\xb1\xb1\x8d\xd3\x1a\x92\x05\xf5\x36\x04\x48\xcf\xa1\x6e\
\xaa\x97\x47\xd2\x1f\xb3\x64\x3b\x14\xcb\x15\x9f\x4f\x4a\x30\x82\
\xe1\xeb\xa7\xaf\xa9\xbe\x3e\x4b\xc8\x23\x36\xb4\xae\x02\xfe\x14\
\xb1\xb2\xac\x85\x05\x83\xbf\xc9\xb3\xa9\x3b\xc7\x0b\x11\x20\xa5\
\x3f\xa9\xfd\x73\x59\xcb\x28\xf7\x9e\x74\xcf\x78\x99\x93\xe9\x78\
\x73\xc0\xc3\xa9\xa3\x3e\xe7\x7d\xde\xb3\xc4\x73\xb1\x4a\x7d\x6f\
\xd8\x98\x92\x57\x6a\x60\xb4\x8e\x0c\x8e\xfe\x7b\x64\xe6\x8c\x36\
\x03\xf8\xec\x2a\x0d\x1f\xf1\x3a\xbe\x5e\x19\xc5\x32\x42\xd5\x43\
\xab\x08\xb6\xde\x32\xb2\x8d\x32\x66\x3d\x95\x33\x81\x5f\xd9\x84\
\xef\xfe\x0e\xa4\x01\xfe\x1b\x24\x0b\x28\xa5\x3c\xe7\x00\x14\x95\
\x25\x06\x1b\x4f\x1d\x4f\x89\x7c\xfe\xba\x01\x41\xd5\x75\xa3\x6b\
\x7b\x29\xa5\xde\x4a\xce\x3d\xe7\x01\x2a\x7d\x66\x3f\xe2\x92\x7a\
\x2f\x92\x14\xf2\x5c\x60\x77\xe6\xfa\x1d\x84\x4c\xa3\xf3\x4f\x0c\
\xdf\x70\x36\xe5\x3b\xa7\xaf\x32\x08\xa3\xb4\xb4\x0d\xa8\xbe\x36\
\x20\xd0\xf9\x34\xf2\x20\xbc\x4b\x80\x7f\x61\x70\xd2\xd6\xc8\x3d\
\x07\x32\xd6\xaa\xa4\x0d\x64\x6c\xd1\xd3\x90\x64\x8c\x87\xf6\xbe\
\xeb\x2e\xc4\x05\xf8\x29\x64\x4c\x94\x3e\x3e\x9b\x94\x60\x2d\xa2\
\x1c\x90\xbc\x3f\xad\x3d\x9e\xdc\xba\xde\x3e\x2a\x94\x6c\x9c\x51\
\x03\x29\x6d\x1b\xb5\xac\xd3\x07\x52\x9b\xb1\x61\x36\xa5\x61\x54\
\xd3\xde\x2c\x31\x0c\x2c\xaf\x43\xe6\xb5\xf3\x59\x10\x2d\xf5\x52\
\xea\x26\x71\x52\xa1\x8c\x65\x14\x59\x08\xfa\x24\x77\x22\x3d\xd4\
\x33\x36\xf5\xc0\xa4\x67\xfd\x0a\xc4\xc5\xe3\xc1\x68\xcd\x2c\xa3\
\xba\xfe\x5c\x8d\xdf\x1f\x86\x2d\x8b\x52\x2f\xa4\x74\x93\xe4\x46\
\x4e\xe7\x06\xb3\xd9\x72\x3a\xf2\xcc\xa1\x33\x19\xbc\xb9\x92\xd6\
\x81\xdf\x46\xd2\x41\xf5\x8d\x76\x1a\xf2\x8c\xa0\x1a\xfd\x2a\x92\
\x70\x00\xc3\x30\xf2\xac\x54\x5b\x6a\xaf\x7b\xd2\x59\x4c\xce\xc2\
\xbe\x06\xf8\x0b\x24\x51\x22\x1d\x8b\x8d\xa3\xec\xcb\x94\x5c\xcc\
\x45\x9f\xa3\xe7\xba\xf4\x94\xbb\x8f\x60\xb8\x27\x5b\x73\x1f\x79\
\xc5\xce\xdc\xb0\x43\x2d\x53\x39\x40\x2d\x75\x39\x12\xf8\x4f\xb4\
\xa4\x86\x59\xd4\xbd\x48\xe8\x62\x0f\xe2\xf1\xb8\xb7\x57\xee\x51\
\xcb\x7b\x90\xd9\xfa\xef\x31\xaf\xa5\xa1\x1e\x7b\x54\xd9\xcb\xf0\
\xbd\x5e\x73\x7f\x03\x9b\x6c\x19\x15\x40\xa4\xeb\xba\xfc\x5f\x6c\
\x3e\x88\x40\xac\x80\x3f\x41\xd2\x78\xff\x11\xb9\x90\xb6\xd1\x5b\
\x33\x75\xdd\x8b\x5c\x52\xef\xd5\xbd\x78\x6d\x25\x45\xee\x96\x54\
\xcf\x35\x26\x9e\xb5\x14\x35\x26\x5e\x7c\x28\xb2\x98\xbc\xf1\x4a\
\xa9\x5c\x82\xcc\x7f\x77\x3c\x02\xa5\x27\x21\x0d\x4a\x52\xb2\x42\
\x74\xac\x64\x09\xb1\x5a\xd6\xd5\xeb\x39\xed\xa4\xff\x08\x6f\xdb\
\x7b\xb7\x2e\x3b\xcf\x9d\xb5\xac\x5e\x4f\xeb\xda\x2a\xb5\x3d\xb0\
\x1a\xab\xa8\x56\x0f\x41\x60\xfa\x0f\xc8\x6c\xe8\x16\xd8\x35\xd6\
\xb5\xbe\xde\xd6\x0a\xd4\x16\x4d\x4e\x1b\x99\xf7\xe9\xeb\x65\xf7\
\x5d\x63\x29\xd5\x5a\x49\x3a\xdd\xdb\xeb\xac\xa5\x72\x2b\xf2\x08\
\x8e\x1f\xa2\x4d\x1f\x34\x6b\x4a\xed\x40\xae\x23\xec\x59\x43\xb6\
\x50\xb1\x0d\xb5\xcd\xbd\xbf\xa7\x39\x03\x83\x77\xc0\x27\x20\x30\
\xda\x2a\x2d\x23\x49\x12\xe7\x20\x56\xd2\x55\xd4\xb9\x27\xb4\x8b\
\x4c\xc3\x49\xbb\x6e\x46\x81\x52\xaa\xdb\xe2\xc5\x93\x72\x30\xf2\
\x5c\x76\xd6\x4d\x97\xb3\x90\xae\x45\x66\xd1\x7e\x13\x12\x53\x7a\
\x26\x32\x38\xf6\xcb\xc0\x4d\xce\x71\xde\xd9\x7b\xad\x66\x26\x87\
\x9d\xe6\x7c\x3d\x69\xc8\x44\x7f\x00\x7b\xd3\xdb\xcf\x83\xcc\x3e\
\x31\xe9\x8e\xcd\x2e\xa4\xa7\xbf\x82\x3c\x41\x37\x29\x67\xd1\xa5\
\x7b\x26\x17\x3f\xb2\xd0\xd5\xfb\xf5\xfe\xc0\x3a\x16\x59\x82\x92\
\x07\x3b\x0d\x43\x7b\x2f\xa5\xe3\xf4\x5c\x8d\x9e\x95\x1a\x81\x28\
\x95\x2b\x80\x77\xd0\x6d\xde\xc2\xa6\xcd\x57\x57\xe8\x78\xa0\xc2\
\x59\x07\xff\x3f\x99\xed\x68\x4d\x2b\x66\x94\xea\xf6\x64\x5e\x80\
\xf4\xb8\xb6\x5a\xbb\x81\x3f\x44\x02\xfb\x6f\x67\xd0\xbc\xcc\xd5\
\x53\xc3\x9e\x80\xe1\x41\x29\x8a\x25\x45\xf5\xa8\xa7\x91\xf6\xa9\
\x1b\xb1\x74\x63\xd8\x31\x47\x91\x75\x64\x81\x54\x72\xdb\xdd\x86\
\x58\x8e\xe7\x21\x8d\x70\x3a\x17\xcf\x6f\xfc\x6f\xd4\xc1\xe8\x30\
\xfa\x40\xd3\xe7\x8b\xd9\xa6\x41\x6d\x6f\x74\xef\xfd\x9e\x6a\x32\
\xe8\x46\xd5\x77\x22\x31\xac\xbd\x0c\xbb\x1d\xd2\x18\x2a\xfd\x1b\
\x78\x96\x91\x05\x82\x8d\x29\xda\x64\x05\xaf\xf3\xa2\x15\xbd\x3f\
\x4a\x96\x48\xbf\x9d\xe7\x16\xd4\x96\xd2\xb8\x65\x03\x01\xf7\xf1\
\xc8\x3c\x8a\x4d\xb3\xa1\x64\xa9\xd6\x82\xa7\xd4\x29\xc4\x59\x2f\
\xe9\xfe\xfb\x74\xab\x60\x54\x82\x50\x2a\xdf\xb1\x45\xc7\xe3\x69\
\x07\xf0\x52\xc4\x4a\xfa\x3f\xc8\x0c\x01\x7a\x54\x7a\x6a\x54\x52\
\x7d\x99\xc1\x69\x76\x12\x88\xd2\x52\x2b\x4a\x70\x88\x7a\xb4\x10\
\x5f\x23\x6d\x25\x2d\xab\x6d\xd6\xf7\xef\xb9\xee\x3c\xab\x28\x82\
\x52\x34\xa8\xd6\x96\xf4\xfd\x9f\x42\xe6\x29\x3b\xc6\x39\x27\xad\
\x67\x20\x73\xea\x95\x54\x73\x53\xdb\x9e\x96\x5e\x3f\x0a\x71\x33\
\xd6\x68\x1f\x32\x10\xf7\x52\x64\x18\xc1\x33\x29\x9f\xc7\xd1\xc8\
\xbd\xf2\x89\xde\x7a\x94\xb4\xe0\x59\x14\xfa\x5a\x6e\x98\x65\x92\
\xbe\xee\x56\x35\x81\xde\x92\x45\x55\x63\x25\xe9\xed\xa3\x00\xc8\
\x96\xf3\x90\xe7\x66\x3d\xb8\xe2\xf8\x9b\x36\x5f\x39\xe0\xd8\xd0\
\xc0\x38\x50\xf2\xac\xa4\xa1\x7b\x78\xd3\x60\x54\x48\xe9\x86\xe1\
\xc6\x76\x99\xfa\x09\x3b\x37\x53\xa7\x21\x8f\xb5\xfe\x5b\xe0\xa3\
\x0c\x06\x9c\x93\x0f\xdd\x42\x28\xad\xa7\x73\xb1\x60\xb2\x56\x92\
\x06\x8e\x0d\x50\x47\xbd\xe0\xc8\x4a\xd2\x60\xb2\xee\x1f\x0f\x4a\
\x91\x9b\xce\x6e\xd3\xef\xb7\x83\x24\x2d\x8c\xd2\xfb\xff\x09\xf8\
\xd9\xdc\xc5\x45\x52\xc4\x1f\x82\x64\xa6\xe5\x94\x0b\xdc\xe7\x94\
\xae\xd7\xf3\xa8\x8b\x51\x7c\x13\x99\x6c\xf6\x7a\xfa\xe7\x76\x05\
\xf2\xc8\xf4\xd2\xec\xde\xe7\x22\x16\xa1\xd7\x60\x27\xeb\x48\xc7\
\x5c\xbc\xeb\xa9\x61\x00\x83\x16\x8b\x75\xe3\x75\x55\xad\x2b\x2f\
\x1d\x83\xbe\x1f\xb5\xdb\xd1\x5a\x49\xde\xf9\xda\x84\x92\x08\x4c\
\x6f\x04\x7e\x9e\x41\xf0\x36\x4d\x4f\x7a\x16\x06\x18\x6e\x67\xba\
\x00\x08\x67\x5b\xb5\x95\xb4\x95\x6e\x3a\xef\x00\xf5\x09\xed\xa0\
\xdc\x1b\xdd\x2a\x1d\x88\x4c\x3f\xf4\x18\x24\x3d\xf5\x6e\x06\xb3\
\xa5\x74\x70\x37\x81\x68\x3f\x83\x60\xd0\x40\xd2\xd2\x70\xf0\x7a\
\xad\xe9\x3d\x50\x86\x52\x4d\x40\xda\xab\x47\x16\x51\x14\x57\xf2\
\xe0\xe6\x59\x48\x17\x23\x33\x71\x3f\xd1\xbb\xa8\x4a\xdf\x8e\x58\
\x9f\xf6\x1c\xa3\x46\x37\xb7\xdd\xd3\x41\xc8\xd8\xa2\x92\xd6\x81\
\xff\x17\xb1\x82\x75\x06\xe2\x1d\x48\x0c\xec\xb1\x85\xcf\x3f\x90\
\xe1\xc1\xb6\xba\x21\xd6\x09\x00\xd6\x42\xd2\x9f\x4b\x75\x7d\x4e\
\x9e\x65\x64\x7f\xf3\x48\x91\x3b\x2f\xf7\xd9\x64\x71\x6b\x20\x69\
\x50\x59\x77\x5e\xc9\x22\x8a\xac\xa3\x6b\x10\x2b\xfa\x09\x99\xe3\
\x6f\xda\x7a\x79\x96\x8c\xd7\xe6\xd8\xf7\x7a\xaf\x77\xf9\xce\xfb\
\xef\xc5\x69\xc4\x8c\x22\x02\xa7\x01\x75\xb3\xd4\x63\x7a\x0a\xf0\
\x30\x24\x9d\xf7\x0a\xfa\xd6\x91\x86\x92\x6d\x94\x13\x94\x6c\xa9\
\x8d\x27\xe9\x86\x22\x82\x92\x85\x51\xc9\x95\x96\x7b\xcd\x83\x54\
\x6e\xde\x3b\xcf\x3a\xd2\x16\xd2\xdf\x20\xe9\xbc\xb9\x07\xff\x9d\
\x0a\xfc\x20\x12\xa3\xbb\x57\x6d\xf7\x1a\x2f\x0b\x2a\xbb\xdd\xd3\
\x73\xa8\x9b\x5d\xe2\x42\x24\x4d\xdb\x73\x51\x5e\x43\x19\x46\x47\
\x32\x3c\x07\x9d\x75\xd1\x59\x0b\x29\x72\x63\x79\x56\x9c\x77\xee\
\xfa\x77\xd7\xef\xd1\x9f\xc9\x35\x0a\x1e\x90\xac\xeb\xce\x42\x2f\
\x82\x6d\x04\x1c\xef\x77\xd3\xc7\xfa\x0e\x24\xe5\x5e\x67\x6a\x36\
\x4d\x47\x3a\xac\xe0\x59\x3c\x39\x6b\x28\x07\xa0\x12\x9c\x86\x3a\
\x45\x5b\x01\x23\xef\x80\x3c\xd3\x6e\x2f\x92\xf3\x7e\xf6\xa6\x1f\
\x51\x37\x3d\x08\x19\x80\x7b\x1e\xf0\x1e\xfa\x30\x5a\x41\x80\x14\
\x35\xce\x1e\x94\xac\x95\x04\xc3\xae\x3b\x9c\xf5\xd4\x6b\x4d\xdb\
\xed\x0d\xb1\xcc\x60\xe3\x91\xb3\x5e\xd2\xf1\x5a\x57\x90\x07\xa8\
\xd2\xd2\x2b\x6b\xc0\x9f\xf5\xae\x59\x2e\x36\xf0\x58\xc4\x5d\xf7\
\x1a\x64\x20\xac\x3e\x67\xdb\xc8\x01\x3c\x02\x79\xcc\xf8\x61\xc8\
\x94\x3d\x97\x39\xef\xa1\x77\x6e\x35\xb1\xc7\x7d\xc8\x80\x5f\x7b\
\xfc\xda\x32\x2c\x69\x47\xef\x78\xee\x20\x86\x91\x85\x92\x17\x37\
\xd2\x96\x51\x52\xea\x64\xa4\x65\xd4\xb8\x5b\x28\xd5\x58\x4d\x11\
\xcc\x3c\x28\xe9\xcf\xa4\x62\xad\xa4\x52\xd1\xfb\x07\x99\x32\xe8\
\x7c\xc4\x42\x6e\x9a\x9e\xb4\x35\xdc\xd5\x2d\x17\x59\x46\x11\x84\
\xf4\xe7\xdc\xfb\x73\xda\xa9\xdd\xb6\x7c\x9c\xd9\x83\x11\x48\x63\
\xf1\x12\x24\xde\xf1\x37\xc8\x8c\x03\xda\x55\x97\xa0\xa4\x1b\xfd\
\x54\xec\xba\xb6\x92\x92\xac\x4b\xc6\xfb\x03\x7b\x8d\x06\x0c\xf6\
\x62\x6d\x8f\x56\x37\x78\x4b\x0c\xc3\xa6\x04\x23\x2f\x45\xdc\x5a\
\x4f\x5e\xb9\x13\x19\x1c\xfb\xe3\xe4\x7f\xcf\x07\x20\xb1\x99\x8f\
\x22\xb3\x1f\x7c\x99\x7e\x43\x7d\x38\x02\xab\x53\x90\x44\x01\x3d\
\x9d\xcf\x09\xc4\x33\x74\x3c\x85\xba\x39\xd1\x3e\x8e\xb8\x5f\xf5\
\xfc\x5c\xfa\x3a\x79\x73\xe1\x45\xd2\x50\x89\x60\x54\xb2\x8e\x3c\
\xcb\x48\x03\x29\xb2\x3a\x30\xf5\x1c\x68\xc0\x6f\x28\xec\x7b\xf5\
\x7e\x46\x81\x4f\xce\x3a\x4a\x7a\x0f\xf2\x5b\x75\x99\xd7\xb0\x69\
\xb2\xca\x75\xb8\x4a\x60\xa9\x75\xcd\x59\x68\x85\x1d\xa5\x69\x4e\
\x94\xaa\xd7\x35\x8c\x7e\x7a\xcb\x8f\xa8\x5e\x8f\x04\x7e\x1d\xe9\
\xcd\x5f\x4c\xdc\x18\x97\x2c\x24\xcc\xb2\xe4\xba\xb3\xf5\xb4\x6e\
\x41\x64\x61\xa4\x5d\x78\x1e\x78\x96\x18\x3e\x5e\x6f\x2c\x8c\x07\
\xa1\x9c\x75\xb4\x8c\x24\x06\xbc\x02\x99\x42\xe8\xbb\x89\x93\x09\
\x96\x91\x67\x2c\x3d\xb5\xb7\xcf\xbb\x7a\xdb\x73\x8d\xd4\x55\xc4\
\xbd\xef\xe7\x67\x3e\x97\xb4\x01\xbc\x1f\xbf\xa3\x90\xb6\xd5\x3c\
\x9a\x7c\x83\xbe\xbb\x36\xc1\x5f\xc7\x89\xac\x8b\x4e\xc3\xc8\x3b\
\x76\xf0\x3b\x19\xa5\x86\x5e\x2f\x51\xaf\x5b\x6b\xda\x7b\xaf\x77\
\x4e\x56\x11\x10\x6b\xac\x21\x6f\x9f\x4b\xc8\xfd\xf1\x3e\xe0\xc5\
\x99\x63\x69\xda\x5c\x69\x8f\x4b\x0e\x30\x35\x56\x4f\xc9\x25\x57\
\xd4\x56\xa7\x76\x7b\x27\xae\xd7\x3f\x86\x34\x46\xd1\xe3\x02\x66\
\x41\x87\x21\xcf\x55\x3a\x1f\x78\x2b\x32\x25\x86\xb6\x92\x22\xf7\
\x98\xb5\x92\xf6\xf7\xf6\xe7\xfd\x50\xa9\x61\xd3\xeb\x5e\x5d\x6f\
\xb3\x37\x8c\xb5\x96\xac\x75\xe3\x81\xc8\x42\x46\x67\x82\x59\x08\
\x95\xac\xa3\xf4\x9e\xf3\x90\x80\xf5\xf7\x01\x8f\x73\x8e\x5d\x6b\
\x99\x72\x4f\xf9\x73\x48\xa6\xa3\xd7\xf0\x9d\x09\x9c\x54\xf8\x3c\
\x88\x3b\xf8\x66\xfc\xe7\xb9\x74\xb1\x8c\xf6\x98\xcf\x7a\xd0\xd1\
\x2e\x3a\xed\xaa\xf3\x8e\x5f\x5b\xcd\x69\xde\xc4\x2e\x30\x8a\xb6\
\x59\xb0\x69\x45\xf7\x93\xae\xdb\xff\x6b\xce\xf2\x29\x59\x44\x7a\
\x5f\x9f\xa4\xc1\x68\x9a\xd2\x31\x69\x4f\x35\x2e\xb7\x2e\xaf\x65\
\x35\xad\x6c\x3a\x6f\xfb\x12\x12\xcc\x7e\x3b\xd2\x70\xcd\xb2\x96\
\x90\x20\xf9\xc3\x91\xd9\xc0\x53\x36\x96\x6e\x94\xb4\xeb\x2e\x35\
\x58\x51\x1c\xc9\xba\xee\xd2\x1f\x58\x03\x49\x6f\xf7\xd6\x75\xa3\
\x81\xaa\x2f\xab\xd7\x72\xb1\x1f\x0b\xa7\x68\xb6\x00\xbd\xad\x06\
\x48\xcb\x48\x32\xc0\x1f\x22\x96\xe5\x0b\x90\xd8\x4f\xd7\xa9\x61\
\x6e\x40\x52\xc7\x3f\xc1\x78\x56\x11\x48\x8f\xdc\xfe\x0e\xb6\xd4\
\x58\x46\xf7\x12\x5b\x96\x1a\xe2\x1a\x50\xf6\xb1\xe8\x1e\x0c\xb4\
\xb5\x9c\xae\x79\x57\x18\x45\xeb\x4b\x0c\x7f\x6f\xce\xea\xf6\xb6\
\x2d\x3b\xdf\xed\xed\x2b\x07\xa2\x25\x24\x9d\xfe\x1a\xc4\x1d\xdb\
\xb4\xf5\xb2\xed\x0b\xf8\x30\xa9\x85\x8e\x67\x51\x55\x6b\x9a\x31\
\x23\xf0\x4d\xbf\xd7\x33\xfb\x30\x4a\x3a\x09\x89\x5d\xbc\x01\x71\
\x31\xd6\xb8\xed\xac\x95\x94\x20\x05\xfd\xeb\xa0\x6f\x12\xef\x86\
\xc9\xb9\x5b\xbc\x9e\xb0\x67\x31\x95\x2c\x25\xcf\x42\xf2\xdc\x73\
\x39\x20\x59\x6b\xea\x22\x64\xfe\xbb\xc3\x90\x01\xa9\x4f\x46\x32\
\xeb\xa2\x9b\x76\x1d\x49\x6e\xf8\x20\xe2\x56\xdb\x47\xdc\x20\x3f\
\x11\xb1\x8c\x4a\xba\x92\xfe\x83\xf8\x60\xf8\xfe\x4b\xf5\x1a\xcb\
\xe8\x16\x62\x0b\xd3\x82\xc9\x8b\x17\x9d\x84\xa4\x38\x9f\x8d\xc4\
\xc4\x8e\x40\x26\x14\xbd\x19\x69\xa4\xaf\x46\xac\x87\xf3\x11\xf0\
\xe9\x98\x62\x8d\x75\x12\x15\x0f\x48\x90\x07\x89\x56\x3a\x7e\x0f\
\x4a\xd1\xe7\x22\xe8\x7f\x8a\x06\xa3\x69\x49\xb7\x2d\x35\xf0\x29\
\xb9\xe3\xc6\xd2\xa6\xc0\xa8\xe2\x19\x46\x7a\xa9\xb7\x2f\x01\x9f\
\x47\x02\xd9\xa7\x6e\xc2\xa1\x6d\x86\x76\x01\xff\x11\xc9\xf6\x7a\
\x1d\xe2\x66\xcc\x59\x0b\x5d\xac\x24\xdd\x43\xf6\xac\x24\xaf\xf7\
\x6a\x5f\xcb\xb9\xef\x6a\xb3\xe4\x6a\x13\x1e\x4a\xdb\xd3\x75\xf9\
\x06\x12\xc0\x7e\x2f\x32\x57\xdd\x83\x7a\xe5\x98\xde\xb9\xdf\x8d\
\xc4\x14\xbe\xd2\xab\x27\x37\x63\x64\x51\x9c\x42\x79\xb0\x6d\xd2\
\xbf\xaa\xba\xb5\x22\x53\x59\xa5\xee\xb1\x07\x37\xaa\xcf\x44\x10\
\xb2\x30\xda\x00\x9e\x0e\xfc\x00\xb1\x4b\xf1\x10\x64\x5e\x3d\x90\
\x7b\xeb\x1e\x04\x48\xe7\x01\x17\x10\x43\xc7\xdb\x96\x2b\x51\x47\
\x27\xba\xaf\xf4\xeb\xd6\x62\xb3\xef\xd3\xb2\x0d\x99\xbe\x5e\x1f\
\x43\x62\x8a\x4d\x5b\x2f\x9b\xc0\x30\x29\xd0\x8c\xb4\x9f\x69\x59\
\x46\x91\x39\x97\x6e\xd8\x37\x22\xb3\x23\xcf\x93\xce\x01\x76\x23\
\xf1\x8c\x2b\x19\x6c\x7c\xbb\x58\x49\xa3\x4c\x2b\x64\xd7\x23\x17\
\x8b\xd7\x20\x44\x96\x52\x54\xbc\xd7\x23\xeb\xc8\xbe\x37\xfa\xec\
\x55\x88\x15\xe0\x9d\x6f\x54\x9e\x82\xb8\x62\x82\x94\x0b\x00\x00\
\x20\x00\x49\x44\x41\x54\xfd\x1e\x45\x7d\xcf\xfa\x66\x24\xe6\x94\
\xae\x37\xf8\x7f\x9c\x13\xa9\xfb\x6f\xdc\x44\xff\x1a\x26\x4b\x21\
\xb2\x8e\x56\x90\x67\x24\xfd\x04\x7d\xd0\xd4\x2a\x3d\x4b\xea\xf9\
\xc8\x7c\x78\xbf\xd7\x3b\x8f\xc8\x75\x17\xb9\xf5\x2c\xd4\x71\x3e\
\x9b\xb6\xd9\x7b\x08\xb3\xae\xd3\x82\xbd\xd7\xb5\x2c\xec\xf5\xfd\
\x7e\x35\x70\x1d\x92\x21\xd9\xb4\xb5\xf2\x3a\x23\x53\xd3\xb4\xdd\
\x74\x5a\xfa\xa6\x7e\x1b\xf2\xa4\xd7\x79\x1b\x14\x77\x34\xf0\xdf\
\x90\xde\xf7\x3b\x91\xe4\x86\x12\x8c\x22\x2b\x29\x01\x09\xb5\xae\
\xdd\x34\xb9\x78\x52\xd4\xb0\x58\x18\x45\x2e\xbc\xb4\xff\xe8\x78\
\x6b\x21\x15\xb9\xfa\xd2\xba\x6e\x98\x22\x17\x80\xd7\x70\xbe\x04\
\xb1\x2c\xba\xea\xbd\xea\x1c\x73\xda\x5d\xb9\xbf\xaf\xf7\x96\x9e\
\x75\x64\xcf\xf9\x5b\x91\x81\xbe\xa5\xff\xdc\x3e\x04\x9a\xc7\xd2\
\x77\x83\x69\x9d\x8d\x74\xd6\xde\x06\xfc\x26\x62\x35\xd9\x6b\x64\
\x61\xa4\xd7\x97\xd4\x3a\xe6\x3d\x5a\xb5\x1d\x1d\x9c\xcf\x26\x45\
\xae\xb9\x74\xad\x52\x5c\xf5\x0a\x1a\x8c\xa6\xa1\xd2\x6f\xbe\xa5\
\x9a\x25\x18\x69\xdd\xc1\xfc\x0e\x8a\x5b\x41\x9e\x05\x74\x06\x32\
\x95\xd0\x55\xd4\x59\x49\xa9\xe4\xdc\x77\x5d\xa1\x64\xb7\xe9\x86\
\xd8\x6b\x20\x2c\xb8\x6a\x52\xc1\x6b\x61\x14\x81\xc9\x02\x29\x1d\
\x5b\xce\xfd\xf8\x1f\x9c\x73\xac\xd1\xa7\xcd\xfe\x3c\x6d\x50\x97\
\x91\xb7\x97\xc1\x87\x0c\xda\x86\x56\x9f\xeb\x8b\x29\xdf\xcb\x1b\
\x88\x9b\xf7\x75\x08\x8c\x96\x91\x29\x8d\x7e\x91\xe1\x07\xd3\x2d\
\x21\x33\x92\x9f\x8e\x64\x76\x5e\x47\x0c\x9f\xb4\x9e\xb6\xd9\xdf\
\xda\x82\x69\x94\xa4\x99\xf4\xfb\xea\xe3\xd3\x9d\x29\xbd\xcd\xbb\
\x87\x6e\x75\xae\x47\xd3\xe6\x2b\xea\x44\x44\xff\x8f\x5a\x58\x8d\
\x04\xb5\x59\x85\x11\x48\x43\x3e\x8f\x30\x4a\x3a\x01\xb1\xee\xde\
\x8b\x4c\x7f\x92\x1e\x91\x5d\xeb\xb6\xb3\x50\xd2\x40\x4a\x8a\x7c\
\xf5\x91\x95\x64\xe5\x59\x4b\xd6\x62\xd2\x56\x92\x6d\x48\x72\x70\
\xca\xc1\xc8\x83\x9c\xe7\x46\xf4\xce\x61\x27\x12\x97\x3b\x22\x73\
\x5e\x9e\x6e\x47\x06\xe3\xa6\x7b\x3e\x8a\xb1\xac\x52\xd7\x4b\xbf\
\xc9\xac\xeb\xdf\x4e\x9f\xdf\x33\x28\xdf\xc7\xeb\x48\xb6\xe1\xbb\
\x7b\xf5\x1d\xbd\xe5\xf9\x48\xd2\xc7\x5f\xe3\x0f\xe4\x3d\x0d\x49\
\x9e\xf9\xe9\xde\xfb\x22\x20\xe9\xd8\x95\xf7\x1b\xa7\x46\x49\xbb\
\x6a\xb5\x72\x1d\x9c\xdc\xe7\x92\x6c\x87\x43\x83\x7a\x85\xe1\x6b\
\xd9\xb4\x35\xd2\x9d\x85\x52\x3b\x61\xdb\x9a\xd2\x3d\x51\xda\xe7\
\x90\x3c\x37\xc0\xac\xe8\x62\xe0\x33\xd3\x3e\x88\x31\xb5\x82\x34\
\x44\xbf\x8c\xc4\x09\x76\xa9\xb2\xd3\x94\x03\xd4\x72\x87\x53\xd2\
\x23\x9f\x57\xd4\xb2\xd4\xa0\x7b\xb2\x8d\x95\x0d\xb4\xa7\x94\xe4\
\x5c\xb1\x8f\xcf\x8e\x8a\x7e\x04\xb1\x57\xcf\x3d\x92\x3b\x7a\x3c\
\xf7\x3d\xc8\xac\x0d\xc9\xca\xa9\xd5\x37\xcd\xf9\xc3\x30\xb4\x37\
\x90\x29\x8c\x6a\xd2\xce\xbd\x06\xd4\x36\xb6\x0f\xa5\xce\x8a\x7b\
\x23\x92\x98\x60\x1f\xe7\xbd\x8a\x58\x0d\xff\x37\x71\x43\x7f\x24\
\x32\xeb\xf8\x6e\xf3\x39\x7d\xcf\x78\x25\x37\x26\xce\xbb\x9f\x6c\
\xe7\xc0\x73\xf3\x45\xa5\x74\x1f\xdd\x52\x71\x8d\x9a\x26\x2f\x6f\
\x06\x86\x5c\x2c\xd1\xbe\xc7\xd6\xbd\xf5\x6a\x6d\x0a\x8c\x36\x36\
\x36\xc6\xf5\x3d\xa6\x8b\xf0\x77\x13\x38\x9c\x59\xd0\x89\xc0\x2f\
\x21\x01\xe8\x83\x88\xa1\xa4\x81\x94\x8a\xd7\xb8\x68\x20\xa5\x46\
\x25\x07\x27\x2b\xaf\x21\x89\x1a\x15\xaf\x01\xb1\x4b\x0b\x1f\x0b\
\x19\x6f\x7b\xae\xec\x67\x18\x50\xfa\x18\xbe\x8e\x24\xb8\xfc\x24\
\x32\x66\x28\xa5\xc6\xe7\xf4\x10\x64\x3e\x3c\x6b\x09\x69\x17\xd6\
\x06\xf5\xf1\xa2\x1b\x19\x8c\xa3\x58\xeb\x72\x19\x89\x6d\x95\xfe\
\x63\x77\x00\x6f\xa1\xff\xdb\x5a\x20\xed\x40\xac\x9e\xf7\x65\xf6\
\x71\x24\x32\xfb\xf8\x03\xa8\x03\x52\xba\x6f\x74\x5d\xdf\x3f\x9e\
\xeb\xd4\x53\x64\x5d\xea\xeb\xaa\x9f\x86\x6c\x21\x94\xea\x37\x67\
\xbe\xa3\x69\xf3\xa4\x87\x4a\x40\x19\x24\x11\x78\x3c\x68\x75\x66\
\xc0\xb4\x2c\x23\xef\xc0\xbd\x0b\xf2\x61\xfa\x93\x68\xce\xbb\x56\
\x90\xa7\x83\xfe\x32\xd2\xe0\x25\x10\x59\x28\x79\x40\xd2\xd6\x52\
\x0e\x48\xb9\xde\xad\x55\xd4\x80\xd4\x58\x4b\x39\x20\x45\xd6\x51\
\xc9\x2a\xca\x59\x47\xb6\x01\x4b\xe5\x4a\xc4\xbd\xf5\x83\x88\x75\
\x71\x77\xee\x07\x40\xd2\xa4\x0f\x33\xe7\x6a\xcf\x7f\x77\x61\x1f\
\x49\x5e\x9c\x43\x5f\xef\x27\x50\xe7\xee\xfb\x2c\x72\x5e\x9e\x35\
\xac\xcb\x85\x85\xfd\xec\x06\x7e\x8d\x61\xcb\xca\xde\x37\x1e\x94\
\xbc\x0e\x4d\x94\x78\x60\x15\x41\x28\x67\x25\xa5\x65\xfa\x3d\x6f\
\x2c\x9c\x5b\xd3\xe4\xb5\x81\x84\x0e\xf4\x7a\x5a\x7a\x96\x6f\x8d\
\x9b\x2e\xf7\x5d\x45\x4d\x03\x46\x35\x3e\x47\x7d\x01\x5e\xb7\x15\
\x07\xb5\x85\x7a\x30\x02\x24\x6d\x25\x69\x28\x59\x30\x79\x40\xf2\
\x1a\x98\xda\x46\x05\xf2\x8d\x4a\xce\x4a\xf2\xe0\x34\x2a\x98\x4a\
\x56\x53\xc9\x5d\xa7\xcb\xcd\xc0\x5f\x02\x2f\x03\x5e\x4d\x1c\x83\
\x38\x0c\x79\xf4\x75\x04\xdd\x23\xa9\xcf\xea\xba\x8d\xe1\x3f\x6a\
\xd2\x12\xf5\x8f\xd7\xbe\x84\x61\x48\x44\xd6\xd1\x1d\x85\x7d\x3d\
\x0b\x81\xa0\x77\x8f\x44\xf7\x4b\x0e\x48\x51\x87\x66\x94\xce\x4d\
\xfa\xad\xbc\x7a\x8d\x65\xdb\x34\x59\xed\x63\x30\x11\x4a\x2b\xe7\
\xc6\xb6\xaf\xe7\x5c\x76\xb9\x7d\x0c\x69\x2b\x61\x14\x1d\x68\xa9\
\xbc\x9b\xed\x97\x6d\xb3\x8a\xc0\x48\x5b\x49\x5e\x1c\xc9\x03\x52\
\x57\x2b\xc9\x6b\x58\x60\xb8\x41\xb1\x37\x8d\xd7\x60\x97\x62\x49\
\x5d\xe3\x4a\xd6\x2a\xb2\x10\xd2\xeb\x91\x75\xa4\x1b\xb6\xbb\x91\
\x81\xa1\x3f\x8a\x58\x4c\xf6\xf1\xe6\x1b\x08\xb8\x2c\x84\x1e\x80\
\xcc\xde\xf0\x83\xd4\xc5\x8b\xf6\xd3\x7f\x6c\x84\x77\x5f\x1f\x48\
\xfd\xa3\xb5\xbf\x48\x19\x44\x3b\x90\xdf\xef\x43\x15\xfb\xfb\x79\
\xe4\xbe\xc9\x75\x5c\x4a\x16\x52\x17\xeb\xc8\x6b\x6c\x22\x37\x68\
\xd4\xa1\x79\x50\xc5\x79\x35\x4d\x56\x7b\x7b\xcb\x1a\x8b\xc8\x03\
\x4e\x0e\x54\x25\x28\xb9\xda\xaa\x6c\xba\x0d\xf2\xbe\x67\xfb\x5e\
\x7d\x23\xef\x41\x7c\xea\x3f\xb6\x39\x87\x36\x55\x3d\x04\x99\x4e\
\xe8\x1d\x08\x74\x75\x86\x91\x4d\x0f\x8e\x52\xc0\xd3\x7a\xca\xb6\
\x5b\x37\x75\x9d\xbe\xab\x83\xe0\xe9\x37\x89\x7a\x36\xde\x6b\x4b\
\xa6\x5e\x4a\x09\xdf\x50\xf5\x5c\xb0\xbc\x14\x38\x2f\x15\xef\x8f\
\x73\x21\xd2\x78\x3f\x06\xc9\x68\x3b\xa2\xb7\x9e\x1e\x2f\xbe\x86\
\x34\xda\xff\x95\x7a\xd7\x5c\xd2\xed\xf4\xaf\xad\xf7\xe7\x7c\x28\
\x75\x1d\xbd\xeb\x18\x9c\xb1\xc3\x73\x1d\xea\x8e\xc1\x47\x10\x57\
\x6f\x4e\xbb\x81\xa7\x21\xe7\xba\x41\x1f\xd4\xf6\x3e\xf1\xa0\x62\
\xcb\xb2\x7a\x0d\x86\xef\x09\xfd\x59\x2f\xc1\xc1\x9e\x43\x3a\x47\
\x5b\x6a\x66\xbb\x68\x9a\xac\xf6\x10\x5b\x3a\x35\x05\x53\xb7\xca\
\x5a\x41\xde\x6b\x5b\x9d\xda\xad\x1b\xad\x2e\xe5\x2d\xc0\x4b\xa9\
\x7b\x7a\xe7\xbc\x69\x15\x19\x33\x72\x26\x92\xb0\x71\x2d\xc3\xa9\
\xaf\xf6\x79\x49\x16\x4a\x7a\xdd\x42\x49\x03\x09\xe2\x9b\x4a\x83\
\x46\x2f\xb5\x34\x84\x2c\x90\x72\x29\xe1\x1e\x94\x22\x10\x75\x01\
\xd2\x32\x31\x8c\xe8\xbd\x76\x11\x70\x29\x83\xd6\x63\xd2\x33\xe9\
\x0e\x22\x10\x4b\xdd\xeb\x31\xa6\xf5\xda\xa9\xac\xae\xa4\x3f\x93\
\xb7\x86\x4e\x54\xbe\x4a\x5d\xc7\xee\xd9\xc8\x5c\x89\x1a\x00\x76\
\xac\x9a\x55\xae\x87\x9c\xf6\xe1\x65\xd5\x79\x75\xbb\x9f\x1c\x88\
\xd6\x81\xe3\x0a\xe7\xd3\x34\x79\xa5\x78\x91\x07\x96\xdc\x6f\xe9\
\xfd\xcf\xbc\x6d\x35\x1a\x78\xff\x34\xc6\x19\x79\xbd\xa8\xb4\x8c\
\x7a\x54\x77\x22\x33\x1a\x6c\xe7\x39\xac\x76\x03\xff\x03\x99\xb5\
\xfc\xbd\xc8\xcd\xe2\x59\x44\x91\x95\x64\x1b\x71\x0d\xa1\x75\xb3\
\x3d\x5d\x57\x2b\xdd\x59\xb0\xdb\xa3\xf7\xe5\xac\x15\x0b\x25\x0d\
\xa4\x9c\x55\x54\x03\x24\xbd\xbf\xe8\x4f\x62\x65\x1b\xe1\x5a\x6b\
\xdd\xea\x16\xfa\xd7\xcf\xbb\x5e\x0f\xaf\xdc\x4f\x7a\x62\x70\xda\
\x87\x77\x2e\xb6\xdc\x4b\x79\x46\xf1\x73\x91\x87\x13\xde\xc5\x60\
\x87\x24\x02\x11\x6a\xff\x2b\x66\x3d\x1d\x93\xfd\x6d\x4b\x8a\x7a\
\xd1\xf6\xbf\xbd\x41\x83\xd1\x34\x94\x2c\xa3\x9a\xdf\xa9\xf4\x1e\
\xad\x5c\x27\x2d\xab\xad\x80\x51\xd4\x93\xab\xb9\x51\x75\x4f\xf1\
\x8d\xc0\x0b\xe9\xfe\xe8\x81\x79\xd2\x2a\xf0\x22\x24\x05\xf9\x35\
\x88\x1b\x47\x5b\x48\xda\x4a\xb2\x50\xda\x6f\x96\x9e\xdb\xce\x03\
\x55\x64\x25\x45\x37\x50\x04\x26\xdd\xd0\x69\x98\x58\x70\x79\x70\
\xf2\x00\x94\x03\xd2\xb2\xb3\x8f\x74\x4d\xa2\x1e\xbe\x77\xfc\xef\
\x42\xe6\xb7\xeb\x3a\x29\xef\xe1\xc4\x83\x90\x8f\xa0\xdb\xd3\x4b\
\xb5\x75\x97\xf6\x91\x2b\xf7\x51\x86\xd1\x01\xc8\x63\x3a\xfe\x8d\
\x61\xd7\x5c\x3a\xde\x92\x5b\x4d\x83\xd1\x7e\x4e\x1f\xaf\xbd\x57\
\xec\xf6\x52\x59\x47\x92\x4a\x9a\xb6\x4e\xeb\x48\xcc\xa8\xe6\xf7\
\xe9\x5a\x92\x72\x10\x72\xb7\x4f\x6b\x06\x06\x0d\xa8\x9a\x9b\x75\
\x1d\x79\x9e\xcd\x07\x91\x8c\xa1\xed\xae\x93\x91\x71\x34\xef\x42\
\xac\xa4\x7b\x18\x8e\x25\x79\xd9\x4f\x16\x48\x39\x28\x45\x40\xf2\
\x6e\x2a\x4f\x39\x28\xd9\x9e\xb8\x07\x25\x0d\x13\xcf\x32\xf2\xf6\
\x61\x5f\x4b\xe7\xe8\x35\xa2\xb6\xd3\xe2\x9d\xd7\x5d\xc0\xef\x22\
\x19\x68\xdf\x46\xfd\x04\xa6\xa7\x22\x8f\x98\xb8\x8b\xe1\x8e\x56\
\xd7\xa4\xa0\x04\xd0\x08\xa2\x1e\x8c\x6a\x74\x3c\x7d\x17\xa0\xbd\
\x86\x49\xb9\xff\x9d\x75\xaf\xda\x4e\x8a\xfe\xff\x7a\xf2\xfe\xe3\
\xd1\x77\xb6\x79\xe9\xb6\x56\xfb\x7a\xcb\xdc\x6f\xa2\xdd\xa8\xb5\
\x10\x8a\x3a\x80\xa8\xd7\x43\x6d\x25\x8c\xf4\x81\xe8\x5e\x13\xe4\
\x2f\x84\x2e\x6f\x60\x31\x60\x04\x92\x01\xf5\x02\xe4\x99\x3f\x6f\
\x42\x66\x1c\xd0\x20\xfa\xff\xdb\x3b\xbb\x58\x5b\x92\xeb\xae\xff\
\xce\xbd\x73\xe7\xde\x19\xcf\xf8\x83\x8c\x07\x43\xe2\x19\x13\x6c\
\x19\x13\x3b\x76\x02\x31\xc4\x24\x58\x40\x14\x47\x13\xc4\x97\x20\
\x48\x08\x04\x41\x48\x79\x40\xbc\x44\x91\x10\x12\x04\x24\x94\xb7\
\x48\x20\xe0\x01\x84\x20\x21\x26\x19\x42\x88\x12\x48\x62\x63\x59\
\x46\x21\x09\x11\x09\xb6\x83\x43\x00\x0f\x98\xc4\x8c\x71\x3c\xe3\
\xaf\xf1\x9d\x3b\x73\x3f\xcf\x3d\x87\x87\xb5\xcb\xbb\xf6\xda\x6b\
\xad\x5a\xd5\xbb\xf7\x3e\x7b\x9f\x53\x7f\xa9\xd5\xd5\xbd\xf7\xe9\
\xd3\xdd\xbb\xaa\x7e\xf5\x5f\x55\x5d\xad\x1d\x52\x81\x95\x05\x24\
\x0d\xa5\x7a\xd1\x40\xf2\xc2\x4f\x51\x46\xd2\xdf\x8b\xc2\x6b\xa7\
\x4e\xba\x76\x49\x59\x10\x59\x83\x23\xea\xca\xbd\xd5\x6a\x2b\xcb\
\x7f\x42\xfa\x58\xde\x8c\xcc\x98\xf1\x0e\xe2\x10\xde\x55\xe4\xb7\
\x79\x2f\xeb\x15\xbc\x15\xfe\x8c\x54\x2a\x7a\x9c\xf5\x54\x18\xbd\
\x0e\x29\xdf\x96\x2b\xf2\x2a\x1f\x7d\x2f\x35\x88\x7a\x43\x75\xf5\
\xb5\x58\xd7\x05\xf2\x1e\xa7\xc7\x92\xc7\x1a\x9a\x47\xc5\x15\xc1\
\x7a\x1e\xc8\x98\x03\x0f\x42\x18\x6b\x9c\xed\xb5\xfd\x5b\x83\xd1\
\xe9\xe9\xe9\x69\xf0\x5e\x23\xdd\x6a\x2a\x6b\x0f\x4a\x65\x08\xe8\
\x33\xc8\xd4\xf9\xef\xd8\xd2\x69\xef\xa3\x1e\x43\x66\x1a\xf8\x38\
\xf2\xa6\xd3\x67\xc9\x85\xed\x0a\x80\x2c\x28\x79\xa1\xbb\x53\x95\
\xd6\xf2\x32\x98\xd5\x4a\x6e\x41\x49\xc3\xc8\x82\x90\xd7\x0f\xa6\
\x2b\xca\x13\x56\x21\x14\x01\xc9\x6a\xe4\x94\x89\x5b\xff\x27\x92\
\xc7\x7e\x1b\xe2\x94\xde\x85\x3f\x73\xfc\x5b\x91\x0a\xff\x37\x59\
\xad\xe8\x5b\x0f\xde\x6a\xd5\x30\x02\xbb\x50\xd7\x4b\xfd\xa0\x62\
\xa4\x57\xb3\xec\x8f\xb2\xa6\x7d\xa9\x8f\x5d\xdf\x03\x0b\x48\xde\
\xef\x57\x8e\xe1\xc1\xa9\x2e\xe7\xde\xff\xff\x63\x8d\xef\x0c\xcd\
\x2f\xab\xbf\xa8\x07\x48\x91\x2b\xc2\xd8\x97\x6a\xd4\x9e\xe5\xd0\
\xee\x9e\xca\xa2\x86\xd2\x8f\x71\xb1\x60\x54\xf4\xbb\x80\xef\x05\
\xfe\x23\xf0\x93\xc8\x73\x2e\x1e\x94\xa6\xba\x24\xcf\x2d\xd5\xd0\
\x69\x6d\xc3\x7a\x86\xd3\xd0\x01\xbf\x82\xf3\xe0\xa3\xf7\x6b\x67\
\x74\xaa\xd2\x11\x90\xac\x3c\x57\x57\xc6\x9f\x06\x7e\x00\xf8\x71\
\xe0\x0f\x23\xa3\xd3\xac\x7e\xa0\x87\x59\x87\xfa\x4b\xc8\x03\xb1\
\xd6\xc4\xa6\x5a\x8f\xab\x7b\x52\xee\x95\x4e\xd7\xe7\xfa\xda\xc4\
\x71\x61\x19\xda\xf5\xc2\x73\xf5\x35\x6b\x10\x79\x6e\x54\x1f\x07\
\xd6\x43\xb0\xfa\xb3\x96\xfe\x54\xf2\x7a\x86\xe6\x53\x0d\x23\x0b\
\x3e\x5e\xbd\xd0\x03\xa7\x6e\x9d\xf5\xac\xdd\xd6\x4d\xa8\x5b\xbb\
\x1a\x44\xf7\x81\x5f\x42\x5e\xcb\xf0\x86\x9d\x9f\xed\xd9\xeb\x12\
\x12\xa6\xfc\x06\xe0\xdf\x22\x93\x6b\xea\xa7\xe8\xef\xd1\xef\x92\
\xb4\x53\xaa\x2b\x97\x16\x94\x5a\x2d\x5f\xbd\xed\xb9\xa2\x08\x56\
\x16\x94\x74\x5e\xb1\x42\x74\xd6\xe8\x34\xab\x90\x5d\x52\xc7\x28\
\xe9\x17\x10\xf0\xbf\x0f\x71\x49\xef\x61\xd9\xd9\xfe\x45\xe4\xc5\
\x70\x1a\x46\x47\x8b\xfd\x19\x18\xbd\x09\x09\xc7\xd6\x33\x10\x68\
\xc7\x51\xd2\xa7\xc8\xc0\x89\x6c\x48\xab\x3c\xbf\x64\x85\xe7\xea\
\xeb\xf4\x1c\x91\xe7\x8c\x60\xf5\x37\xac\x65\xe5\x85\x28\x7f\xbc\
\x93\xdc\xeb\x3a\x86\xe6\x55\x81\x91\x0e\xcf\xb7\x9c\x51\x0b\x48\
\x45\xdd\x70\x3a\x3d\x3d\x3d\xdd\x2a\x8c\x8c\x50\x9d\x97\x79\xa3\
\x8b\xb6\xa0\xf4\x6f\x80\xef\xd9\xde\x99\xef\xbd\x1e\x41\x5e\x2e\
\xf7\x07\x91\xd0\x5d\x79\x8e\x46\x03\xe9\x1e\xeb\x2e\x49\x43\x49\
\x3f\x8b\xa4\xdd\x91\xe5\x92\x34\x94\xc0\xcf\x74\xd6\x7e\x5d\xd1\
\x66\x1d\x93\x06\x98\x6e\xc0\x68\x77\x54\xef\xaf\x43\x72\x3a\x5f\
\x45\xa3\xf3\x4a\x9e\xfb\x59\x64\x00\xcd\x1b\x91\x10\xd8\xb3\xc8\
\x23\x07\xd6\x68\xc0\x8f\x02\x5f\xe7\xdc\x8f\x5a\x0f\x22\x0f\xc8\
\x3e\xc3\x7a\xa5\x6d\x85\xc1\x7a\x46\xfd\xbd\xc8\x12\x46\xe5\x38\
\x35\xac\x3d\x10\x59\x4e\x34\x5a\xa8\x8e\x5f\x9f\x7b\x04\xa6\xf2\
\xf9\x77\x74\x5c\xcf\xd0\x3c\xba\x83\x94\x7f\xab\xbe\xad\xd7\x9e\
\x33\xf2\x5c\x12\xce\x3e\xbd\xdf\xd5\xae\x07\x30\x44\xa1\xba\xb2\
\x5d\x57\x0a\xda\x15\x95\xe5\x3f\x00\xdf\x89\x74\x7e\x5e\x64\xbd\
\x1e\x79\x67\xd2\x87\x11\x40\x7f\x86\x18\x48\x1a\x4a\xf5\xa2\x9d\
\x92\x06\x93\xd7\x32\xd2\x8a\xa0\xa4\x5b\xd3\xf5\x3e\x0b\x46\x7a\
\xdb\x83\x93\xd7\x52\xb3\xfa\x94\x34\x80\x34\x84\xee\xb3\x3a\x23\
\x82\xee\xcc\x7f\x86\x75\xe7\xa9\x2b\xf0\x8f\x21\xbf\x45\xe6\xf9\
\x99\xb7\x2c\x8e\x59\x14\x39\x89\xec\xf3\x4b\x2c\x8e\x59\x46\xf6\
\xe9\x7b\xa2\x1d\xa0\x5e\x5a\x8e\xd5\x92\xfe\x1d\xcb\x3e\xef\xf7\
\x7c\x35\xf0\xad\x1d\xd7\x33\x34\x8f\xea\x37\x03\x47\x11\x83\x08\
\x56\x2d\xb7\x54\xd4\xd3\x40\xed\x1e\x86\x3a\x97\x22\x4b\xe7\xdd\
\x9c\x1a\x4a\xb7\x91\x39\xc8\x86\x44\xbf\x17\xf8\x3e\x64\x4e\xb6\
\xdf\xce\xea\x5c\x77\xad\x39\xef\xa2\x77\x27\x45\x13\x6b\x66\x5a\
\xd3\x5a\x51\x2b\x2a\x72\xc3\x51\x1f\x62\xcf\x7c\x78\xd6\x5c\x78\
\xd1\x72\xd7\xd8\xe7\x4d\xf8\xaa\xff\xcf\xfb\x8c\xeb\xb7\xf4\x96\
\xc6\xe7\xf5\xfd\x7c\x63\xf2\x98\xcf\x22\x21\x46\x2f\xf4\xd6\xe3\
\x7c\x2c\x10\x45\xfb\x61\xfd\xf7\xb7\x8e\xf7\x27\x90\x7c\x38\xb4\
\x5b\xbd\x84\x5d\xcf\x46\xf5\xaf\xb7\xed\xd5\xdd\xba\x9c\x5b\x5a\
\xdb\x7f\x96\x33\x30\xd4\xa1\x9e\xb2\xbf\xbe\x11\x96\x3b\xaa\x2b\
\xa0\x9f\x42\x6c\x7e\xcf\x03\x86\xe7\x59\x97\x91\xb0\xdd\xbb\x90\
\x70\xd2\xbf\x43\x26\x05\x2d\x4f\xf9\x97\x4a\x52\xbb\xa4\xb2\xd6\
\x2e\xa9\xbe\xe7\x56\xab\xc9\x72\x4b\xb5\x4b\xd1\xb2\x5a\x4c\x56\
\xbf\x83\x76\x4b\x3a\x34\x47\x95\xbe\xc4\xea\xff\xf4\x5c\x52\x1d\
\xb6\xd3\xe1\x29\x2b\x3c\x67\xa5\xbd\x30\x9e\x07\xe4\x5f\x42\x1e\
\xa8\xfd\x46\xe3\x5e\xd4\x7a\x2d\xf0\x7b\x90\xa1\xfb\x96\xbb\x28\
\x7a\x82\x7c\x24\xe0\xbf\xb2\x7a\xcf\x6a\x87\x58\xef\xcb\x80\xa9\
\xc8\x6b\x64\x78\xe7\x1c\x1d\xf3\x0a\x12\x66\x1e\xda\xad\x8e\x91\
\x30\x9d\xe5\x80\x32\x8d\xbf\x8c\x53\xc2\x59\xb7\xe0\xb4\x7d\x18\
\x35\x86\x78\xc3\x34\x67\x74\x9f\xe5\x0c\xcd\x7f\x71\x6b\x27\x7f\
\x98\x7a\x00\x19\x01\xf6\xcd\xc8\x00\x87\x9f\x42\xe6\x52\x8b\xc2\
\x76\x16\x90\x5a\x50\xca\x84\xc9\x2c\xd8\x44\xf2\xc0\x54\xa7\x2d\
\x50\x59\x7d\x44\x75\xa3\xe6\x72\xf5\xb9\x37\x58\xa1\x86\x8c\x15\
\xaa\x6b\x41\xcb\x02\xd2\x0f\x21\x0f\x74\x3e\xd1\xb8\xee\x3f\x8d\
\x0c\xca\xf9\x02\x76\xe5\x7e\x95\x7c\xe5\x7d\x0b\x79\x66\xaa\xd7\
\xf9\x44\x6e\x28\x02\x4d\x91\x6e\x5c\x5a\xc7\x2b\xf7\xe9\xbb\x81\
\xaf\x4e\x5e\xcf\xd0\x7c\xb2\x42\x74\xd9\x28\x44\x04\xa7\x0c\x90\
\x74\xfa\xcb\xdb\xe5\x65\xac\xbb\x0e\xd3\x59\xe1\xb9\x3a\xed\x85\
\x6c\xbc\xb7\x45\xfe\x24\x62\x3b\x87\xd6\x75\x05\x89\xc9\x7f\x3f\
\x32\xc9\xec\x6b\x59\x7d\x67\x92\xf7\xea\xf3\x3a\x74\xa7\xc3\x78\
\x56\xe8\x2e\x7a\x75\x45\x36\x7c\xa7\xa5\xf3\x86\x0e\x15\xe8\x82\
\x64\xe5\x8f\x4c\xf8\x2e\xf3\x5e\xa5\xbb\xce\xda\x0a\xe3\xe9\xd7\
\x5e\xdc\x02\xfe\x3e\x32\xba\x2e\xd2\x55\xe4\xd5\x0f\x5f\xc3\x7a\
\x21\x7f\x12\xf8\x6b\xe4\x47\xd1\xbd\x9f\xe5\xcc\x10\x16\x54\x22\
\xb8\x68\x69\x67\x14\xed\x8b\xe0\x53\x2f\xef\x04\xbe\x2b\x79\x2d\
\x43\xf3\xea\x65\xb6\x03\xa1\xb2\x0f\x6c\x20\xa5\xb4\x2f\xd3\x01\
\xd5\xad\xeb\xd2\xea\xb6\x5c\x51\x3d\xba\xe9\x3e\x70\x03\x19\xe2\
\x3c\x2c\xbf\xaf\xab\xc0\x53\x88\x5b\xfa\x20\xf0\xd3\xc8\x33\x4a\
\xc5\x21\x95\x8a\x53\x3b\xa5\x7a\xd4\x5d\xd9\xf6\x9c\x92\x76\x0e\
\xad\x38\x72\xad\x28\xc3\x7a\xe1\xbc\xda\x25\x15\xd5\x21\x28\x2f\
\x6c\xa7\x9d\x8c\xe7\x70\x74\xe7\xfe\x14\x77\x54\xd2\x9f\x03\xfe\
\x2e\xf2\x0a\x94\xdf\x17\x5c\xeb\x2b\x90\x3e\xbf\x4f\x21\x7d\x3e\
\x27\x08\x88\x5e\x4f\x0e\xe0\x20\x83\x26\xac\x77\x1e\x79\xa0\xb1\
\xa0\x14\x7d\x4f\xc3\x47\x3b\xd4\xfa\x33\x0b\x4c\xaf\x04\xfe\x1e\
\x67\xd7\x57\x7d\x91\x75\x82\x34\x8e\x5a\xa0\xf1\x42\xf3\x9b\x38\
\x24\xaf\xec\xaf\x68\x27\x30\x52\xa1\x3a\x0f\x44\x65\x3b\xb2\x90\
\x56\xab\xf7\x27\x90\xc9\x45\x5b\x93\x47\x5e\x74\x5d\x43\x5e\xe8\
\xf7\x2d\xc8\xbb\x93\xde\x8f\x40\xa9\x76\x09\xc5\xe9\xd4\x80\xb2\
\xee\x79\xd9\x6f\x65\xcc\x1a\x48\x51\x4c\xb9\x07\x4c\x1a\x4a\x3a\
\xcf\x44\x21\x26\x0d\xa2\x08\x4a\x1e\x60\x34\x84\xea\x30\x5e\x81\
\x74\xd9\xb6\xfa\x63\xee\x03\xff\x00\xf8\x76\xe4\x21\xcf\x6b\xce\
\x75\x82\xc0\x27\xfb\x62\xbe\x5a\xd7\x81\x7f\xbe\x38\xc7\x8c\x5a\
\x15\x84\x07\x2a\xcb\x19\xe9\xef\x79\xae\xe8\xef\x30\xed\xda\x86\
\x36\xd7\x2d\xd6\x9d\x4c\x04\xa4\xfa\xa5\x95\x1a\x3c\x99\x06\x67\
\x77\xe3\xf3\x2c\x1f\x7a\xd5\x95\x8a\xd7\xf7\xd0\x02\xd2\x75\xa4\
\x5f\xe4\xcf\xee\xf0\xdc\x0f\x59\x0f\x21\xf0\x7e\x0a\xf8\x05\x04\
\x4a\x9f\x62\xdd\x25\xd5\x50\x6a\x01\xa9\xce\xb4\xf5\x6f\x96\x71\
\x4a\x5e\xbf\x52\xc6\x31\xb5\x3e\xaf\x5b\xf0\x75\x7f\x92\x05\x29\
\xcb\xd9\x78\xfd\x46\x1a\x48\x35\x94\xbc\x50\xe5\x25\x24\x9f\xfe\
\x02\xf0\x67\x90\x17\xfe\xcd\xe5\x10\xbe\x04\xfc\x23\xc4\x85\xe9\
\x7b\x50\xd2\x99\x90\x49\xeb\x3b\x51\x3f\x52\xbd\x5f\xdf\xc3\xcb\
\xc8\x9c\x7f\xe3\xb9\xa2\xb3\xd3\xcb\xd8\x65\xb4\xe5\x8a\x22\x20\
\xe9\x90\xb9\x17\x9e\xd3\xfb\xcd\x7c\x76\xb4\xe8\x3b\xda\x89\xd4\
\x40\x06\xcf\xca\x1f\xb1\x3a\xf9\xa7\xee\xa7\x28\xfd\x18\xa5\x8f\
\xe3\x1a\xd2\x1f\xf2\x2f\x88\x5b\x9c\x43\xb6\x4e\x81\x5f\x43\xa0\
\xf4\x11\xd6\x87\x2a\xdf\x37\xd6\x75\xab\xc9\x02\x52\x94\x69\x33\
\x2d\xaa\x7a\xdd\x92\x55\x41\x46\xa1\x22\x9d\xb6\x42\x6b\x16\x54\
\xb2\xef\x96\xca\x2e\x4f\x20\xc3\x9b\xdf\xc1\x66\x2f\x8d\xfc\x55\
\x64\xda\xa2\x2f\xb1\x7a\xef\xea\xfb\x6f\xf5\x9f\xb5\x86\xb5\x5b\
\xf9\xa0\xfe\xad\xbd\xf0\x8b\xbe\x7f\x97\x91\xd7\x8a\x7f\x88\xdc\
\xac\x14\x43\xf3\xeb\x14\xe9\xb7\xbc\x8b\x8c\xa6\x2b\xeb\xdb\x8b\
\xe5\x56\xb5\xdc\xac\x96\x5b\x2a\x7d\xab\xfa\x9b\xdb\xd5\x71\x4a\
\xff\xa9\x97\x5f\x2c\x47\x55\xce\xeb\xcb\x03\x18\xf6\x61\x3a\x20\
\xbd\x6d\xc5\xf9\xad\xbe\xa3\xba\x70\xbd\x80\x3c\xd7\x31\xe6\xb9\
\xea\xd7\x11\xf0\xb6\xc5\xf2\x1c\xf0\x01\xa4\xe2\x78\x89\x65\xc6\
\x2a\x2e\xc9\x0b\xdb\xb5\x42\x77\x9e\xbd\xb7\x32\x67\xe4\x98\xac\
\x8a\x4f\x7f\xd6\xea\x5f\xb2\xdc\x52\xd9\x8e\x42\x79\xad\x7e\xa5\
\xec\x52\x00\xf6\x49\xe0\x1f\x22\x0d\xab\xb7\x02\x5f\x8f\xcc\xda\
\x90\xa9\xb0\x4f\x91\x7e\xa5\xf7\x21\x93\xbb\xd6\xd7\x6f\x95\x9d\
\x4c\x43\xc0\x83\x4b\xb9\x67\xd6\xda\xfa\x9e\x76\x45\xaf\x02\xfe\
\x49\xf2\xba\x86\xb6\xa3\xdb\x2c\xcb\x66\x2b\x3c\x67\x45\xa1\x5a\
\xe5\xd9\xcb\x63\xb5\x5a\xdb\x67\xee\x8c\xca\xda\x1b\x81\x53\x0f\
\x41\x2e\xce\xa8\x1e\xe9\xf5\x20\xcb\x91\x60\xaf\x43\x26\xb7\x1c\
\x0f\xd2\x6d\xae\x5b\xc8\xf4\x37\xef\x07\xfe\x1f\x6d\x87\xe4\xb9\
\xa5\x0c\x94\x32\xfd\x4a\x1a\x2e\x9e\xbc\x4a\xd3\x73\x4a\x96\x6b\
\xca\x3a\xa5\x29\x8b\x7e\x07\x95\xb5\x7e\x03\xe2\x96\x7e\x2b\x52\
\x91\x3f\x8a\xdc\xef\x1b\xc8\x14\x3f\xff\x17\xf8\xef\x8b\xb4\x56\
\x8f\x33\xf2\x1e\xde\x8d\x5c\x91\x6e\xe9\xb6\x5c\xd1\xe3\xc8\x6b\
\x36\xde\x66\x9c\xeb\xd0\xee\xf4\x39\xa4\x3b\xe3\x2e\xeb\xae\xa8\
\x76\x46\xda\x0d\xdd\x54\xfb\xeb\xbf\xb9\xc3\xd2\x65\xe9\x3c\x13\
\xe5\x97\x95\x72\x7e\x5a\x01\x68\xa7\xce\xc8\x19\xc8\x50\x67\x68\
\xcb\x15\x95\xca\xa2\xd5\x77\xf4\x79\xa4\x63\xfe\x8f\x6f\xfd\x42\
\xce\xbf\x1e\x42\x62\xfc\xdf\x06\xfc\x0a\xf0\x33\xc8\x83\x94\xda\
\x29\xd5\x15\x9c\x1e\x5e\x1d\x41\xa9\x6e\x9d\xd5\x4e\x24\x03\x25\
\xaf\x8f\xc9\x52\xe4\xb0\x34\x8c\x7a\x9d\x92\xb7\x58\xf0\xaa\xfb\
\x9e\xf4\x04\xa5\x97\xd5\xff\xfe\x75\xc4\x35\x69\x38\x5a\xa3\xda\
\xea\xb4\x06\xb6\x15\x26\x6d\x35\x02\x3c\x67\x54\xff\x2f\x6b\x80\
\x88\x05\xf6\x27\x81\x1f\x21\xff\xc2\xc2\xa1\xed\xe8\x18\x89\x72\
\x78\x0e\xc8\x0a\xb7\xf7\x34\x2c\x7b\x1c\x76\x58\x6e\xcf\x3a\x4c\
\xa7\x65\x85\x1a\x74\xc8\xa1\xee\x28\xae\x2b\xc3\x07\x90\xd7\x4b\
\x3c\x85\x38\xa7\xa1\xcd\x75\x84\x84\x8f\xbe\x1e\x71\x48\x1f\x40\
\x3a\xe0\x5f\x60\xd5\x25\x95\x97\xb8\x79\x4e\xc9\xca\xd4\x51\x45\
\x59\x6f\xc3\x7a\x06\xcf\x3a\x25\xad\xd6\x77\xeb\xc6\x4f\x0d\x08\
\x0b\x50\x2d\x00\x59\x21\x3e\x0f\x40\x75\xda\xfb\x5b\x2b\xd4\xe8\
\x5d\xa3\xbe\x87\x99\xfb\xdf\xaa\x4c\x34\x6c\xbc\xcf\x2f\x21\xaf\
\x3b\xf9\x61\x24\x5a\x31\x74\xb6\xba\xc1\x7a\xfd\x69\x35\x1a\xa3\
\x08\x87\xf5\x37\x3d\x60\xc2\x58\xaf\x69\xe7\x30\x6a\x0c\xf3\x06\
\xdf\x1d\x95\x82\xe9\xb9\xa3\x63\xc4\x8e\x7e\x10\x01\xd2\xd0\xbc\
\xfa\x2a\xe4\x39\x98\xbf\x84\x4c\x04\xfa\x73\xc8\x94\x37\x2f\xb1\
\x79\xe8\xce\x8a\x41\xd7\x15\x75\x26\x73\x6f\xe2\x96\xac\xd6\xbd\
\xe7\x96\xbc\x91\x78\x19\xe7\x54\x83\xa8\x4e\x47\x30\x2a\x7f\x67\
\x9d\x9f\x77\x7d\xe0\xf7\x0f\x58\x50\x8a\x5a\xb3\xde\xff\xb5\x06\
\x23\x5d\x42\xa6\x36\xfa\x41\x64\x22\xd4\xa1\xb3\xd5\x09\x02\x23\
\xaf\xcc\x79\xe5\x35\x53\x7e\x7b\x5c\x51\x6b\x1b\xd8\x1f\x67\x64\
\x41\xc9\x72\x46\x75\xb8\x4e\x0f\x64\x28\x15\xe2\xbf\x46\x66\x1e\
\xd8\x97\x6b\x3b\x6f\xba\xcc\xd2\x2d\xdd\x01\xfe\x0b\xf2\xc2\xbf\
\x0f\x23\xf1\xe3\x68\xd4\x9d\xd5\x41\x3a\xa7\x53\xca\x80\x49\x57\
\xe2\x16\x9c\x6a\xd5\x20\x80\x55\x18\x4d\x09\xe7\x69\xf8\x68\x30\
\x45\xe1\xbf\x08\x08\xfa\x9a\x34\x88\x5a\x0d\x83\xa9\xae\xa8\xfe\
\xec\xdd\xc8\x60\x85\xf1\xcc\xdf\x7e\xa8\x34\x14\x3d\xf8\x58\x0d\
\xfa\x56\x84\x23\xe3\x88\x30\xb6\x9b\x3a\x93\x0a\x7b\x82\x3b\xaa\
\x0b\x79\x1d\xaa\xd3\x37\xf2\x01\xe4\x29\xf4\x0f\x21\x2f\x42\x1b\
\xda\xae\xae\x02\xdf\xb4\x58\x6e\x00\xbf\x88\x80\xe9\xbf\xe1\x67\
\x6c\xcb\xfe\xb7\x5c\x92\x05\xa7\x5e\x20\xd5\x79\x2b\x52\x54\x78\
\xbc\x30\x5e\x36\x9c\x67\x39\xa1\x53\x63\xbf\x7e\xef\x90\xee\x3f\
\x2a\xd7\x61\x5d\x4b\x7d\xfd\x91\x13\x8d\x2a\x92\x5a\x16\x88\x4e\
\xd5\x67\x97\x81\xbf\x00\xfc\x4d\x46\x88\x7c\x5f\x74\x8a\x0c\x72\
\xb1\x1a\x7e\x1a\x3e\x56\x59\x8d\xca\x6f\x94\x9f\xc0\xce\x47\x6b\
\xf9\xeb\x54\x8d\x9e\xdb\x27\xf7\xa0\xa1\xa4\xc3\x21\xc5\x15\xe9\
\x70\x9d\xbe\x81\x97\x81\x1f\x45\x66\x1a\xb8\xbc\xbb\xd3\xbf\xf0\
\x7a\x14\x69\x00\xbc\x07\x19\x4c\xf2\xf3\xc8\x88\xbc\x4f\xb0\x7b\
\x28\x59\x85\xa2\xd5\x42\xb3\x1c\x93\xa5\x02\x0c\x58\xe6\x4b\x0b\
\x4c\x5e\x98\xf1\xb2\x5a\x6b\x38\x59\xe1\xba\x3a\xdf\xb7\xdc\x51\
\x39\x6f\x2b\x4c\xe7\x55\x28\xd6\x3d\xb3\x06\x25\xe8\x0a\xe5\x08\
\x78\x3b\x32\xdd\xd1\x18\x31\xb7\x5f\x7a\x19\xa9\x0f\x75\x39\x6b\
\x41\xc7\x82\x50\x4f\x63\x26\x6a\x28\x86\x3a\x33\x18\x6d\x38\x45\
\x50\xe4\x90\xee\x03\x9f\x46\x2a\xc2\x3f\xb2\xed\xeb\x18\x32\xf5\
\x18\x32\xcb\xc3\x9f\x44\x06\x3e\xfc\x2c\xe2\x9a\x3e\x49\x2e\x1e\
\x5d\xb6\x75\x65\xaa\x61\x94\x09\x13\x60\xac\x6b\x79\x8e\xe9\xc8\
\xf8\x4e\xd9\x5f\xbb\xa0\x16\x98\xf4\xb9\x58\xe7\x63\x41\xca\xeb\
\x37\x2a\xc7\xf4\x80\x64\x95\x97\x53\xf2\x1d\xcf\xf5\xf1\x22\x10\
\xbd\x06\x79\xdb\xf2\x77\x54\xe7\x34\xb4\x3f\xaa\x5d\x91\x07\x22\
\x0d\xa1\xec\xa3\x1b\x59\x28\xc1\x7a\x99\x73\xc1\xb4\x4f\xce\x08\
\xd6\x41\xe4\x0d\x66\xd0\x37\xc3\x0a\xd7\xfd\x28\xf0\x87\x18\x05\
\xe5\xac\xf5\x55\xc8\xac\xe1\x7f\x1e\x79\x45\xc2\xaf\x20\xaf\xe5\
\xfe\x08\x32\x2a\x2f\xeb\x92\x22\xb7\x64\xc1\x09\xfc\x82\xd1\x2a\
\x20\x11\x98\xca\xf7\xad\x21\xd5\x45\x75\x83\x49\xff\x7d\x0b\x4a\
\xfa\xbc\xeb\x06\x58\xc9\xfb\x99\x41\x0c\xfa\xef\xad\x7b\xab\xef\
\x4f\x7d\xae\x35\xf8\xea\xf3\x3a\x42\x5e\x79\xf1\x3d\x08\x90\x86\
\xf6\x4f\x37\x91\xe7\x7e\xb4\x1b\xb6\xe0\xe3\xcd\xb6\xb2\xc9\x40\
\x86\xa2\x94\x23\x2a\x3a\x53\x18\x25\xdf\x75\xe4\xf5\x1f\x59\x4b\
\x7d\xa3\x9f\x45\x42\x45\xef\xde\xd6\xf9\x0f\x75\xeb\x2b\x90\xf0\
\xe9\xb7\x20\xbf\xe3\xff\x41\xc0\xf4\x61\x64\x4a\xa2\xf2\xe2\x2f\
\x1d\xdf\xb6\x60\xd4\x13\xbe\xf3\x1c\x13\xac\x17\x18\xab\x62\xd6\
\xdb\x51\x5f\x8d\xde\x2e\x20\xd1\xf9\xd7\x92\x07\xa3\x7a\x24\xdf\
\x1c\x23\xea\x22\x10\x69\x08\xd5\xe5\xef\x2d\xc0\xf7\x22\x0f\xe5\
\x0e\xed\xaf\x5e\xa4\x0d\x21\x2b\x34\x77\x1c\x7c\xc7\xcb\x3f\x2d\
\x28\x59\xf9\x6c\xad\xbf\x08\xf6\xcb\x19\x69\x57\x54\xef\x07\xbf\
\xdf\xc8\x0b\xd5\x1d\x03\xff\x0a\x79\xfb\x69\xab\xd3\x7a\x68\xf7\
\x3a\x42\x5e\xa3\xfd\x46\x24\xd4\x73\x1b\x19\xf8\xf0\x51\x64\x84\
\xde\x27\xd9\x1e\x94\x22\x47\x92\x39\x6f\x2f\xad\x1d\x50\xed\x9e\
\x3c\x10\x1d\x19\xfb\x7a\x61\x64\x39\x2f\xcf\x31\x6a\xf7\xa8\xcf\
\xdf\x0a\xcd\x3d\x0e\xfc\x15\x64\x32\xe2\x11\x69\xd8\x6f\x95\xd9\
\x11\xac\x06\xba\xe7\x8c\xac\xed\x6c\xff\x51\xa6\x5c\xa5\xb4\x4f\
\x30\xf2\x64\xb9\x23\x2b\x5c\x67\xd9\xca\xdf\x40\xfa\x2a\xfe\xc0\
\xce\xcf\x7a\xa8\x57\xd7\x80\x6f\x58\x2c\xdf\x85\x0c\x82\x28\xae\
\xe9\xc3\xc8\x44\xa0\x99\xf0\x5d\xa6\x4f\xa9\xd7\x2d\x95\x7d\x56\
\xa3\x46\x03\x21\x72\x2d\x16\xa0\x3c\x97\xa4\xff\xc7\x29\xed\xd9\
\x18\xf4\xff\xb2\xa2\x09\xd6\xb1\x35\x84\x8e\x90\x51\x71\xef\x46\
\x66\x34\xf9\xfd\x0c\x08\x1d\x82\x4e\x59\x2d\x27\x5e\xbf\x90\xb7\
\x78\xae\x28\x0b\x22\x0b\x48\xfa\xfc\x5c\x9d\x39\x8c\x12\x53\x04\
\xe9\xfd\x56\x01\xb3\x5a\x01\x65\x3e\xbb\xa7\x81\x77\x31\xdc\xd1\
\xa1\xe9\x31\xe4\x79\xb1\x6f\x45\x7e\xeb\x67\x91\xb0\xde\xff\x06\
\xfe\xd7\x62\x7d\x9d\x9c\x5b\x6a\x81\x09\x23\x5d\xaf\x6b\x95\x7d\
\xad\x10\x5e\xcb\xc1\x58\xb2\xf2\x77\xf9\xbb\xd6\x68\x3a\xab\x0f\
\x2b\x53\x49\xe8\xd0\xdc\x9b\x91\xf7\x5e\xbd\x07\x79\x19\xde\xd0\
\xe1\xe8\x25\xc4\x15\x65\x06\x2a\x44\x40\xd2\xae\xc8\x8b\x4e\x4c\
\x0a\xd1\x79\x3a\x73\x18\x25\x65\x15\xd2\x52\x88\xea\x50\x9d\xf5\
\xec\xd1\x27\x80\x5f\x26\x7e\xcb\xe6\xd0\x7e\xeb\x08\x99\xeb\xec\
\x49\xe4\x8d\xb5\x45\x9f\x45\xa0\x54\x96\x67\x80\xe7\xf1\x43\x77\
\x53\x9c\x52\xcb\x31\xe9\xf3\xac\xd3\x1a\x1a\xbd\x60\xd2\xa3\x4a\
\x5b\xdf\xb7\xf6\xe9\xca\xa0\x0e\xf9\x15\xc0\xfd\x16\x04\xfa\x4f\
\x21\x61\xd3\xa1\xc3\xd3\x31\xab\x8d\x33\x0f\x3e\xd6\x3e\x3d\x31\
\x6e\xe6\x19\xc1\xa8\x3c\x41\x90\x5f\xad\xfe\x22\xd8\x13\x18\x75\
\xb8\x23\x6b\xf1\xdc\x51\x3d\xb2\xee\x69\x06\x8c\xce\xa3\x1e\x5f\
\x2c\x75\x18\xf6\x3a\xe2\xa0\x8a\x7b\x7a\x06\x71\x55\x75\x21\xca\
\x80\x09\x23\x5d\xaf\x5b\xf2\x1c\x92\x15\x12\xcb\x00\xca\xfa\xbf\
\x35\x58\xa2\xef\xeb\xcf\x2f\x21\x0f\x2c\x7f\x1d\x32\x19\xee\x37\
\xb2\x27\x75\xc1\xd0\x64\x95\x91\xa9\x2d\x47\xa4\xc1\x63\x81\x28\
\x7a\x2f\x91\x37\x88\x21\x13\xe6\x0e\x75\x48\x19\xd0\x73\x47\xde\
\x60\x86\x12\xaa\x3b\x46\x2a\xa4\x8f\x20\xf3\x66\x0d\x9d\x6f\xbd\
\x8a\xe5\x74\x45\x45\x77\x10\x40\x7d\x02\xf8\x4d\xc4\x51\x7d\x06\
\x71\x51\x9f\x63\xf9\x70\x60\x2b\xcc\xd0\x0b\xa6\xc8\x15\xe9\xfe\
\x9f\x68\xca\x9f\xec\x28\x3a\xeb\x7f\x17\x5d\x43\x46\xc3\xbd\x1d\
\xf8\x5a\x24\x1c\x77\x48\xe5\x7f\xc8\xd7\x4d\x96\xef\x2c\xca\x84\
\xe3\xbc\x17\x28\x46\xae\xa8\x86\x52\x2b\xda\x80\xb1\xdd\xd4\xde\
\x64\xc6\x09\xaf\x97\xa8\xa1\x14\xcd\xca\x50\x7e\x98\xa7\x19\x30\
\xba\xa8\xba\x0a\xfc\xee\xc5\xa2\x75\x02\x7c\x11\x01\xd3\x67\x17\
\xeb\xe7\x16\xeb\x92\x7e\x81\xf5\x51\x68\xd9\xf0\x9d\x17\xba\xcb\
\x3a\xa6\x08\x46\x16\x98\x8e\x90\xd9\x30\x9e\x58\x2c\x4f\x22\xa1\
\xb7\x37\xb1\x47\xe5\x7d\x68\x36\x9d\x20\xd1\x00\x6f\xa8\x76\xcb\
\x05\xdd\x0b\x3e\x6b\x0d\x5e\x68\xf5\xc3\xae\xc9\x0b\xd1\xc1\x61\
\x65\x4e\x8b\xb8\xde\xa8\xba\x32\x81\x6a\x71\x47\x97\x91\x17\x92\
\x7d\x0c\x69\x19\x0e\x0d\x15\x5d\x42\x06\x4b\x3c\x06\x7c\x8d\xf3\
\x9d\x7b\x08\xa8\x0a\xac\x0a\xb8\x5e\x62\xf5\x45\x63\x77\x90\x97\
\x90\xdd\x51\xcb\xf1\xe2\x38\x16\x44\x32\x60\x42\x6d\xbf\x1a\xe9\
\xe7\x79\xcd\x62\xf9\x8a\xc5\xf2\x7a\x04\x40\xe3\x61\xd4\x8b\xa3\
\xeb\x48\xfe\x8c\x06\x2a\x58\x2f\x4f\xd4\xfb\x5a\x20\xca\x8e\xa6\
\x2b\xea\xe9\x6b\x05\xf6\x0c\x46\x13\x27\x50\xf5\xfa\x8d\xac\xc1\
\x0c\x4f\x33\x60\x34\xd4\xaf\x2b\xc0\x57\x2e\x96\x29\x3a\x61\x1d\
\x50\xe5\x2d\x99\xb7\x59\xbe\x81\xf3\x2e\xeb\x6f\x31\x7e\xb0\x5a\
\x1e\x42\x40\x34\x86\x59\x0f\x81\xe4\xa1\x97\x99\x16\x9e\xb3\x42\
\x75\x25\x6d\x0d\xf1\xce\x38\x23\x8c\x74\x5a\x7b\x05\x23\x47\x16\
\x94\x7a\xdc\x51\x3d\x90\xe1\x63\xc8\x93\xfe\x6f\xdd\xd1\xb9\x0f\
\x0d\x81\xc0\xe3\xa1\xc5\x32\x34\x34\x87\x4e\x59\x1f\xb4\x90\x05\
\xd0\x26\xa3\xe9\x5a\x20\xb2\xce\x53\x12\x41\x88\x0e\xf6\xb0\x85\
\xa5\x4e\x58\xa7\x2d\x18\x45\xee\xc8\x1a\xe2\xf8\xf4\x16\x4f\x7f\
\x68\x68\x68\x68\x17\xba\xce\xf2\xfd\x61\x5e\x3f\x91\xe7\x84\xa2\
\x50\x9d\x35\xf3\x42\x5d\xa7\xb6\x40\xd4\x3d\x70\xa1\x68\xef\x60\
\xe4\xc8\x82\x52\xef\x30\xef\xb2\x7c\x14\xf8\xf8\xae\x4e\x7c\x68\
\x68\x68\x68\x66\xbd\x8c\xbc\x3f\x4c\x87\xd3\xbc\xd1\x72\x59\x20\
\xe9\x63\xf5\xf6\x17\x75\x03\xa8\xd6\x5e\xc2\x68\x82\x3b\xb2\xc6\
\xc0\x47\x1d\x7a\xc3\x1d\x0d\x0d\x0d\x1d\xa2\xee\xe0\x87\xe7\x74\
\xff\xcf\x3d\xc4\x3d\x69\xf0\xd4\xfb\x5a\xcf\x17\x79\xe1\xb9\x56\
\x7f\x11\x75\xba\x15\xa2\x83\x3d\x85\x91\xa3\x39\xdd\xd1\x2f\x23\
\x0f\x44\x0e\x0d\x0d\x0d\x1d\x8a\x8e\x91\xc7\x10\xbc\x11\x73\x91\
\x0b\xb2\xa0\xe4\xb9\xa3\xd6\xcc\x0b\x2d\x57\x34\xc9\x21\x1d\x0a\
\x8c\xe6\x76\x47\xf7\x81\xf7\xee\xe2\xc4\x87\x86\x86\x86\x66\x50\
\x79\x1e\xae\x0c\xe3\xee\x19\x2d\x77\x97\x18\x48\x51\x88\x2e\x13\
\xa6\x2b\x9a\xec\x8a\x60\x8f\x61\xe4\x5c\xc0\x5c\xee\xe8\x18\x79\
\x4d\xc1\xff\xd8\xd2\xe9\x0f\x0d\x0d\x0d\xcd\xa9\x17\x58\x4e\x82\
\x1a\xf5\x11\x15\xe8\xd4\x4b\x04\x24\x6b\x34\x5d\x6b\xd6\x85\xc8\
\x19\x4d\xee\x37\xda\x5b\x18\x19\xda\x86\x3b\xfa\xa1\x5d\x9c\xf8\
\xd0\xd0\xd0\xd0\x06\xba\x8e\x3c\x4c\x5d\x83\x48\x83\xc4\x0b\xc7\
\x59\x40\x2a\x69\x0d\xa2\x68\x38\x77\xcf\x90\xee\xf3\x17\xa6\xdb\
\x81\x3b\xfa\x55\xe4\x35\xd8\x43\x43\x43\x43\xfb\xa8\x9b\xc8\xc8\
\xb9\x4c\xff\x50\x0d\x1d\x0d\x21\xcb\x2d\xb5\xe6\xa6\x8b\x26\x47\
\x6d\x0d\x5e\x90\x9d\xc9\x10\x1d\xec\x39\x8c\x0c\x4d\x75\x47\x1a\
\x48\xf5\x8d\x1f\x7d\x47\x43\x43\x43\xfb\x28\x3d\x72\xce\xeb\x1f\
\x6a\x81\x47\x03\xa8\xd5\x67\xe4\x0d\xe9\xce\x0c\x58\x38\xbf\x61\
\xba\x99\xdc\x91\x65\x3f\xcb\x8f\xfb\x71\xe0\x3f\x6f\xe9\xf4\x87\
\x86\x86\x86\xa6\xe8\x0e\xf0\x05\xda\x03\x15\x32\x10\xb2\xa0\xa4\
\x1d\x96\xd7\x57\xd4\xea\x27\x72\xfb\x8a\x7a\x5c\x11\x1c\x00\x8c\
\x0c\xb5\x9e\x41\xea\x71\x47\x65\xfd\x5e\x36\x20\xfa\xd0\xd0\xd0\
\xd0\x8c\xba\x0d\x7c\x1e\xfb\xb9\xa1\x29\x20\x9a\x32\x94\xdb\x5b\
\x9a\xa1\xb9\xa9\x3a\x08\x18\x35\xdc\x91\x17\xae\xcb\xb8\xa3\xf2\
\x63\xfc\x06\xf0\x73\x5b\x3a\xfd\xa1\xa1\xa1\xa1\xac\x6e\x32\xdd\
\x11\xdd\xa1\x0f\x4c\xad\x01\x0c\xbd\x33\x74\x77\x0f\xe7\xae\x75\
\x10\x30\x32\xe4\xc1\xa9\xd7\x1d\xd5\x50\xfa\xe1\x45\x7a\x68\x68\
\x68\xe8\x2c\xf4\x32\xd2\x47\xd4\x82\x90\x06\xd1\x1d\x95\xd6\x33\
\xc3\x47\x0e\x29\x9a\x71\x21\x13\xa6\x2b\xda\xd8\x21\x1d\x0c\x8c\
\x02\x77\x94\x59\x32\x53\x04\x7d\x0a\xf8\xd0\x56\x2f\x62\x68\x68\
\x68\xc8\xd6\x0d\x62\x10\x59\x00\xaa\x81\xd3\x72\x45\xde\x34\x40\
\xd1\x6c\x0b\x2d\x47\x84\xb1\x3d\xc9\x15\xc1\x01\xc1\xa8\x43\x19\
\x77\x64\x41\xe9\x3e\x32\x67\xdd\xbd\xdd\x9f\xf2\xd0\xd0\xd0\x05\
\xd6\xf5\xc5\x92\x05\x91\x5e\x6a\x20\x59\x8e\xa8\x67\x38\xb7\x35\
\x17\x5d\x6b\x62\xd4\x59\xfa\x8d\x0e\x0a\x46\xce\x04\xaa\x53\xdc\
\x91\x37\x90\xe1\x39\xe0\xfd\xdb\xbe\x8e\xa1\xa1\xa1\xa1\x85\x5e\
\x00\x5e\xa4\x6f\xc8\xb6\xf5\xa2\xc6\xc8\x29\x6d\x32\x78\x21\xf5\
\x3c\x51\xd1\x54\x57\x04\x07\x06\x23\x43\xde\x85\x5b\x20\xca\x86\
\xeb\x7e\x04\xc9\x1c\x43\x43\x43\x43\xdb\xd2\x09\x32\x50\xe1\x25\
\xfa\xc2\x72\x16\x94\xac\x74\xc6\x19\xd5\x8d\xf1\xcc\x80\x85\x70\
\xd0\xc2\xa6\x3a\x38\x18\x4d\xe8\x3b\xd2\x20\x6a\xcd\xe8\x7d\x1d\
\xf8\x97\x5b\xbd\x88\xa1\xa1\xa1\x8b\xac\xbb\xc0\x67\x91\x01\x0b\
\x91\x23\x8a\xc2\x70\x19\x47\xe4\x8d\xa0\xcb\xce\xb6\x90\xe9\x33\
\xfa\xb2\x36\x71\x45\x70\x80\x30\xea\x50\x6b\x74\x5d\xe4\x8e\xfe\
\x3d\xf0\xeb\xbb\x3f\xe5\xa1\xa1\xa1\x73\xae\x97\x10\x10\xdd\xc1\
\x1f\xae\xed\x01\x29\xb3\x44\x03\x17\x22\x10\x65\x1e\x72\x2d\x9a\
\xdd\x15\xc1\x81\xc2\x28\xd9\x77\x54\xef\x3b\x21\x07\xa5\x7a\x12\
\xc2\x7f\xba\xd5\x8b\x18\x1a\x1a\xba\x48\x2a\x61\xb9\x7a\xc4\x9c\
\xf7\x20\x6b\xe4\x84\x6e\x57\x8b\xe5\x8a\x3c\x20\x45\x03\x16\x7a\
\x5e\x11\x61\x82\x68\x53\x57\x04\x07\x0a\xa3\xa4\xa2\x41\x0c\x11\
\x88\xca\x8f\xf5\x6b\xc0\xcf\xef\xfc\xac\x87\x86\x86\xce\x9b\xee\
\x00\xcf\xb3\x0c\xcb\x45\xaf\x7c\xb0\x40\xa4\xc1\xd3\xe3\x8a\xf4\
\xa4\xaa\x73\x3c\x53\xb4\xa2\x39\x40\x04\xe7\x07\x46\x99\x91\x75\
\x19\x77\xa4\x3b\x12\x7f\x10\xf9\x91\x87\x86\x86\x86\xa6\xe8\x45\
\x96\x61\xb9\x16\x84\x5a\x8e\xa8\x17\x48\xad\xbe\xa2\x6c\x1f\x91\
\x76\x43\xb3\x86\xe7\x8a\x0e\x16\x46\x1d\x34\x6e\x3d\x77\x14\x4d\
\x13\xf4\x3c\xf0\xe3\xb3\x9e\xf8\xd0\xd0\xd0\x45\xd0\x7d\xe0\x73\
\xc0\x97\xc8\x0d\x52\xc8\x40\xe8\xb6\xb1\x64\x5c\x51\xf4\xbe\xa2\
\x02\x25\xab\xd1\x5e\x6b\x6b\xe1\xb9\xa2\x83\x85\x11\x6c\xf4\xdc\
\x51\x26\x5c\x57\xd2\x3f\x81\xb4\x6c\x86\x86\x86\x86\x5a\x3a\x45\
\x06\x29\x7c\x06\x09\xcb\x45\x6e\xc8\x02\x90\x05\x1b\xaf\x9f\xa8\
\x67\xea\x9f\xa9\xef\x2a\x72\x43\x74\x73\x82\x08\x0e\x1c\x46\x1d\
\xea\x1d\xea\x5d\xb7\x26\x6e\x02\x3f\xb0\xfb\x53\x1e\x1a\x1a\x3a\
\x30\xdd\x46\xa2\x29\x5f\x60\x1d\x08\x53\x46\xc7\x79\x60\xca\xf6\
\x15\x45\xaf\x86\xd0\x8e\x48\xbb\xa2\xc8\x1d\x6d\x45\x0f\x6c\xf3\
\xe0\xbb\xd0\xe9\xe9\xe9\xe9\xd1\xd1\xd1\x51\xd9\x04\x8e\xb0\x6f\
\x9a\xbe\xe9\x47\x2c\x7f\x94\x23\x04\xcc\x97\x58\x05\xd2\xe5\xc5\
\xf2\x8b\xc8\x5b\x61\xbf\x76\x6b\x17\x32\x34\x34\x74\xa8\x3a\x46\
\xc2\x71\x37\x89\xc3\xfe\xad\x51\x74\xd1\xf3\x45\xd6\xba\xa4\xf5\
\x6c\x0d\xad\x67\x8a\xb2\x03\x17\x30\xd6\xb2\x31\xb3\x2b\x82\x8b\
\xe1\x8c\xa2\xf0\x5d\x14\xaa\xd3\xcb\x3f\x63\xcc\xea\x3d\x34\x34\
\xb4\xd4\x29\x32\x40\xe1\x33\x48\x68\xae\x37\x24\x17\xf5\x05\x79\
\x8e\xc8\x1a\xd2\xdd\x02\x51\xeb\x5d\x45\x5d\xcf\x13\x6d\x03\x44\
\x70\x0e\x9c\x91\x21\xed\x8e\xea\xb4\xe5\x8e\x8a\x43\xaa\xa1\x54\
\x1c\x52\x71\x47\xe5\x9d\x47\x1f\x00\x9e\xda\xc5\x45\x6c\x49\xe5\
\xfa\xea\xe7\xa9\x0a\x60\x2f\x21\xf7\xe2\x72\xb5\xbe\xbc\xd8\xff\
\xc0\x62\xdf\xd0\xd0\x90\xe8\x26\xf2\xcc\xd0\x3d\xda\x0f\xd1\xd7\
\x8e\x68\xca\x04\xa8\xd1\xcc\x0a\x51\xff\x90\x9e\xf2\xa7\xf5\x70\
\x6b\x51\x38\x94\x7b\x5b\x3a\x17\x30\x52\xa1\xba\xb5\x8f\x17\xeb\
\x02\xa5\xc8\x21\x15\x10\xe9\x70\x5d\x81\xd2\xd3\xc0\x37\x01\xaf\
\xdc\xca\x85\x6c\x4f\xf7\x59\x76\xa6\x7a\xd3\x7e\xb4\x66\xea\xbd\
\x02\x5c\x5d\x2c\xd7\x16\xcb\x55\x06\xa4\x86\x2e\x96\xee\x22\x10\
\xba\x45\x3c\x1a\xb7\xac\x6b\x38\x58\xce\x29\x0b\xa3\x16\x88\xf4\
\xff\xb2\x06\x2b\x58\x33\x72\xb7\x06\x2b\xec\xc4\x15\x01\x1c\x6d\
\xf1\xd8\x3b\x95\x01\xa3\xa3\x6a\x5d\x2f\x97\xd4\x52\x1c\xc0\x03\
\xd5\x72\x65\xb1\x3c\xc8\xb2\x02\x2e\xcb\xb7\x01\x7f\x75\x8b\x97\
\x32\xa7\x4e\x91\x42\x53\x0a\x8e\x37\x68\xa3\x05\x26\x2f\x8e\x0c\
\xf0\x10\xf0\xf0\x62\x79\x68\xb1\x3c\xb8\xc5\x6b\x1a\x1a\x3a\x0b\
\xdd\x46\xe6\xad\xd4\x10\xd2\xd1\x06\xeb\x79\xc5\x4c\x3f\x51\x04\
\xa5\x68\x80\x42\xa6\x7f\xa8\x3e\x4f\xaf\xb1\x79\x26\xfd\x44\xb5\
\xce\x85\x33\x82\x8d\xdc\x91\x1e\xcc\x70\x49\xad\x8b\x2b\x2a\xe0\
\xfa\x20\xf0\x76\xc4\x21\xed\xb3\x4e\x58\x4e\x4d\x6f\xc1\xc7\x5b\
\xf7\x02\xe9\x36\xd2\x52\x2c\x3a\x42\xf2\xd5\xa3\xd5\xf2\x08\x02\
\xf7\xa1\xa1\x43\x52\x69\xcc\x5d\x47\xf2\xb9\x55\x86\xb4\x13\xaa\
\x61\xd4\x02\x91\x07\x20\x6b\xbf\x17\x92\xcb\x86\xe5\xf6\x1a\x44\
\x70\x8e\x9c\x51\x91\x02\x52\xe4\x8e\x4a\xbf\x48\xed\x8e\x8a\x43\
\xba\xb2\x58\x3f\xc8\x32\x3c\x55\x5c\xd2\x35\xe0\xd5\xc0\xf7\x03\
\xaf\xdb\xee\xd5\x4c\x56\xe9\x58\xbd\x8b\x5f\x80\x74\x8b\x29\x82\
\x92\x06\x12\xa8\xcc\x5a\xc9\xbb\xe7\x0f\x21\xe1\xcd\x57\xb2\x04\
\xd4\x45\x18\x40\x33\x74\xcd\x9f\x7c\x11\x00\x00\x10\x2f\x49\x44\
\x41\x54\x78\x2a\xcf\x0a\xd5\x65\xc8\x2b\x3f\x3d\x7d\x44\xd6\x64\
\xa8\x11\x78\x7a\x20\x14\x0d\x56\xd8\x08\x44\x30\x60\x34\x49\x4e\
\xb8\xae\xae\x20\x2f\xb1\x0a\x25\x0d\x24\x1d\xaa\x2b\xe1\xba\x3a\
\x64\x77\x0d\x78\x33\xf0\x7d\xec\x67\x8b\xff\x45\xd6\x5b\x72\x3d\
\x4b\x26\xbe\x0c\xeb\x99\xd6\x03\x91\x17\x2a\x7d\x14\x78\x15\x4b\
\x40\x3d\x3c\xcb\xd5\x0f\x0d\x4d\xd3\x09\xf2\xfa\xef\xf2\xd6\x55\
\x5d\x0e\x22\x08\x65\x1d\x91\x07\xa2\x08\x40\x77\x8d\x63\x7a\x6e\
\xc8\x7b\x96\x68\xaf\x41\x04\xe7\x10\x46\xd0\xed\x8e\x34\x90\xbc\
\xbe\x23\x0b\x48\x7f\x14\xf8\xcb\xdb\xbd\x9a\x6e\xbd\x8c\xb4\xea\
\xa2\x70\x82\x15\x5a\xf0\xa0\xd4\xe3\x8e\x5a\x30\xd2\x0d\x01\xbd\
\x7e\x10\x01\x53\x0d\xa8\xd1\xff\x34\xb4\x6d\xdd\x65\xe9\x84\xac\
\xc6\x58\xe4\x86\xa2\xe7\x88\x32\xae\x28\xeb\x82\x5a\x83\x14\x34\
\x3c\xa7\x80\x48\xa7\x77\x06\x22\x38\x47\x7d\x46\x81\xca\x50\xef\
\x92\x46\xa5\xeb\x7e\xa3\x92\xbe\xcf\x6a\x0b\xfe\x98\xf5\x01\x0f\
\xf7\x90\x57\x94\xbf\x15\x78\xe7\x56\xaf\x20\xaf\x63\xa4\x65\xd7\
\xd3\x8a\xd3\xe9\x56\xeb\xca\x1b\x75\x53\x14\x39\x51\x0d\x1f\x0d\
\xa4\x3b\x08\x4c\x9f\xaf\xf6\x3f\x84\xc0\xa9\x00\xea\x11\xe4\xfe\
\x0f\x0d\x6d\xa2\x63\x24\xaf\xdd\x40\xf2\x9d\x37\xb0\xa7\x2e\x0b\
\x5e\x63\xce\x72\x44\xad\xbe\xa2\x28\x9d\x85\x50\xe4\x86\xb2\xa3\
\xe6\xf6\x02\x44\x70\x4e\x61\xe4\x0c\x66\xa8\xa1\x54\xb6\xcb\xba\
\x06\x52\xfd\xec\x51\x19\xc8\x50\x03\xa9\x76\x51\xf7\x80\x7f\x0c\
\xbc\x01\x78\x7c\x0b\x97\xd2\xab\x32\x29\xa3\x86\x91\xce\xc4\x5e\
\xc6\xf6\x5c\x92\x6e\x59\x9d\x2c\xfe\x9f\x95\x59\x5b\xe1\x39\x0b\
\x44\x3a\x5d\xef\xbb\x83\xb4\x58\x3f\xcd\xb2\x9f\xef\x11\xa4\xdf\
\xae\xf4\x41\x3d\xcc\x18\x62\x3e\xd4\xd6\x09\xf2\x7c\xd0\x8d\xc5\
\xba\x76\x0d\x59\x37\xe4\xf5\x0f\xf5\x84\xe8\x5a\xf0\x89\x20\x64\
\x81\x28\xdb\xd7\xbb\xb7\x20\x82\x73\x1a\xa6\x83\xf4\x50\x6f\xab\
\x12\x6c\x0d\xf5\xb6\xc2\x75\xaf\x07\xfe\x36\xf0\x9a\xad\x5d\x50\
\x5b\x37\x10\x18\x45\xa1\x04\xfd\xcc\x83\x57\xa0\x5a\xe1\xba\xc8\
\x1d\x65\x40\xd4\x82\x50\xeb\x33\xbd\xff\x0a\xab\xe1\xbd\x47\x10\
\x47\x35\x34\x04\x32\x22\xee\x06\x12\x8a\xb3\xc2\x57\xde\xe8\xd2\
\x6c\x58\xae\xf5\x3c\x51\xcf\xe2\x95\x53\xfd\xff\xbd\x81\x47\xad\
\xb0\xdc\x5e\x82\x08\xce\x31\x8c\x20\xdd\x77\x94\x79\xf6\x28\x1a\
\xcc\x50\x80\xf4\x24\xf0\xb7\x38\x9b\x07\x62\xef\x02\xcf\xb1\x9a\
\x49\x5b\x61\x04\x2b\xa4\xd0\x1a\x1e\xba\x0d\x18\x65\xa0\xd4\x03\
\x2b\xdd\xff\x54\xfa\x9e\x1e\x65\x00\xea\xa2\xa8\x0c\xc9\x2e\x2e\
\x48\x3f\xde\x50\xf2\xb1\x76\x42\x53\xfa\x87\x7a\x42\x74\x99\xfd\
\xd9\x06\xa2\xd5\x50\x6c\xb9\xa1\x26\x88\x60\xc0\x68\x2b\xea\x7c\
\x10\xb6\x1e\xcc\x50\x4f\x83\xd3\x03\xa4\xdf\x09\xfc\x0d\xa4\x65\
\xbe\x2b\x9d\x20\x21\xac\x12\xf7\x8e\x40\xd4\x2a\x10\x5e\x01\xd0\
\xc3\x43\x33\x30\x02\xbb\xbf\x68\x4e\x18\xf5\x80\xea\x08\xf9\xed\
\xea\xc1\x11\x03\x50\xe7\x47\x77\x11\x00\xbd\x8c\x40\x48\x57\xce\
\xde\x62\x41\x28\xd3\x3f\xd4\x03\xa3\x68\x3b\x1b\xa5\xb0\xdc\x50\
\x76\xd8\xf6\xde\x83\x08\xce\x39\x8c\x20\x74\x47\x65\xad\x47\x78\
\xe9\xe7\x8e\xbc\x67\x8f\xac\x70\xdd\x35\xe0\x4d\xc0\x5f\x67\x77\
\x95\xdc\xf3\xc8\x50\xd4\x28\xae\xdd\x13\x22\xf0\x5a\x63\x5e\xa8\
\x4e\x4b\x03\xdf\xba\xbf\x16\x28\x2c\xa0\x5c\x76\xf6\x6f\xe2\x9c\
\xf4\xfe\x07\x58\x05\x54\x09\xf1\x8d\x3e\xa8\xfd\x56\xe9\xff\xb9\
\xc9\xea\x54\x57\xa7\xe4\x20\x94\x71\x43\xbd\x20\x8a\xa2\x0f\x51\
\x24\xa2\x05\xa1\xde\xbe\xa1\x92\x86\x03\x01\x11\x5c\x3c\x18\x41\
\x3e\x5c\xa7\x61\xe4\xf5\x1f\xe9\x07\x62\xaf\x01\x6f\x01\xbe\x7b\
\x91\xde\xa6\x3e\x0b\x7c\x9e\xf5\x4e\xd7\x16\x88\x5a\x23\x77\x74\
\xb8\xce\x1b\x55\x07\xeb\x99\xba\xe5\x8c\x7a\x5c\xd1\xa6\x30\xea\
\x75\x4e\x35\xa0\x5e\x81\x80\xe9\x15\x8b\xe5\x61\xe4\xf7\x1c\x90\
\x3a\x1b\xdd\x47\xdc\x7f\x71\x3f\xb7\x58\x07\x4f\x16\x44\xbd\xfd\
\x43\x99\xf0\x5c\xe4\x90\x3c\x60\x59\x65\xcd\x0b\xc9\x59\x83\x2c\
\xac\xeb\xf6\x9c\x90\x57\x5e\x65\xe7\x1e\x80\xe0\xdc\xc3\x08\x52\
\xee\xa8\x35\x98\x21\xd3\x7f\xf4\x20\xcb\xc9\x43\xaf\x02\xbf\x03\
\xf8\x4e\x64\xa4\xdd\xdc\x3a\x45\x42\x73\x5f\x64\xbd\x90\x59\x85\
\xc5\x02\x91\xf7\x5c\x83\x55\x48\xa2\x7e\x23\x4b\xbd\x7d\x46\xad\
\x10\x5d\x2f\x94\xa2\xef\xf7\x0c\x98\xd0\x6e\xee\x01\x04\x4a\x05\
\x52\xf5\x9c\x7c\x03\x52\xf3\xe9\x84\xd5\x57\x2b\xdc\x62\x39\x13\
\x42\x9d\xf7\x3c\x00\x59\x30\x9a\xda\x3f\xa4\x21\x91\x01\x51\xe4\
\x98\x5a\x00\xd2\x65\xce\x72\x42\xbd\xa3\xe5\xf6\x1e\x44\x70\x31\
\x61\x04\xd3\x06\x33\xe8\x70\x9d\x1e\x5d\xa7\x43\x76\x57\x91\x4a\
\xea\x3d\xc0\xb7\x33\xdf\x4c\x0d\x27\xc8\xeb\x2c\xbe\xc4\x6a\xa1\
\xd3\x85\x49\x87\x08\x2c\x08\xe9\xe7\x1c\x74\xa1\xb1\x9c\x91\x05\
\xa3\x53\x56\x2b\x63\xcf\x1d\x45\x40\xb2\x00\x30\xd5\x19\x4d\xfd\
\xbb\x96\x6b\xb3\xd2\x65\xb8\xf9\xc3\x2c\x5d\x54\xed\xa4\x2e\x31\
\x14\xa9\x06\xcf\x2d\x96\xef\xeb\xd1\xc0\x69\x41\xa8\xb7\x6f\xa8\
\xe5\x88\x22\x08\xb5\x96\x4c\x08\x4e\xaf\x2d\x27\xe4\x81\xa8\x67\
\x90\xc2\x41\x80\x08\x2e\x08\x8c\x60\xf2\x60\x06\xcf\x1d\x65\x06\
\x34\xd4\x60\xfa\x4a\xe0\xcf\x01\x5f\xbd\xc1\x25\x1c\x23\xfd\x43\
\xcf\x21\xe0\xa8\x33\x9f\xee\x74\x8d\xc2\x73\xd6\xd3\xde\xd6\x54\
\xf4\x56\xbc\xda\xea\x37\xb2\xe4\x8d\xa8\xeb\x1d\xda\x3d\x75\x99\
\x2b\xbc\xd7\x72\x70\x1e\x60\xeb\x6b\x2d\x8e\xb9\x7e\xed\x46\x59\
\x4a\xbe\x39\xef\xae\xea\x04\xff\x15\x09\xc7\xc4\x9d\xee\x16\x94\
\x32\x4e\xa8\x15\x92\xb3\x60\x64\x39\x14\xcf\xc9\xf4\x2c\x16\xd8\
\xa2\xd1\x71\x59\x08\x59\x7d\x43\xa9\xfe\x21\xd8\x2f\x10\xc1\x05\
\x82\x11\xcc\x1e\xae\xf3\x9e\x3f\xb2\x46\xd9\x95\xf5\x37\x23\xb3\
\x7d\xbf\xb6\xe3\xb4\x6f\x02\x9f\x42\x40\x74\x52\xed\xaf\x33\x64\
\xab\xbf\xc8\x9a\x90\xd1\x72\x47\x3a\x54\x67\x15\x14\x5d\x20\x2c\
\x65\x40\x3f\xa5\x0f\x69\xd7\x30\xca\xba\x26\xcf\x31\x79\x90\xd2\
\xdb\x3a\xaf\x68\x58\xed\xf3\x94\x48\x75\x78\xb8\x6e\x08\xd5\xef\
\xe3\xb9\x87\xdf\xa1\x3e\x15\x42\x99\x01\x0a\xd9\xfe\xa1\x1e\x67\
\xe4\x01\x29\x02\x57\x0b\x40\x2d\x08\x4d\x75\x43\x3a\xbd\xdc\xb9\
\x87\x15\xff\x45\x86\x11\x6c\x16\xae\xab\x81\x64\x8d\xb0\xf3\x9c\
\xd2\x55\xe0\x09\xe0\x6d\x08\x94\x5e\x85\x84\xf3\xca\xc8\xa0\x12\
\xaa\xa8\x5f\x2f\x5c\x57\x5e\x45\x75\x01\xad\x9d\x51\x16\x46\x51\
\x9f\x51\xcb\x19\x95\xff\x5b\xce\x63\xed\x56\x3b\xf7\x35\xaa\xa4\
\x7b\x60\x34\x77\x1f\xd3\x5c\x6e\xc9\x83\x92\x75\xdd\xde\xb6\x97\
\x17\xaf\xb0\xcc\x7b\x3a\x3f\xd6\x8f\x23\xe8\xb5\x75\x3f\xca\xef\
\xe6\x55\xfa\x16\x04\xbc\x56\xbf\x95\x0f\xac\xca\x31\x6a\xc1\x67\
\xcf\xc5\x82\x90\xde\xd6\x79\xd5\x82\x50\x8f\x2b\x6a\xf5\x1d\x79\
\xd0\xb1\x8e\xe7\x9d\x83\x3e\x5f\xcb\xf5\x45\xc0\xf6\xee\xf9\x9a\
\xf6\x11\x42\x45\xe7\x72\x3a\x20\x4f\xc9\x77\x1e\xd5\xdb\xb5\x13\
\xa9\x2b\x87\xfb\xac\x56\x14\xc7\xb4\x2b\x94\xfa\xff\x3e\x8b\x84\
\xdb\x0a\xb4\x6a\xa0\xd5\xa0\xd3\x95\xc8\x14\x18\x79\x7d\x45\x99\
\x01\x0c\xba\xf0\x6c\x0a\xa3\x1e\x97\xb4\x0d\xc7\xb4\x0b\x20\x45\
\xd7\x15\x81\xa9\x05\xa5\xdb\x6a\x5b\xdf\x5f\x8c\xb4\xb5\xd6\x69\
\x6b\x3b\x2b\xaf\x05\x3e\x15\x42\x9e\x13\xea\x75\x43\x1a\x4a\x2d\
\x10\x45\x40\x6a\xc1\xa9\xd5\xff\x63\x0d\x48\xd0\xe7\x16\xb9\x20\
\x0f\x44\xd6\xfd\xb5\x7e\x8b\xe5\xce\x3d\x06\x11\x5c\x30\x18\x19\
\x3a\x45\x0a\x62\x59\xeb\x7d\x65\xbb\x64\x8a\xba\x60\xd7\x40\xf2\
\x2a\x5f\x58\x2d\xe8\x56\x41\xd4\x30\xa9\x81\x54\xc3\xa8\x3e\xae\
\xfe\x7b\x2b\x4c\x17\x8d\xa2\x8b\x66\x08\xce\xc2\xc8\x2b\x08\x56\
\x25\x38\x05\x48\x11\x98\x3c\x28\xed\x0a\x56\x2d\x50\xb6\x1c\x52\
\xc6\x31\xf5\x2c\xfa\x3e\x7b\xbf\x43\xbd\xd6\x69\x12\xfb\xc1\x6e\
\xb4\xe9\x74\x0b\x46\xf5\x3e\xab\xb2\x9d\xda\x3f\x64\x41\xa8\xd5\
\x4f\x34\x05\x4a\x16\x78\x5a\xee\x27\x13\x8a\xcb\x3a\xa1\xc8\x05\
\x1d\x24\x88\xe0\x02\xc2\xc8\x70\x47\x1a\x3e\x75\xba\x7c\x7e\x52\
\x7d\x06\x92\xa1\xca\xb6\x57\x01\x64\x60\xa4\x41\x72\x05\xc9\xd4\
\x53\x9c\x91\x86\x91\x06\x52\x06\x46\xde\x88\x1f\xab\xc0\xb4\x60\
\xe4\xdd\x1f\xaf\xe2\x9d\x02\xa6\x2c\xa4\xe6\x06\x56\xc6\xb5\x65\
\x81\xb4\x2d\x28\x91\x58\xeb\xb4\xa5\xba\x91\xa6\xd5\x0b\xa2\x3a\
\xed\xc1\xc7\x72\x05\x53\x5d\x91\xb5\xb6\xe0\xd0\xea\xcf\xc9\x7e\
\xa7\x15\x86\x8b\x5c\x50\x06\x44\xfa\x5e\x5a\xf7\x7d\x4d\x87\x00\
\x22\xb8\x80\x30\x4a\xc8\x6b\xf9\x69\x28\x59\xee\x48\x57\x0c\xe5\
\xbb\x56\xe1\xd3\x85\xa7\x64\xf8\xe2\x8c\xea\x7e\x80\xb2\xc0\x6a\
\xe5\x50\x32\x6e\x14\xa6\x6b\x3d\x67\x64\x3d\x1d\x6e\x85\x17\x2c\
\x10\xe9\x82\x51\xcb\x73\x46\xf5\x3e\x5d\xf1\xb6\x2a\x68\xaf\x72\
\x6f\x41\x6a\x4e\x50\xf5\x82\x68\x13\x77\xd4\x03\x26\x7d\xaf\xad\
\xdf\x40\xff\x36\x3a\x6d\x6d\x6b\x45\xe5\xc3\x5b\x4f\x71\x45\x11\
\x88\x74\x43\x6e\x0a\x8c\xb2\x2e\x29\x03\x1b\xcb\xf9\x44\x10\x8a\
\x00\x54\xa7\xf5\xfd\xb3\xee\xaf\x4e\x2f\x77\x1e\x08\x84\x8a\x2e\
\x24\x8c\x1a\xee\x48\xb7\x04\x75\xe1\x39\xaa\xd6\x90\x2b\xcc\x3a\
\xe3\x68\x57\x53\xe0\x51\x3b\x23\x0d\x23\x5d\xa1\x78\xee\xaa\x1c\
\x4f\x3f\x67\x14\xcd\xbe\x50\x7f\xdf\x0b\x37\x78\x30\xd2\xd7\xa7\
\xef\x81\x57\x59\x7a\x4b\x06\x50\x53\xdd\x53\x0f\xa4\x22\x30\x65\
\xe1\x73\x16\x0e\xc9\xbb\xe7\x18\x6b\x9d\x8e\xf6\x81\x0f\xa2\x3a\
\x1d\x55\xa2\xde\xe2\x55\xc6\x5e\x68\x2e\x0b\xa3\x56\xa8\x2e\x02\
\x4a\x4f\xc8\xcd\x0b\xc1\xf5\x40\x68\x8a\x1b\xd2\xe9\xe5\xce\x03\
\x03\x11\x5c\x50\x18\x41\x13\x48\xb0\x0e\xa5\x13\xa4\x82\x38\x61\
\x55\xad\x90\x5d\x7d\x0c\xdd\xd2\xb3\x42\x01\x75\x88\x6e\x13\x18\
\x45\x40\xb2\x42\x73\xb5\x2b\xf2\x60\xe4\xb5\xdc\x2c\x79\x15\x60\
\x6f\xe5\xda\x03\xa7\x4c\xc5\xdf\x0b\x93\x0c\xc4\x32\x30\xf2\xf6\
\x79\xd7\x31\x37\x90\xf4\x3e\x54\xda\xda\xf6\xd4\xaa\x18\x7b\x40\
\x34\x05\x46\x3a\x22\xd0\x1b\xaa\xeb\x81\x54\xe6\x18\x1e\x14\xad\
\x72\x33\x25\x1c\x77\x6e\xdd\x50\xad\x0b\x0b\xa3\x84\xac\x1f\xb5\
\x64\xa2\xa2\x56\xe1\xb5\x5a\x92\x1e\x44\x6a\x10\xd5\xfd\x45\x97\
\x59\x56\x4c\xe5\x7f\xd6\x80\xb4\xc0\xe6\x85\xeb\x34\x98\xbc\xe7\
\x25\x22\x57\x54\xd6\x18\xeb\x5a\x2d\x18\xd5\xe9\xb9\xe0\x14\x39\
\x8f\x4d\x5c\xd4\x1c\xe9\xcc\x3a\x4a\x6f\x0a\x23\xfd\x3b\x44\xe9\
\x8c\xe6\x72\x45\x1e\x8c\xa2\x30\x9d\xce\xf7\x2d\x20\xb5\x00\x32\
\x17\x74\xbc\x73\xf4\x60\x3b\x05\x42\xd6\xb6\xec\x3c\x60\x10\xc1\
\x05\x87\x51\xf9\xf1\x2a\x87\x54\xbb\xa3\xba\xd2\x2f\x2a\xee\xa8\
\xce\x58\x60\x17\xf4\x95\x7f\xa5\xfe\xa6\xce\xd8\x57\x16\x6b\x0d\
\x22\x6b\xf0\xc2\x91\x71\x4c\x7d\xbc\xba\xbf\xc7\x72\x48\x3a\x24\
\x37\x05\x44\x19\x67\x64\xdd\x97\x0c\x90\xac\x7d\x59\x30\x65\x2a\
\xf6\x5e\x48\x65\x01\x36\x15\x40\x11\x7c\x76\x15\xaa\xb3\xb6\x5b\
\x9a\x0b\x46\x3a\x4f\x65\x60\x64\xc1\x29\x02\x51\x6b\x3b\x93\x9e\
\x02\x9f\x0c\x84\xbc\xfb\x15\xdd\xe7\xe5\x8e\x03\x07\x50\xad\x0b\
\x0d\x23\x47\x2d\x20\x69\x77\x54\xeb\xbe\xda\xf6\x0a\x9f\x86\x87\
\x05\x22\x6f\x24\xdd\x91\x3a\xb6\x75\x3c\xcf\x21\x59\x20\xaa\xe1\
\xe5\xc5\xc4\xbd\xc2\x04\x46\x01\xa9\xe4\xb5\xc6\x3d\x38\x6d\x02\
\x28\xaf\xe2\xce\xb8\x8e\xa9\x00\xd9\x74\xbd\x4b\x18\x45\x6b\x9d\
\x6e\xa9\x05\xa2\xb2\xce\x00\xa9\x17\x46\x11\x88\xea\xcf\x32\x20\
\xc9\xba\xaa\xe8\x7f\xb7\xdc\x4f\x06\x42\xd1\x7d\xd4\xe9\xe5\xce\
\x73\x04\x22\x18\x30\x02\x98\x3a\xa0\xc1\x03\xd2\xca\xa1\xab\x75\
\x0b\x1e\xc7\xac\x3f\x61\x6f\xc1\x48\x1f\xdf\x2a\x44\x1a\x46\x16\
\x98\xb4\x83\xb2\x20\xb4\x89\x2b\x2a\xb2\x2a\xbc\x68\x9d\x05\x54\
\xf4\x59\x54\x89\x47\x15\x7e\x16\x56\xbd\xa0\xe9\xf9\x1f\xdb\x00\
\x51\x0f\x84\x5a\x50\xf2\x42\x46\x5e\x05\xdb\x02\x92\x07\xa3\x08\
\x44\x2d\x28\x6c\xba\x78\xc7\x8a\xce\x25\xba\xa6\x01\xa1\x84\x06\
\x8c\x16\x9a\x30\xa0\x01\x7c\x20\x79\x19\xd1\x83\x51\x3d\x82\xee\
\x98\x55\x18\xd5\x15\x93\xf5\x7f\xac\x16\xa1\x06\x52\xb4\xf6\xdc\
\x50\x04\xa2\x1e\x18\x81\x5f\xf9\xb5\x2a\xcc\x4d\x20\xd5\xb3\x64\
\xfb\xa1\xe6\x4c\xcf\x09\xa0\x39\x61\xe4\xed\x2b\xf2\x2a\xcb\x08\
\x46\x75\x7a\x13\x20\x65\x9c\x52\x6b\x7b\x13\xe0\xf4\xba\x9f\xa9\
\x10\xb2\xb6\xcf\x2d\x84\x8a\x06\x8c\x72\x8a\x32\x41\xc9\x8c\xad\
\xef\x5b\x30\xba\x8c\x54\xfe\x05\x42\x7a\x8e\x31\xab\x82\xd2\xc7\
\xd3\xc7\xf5\x86\xa7\x66\x1e\xda\xf3\x0a\x66\x54\xb8\x32\xca\xc0\
\x28\xbb\x6e\x01\x6a\x9b\x90\xca\x02\xa4\x35\x08\x21\xbb\x6f\x0a\
\x80\x32\x10\x8a\x60\x14\x81\x08\x72\xce\xa8\xac\x33\x20\x6a\xc1\
\xa9\x05\xa6\x0c\xa4\x7a\xd2\xd1\x3a\x0b\x9e\x59\x21\x04\xe7\x1f\
\x44\x30\x60\xb4\xa2\xc0\x1d\xd5\xdb\x5a\x27\x48\x45\x62\xb9\x24\
\x0b\x16\x1a\x46\xde\x44\x97\x7a\xe0\x42\x16\x46\xda\x21\x59\x60\
\x6a\xb9\xa1\xa9\x20\x2a\xfb\x74\x85\x56\xef\xaf\xff\x2e\xaa\x1c\
\x37\x01\x54\x66\x7b\x5b\xb0\xda\xf4\xb3\x5d\x81\xa8\x17\x42\x5a\
\xa7\x46\x7a\x5b\x40\xca\x40\x69\x8e\x75\x36\x9d\x01\x4f\x0b\x3e\
\x03\x42\x4a\x03\x46\x4a\x89\xfe\x23\x0f\x48\x16\x28\xea\xed\xcb\
\xac\x66\xec\x1a\x1a\x11\x88\xac\xc1\x0b\xe5\x98\xb0\x5a\x50\x2c\
\x20\x59\x60\xb2\xd6\x51\x0b\x31\x2a\x5c\x3a\x5d\x6f\x47\x50\x2a\
\xdb\x47\x6a\xbf\xf5\xb7\x9b\x80\xc9\x4b\xf7\x42\xca\xfb\xde\x9c\
\x60\x99\x7a\x1e\xad\xeb\xb5\xd6\x3a\x6d\x6d\x7b\xf2\x7e\xfb\x1e\
\x18\x59\xfb\x22\x18\x45\x80\xea\x81\x49\x04\x18\x0f\x38\x5e\x39\
\xf0\xae\x29\xb3\xb6\xee\xdf\x72\xe7\x05\x82\x50\xd1\x80\x91\xa1\
\x89\x40\x82\xa5\x3b\xb2\xc0\x74\xca\x72\x58\x78\x71\x52\xc5\x55\
\x15\x20\xdd\xc7\xef\x10\xb7\x8e\x5b\x1f\xbf\x05\xa4\x28\xed\xc5\
\xc5\x5b\x05\x4e\x9f\x4b\x56\xe5\x3e\xd6\x7f\x1b\x41\x69\x97\x80\
\xd2\xdb\xbd\xd0\x9a\xf3\x6f\xad\xbf\x8b\xce\xd7\x4a\x5b\x6b\x9d\
\xb6\xb6\x5b\xca\x00\xc9\x83\x53\x16\x48\x53\x40\x91\x81\x4c\x6f\
\xa8\x2d\x2a\x07\xad\xeb\xb5\xee\x91\xb5\x2d\x3b\x2f\x20\x84\x8a\
\x06\x8c\x1c\x6d\x08\x24\x0f\x46\x35\x94\x0a\x90\x4a\xfa\x3e\xb6\
\x23\xd2\x15\xcf\xca\x69\x1a\x8b\x15\x0e\x8c\x16\x0b\x42\x51\x4b\
\xb0\xfe\xdf\x2d\x79\xdf\x89\xee\x5f\xfd\x77\x3d\x80\xca\x82\xaa\
\x17\x56\x73\x01\x6b\xca\x67\xd9\xf3\x88\xae\xcd\x5a\xeb\x74\xb4\
\xcf\x52\x54\xb1\x7a\x00\xf2\xd2\xbd\x50\xea\x01\xd5\xd4\xef\x79\
\xe7\x63\x5d\x43\xb4\xd6\x69\x6b\x5b\x76\x5e\x60\x08\x15\x0d\x18\
\xf5\x29\x0b\x24\x58\x66\xfc\xfa\x21\xd9\xba\x50\x5c\xc2\x0e\xc9\
\x45\x61\x1f\xeb\x7c\xa2\x42\x17\x81\xa7\x15\x92\xb3\x0a\x61\xbd\
\xd6\xe9\x8c\xca\x35\x4c\x29\x78\xe5\x9e\xd7\x7f\x6f\x41\xa9\x4e\
\xcf\x05\xa8\x7a\xdf\x1c\xe0\xea\xfd\x1b\xef\xff\xb5\xce\xd9\xba\
\x5e\x9d\xb6\xb6\xb3\xf2\xf2\x42\x54\x49\xb7\xc0\x34\x17\xa0\xa6\
\x1e\x33\x73\x9e\xd6\xb5\x79\xfb\xac\xed\xe5\x07\x03\x42\x5f\xd6\
\x85\x7a\xd3\xeb\x14\x39\x2f\xe3\xcb\xb4\xae\x0b\x5c\x74\xba\xe7\
\x81\xc8\x08\x44\x45\x59\x20\x59\xe0\xf1\xc2\x17\xfa\xb8\x60\x17\
\xba\x39\x14\x5d\x5b\xa6\xf5\x1e\x6d\x67\x60\x14\x7d\xd6\x0b\xaa\
\x4c\x7a\xca\xdf\x44\xff\x37\xb3\x8e\xd2\xd6\x76\x56\x59\x18\x95\
\x74\x06\x4e\x1e\x34\xac\x7d\x19\xc0\x64\x8f\x95\x3d\xc7\xcc\x75\
\x7b\xdb\xcb\x0f\x46\xc5\xbb\xa6\x01\xa3\x84\x36\x04\x52\x0b\x4e\
\x11\x80\x7a\x60\x54\xa7\xe7\x18\x1d\x44\xb0\x5e\x3d\x81\x44\x26\
\x0a\xde\xb0\x6b\x7e\xbd\xf3\xb3\xb9\x00\x65\xed\xeb\x59\x6f\x0a\
\xae\x68\x5f\xeb\x3b\xd1\xf7\x75\xda\xda\x6e\xed\x2f\xb2\x7e\x6b\
\xaf\x12\xde\x04\x4a\x5e\x7a\xee\xed\xe8\x3c\xac\x73\xf7\xf6\xd1\
\xd8\x27\x1f\x8c\x0a\xd7\xd5\x80\x51\x52\x1d\x40\x2a\x6b\xab\xd2\
\x69\x41\x47\x0f\x56\xd0\x20\xaa\xd3\x51\x01\xcf\x00\xe7\x24\xf8\
\x3b\x82\xf5\xf2\x9f\x6e\x98\x79\xce\x01\xa0\xa2\xcf\xe6\x70\x34\
\xbb\x76\x42\xd9\xdf\x63\x0a\x90\xac\x7d\x3d\x50\x6a\x7d\x3e\xf5\
\x18\xd1\xda\xdb\x97\xd9\x5e\x7e\x30\x2a\xd9\x94\x06\x8c\x3a\x94\
\x04\x52\x49\xb7\x5c\x52\xe6\x3b\xde\xf1\x8b\xbc\x82\xe6\x41\x26\
\xe3\x84\x9a\xad\xbf\x6d\x16\xae\x3d\x07\x54\x9d\x9e\x13\x56\xbd\
\x7f\xd3\xda\xa7\xd3\x99\xed\x4d\x14\x55\xcc\xad\x74\x2f\xa0\x7a\
\x3e\x6b\x7d\x27\xfa\x3b\x9d\xce\x6c\xaf\x7e\x38\x2a\xd7\x2e\x0d\
\x18\x75\xaa\x01\xa4\x3a\xed\xb5\x8c\x23\x08\x59\xdf\xd7\xc7\xd7\
\x6a\x15\xc2\x08\x4e\x18\xe9\x7a\xad\xd3\x3b\x2f\x60\x9d\x70\x82\
\xb3\x05\x94\x97\x9e\x7b\xdf\x94\x74\xb4\x2f\xda\x6f\xc9\xcb\x03\
\x73\x42\x29\xfa\x6c\xea\xba\xb5\x4f\xa7\x33\xdb\xab\x1f\x8e\x0a\
\x75\xb2\x06\x8c\x26\xa8\x03\x48\x25\x9d\x01\x94\xf7\x5d\x9d\xd6\
\xf2\x0a\xda\x94\x10\x46\x94\xde\x9b\x82\xb6\x67\x80\xd2\xdb\x67\
\x95\xce\x6c\x7b\xfb\xb2\xdf\x69\xfd\xfe\xd6\xe7\x3d\x40\xaa\xd3\
\xbd\xfb\xa6\x1c\xaf\x75\x2e\xd1\xbe\xe5\x87\x7b\x52\x2e\x0e\x5d\
\x03\x46\x13\x15\x54\x88\x9b\x84\x68\x7a\x1c\x91\xd6\x36\x5a\x8f\
\xcb\x1d\x7b\x9e\x51\xce\x00\x50\xd6\xbe\xa9\xd0\x9a\xeb\x33\x6b\
\xdb\xdb\x97\xf9\x2c\xa3\x29\x2e\x49\x6f\xef\x32\x9d\xd9\xf6\xf6\
\x2d\x3f\xdc\xf3\xf2\x70\x88\x1a\x30\xda\x40\x49\x20\xd5\xdb\xbd\
\xfd\x0c\xd6\xb1\x2c\x79\x85\xab\x37\x5c\x61\x6d\x1f\x6c\xc1\xdb\
\x01\xa0\xbc\xfd\x53\x00\xb1\xe9\xb6\xb7\x2f\xda\x9f\xfd\xdc\xd2\
\xa6\x2e\xa9\x77\x7b\x13\xb8\x64\x43\x6d\x03\x40\x67\xa8\x01\xa3\
\x0d\xd5\xa8\xf0\x7a\xc3\x39\x99\x0a\xc7\x53\xa6\x20\xf7\x14\x68\
\xd9\x79\xce\x32\xc8\xcc\x80\x8a\x3e\x9f\xea\xae\x7a\xf6\xf5\x7e\
\x37\xfb\xf9\x14\x45\xf9\x24\xeb\x3c\xe6\x80\x4a\x8f\xcb\x69\xe6\
\xed\xf3\x96\xff\xf7\x59\x03\x46\x33\x28\x51\xc1\x6d\x12\xbe\x89\
\xf6\x67\x0a\xd9\xe4\x0e\xd9\x8b\x52\x10\x27\x00\x0a\xe6\x85\xd4\
\xd4\xbf\x99\x2b\xfc\x36\x15\x4e\xd9\xfc\xd1\x03\x83\x4d\x61\xd2\
\x0b\xc5\xd5\x2f\x5c\x90\x3c\xbf\x8f\x1a\x30\x9a\x51\x13\xa0\xd4\
\xb3\x2f\xab\x4d\x0b\xb8\x7c\x38\x32\xc6\x36\x5c\x54\xe6\x3b\x9b\
\x02\x66\x17\x10\xd2\xda\x14\x4a\xd1\x67\x53\xe1\x92\xce\xbf\x23\
\xaf\xef\x87\x06\x8c\xb6\xa0\x64\x25\x36\x35\xbe\x9f\xd1\x68\x1d\
\x6e\x49\x13\x5d\x14\xe4\x7f\xd7\x7d\x05\xce\x14\x65\xf2\xd1\x94\
\xbe\xa7\x29\xdf\x91\x2f\x8e\xbc\xbd\xb7\x1a\x30\xda\xa2\x3a\x2a\
\xae\x6d\x56\x18\xa3\xa0\xee\x40\x1b\x40\x0a\xfa\x7f\xff\x6d\x03\
\x71\x13\xf5\xe6\xa1\x9e\xef\x77\xe7\xcf\x91\xa7\x0f\x47\x03\x46\
\x3b\xd2\x0e\x5a\xd4\x93\x7f\xc8\x51\x60\xb7\xa7\x0d\x21\xb5\x72\
\xa8\x3d\x39\x46\x4b\x9b\xe6\xa5\x49\x7f\x3f\xf2\xf0\xe1\x6b\xc0\
\xe8\x0c\x34\x63\x05\x35\x49\xa3\xe0\xee\x8f\xb6\x94\x17\xce\x34\
\x7f\x19\x9a\x35\xbf\x8d\xfc\x7b\x3e\x35\x60\xb4\x47\x9a\xbb\x62\
\x1a\x85\xf6\xf0\x75\xd6\x0d\x97\xb3\xd0\xc8\xb7\x17\x53\x03\x46\
\x43\x43\xe7\x44\xfb\x0e\xae\x01\x99\xa1\x48\xff\x1f\xe1\x02\x16\
\xef\x12\xb7\x4a\x4b\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x02\xa6\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x16\x00\x00\x00\x16\x08\x06\x00\x00\x00\xc4\xb4\x6c\x3b\
\x00\x00\x02\x6d\x49\x44\x41\x54\x78\x5e\x95\xd4\x4d\x48\x54\x51\
\x14\x07\xf0\xff\x7d\x73\x07\xc1\x2c\x24\x50\x68\xe7\x26\x82\x04\
\x9c\x55\x42\x50\x0e\xe4\x26\x97\x01\x6e\x8b\x06\x30\x68\xe5\x4e\
\x20\xa7\x8d\x64\x53\x44\xb4\xd2\x00\x95\xf6\x05\x14\x60\x40\x04\
\x45\xe2\x4a\x4a\x91\x2a\x2a\x40\x31\xc8\x22\x53\x07\xe7\xbd\x79\
\x5f\xe7\xd4\xb9\xd3\x85\xe7\x34\x9f\x3f\xb8\xdc\x07\xf3\xde\xff\
\x9d\x73\xee\x63\x14\x6a\x28\x14\x1e\xdd\x07\x90\x41\x02\x33\x56\
\x27\x26\x2e\x8f\xa3\x0a\x33\xa3\x25\xf9\xfc\xec\xc2\xec\xec\x13\
\xae\x36\x33\xf3\x98\x27\x27\x67\x16\xaa\x42\xeb\x2e\xfd\xe1\x41\
\x7f\xb7\xa3\x70\x53\x29\x64\x5e\xff\x3a\xdf\xbd\xdf\xd5\x95\x19\
\x1b\xbb\x04\xd7\x2d\x23\x69\x74\x74\x18\xf3\xf3\xcf\xae\x3c\xcc\
\x5f\xcb\x64\x7b\xde\xec\x49\x07\x00\xc6\x51\xcf\x4a\xe1\xf4\xbb\
\xed\xe5\xeb\x7c\xb0\x55\xe0\xbb\xd3\xb7\x79\x69\x69\x95\xb7\xb6\
\x7e\xd4\x5c\xf2\xdb\x9d\x5b\xd3\xe6\xde\xed\xe5\xab\x2c\xcf\xd6\
\xad\x18\xc7\x8e\x67\x7a\xcf\xf4\x41\x04\xb1\x0b\xb1\xb9\xf9\x1d\
\xf5\x04\xb1\x8f\xce\x13\x47\xd0\xd9\x7b\x0a\xdf\xde\x7e\xca\xa0\
\x0e\x1d\xb0\x06\x07\x65\x88\x0b\x43\x84\x97\xaf\x9e\xa2\x91\xe1\
\x2c\x57\xee\xf7\x43\x04\x91\x83\x7a\xd4\x8b\x7b\xe7\x38\x9b\x1b\
\x42\x23\xef\x37\x72\x68\x64\x65\xe5\x23\x72\xb9\x8b\x0a\x09\xda\
\x75\x09\x14\x96\xd1\xcc\xc0\x40\x1f\xac\x20\x60\x44\x11\xe1\xe0\
\xc0\x85\xe3\x38\x10\x73\x73\xcf\x39\x19\xae\x5d\x2f\x36\xad\xb5\
\x23\x95\x52\x60\x76\xfe\xee\x0e\x98\x61\x0c\x0e\xf6\x27\xc3\x25\
\x98\x40\x12\xdc\x26\xa5\x20\xc1\x52\xb9\x19\x85\x65\xc3\x75\xd9\
\x37\xa3\x68\x3b\x54\x54\xc6\x40\x18\x19\x39\x8b\xfd\xfd\x12\x8a\
\xc5\x12\xd6\xd7\xbf\x42\x68\x26\x3a\x34\x0a\xf6\x42\xc0\x0d\x81\
\x28\x06\x88\x61\xf4\xd4\xaa\x56\x41\x29\x65\xf6\xdd\x5d\x0f\x9e\
\x57\x36\xd7\x96\x66\x96\x51\xf8\x26\x84\x7f\x97\x80\x90\x5a\xae\
\x58\xf6\x38\x66\x84\x61\x0c\xad\x53\x20\x72\x60\x69\x10\x81\x7c\
\x0f\xbc\xe3\x02\x61\x8c\x66\x98\x81\x30\xb4\x5f\x85\x07\xdf\x8f\
\xd0\xd1\x91\x06\xb3\x46\x1c\x53\x55\xc5\xbb\x45\x70\xc9\x6f\x29\
\x54\x96\x54\xe9\xfb\xbe\xb9\x4e\xa7\x53\x10\x44\x6c\x46\x63\xc9\
\x6b\x40\x3b\xc5\x96\x0f\x4d\xaa\x0d\x82\x00\xa2\xd2\x3e\x41\x48\
\x07\x8e\x93\x9c\xb1\x1f\x81\x82\x10\xad\x20\x92\xe0\x48\x2a\xb3\
\xcb\x7c\x19\x44\x6c\x0e\x2e\x8a\x18\x96\x86\x3d\xbc\xe6\xa4\x39\
\x30\x73\xcd\x4e\xec\x8b\x2c\xfd\x73\xcf\x81\x57\x0a\xd0\x91\x26\
\x34\x23\xa7\x6f\x49\x88\xad\xb2\x16\x3d\xb5\xf8\x59\xdd\x18\x39\
\xc9\x3d\x47\x23\xd4\x93\x1d\xb2\xa3\x88\xff\x1d\x20\x9b\x45\xc4\
\xf6\x50\xff\xa3\x65\x9b\x5a\xfc\xa2\xd0\xc0\xda\xda\x06\xc7\xf1\
\xe1\xb6\x2b\xe1\xb6\xfa\xff\xc3\x35\x9a\x93\xff\x02\xb3\xda\xf1\
\x07\xdd\xb7\xb7\x8c\xe3\x21\x45\x3c\x00\x00\x00\x00\x49\x45\x4e\
\x44\xae\x42\x60\x82\
\x00\x00\x0b\x52\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x10\x06\x00\x00\x00\x23\xea\xa6\xb7\
\x00\x00\x00\x04\x67\x41\x4d\x41\x00\x00\xb1\x8f\x0b\xfc\x61\x05\
\x00\x00\x00\x01\x73\x52\x47\x42\x00\xae\xce\x1c\xe9\x00\x00\x00\
\x20\x63\x48\x52\x4d\x00\x00\x7a\x26\x00\x00\x80\x84\x00\x00\xfa\
\x00\x00\x00\x80\xe8\x00\x00\x75\x30\x00\x00\xea\x60\x00\x00\x3a\
\x98\x00\x00\x17\x70\x9c\xba\x51\x3c\x00\x00\x00\x06\x62\x4b\x47\
\x44\xff\xff\xff\xff\xff\xff\x09\x58\xf7\xdc\x00\x00\x00\x09\x70\
\x48\x59\x73\x00\x00\x00\x48\x00\x00\x00\x48\x00\x46\xc9\x6b\x3e\
\x00\x00\x09\xdb\x49\x44\x41\x54\x68\xde\xe5\x59\x5b\x6c\x1b\x55\
\x1a\xfe\xe6\x16\x7b\xc6\x63\x3b\x1e\x27\x8e\x93\x26\x69\xeb\xe6\
\x02\x34\x8d\x4b\xa3\xb6\x5b\x4a\x59\x78\x28\x6d\xa4\x56\x48\x6d\
\xc4\x52\x8a\x40\xa2\x0f\x20\x21\x21\x95\x07\x76\x91\x76\x91\x10\
\x02\x96\x65\x21\x4f\xec\xf2\x82\x8a\x2a\xe0\xa1\xb4\xa5\x69\xcb\
\x6d\xdb\x82\xe8\x06\x52\xea\x26\xa5\xc1\x69\x5a\xd7\x31\x24\x34\
\x76\x62\x3b\x8e\xed\x24\xf6\xd8\x73\xdb\x87\x89\xe3\x5c\xdb\x24\
\x4a\xca\x4a\x1c\x69\x74\x34\x33\xe7\x9c\x39\xdf\x77\xbe\xff\x72\
\xce\x10\xda\x78\xc1\xef\xb4\xd0\x8b\xed\x18\x8f\xc7\xe3\xf1\x38\
\xe0\xf7\xfb\xfd\x7e\x3f\x10\x89\x44\x22\x91\x08\x30\x3a\x3a\x3a\
\x3a\x3a\x0a\x48\x59\x29\x2b\x65\x81\x1c\xbd\x14\x4d\xd1\x14\x0d\
\xf0\x3c\xcf\xf3\x3c\xe0\x74\x3a\x9d\x4e\x27\x50\x5b\x5b\x5b\x5b\
\x5b\x0b\x98\xcd\x66\xb3\xd9\x7c\xe7\x09\x20\xe6\xab\x80\x4c\x26\
\x93\xc9\x64\x00\xaf\xd7\xeb\xf5\x7a\x81\x60\x30\x18\x0c\x06\x01\
\x49\x92\x24\x49\x02\x0a\x0a\x0c\x05\x2c\x0b\xb0\x2c\x6f\x36\x99\
\x00\x8e\x65\x59\x8e\x03\x48\x0a\xd0\x34\x40\x14\xd3\xe9\x54\x0a\
\x48\xc4\x13\xf1\x44\x1c\x48\x8e\x24\x47\x92\x23\x00\x49\x90\x04\
\x49\x00\x55\xd5\x55\xd5\x55\xd5\x40\x43\x43\x43\x43\x43\x03\x40\
\x51\x14\x45\x51\xff\x07\x04\x0c\x0f\x0f\x0f\x0f\x0f\x03\x9e\x8b\
\x9e\x8b\x9e\x8b\x80\x98\x11\x33\x62\x06\x30\x1a\xad\x16\x9b\x0d\
\x28\x2d\x5d\xb5\x6a\xcd\x1a\x80\xe7\x59\x8e\xe3\x00\xa3\x91\xa6\
\x49\x12\x30\x18\xf4\xda\x68\x64\x68\x8a\x04\xe8\x71\x05\x90\x24\
\x49\x92\x24\x20\xa6\xc5\xb4\x98\x06\xda\x3b\xda\x3b\xda\x3b\x80\
\x9f\x03\x3f\x07\x7e\x0e\x00\xbc\x99\x37\xf3\x66\x60\xe7\xce\x9d\
\x3b\x77\xee\xcc\x2b\xe6\x8e\x13\x10\x8b\xc5\x62\xb1\x18\xd0\xd6\
\xd6\xd6\xd6\xd6\x06\xa8\x2a\x40\x10\x40\x51\xd1\xca\x95\xb5\xb5\
\x40\x61\xa1\xcd\x56\x68\x05\x8c\x46\x86\xa1\xe8\xf9\x03\xcf\xad\
\xac\xa2\xe8\x5f\x95\xb2\x8a\xa2\xaa\x40\x7f\x7f\x28\x38\x30\x00\
\xb4\x5d\xf8\xf6\xfc\x37\xdf\x00\x8a\xac\xc8\x8a\x0c\xec\xd9\xbb\
\x67\xef\x9e\xbd\x80\xc5\x62\xb1\x58\x2c\x4b\x4f\x00\x39\xfd\x81\
\x28\x8a\xa2\x28\x02\x1e\x8f\xc7\xe3\xf1\x00\x24\xa9\x4f\xd8\xe9\
\xac\xad\x75\xbb\x97\x1e\xb8\x24\x2b\x8a\xa6\x01\x82\xdd\x5e\x54\
\x54\x04\x6c\xdb\xb6\x7d\x7b\x63\x23\xa0\xaa\x7a\xbb\x96\x96\x96\
\x96\x96\x16\x40\x51\x14\x45\x51\xee\x00\x01\x9d\x9d\x9d\x9d\x9d\
\x9d\x80\x2c\xcb\xb2\xa2\x00\x76\xfb\xaa\x55\x35\x35\x00\xcf\xb3\
\xac\xd1\xb0\xf4\xc0\x65\x59\x07\x26\x49\x8a\xa2\xa9\x00\x4d\x1b\
\x0c\x2c\x0b\x6c\x68\xb8\x6f\xeb\x1f\x1f\xcc\x9b\x60\x6b\x6b\x6b\
\x6b\x6b\xeb\x32\x12\x90\x48\x24\x12\x89\x04\x10\x0a\x85\x42\xa1\
\x10\x60\x34\x5a\x2c\x85\x56\xdd\x3b\x5b\x2d\xcb\x0f\x5c\x92\x14\
\x45\xd5\x00\x59\x56\x15\x55\x05\x4c\x26\x9b\xcd\x6e\x07\xca\xcb\
\x57\xaf\x76\xb9\x80\x1f\x2f\xff\x78\xf9\xc7\xcb\x40\x36\x9b\xcd\
\x66\xb3\xcb\x40\x40\x20\x10\x08\x04\x02\x80\xaa\xaa\xaa\xaa\x02\
\x0e\x47\x65\xe5\x9a\xaa\x3b\x0f\x5c\x92\x14\x75\xbc\x56\x34\x0d\
\x28\x2b\xab\xa9\x59\xb7\x0e\x48\xa5\x53\xe9\x54\x3a\xaf\xd0\x25\
\x27\x60\x68\x68\x68\x68\x68\x08\xe0\x79\xab\xb5\xb0\x50\x97\xbc\
\xc1\xf0\xdb\x01\x97\x65\xbd\x3f\x4d\x1b\x8d\x1c\x07\x08\x42\x51\
\x91\xc3\x01\xf4\xf5\xf5\xf5\xf5\xf5\x2d\x03\x01\xb9\xb0\xc4\x71\
\x1c\xc7\xf3\xbf\x3d\xf0\x6c\x56\xef\x27\x8f\x8f\xc3\x9b\x6c\x36\
\x41\x00\xa2\x91\x68\x24\x1a\x59\x3a\x02\x26\x32\xc1\x5c\xa2\x43\
\xd3\x34\x4d\x2d\x02\x78\x22\x91\x4a\x25\x12\xc0\xcd\x9b\xd1\x48\
\x20\x00\x58\x2c\x2c\x57\x5c\x0c\x70\x1c\xcb\x16\x17\x2d\x1e\xb8\
\x24\xe9\x26\x49\xd1\x34\x65\x30\xe4\x13\xa8\x25\x27\x00\x04\x08\
\x10\x00\x49\x12\x04\x71\x0b\xe0\x1e\x8f\xcf\xf7\xd9\x69\xe0\xd2\
\xa5\x1e\xff\x89\x16\xa0\xa7\x27\x1c\xbe\x70\x01\x48\x26\xd3\xe9\
\x60\x10\x00\x08\x52\x92\x00\x92\x24\x40\x51\x00\x6f\x2a\x30\x38\
\x4b\x00\x67\xa9\xcd\xb6\x61\x03\x50\x5e\x2e\x08\xdb\x1e\x00\x36\
\x6c\xb8\xeb\xae\xfd\xfb\xf3\x40\xe7\x02\x2e\x49\x8a\xac\xaa\x80\
\xaa\x68\x9a\xa2\x4c\x4c\x73\xe9\x09\xa0\x69\x9a\xa6\x69\x40\x91\
\xa5\x6c\x46\xcc\x03\x8f\x46\x13\xf1\x5f\x7f\x05\x0e\x1d\x3a\xf7\
\xf5\xc1\x83\x80\xdf\x1f\x8d\x9c\x3b\x07\x90\x24\x49\xe9\xc9\x91\
\x4e\x0c\x4d\x33\x05\x04\xa1\x13\x45\x51\xe3\x44\x12\x80\xac\x90\
\x64\x24\x0a\x04\x83\xc9\xe4\x7f\xce\x00\xa1\xd0\xc8\xc8\x99\xb3\
\x40\x57\x57\x5f\xef\x91\x23\xc0\x96\x2d\x6b\xeb\xfe\xf6\x57\xc0\
\xe1\x10\x04\xf7\xfa\x99\xc0\x27\x14\x9a\x4d\xa7\x53\x63\x00\x67\
\xe2\x4c\x9c\x69\xe9\x08\x98\xf0\x01\xb9\x94\x33\x9e\x88\x27\xe2\
\x09\xa0\xb7\x77\x70\xb0\xab\x0b\x68\x6e\x3e\x75\x7a\xef\x1e\xa0\
\xa7\x27\x16\x3b\x73\x06\xa0\x28\x8a\xd6\x34\xdd\x04\x74\x53\xc8\
\x9b\xc4\x7c\xee\x69\x5a\xaf\x25\x89\x66\xba\xbb\x81\xef\x5a\xbb\
\xbb\x9f\x7f\x1e\xf0\xfb\xfb\xfb\xbf\xfe\x7a\x26\xf0\x5c\x49\x26\
\x87\x62\x91\x28\xe0\x70\x38\x1c\x0e\xc7\x32\x10\x60\xb7\xdb\xed\
\x76\x3b\xd0\xfb\x4b\xff\xcd\x6b\xdd\xc0\xbf\xff\xf5\xd5\x57\x4f\
\x3d\x09\xc4\x62\x99\x8c\xef\xc6\xed\x81\x91\xa4\x2c\xb3\x2c\x30\
\x3c\xec\xf5\x0a\x02\x10\x89\xf4\xf7\x33\x8c\x9e\x49\x4e\x6d\x3f\
\xb5\x26\x29\x86\x89\x27\x00\xaf\xb7\xaf\xef\x95\x57\x80\x81\x81\
\xe8\x50\x7b\x7b\x7e\x82\xe9\x74\x72\x24\x1e\x07\x06\x07\x43\xa1\
\x60\x10\x70\xb9\x5c\x2e\x97\x6b\x19\x08\xa8\xaa\xaa\xaa\xaa\xaa\
\x02\x7c\x37\x46\x47\x4f\x9d\x06\x92\x23\xb2\xec\xef\x99\x0f\x70\
\x45\x31\x18\x80\x58\xec\xc2\x85\xa2\x22\x20\x14\xba\x71\x83\xe7\
\x81\x58\x6c\x70\x50\x27\x60\x3a\xf0\xd9\xc7\x29\x28\x30\x18\x46\
\x46\x00\x9f\xef\xd7\xbe\x77\xdf\xcd\x4f\x30\x1c\xbe\x7e\xed\xca\
\x15\x40\x10\x04\x41\x10\x80\xba\xba\xba\xba\xba\xba\xa5\x23\x60\
\xc2\x07\x0c\x0c\x24\x12\x3e\x1f\x30\x32\xc2\x14\x5c\xee\x98\xb4\
\x42\x64\xae\xd6\x6d\x5a\x97\x31\x30\x36\xd6\xd3\x63\xb1\x00\xe1\
\xf0\xd5\xab\x3c\x0f\x8c\x8d\x49\x12\xa0\x6f\x98\xf4\x9a\x24\x09\
\x62\xea\x8a\x13\x44\x7e\x9c\xdc\x7b\x92\x24\x88\xdc\x77\xf4\xbe\
\x24\x79\xf5\x2a\xe0\xf5\x7a\xbb\x0e\x1d\x02\x22\x91\xeb\x3e\x51\
\xcc\xef\x0e\x19\x86\x61\x18\x66\x19\x14\xf0\xc3\x0f\x3e\xdf\xf1\
\xe3\x00\x49\x32\x8c\x24\xcf\x2d\x59\x8a\x52\x55\x83\x01\x88\x46\
\xaf\x5c\xe1\x79\x20\x95\xca\x03\xd7\x01\xe8\x00\x75\x88\x0b\xf7\
\x15\x0c\xc3\x30\x14\x05\xf4\xdf\x1c\x1c\xfc\xf2\x4b\xc0\x6e\x37\
\x99\x00\x40\x96\xaf\x5f\x3f\x75\x0a\xf0\x78\x8e\x1d\x7b\xfb\x6d\
\xfd\xa0\x65\x36\x5f\xb1\x68\x05\xf4\xfe\x12\x8d\x5e\xba\x34\x75\
\xe5\x67\x5b\x21\x92\xa4\xe9\x6c\x16\xa8\xad\xdd\xb7\x6f\x60\x00\
\xd0\xb4\xd1\x51\x9e\x07\xae\x5d\x3b\x7d\xda\x6c\x06\xd2\xe9\xf9\
\x2a\x20\xa7\xa8\xe9\x0a\xd3\xdb\xd1\x34\xc7\x0e\x0e\x02\x06\x43\
\x6b\x6b\x73\x33\xd0\xd9\x99\x4e\x8b\x22\x90\x4e\x8b\xa2\xa2\x00\
\xa1\x90\xcf\x77\xf1\x22\xb0\x6b\xd7\x8b\x2f\x7e\xf4\x91\xee\x6b\
\xe8\x45\x9c\x6f\x4d\x74\x49\x8e\xa4\x52\x03\xa1\xc9\xb6\x3d\xd7\
\x04\xa7\x4b\x98\xe3\x34\x0d\xc8\xc9\x52\x14\xf3\x00\xf5\x70\x48\
\x92\xc0\xec\x26\x30\x1b\xf0\xdc\xbd\x89\xb7\x16\xaa\x2a\xc0\x30\
\x26\x93\x5e\xeb\xe3\xe5\xca\xb5\x6b\xe7\xcf\x1f\x39\xa2\xef\x1e\
\x39\x0e\x68\x6c\x3c\x78\xf0\xfd\xf7\xf5\xef\x92\xe4\x22\x08\xc8\
\x66\x55\x65\x2c\xa5\x87\xb9\x5b\x13\xa0\x4f\x74\xf2\x0a\x4e\xbe\
\xcf\x95\xdc\x44\x28\x8a\xa2\xf4\xb0\x39\xb3\xfd\x74\xa5\x4d\x7e\
\x6f\x34\xb2\xac\xde\xce\x6a\xe5\x79\x80\x65\x35\x6d\x6c\x6c\x26\
\x00\xaf\xf7\xcc\x99\x0f\x3e\x00\x24\x49\x4c\x8f\x8d\x01\xbb\x77\
\xff\xf9\x2f\x1f\x7f\x3c\x7f\x45\x4c\xca\x03\x0c\x46\x41\x58\x78\
\x5c\x9f\xbc\xb2\x39\xe0\x93\xeb\xbc\x49\x2d\xcc\x17\xc8\x72\x36\
\xab\x69\xc0\x8a\x15\x56\xab\x20\x00\x82\x50\x5a\x5a\x51\xa1\xa7\
\xd6\x34\x0d\xb0\x2c\xc7\x51\x14\xc0\xb2\x46\x23\x45\x01\xd7\xaf\
\xff\xb7\xf5\x93\x4f\x80\x2f\xbe\x68\x6e\x3e\x70\x00\xd0\x34\x55\
\x9d\xcf\x01\xca\x04\x01\x82\xcd\xc4\x95\xaf\x58\x7c\x82\x93\x73\
\x82\xf9\x2b\xa7\x80\x69\x71\x9f\x9c\xea\x13\xe6\x72\xb6\x0c\x9d\
\xcd\xe8\x07\x30\x92\x14\x8b\x01\x85\x85\x25\x25\x15\x15\x80\xd3\
\xb9\x66\x4d\x7d\xfd\xdc\x44\x74\x75\x9d\x3b\x77\xf8\x30\x70\xf2\
\xe4\x1b\xaf\x3f\xf6\x18\xa0\xaa\xb2\xac\xbb\xe9\xdb\x10\xb0\xda\
\x55\xec\xd8\xfc\x87\x85\x00\x9f\x0a\x24\x2f\xff\xc9\x81\x70\xf1\
\x84\x56\x54\x96\x96\x6e\x7f\x18\x28\x2b\xdb\xb8\xf1\xa9\x27\x81\
\x4c\x26\x12\xf9\xe9\x27\x40\x10\x56\xac\xa8\xae\x06\x2a\x2a\xd6\
\xad\x7b\xe0\x81\x5b\x29\xa2\xf5\xbb\xa3\x47\x81\x93\x27\xdf\xfc\
\xfb\xbe\x7d\x73\x13\x31\x41\xc0\xc6\x8d\x35\x35\x4d\x4d\x00\x4d\
\x69\x5a\xce\x14\x28\xea\x56\xe1\x50\xdf\x0d\xe6\xee\x73\x3e\x20\
\x7f\xdd\x3e\x01\x9a\x3a\xbe\xfe\x5e\x55\x15\x99\x22\x81\xea\xea\
\xd2\xb2\x1d\x3b\x80\x9a\x9a\x5d\xbb\xfe\xf1\x16\x50\x5a\xda\xd0\
\xf0\xc4\x13\x40\x32\x19\x08\x9c\x3d\x0b\x14\x17\xaf\x5e\xed\x76\
\x03\x95\x95\xf5\xf5\x0f\x3d\x34\x37\x11\x3e\x5f\xeb\x77\xc7\x8e\
\xcd\x4d\xc4\x04\x01\x65\x65\x45\x45\x2e\x17\xb0\xae\xbe\xac\xac\
\xa9\x29\x1f\xfe\xe6\xa3\x84\x5c\x82\x34\xdd\x07\x2c\x54\x49\x24\
\x09\x58\xad\x14\x7d\xdf\x56\xc0\xed\x76\xb9\xb6\x6f\xcf\x8f\x58\
\x5d\xbd\x6b\xd7\x9b\x6f\x02\xc5\xc5\x6b\xd7\xee\xde\x0d\x84\xc3\
\x1d\x1d\x87\x0f\x03\x66\xb3\xdd\x5e\x52\x02\x38\x9d\x55\x55\x6e\
\xf7\xed\x89\xf8\xe2\xf3\xe6\xe6\xa7\x9f\x9e\x25\x0a\xe4\xca\xde\
\xbd\xf7\xdf\xff\xf2\xcb\x40\x7c\xf8\xec\xd9\xbe\x5e\x20\x3a\x94\
\xc9\x7c\x7b\x7e\xa6\xb7\xce\x87\x31\x9a\xd6\x34\x60\xf3\xe6\xe7\
\x9e\x4b\xa7\x67\x8f\x1e\x93\x15\x32\x57\x7e\x41\x91\x92\xb4\xc6\
\x05\x3c\xf2\xc8\xe6\xcd\xaf\xbd\x36\x53\xaa\x04\xa1\x2b\xf2\xee\
\xbb\x9b\x9a\xde\x7b\x0f\xa0\x28\x83\xc1\x6c\x06\x42\xa1\xf6\xf6\
\x0f\x3f\x04\x4c\xa6\x92\x92\xf5\xeb\x01\xbb\xbd\xac\x6c\xe5\x4a\
\x00\x08\x06\x7b\x7b\x67\x8e\x53\x51\x59\x5f\xff\xe0\x83\xb3\x28\
\x60\xe2\xc1\xf8\x76\xf6\x4f\x8f\x6d\xdd\xfa\xd6\x3f\x81\xc2\x42\
\x8a\xdc\xb4\x69\x61\x8a\x98\xcb\x64\xa6\x3b\x43\x82\x00\x34\x2d\
\x9d\xae\xac\x00\x1e\xde\x51\x57\xf7\xfa\x1b\xfa\x51\x9c\xcd\x76\
\x2b\xbf\xad\x13\x59\x53\xb3\x7b\xf7\x5b\xe3\xa6\xb1\x7f\x3f\x20\
\x8a\x03\x03\x1d\x1d\x00\xcb\xb2\x2c\xc3\x00\x16\x4b\x61\xa1\xc5\
\x92\x57\xc4\xa6\x4d\x4d\x4d\x2f\xbc\x00\xd4\xd7\xef\xd8\x71\xe0\
\xc0\xa4\xd1\x6e\xf7\x67\x48\x96\x15\x25\x9b\x05\x3e\xfd\xf4\xfb\
\xef\x5f\x7d\x15\xe8\xfd\x65\x78\xf8\xf3\xcf\x81\x02\x03\xc7\xe9\
\x2b\x3e\x7b\x1c\x9f\xbe\xc2\x39\x05\x64\x32\x19\x91\xa6\x00\x41\
\x60\x0a\xee\xdf\x06\x34\x36\xde\x7b\xef\x4b\x2f\x01\x56\x2b\xcf\
\x2f\x66\x9b\x9b\x0b\x77\xdd\xdd\x47\x8f\x3e\xfb\x2c\x10\x0e\x7b\
\xbd\x27\x4e\xe8\xa7\xc7\x00\xe0\x70\xac\x5f\xff\xf8\xe3\x80\xdb\
\xfd\xe8\xa3\xef\xbc\x93\x57\xd2\xbc\x09\x98\x5e\xc2\xe1\x78\xbc\
\xb7\x17\xe8\xe8\xf0\xfb\x8f\x1f\x07\xc2\xe1\xd1\xd1\x2b\x57\x80\
\x74\x4a\x92\x22\x11\x20\x93\x95\xe5\x64\x12\x28\x28\xa0\x69\x13\
\x07\x98\x4c\x0c\x53\x5c\x0c\x08\x02\xcf\xaf\xad\x03\xd6\xae\xad\
\xa8\x68\x6c\x04\x56\xad\x2a\x29\x71\xbb\x17\x0e\x78\x6e\x22\xf4\
\xbd\x81\xcf\x77\xe2\xd3\x83\x07\x01\x93\xc9\x59\x7a\xcf\x3d\x40\
\x79\xf9\x96\x2d\xcf\x3c\x73\x0b\x3d\xfd\xde\x7f\x8f\xff\x0f\x07\
\x67\x68\xeb\x03\xf5\xc0\x64\x00\x00\x00\x25\x74\x45\x58\x74\x64\
\x61\x74\x65\x3a\x63\x72\x65\x61\x74\x65\x00\x32\x30\x31\x31\x2d\
\x31\x30\x2d\x30\x36\x54\x30\x30\x3a\x35\x32\x3a\x34\x32\x2d\x30\
\x34\x3a\x30\x30\x64\xeb\x7e\x4b\x00\x00\x00\x25\x74\x45\x58\x74\
\x64\x61\x74\x65\x3a\x6d\x6f\x64\x69\x66\x79\x00\x32\x30\x31\x31\
\x2d\x30\x31\x2d\x31\x35\x54\x31\x36\x3a\x33\x39\x3a\x35\x30\x2d\
\x30\x35\x3a\x30\x30\xc7\x6b\x7b\x95\x00\x00\x00\x60\x74\x45\x58\
\x74\x73\x76\x67\x3a\x62\x61\x73\x65\x2d\x75\x72\x69\x00\x66\x69\
\x6c\x65\x3a\x2f\x2f\x2f\x68\x6f\x6d\x65\x2f\x6d\x61\x72\x6b\x75\
\x73\x2f\x70\x72\x6f\x67\x72\x61\x6d\x6d\x69\x6e\x67\x2f\x70\x79\
\x74\x68\x6f\x6e\x2f\x73\x63\x6f\x6e\x63\x68\x6f\x2f\x74\x72\x75\
\x6e\x6b\x2f\x73\x63\x6f\x6e\x63\x68\x6f\x2f\x67\x75\x69\x2f\x69\
\x63\x6f\x6e\x73\x2f\x7a\x6f\x6f\x6d\x2d\x31\x30\x30\x2e\x73\x76\
\x67\x6c\x33\x76\x0a\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
"
qt_resource_name = b"\
\x00\x05\
\x00\x6f\xa6\x53\
\x00\x69\
\x00\x63\x00\x6f\x00\x6e\x00\x73\
\x00\x08\
\x0f\x07\x5a\xc7\
\x00\x65\
\x00\x78\x00\x69\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0d\
\x06\xd9\x22\xa7\
\x00\x67\
\x00\x74\x00\x6b\x00\x2d\x00\x63\x00\x6c\x00\x65\x00\x61\x00\x72\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x0d\x6b\x8f\xc7\
\x00\x72\
\x00\x61\x00\x64\x00\x69\x00\x6f\x00\x62\x00\x75\x00\x74\x00\x74\x00\x6f\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x06\
\x07\xc3\x57\x47\
\x00\x75\
\x00\x70\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x13\
\x04\xe6\x5a\x87\
\x00\x67\
\x00\x74\x00\x6b\x00\x2d\x00\x70\x00\x72\x00\x65\x00\x66\x00\x65\x00\x72\x00\x65\x00\x6e\x00\x63\x00\x65\x00\x73\x00\x2e\x00\x70\
\x00\x6e\x00\x67\
\x00\x0d\
\x06\x52\xd9\xe7\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x70\x00\x72\x00\x69\x00\x6e\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x11\
\x01\x01\x10\x27\
\x00\x64\
\x00\x65\x00\x6c\x00\x65\x00\x74\x00\x65\x00\x5f\x00\x63\x00\x6f\x00\x6c\x00\x75\x00\x6d\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\
\x00\x0c\
\x07\x6b\x9c\x27\
\x00\x6b\
\x00\x63\x00\x6f\x00\x6e\x00\x74\x00\x72\x00\x6f\x00\x6c\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0b\
\x04\x14\x52\xc7\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x6e\x00\x65\x00\x77\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x0b\xb2\x58\x47\
\x00\x72\
\x00\x65\x00\x64\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0d\
\x06\x6d\x3d\x27\
\x00\x68\
\x00\x69\x00\x73\x00\x74\x00\x6f\x00\x67\x00\x72\x00\x61\x00\x6d\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x11\
\x08\x1b\x81\x27\
\x00\x7a\
\x00\x6f\x00\x6f\x00\x6d\x00\x2d\x00\x62\x00\x65\x00\x73\x00\x74\x00\x2d\x00\x66\x00\x69\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\
\x00\x0e\
\x0b\xdf\x7d\x87\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x73\x00\x61\x00\x76\x00\x65\x00\x61\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x07\
\x0a\xc7\x57\x87\
\x00\x63\
\x00\x75\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0a\
\x0c\x3c\x18\x47\
\x00\x6c\
\x00\x61\x00\x62\x00\x65\x00\x6c\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x06\xe1\x5a\x27\
\x00\x64\
\x00\x6f\x00\x77\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0d\
\x0f\x55\x06\x27\
\x00\x72\
\x00\x65\x00\x63\x00\x74\x00\x61\x00\x6e\x00\x67\x00\x6c\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x00\x2f\x5a\xe7\
\x00\x66\
\x00\x69\x00\x6c\x00\x6c\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x09\
\x0d\xf7\xa6\xa7\
\x00\x72\
\x00\x69\x00\x67\x00\x68\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x0d\xf0\xfa\x27\
\x00\x73\
\x00\x68\x00\x6f\x00\x77\x00\x5f\x00\x63\x00\x65\x00\x6c\x00\x6c\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x02\x53\x67\x87\
\x00\x69\
\x00\x6e\x00\x73\x00\x65\x00\x72\x00\x74\x00\x5f\x00\x72\x00\x6f\x00\x77\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x02\x66\x3f\x87\
\x00\x72\
\x00\x6f\x00\x77\x00\x5f\x00\x72\x00\x65\x00\x70\x00\x65\x00\x61\x00\x74\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0b\
\x03\x03\x9b\x47\
\x00\x7a\
\x00\x6f\x00\x6f\x00\x6d\x00\x2d\x00\x69\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x11\
\x0e\xab\x33\x47\
\x00\x7a\
\x00\x6f\x00\x6f\x00\x6d\x00\x2d\x00\x6f\x00\x72\x00\x69\x00\x67\x00\x69\x00\x6e\x00\x61\x00\x6c\x00\x2e\x00\x70\x00\x6e\x00\x67\
\
\x00\x0a\
\x05\x78\x4f\x27\
\x00\x72\
\x00\x65\x00\x6c\x00\x6f\x00\x61\x00\x64\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x0b\x63\x58\x07\
\x00\x73\
\x00\x74\x00\x6f\x00\x70\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x0a\x1e\x22\xc7\
\x00\x6c\
\x00\x65\x00\x74\x00\x74\x00\x65\x00\x72\x00\x5f\x00\x54\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x0c\x64\xfe\x67\
\x00\x68\
\x00\x69\x00\x64\x00\x65\x00\x5f\x00\x63\x00\x65\x00\x6c\x00\x6c\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x12\
\x0b\xa8\xa4\xa7\
\x00\x70\
\x00\x61\x00\x74\x00\x74\x00\x65\x00\x72\x00\x6e\x00\x5f\x00\x72\x00\x65\x00\x70\x00\x65\x00\x61\x00\x74\x00\x2e\x00\x70\x00\x6e\
\x00\x67\
\x00\x0e\
\x00\x78\x05\xa7\
\x00\x73\
\x00\x65\x00\x6c\x00\x65\x00\x63\x00\x74\x00\x5f\x00\x61\x00\x6c\x00\x6c\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x04\xb0\x1a\x47\
\x00\x72\
\x00\x65\x00\x64\x00\x5f\x00\x72\x00\x65\x00\x63\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x0b\xd7\x59\x07\
\x00\x6c\
\x00\x65\x00\x66\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x0b\x21\x0f\x87\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x6f\x00\x70\x00\x65\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x07\
\x01\xcc\x57\xa7\
\x00\x6b\
\x00\x65\x00\x79\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x01\x33\x1b\x27\
\x00\x64\
\x00\x65\x00\x6c\x00\x65\x00\x74\x00\x65\x00\x5f\x00\x72\x00\x6f\x00\x77\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x10\
\x02\x7a\x46\xa7\
\x00\x63\
\x00\x72\x00\x65\x00\x61\x00\x74\x00\x65\x00\x5f\x00\x63\x00\x65\x00\x6c\x00\x6c\x00\x73\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x05\x68\x0e\x67\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x73\x00\x61\x00\x76\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x10\
\x01\x08\xfa\xc7\
\x00\x69\
\x00\x6e\x00\x73\x00\x65\x00\x72\x00\x74\x00\x5f\x00\x66\x00\x72\x00\x61\x00\x6d\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x04\xb2\x58\xc7\
\x00\x75\
\x00\x6e\x00\x64\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x0c\xf7\x58\x07\
\x00\x74\
\x00\x65\x00\x78\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x06\xeb\x97\xe7\
\x00\x7a\
\x00\x6f\x00\x6f\x00\x6d\x00\x2d\x00\x6f\x00\x75\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x06\xc0\xd2\xe7\
\x00\x66\
\x00\x69\x00\x6c\x00\x65\x00\x65\x00\x78\x00\x70\x00\x6f\x00\x72\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x06\x7c\x5a\x07\
\x00\x63\
\x00\x6f\x00\x70\x00\x79\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x11\
\x0b\x4b\xe4\x07\
\x00\x69\
\x00\x6e\x00\x73\x00\x65\x00\x72\x00\x74\x00\x5f\x00\x63\x00\x6f\x00\x6c\x00\x75\x00\x6d\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\
\x00\x10\
\x03\x81\x95\x27\
\x00\x73\
\x00\x63\x00\x6f\x00\x6e\x00\x63\x00\x68\x00\x6f\x00\x5f\x00\x69\x00\x63\x00\x6f\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x09\
\x0a\xa8\xba\x47\
\x00\x70\
\x00\x61\x00\x73\x00\x74\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x04\x1f\x97\x67\
\x00\x7a\
\x00\x6f\x00\x6f\x00\x6d\x00\x2d\x00\x31\x00\x30\x00\x30\x00\x2e\x00\x70\x00\x6e\x00\x67\
"
qt_resource_struct = b"\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x2f\x00\x00\x00\x02\
\x00\x00\x02\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x87\x58\
\x00\x00\x03\x82\x00\x00\x00\x00\x00\x01\x00\x01\x01\xd7\
\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x01\x00\x00\x23\x76\
\x00\x00\x04\x70\x00\x00\x00\x00\x00\x01\x00\x01\x4b\x78\
\x00\x00\x04\x0a\x00\x00\x00\x00\x00\x01\x00\x01\x37\x7c\
\x00\x00\x03\xf6\x00\x00\x00\x00\x00\x01\x00\x01\x32\x1b\
\x00\x00\x02\x5e\x00\x00\x00\x00\x00\x01\x00\x00\xa1\xb8\
\x00\x00\x02\x80\x00\x00\x00\x00\x00\x01\x00\x00\xa5\xf5\
\x00\x00\x04\x2c\x00\x00\x00\x00\x00\x01\x00\x01\x3b\xf9\
\x00\x00\x02\xa4\x00\x00\x00\x00\x00\x01\x00\x00\xaa\xf4\
\x00\x00\x05\x40\x00\x00\x00\x00\x00\x01\x00\x01\x78\xb1\
\x00\x00\x01\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x33\x62\
\x00\x00\x05\x7e\x00\x00\x00\x00\x00\x01\x00\x02\x0c\x41\
\x00\x00\x03\xa4\x00\x01\x00\x00\x00\x01\x00\x01\x06\x29\
\x00\x00\x04\x96\x00\x00\x00\x00\x00\x01\x00\x01\x4d\x7e\
\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x01\x00\x00\x15\xfe\
\x00\x00\x04\x52\x00\x00\x00\x00\x00\x01\x00\x01\x41\x2f\
\x00\x00\x02\xe8\x00\x00\x00\x00\x00\x01\x00\x00\xd2\x0f\
\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x01\x00\x00\x1f\x30\
\x00\x00\x01\x40\x00\x00\x00\x00\x00\x01\x00\x00\x48\x55\
\x00\x00\x05\x02\x00\x00\x00\x00\x00\x01\x00\x01\x72\xbb\
\x00\x00\x04\xe0\x00\x00\x00\x00\x00\x01\x00\x01\x6f\xa9\
\x00\x00\x00\x26\x00\x00\x00\x00\x00\x01\x00\x00\x04\x5c\
\x00\x00\x01\xd8\x00\x00\x00\x00\x00\x01\x00\x00\x7a\xfe\
\x00\x00\x04\xc2\x00\x00\x00\x00\x00\x01\x00\x01\x5c\xc8\
\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x01\x00\x00\x28\x35\
\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x01\x00\x00\x0e\xc1\
\x00\x00\x01\x60\x00\x00\x00\x00\x00\x01\x00\x00\x4b\x0f\
\x00\x00\x03\x18\x00\x00\x00\x00\x00\x01\x00\x00\xe5\x84\
\x00\x00\x05\x66\x00\x00\x00\x00\x00\x01\x00\x02\x09\x97\
\x00\x00\x01\xaa\x00\x00\x00\x00\x00\x01\x00\x00\x70\x1d\
\x00\x00\x03\xd8\x00\x00\x00\x00\x00\x01\x00\x01\x26\xc3\
\x00\x00\x05\x18\x00\x00\x00\x00\x00\x01\x00\x01\x74\x21\
\x00\x00\x03\x02\x00\x00\x00\x00\x00\x01\x00\x00\xdb\xfb\
\x00\x00\x03\x58\x00\x00\x00\x00\x00\x01\x00\x00\xee\xe0\
\x00\x00\x01\x2a\x00\x00\x00\x00\x00\x01\x00\x00\x45\x7d\
\x00\x00\x03\xc2\x00\x00\x00\x00\x00\x01\x00\x01\x1f\xa2\
\x00\x00\x01\x88\x00\x00\x00\x00\x00\x01\x00\x00\x5f\x34\
\x00\x00\x01\xbe\x00\x00\x00\x00\x00\x01\x00\x00\x73\x99\
\x00\x00\x03\x36\x00\x00\x00\x00\x00\x01\x00\x00\xed\x9f\
\x00\x00\x04\xac\x00\x00\x00\x00\x00\x01\x00\x01\x50\x4f\
\x00\x00\x00\x46\x00\x00\x00\x00\x00\x01\x00\x00\x0a\x57\
\x00\x00\x02\x3c\x00\x00\x00\x00\x00\x01\x00\x00\x9c\xee\
\x00\x00\x02\x24\x00\x00\x00\x00\x00\x01\x00\x00\x95\xa6\
\x00\x00\x02\xc0\x00\x00\x00\x00\x00\x01\x00\x00\xbe\x86\
\x00\x00\x00\x10\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\
\x00\x00\x01\xee\x00\x00\x00\x00\x00\x01\x00\x00\x81\xd6\
"
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
qInitResources()<｜fim▁end｜> | \x73\x65\x00\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x65\x61\x74\x69\ |
<|file_name|>graphs.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# SyConn - Synaptic connectivity inference toolkit
#
# Copyright (c) 2016 - now
# Max Planck Institute of Neurobiology, Martinsried, Germany
# Authors: Philipp Schubert, Joergen Kornfeld
import itertools
from typing import List, Any, Optional, TYPE_CHECKING
import networkx as nx
import numpy as np
import tqdm
from knossos_utils.skeleton import Skeleton, SkeletonAnnotation, SkeletonNode
from scipy import spatial
if TYPE_CHECKING:
from ..reps.super_segmentation import SuperSegmentationObject
from .. import global_params
from ..mp.mp_utils import start_multiprocess_imap as start_multiprocess
def bfs_smoothing(vertices, vertex_labels, max_edge_length=120, n_voting=40):
"""
Smooth vertex labels by applying a majority vote on a
BFS subset of nodes for every node in the graph
Parameters
Args:
vertices: np.array
N, 3
vertex_labels: np.array
N, 1
max_edge_length: float
maximum distance between vertices to consider them connected in the
graph
n_voting: int
Number of collected nodes during BFS used for majority vote
Returns: np.array
smoothed vertex labels
"""
G = create_graph_from_coords(vertices, max_dist=max_edge_length, mst=False,
force_single_cc=False)
# create BFS subset
bfs_nn = split_subcc(G, max_nb=n_voting, verbose=False)
new_vertex_labels = np.zeros_like(vertex_labels)
for ii in range(len(vertex_labels)):
curr_labels = vertex_labels[bfs_nn[ii]]
labels, counts = np.unique(curr_labels, return_counts=True)
majority_label = labels[np.argmax(counts)]
new_vertex_labels[ii] = majority_label
return new_vertex_labels
def split_subcc(g, max_nb, verbose=False, start_nodes=None):
"""
Creates subgraph for each node consisting of nodes until maximum number of
nodes is reached.
Args:
g: Graph
max_nb: int
verbose: bool
start_nodes: iterable
node ID's
Returns: dict
"""
subnodes = {}
if verbose:
nb_nodes = g.number_of_nodes()
pbar = tqdm.tqdm(total=nb_nodes, leave=False)
if start_nodes is None:
iter_ixs = g.nodes()
else:
iter_ixs = start_nodes
for n in iter_ixs:
n_subgraph = [n]
nb_edges = 0<｜fim▁hole｜> if nb_edges == max_nb:
break
subnodes[n] = n_subgraph
if verbose:
pbar.update(1)
if verbose:
pbar.close()
return subnodes
def chunkify_contiguous(l, n):
"""Yield successive n-sized chunks from l.
https://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks"""
for i in range(0, len(l), n):
yield l[i:i + n]
def split_subcc_join(g: nx.Graph, subgraph_size: int, lo_first_n: int = 1) -> List[List[Any]]:
"""
Creates a subgraph for each node consisting of nodes until maximum number of
nodes is reached.
Args:
g: Supervoxel graph
subgraph_size: Size of subgraphs. The difference between `subgraph_size` and `lo_first_n` defines the
supervoxel overlap.
lo_first_n: Leave out first n nodes: will collect `subgraph_size` nodes starting from center node and then
omit the first lo_first_n nodes, i.e. not use them as new starting nodes.
Returns:
"""
start_node = list(g.nodes())[0]
for n, d in dict(g.degree).items():
if d == 1:
start_node = n
break
dfs_nodes = list(nx.dfs_preorder_nodes(g, start_node))
# get subgraphs via splicing of traversed node list into equally sized fragments. they might
# be unconnected if branch sizes mod subgraph_size != 0, then a chunk will contain multiple connected components.
chunks = list(chunkify_contiguous(dfs_nodes, lo_first_n))
sub_graphs = []
for ch in chunks:
# collect all connected component subgraphs
sg = g.subgraph(ch).copy()
sub_graphs += list((sg.subgraph(c) for c in nx.connected_components(sg)))
# add more context to subgraphs
subgraphs_withcontext = []
for sg in sub_graphs:
# add context but omit artificial start node
context_nodes = []
for n in list(sg.nodes()):
subgraph_nodes_with_context = []
nb_edges = sg.number_of_nodes()
for e in nx.bfs_edges(g, n):
subgraph_nodes_with_context += list(e)
nb_edges += 1
if nb_edges == subgraph_size:
break
context_nodes += subgraph_nodes_with_context
# add original nodes
context_nodes = list(set(context_nodes))
for n in list(sg.nodes()):
if n in context_nodes:
context_nodes.remove(n)
subgraph_nodes_with_context = list(sg.nodes()) + context_nodes
subgraphs_withcontext.append(subgraph_nodes_with_context)
return subgraphs_withcontext
def merge_nodes(G, nodes, new_node):
""" FOR UNWEIGHTED, UNDIRECTED GRAPHS ONLY
"""
if G.is_directed():
raise ValueError('Method "merge_nodes" is only valid for undirected graphs.')
G.add_node(new_node)
for n in nodes:
for e in G.edges(n):
# add edge between new node and original partner node
edge = list(e)
edge.remove(n)
paired_node = edge[0]
G.add_edge(new_node, paired_node)
for n in nodes: # remove the merged nodes
G.remove_node(n)
def split_glia_graph(nx_g, thresh, clahe=False, nb_cpus=1, pred_key_appendix=""):
"""
Split graph into glia and non-glua CC's.
Args:
nx_g: nx.Graph
thresh: float
clahe: bool
nb_cpus: int
pred_key_appendix: str
verbose: bool
Returns: list, list
Neuron, glia connected components.
"""
glia_key = "glia_probas"
if clahe:
glia_key += "_clahe"
glia_key += pred_key_appendix
glianess, size = get_glianess_dict(list(nx_g.nodes()), thresh, glia_key,
nb_cpus=nb_cpus)
return remove_glia_nodes(nx_g, size, glianess, return_removed_nodes=True)
def split_glia(sso, thresh, clahe=False, pred_key_appendix=""):
"""
Split SuperSegmentationObject into glia and non glia
SegmentationObjects.
Args:
sso: SuperSegmentationObject
thresh: float
clahe: bool
pred_key_appendix: str
Defines type of glia predictions
Returns: list, list (of SegmentationObject)
Neuron, glia nodes
"""
nx_G = sso.rag
nonglia_ccs, glia_ccs = split_glia_graph(nx_G, thresh=thresh, clahe=clahe,
nb_cpus=sso.nb_cpus, pred_key_appendix=pred_key_appendix)
return nonglia_ccs, glia_ccs
def create_ccsize_dict(g: nx.Graph, bbs: dict, is_connected_components: bool = False) -> dict:
"""
Calculate bounding box size of connected components.
Args:
g: Supervoxel graph.
bbs: Bounding boxes (physical units).
is_connected_components: If graph `g` already is connected components. If False,
``nx.connected_components`` is applied.
Returns:
Look-up which stores the connected component bounding box for every single node in the input Graph `g`.
"""
if not is_connected_components:
ccs = nx.connected_components(g)
else:
ccs = g
node2cssize_dict = {}
for cc in ccs:
# if ID is not in bbs, it was skipped due to low voxel count
curr_bbs = [bbs[n] for n in cc if n in bbs]
if len(curr_bbs) == 0:
raise ValueError(f'Could not find a single bounding box for connected component with IDs: {cc}.')
else:
curr_bbs = np.concatenate(curr_bbs)
cc_size = np.linalg.norm(np.max(curr_bbs, axis=0) -
np.min(curr_bbs, axis=0), ord=2)
for n in cc:
node2cssize_dict[n] = cc_size
return node2cssize_dict
def get_glianess_dict(seg_objs, thresh, glia_key, nb_cpus=1,
use_sv_volume=False, verbose=False):
glianess = {}
sizes = {}
params = [[so, glia_key, thresh, use_sv_volume] for so in seg_objs]
res = start_multiprocess(glia_loader_helper, params, nb_cpus=nb_cpus,
verbose=verbose, show_progress=verbose)
for ii, el in enumerate(res):
so = seg_objs[ii]
glianess[so] = el[0]
sizes[so] = el[1]
return glianess, sizes
def glia_loader_helper(args):
so, glia_key, thresh, use_sv_volume = args
if glia_key not in so.attr_dict.keys():
so.load_attr_dict()
curr_glianess = so.glia_pred(thresh)
if not use_sv_volume:
curr_size = so.mesh_bb
else:
curr_size = so.size
return curr_glianess, curr_size
def remove_glia_nodes(g, size_dict, glia_dict, return_removed_nodes=False):
"""
Calculate distance weights for shortest path analysis or similar, based on
glia and size vertex properties and removes unsupporting glia nodes.
Args:
g: Graph
size_dict:
glia_dict:
return_removed_nodes: bool
Returns: list of list of nodes
Remaining connected components of type neuron
"""
# set up node weights based on glia prediction and size
# weights = {}
# e_weights = {}
# for n in g.nodes():
# weights[n] = np.linalg.norm(size_dict[n][1]-size_dict[n][0], ord=2)\
# * glia_dict[n]
# # set up edge weights based on sum of node weights
# for e in g.edges():
# e_weights[e] = weights[list(e)[0]] + weights[list(e)[1]]
# nx.set_node_attributes(g, weights, 'weight')
# nx.set_edge_attributes(g, e_weights, 'weights')
# get neuron type connected component sizes
g_neuron = g.copy()
for n in g.nodes():
if glia_dict[n] != 0:
g_neuron.remove_node(n)
neuron2ccsize_dict = create_ccsize_dict(g_neuron, size_dict)
if np.all(np.array(list(neuron2ccsize_dict.values())) <=
global_params.config['min_cc_size_ssv']):
# no significant neuron SV
if return_removed_nodes:
return [], [list(g.nodes())]
return []
# get glia type connected component sizes
g_glia = g.copy()
for n in g.nodes():
if glia_dict[n] == 0:
g_glia.remove_node(n)
glia2ccsize_dict = create_ccsize_dict(g_glia, size_dict)
if np.all(np.array(list(glia2ccsize_dict.values())) <=
global_params.config['min_cc_size_ssv']):
# no significant glia SV
if return_removed_nodes:
return [list(g.nodes())], []
return [list(g.nodes())]
tiny_glia_fragments = []
for n in g_glia.nodes():
if glia2ccsize_dict[n] < global_params.config['min_cc_size_ssv']:
tiny_glia_fragments += [n]
# create new neuron graph without sufficiently big glia connected components
g_neuron = g.copy()
for n in g.nodes():
if glia_dict[n] != 0 and n not in tiny_glia_fragments:
g_neuron.remove_node(n)
# find orphaned neuron SV's and add them to glia graph
neuron2ccsize_dict = create_ccsize_dict(g_neuron, size_dict)
g_tmp = g_neuron.copy()
for n in g_tmp.nodes():
if neuron2ccsize_dict[n] < global_params.config['min_cc_size_ssv']:
g_neuron.remove_node(n)
# create new glia graph with remaining nodes
# (as the complementary set of sufficiently big neuron connected components)
g_glia = g.copy()
for n in g_neuron.nodes():
g_glia.remove_node(n)
neuron_ccs = list(nx.connected_components(g_neuron))
if return_removed_nodes:
glia_ccs = list(nx.connected_components(g_glia))
assert len(g_glia) + len(g_neuron) == len(g)
return neuron_ccs, glia_ccs
return neuron_ccs
def glia_path_length(glia_path, glia_dict, write_paths=None):
"""
Get the path length of glia SV within glia_path. Assumes single connected
glia component within this path. Uses the mesh property of each
SegmentationObject to build a graph from all vertices to find shortest path
through (or more precise: along the surface of) glia. Edges between non-glia
vertices have negligible distance (0.0001) to ensure shortest path
along non-glia surfaces.
Args:
glia_path: list of SegmentationObjects
glia_dict: dict
Dictionary which keys the SegmentationObjects in glia_path and returns
their glia prediction
write_paths: bool
Returns: float
Shortest path between neuron type nodes in nm
"""
g = nx.Graph()
col = {}
curr_ind = 0
if write_paths is not None:
all_vert = np.zeros((0, 3))
for so in glia_path:
is_glia_sv = int(glia_dict[so] > 0)
ind, vert = so.mesh
# connect meshes of different SV, starts after first SV
if curr_ind > 0:
# build kd tree from vertices of SV before
kd_tree = spatial.cKDTree(vert_resh)
# get indices of vertives of SV before (= indices of graph nodes)
ind_offset_before = curr_ind - len(vert_resh)
# query vertices of current mesh to find close connects
next_vert_resh = vert.reshape((-1, 3))
dists, ixs = kd_tree.query(next_vert_resh, distance_upper_bound=500)
for kk, ix in enumerate(ixs):
if dists[kk] > 500:
continue
if is_glia_sv:
edge_weight = eucl_dist(next_vert_resh[kk], vert_resh[ix])
else:
edge_weight = 0.0001
g.add_edge(curr_ind + kk, ind_offset_before + ix,
weights=edge_weight)
vert_resh = vert.reshape((-1, 3))
# save all vertices for writing shortest path skeleton
if write_paths is not None:
all_vert = np.concatenate([all_vert, vert_resh])
# connect fragments of SV mesh
kd_tree = spatial.cKDTree(vert_resh)
dists, ixs = kd_tree.query(vert_resh, k=20, distance_upper_bound=500)
for kk in range(len(ixs)):
nn_ixs = ixs[kk]
nn_dists = dists[kk]
col[curr_ind + kk] = glia_dict[so]
for curr_ix, curr_dist in zip(nn_ixs, nn_dists):
col[curr_ind + curr_ix] = glia_dict[so]
if is_glia_sv:
dist = curr_dist
else: # only take path through glia into account
dist = 0
g.add_edge(kk + curr_ind, curr_ix + curr_ind, weights=dist)
curr_ind += len(vert_resh)
start_ix = 0 # choose any index of the first mesh
end_ix = curr_ind - 1 # choose any index of the last mesh
shortest_path_length = nx.dijkstra_path_length(g, start_ix, end_ix, weight="weights")
if write_paths is not None:
shortest_path = nx.dijkstra_path(g, start_ix, end_ix, weight="weights")
anno = coordpath2anno([all_vert[ix] for ix in shortest_path])
anno.setComment("{0:.4}".format(shortest_path_length))
skel = Skeleton()
skel.add_annotation(anno)
skel.to_kzip("{{}/{0:.4}_vertpath.k.zip".format(write_paths, shortest_path_length))
return shortest_path_length
def eucl_dist(a, b):
return np.linalg.norm(a - b)
def get_glia_paths(g, glia_dict, node2ccsize_dict, min_cc_size_neuron,
node2ccsize_dict_glia, min_cc_size_glia):
"""
Currently not in use, Refactoring needed
Find paths between neuron type SV grpah nodes which contain glia nodes.
Args:
g: nx.Graph
glia_dict:
node2ccsize_dict:
min_cc_size_neuron:
node2ccsize_dict_glia:
min_cc_size_glia:
Returns:
"""
end_nodes = []
paths = nx.all_pairs_dijkstra_path(g, weight="weights")
for n, d in g.degree().items():
if d == 1 and glia_dict[n] == 0 and node2ccsize_dict[n] > min_cc_size_neuron:
end_nodes.append(n)
# find all nodes along these ways and store them as mandatory nodes
glia_paths = []
glia_svixs_in_paths = []
for a, b in itertools.combinations(end_nodes, 2):
glia_nodes = [n for n in paths[a][b] if glia_dict[n] != 0]
if len(glia_nodes) == 0:
continue
sv_ccsizes = [node2ccsize_dict_glia[n] for n in glia_nodes]
if np.max(sv_ccsizes) <= min_cc_size_glia: # check minimum glia size
continue
sv_ixs = np.array([n.id for n in glia_nodes])
glia_nodes_already_exist = False
for el_ixs in glia_svixs_in_paths:
if np.all(sv_ixs == el_ixs):
glia_nodes_already_exist = True
break
if glia_nodes_already_exist: # check if same glia path exists already
continue
glia_paths.append(paths[a][b])
glia_svixs_in_paths.append(np.array([so.id for so in glia_nodes]))
return glia_paths
def write_sopath2skeleton(so_path, dest_path, scaling=None, comment=None):
"""
Writes very simple skeleton, each node represents the center of mass of a
SV, and edges are created in list order.
Args:
so_path: list of SegmentationObject
dest_path: str
scaling: np.ndarray or tuple
comment: str
Returns:
"""
if scaling is None:
scaling = np.array(global_params.config['scaling'])
skel = Skeleton()
anno = SkeletonAnnotation()
anno.scaling = scaling
rep_nodes = []
for so in so_path:
vert = so.mesh[1].reshape((-1, 3))
com = np.mean(vert, axis=0)
kd_tree = spatial.cKDTree(vert)
dist, nn_ix = kd_tree.query([com])
nn = vert[nn_ix[0]] / scaling
n = SkeletonNode().from_scratch(anno, nn[0], nn[1], nn[2])
anno.addNode(n)
rep_nodes.append(n)
for i in range(1, len(rep_nodes)):
anno.addEdge(rep_nodes[i - 1], rep_nodes[i])
if comment is not None:
anno.setComment(comment)
skel.add_annotation(anno)
skel.to_kzip(dest_path)
def coordpath2anno(coords: np.ndarray, scaling: Optional[np.ndarray] = None) -> SkeletonAnnotation:
"""
Creates skeleton from scaled coordinates, assume coords are in order for
edge creation.
Args:
coords: np.array
scaling: np.ndarray
Returns: SkeletonAnnotation
"""
if scaling is None:
scaling = global_params.config['scaling']
anno = SkeletonAnnotation()
anno.scaling = scaling
rep_nodes = []
for c in coords:
n = SkeletonNode().from_scratch(anno, c[0] / scaling[0], c[1] / scaling[1],
c[2] / scaling[2])
anno.addNode(n)
rep_nodes.append(n)
for i in range(1, len(rep_nodes)):
anno.addEdge(rep_nodes[i - 1], rep_nodes[i])
return anno
def create_graph_from_coords(coords: np.ndarray, max_dist: float = 6000, force_single_cc: bool = True,
mst: bool = False) -> nx.Graph:
"""
Generate skeleton from sample locations by adding edges between points with a maximum distance and then pruning
the skeleton using MST. Nodes will have a 'position' attribute.
Args:
coords: Coordinates.
max_dist: Add edges between two nodes that are within this distance.
force_single_cc: Force that the tree generated from coords is a single connected component.
mst: Compute the minimum spanning tree.
Returns:
Networkx graph. Edge between nodes (coord indices) using the ordering of coords, i.e. the
edge (1, 2) connects coordinate coord[1] and coord[2].
"""
g = nx.Graph()
if len(coords) == 1:
g.add_node(0)
g.add_weighted_edges_from([[0, 0, 0]])
return g
kd_t = spatial.cKDTree(coords)
pairs = kd_t.query_pairs(r=max_dist, output_type="ndarray")
g.add_nodes_from([(ix, dict(position=coord)) for ix, coord in enumerate(coords)])
weights = np.linalg.norm(coords[pairs[:, 0]] - coords[pairs[:, 1]], axis=1)
g.add_weighted_edges_from([[pairs[i][0], pairs[i][1], weights[i]] for i in range(len(pairs))])
if force_single_cc: # make sure its a connected component
g = stitch_skel_nx(g)
if mst:
g = nx.minimum_spanning_tree(g)
return g
def draw_glia_graph(G, dest_path, min_sv_size=0, ext_glia=None, iterations=150, seed=0,
glia_key="glia_probas", node_size_cap=np.inf, mcmp=None, pos=None):
"""
Draw graph with nodes colored in red (glia) and blue) depending on their
class. Writes drawing to dest_path.
Args:
G: nx.Graph
dest_path: str
min_sv_size: int
ext_glia: dict
keys: node in G, values: number indicating class
iterations:
seed: int
Default: 0; random seed for layout generation
glia_key: str
node_size_cap: int
mcmp: color palette
pos:
Returns:
"""
import matplotlib.pyplot as plt
import seaborn as sns
if mcmp is None:
mcmp = sns.diverging_palette(250, 15, s=99, l=60, center="dark",
as_cmap=True)
np.random.seed(0)
seg_objs = list(G.nodes())
glianess, size = get_glianess_dict(seg_objs, glia_thresh, glia_key, 5,
use_sv_volume=True)
if ext_glia is not None:
for n in G.nodes():
glianess[n] = ext_glia[n.id]
plt.figure()
n_size = np.array([size[n] ** (1. / 3) for n in G.nodes()]).astype(
np.float32) # reduce cubic relation to a linear one
# n_size = np.array([np.linalg.norm(size[n][1]-size[n][0]) for n in G.nodes()])
if node_size_cap == "max":
node_size_cap = np.max(n_size)
n_size[n_size > node_size_cap] = node_size_cap
col = np.array([glianess[n] for n in G.nodes()])
col = col[n_size >= min_sv_size]
nodelist = list(np.array(list(G.nodes()))[n_size > min_sv_size])
n_size = n_size[n_size >= min_sv_size]
n_size = n_size / np.max(n_size) * 25.
if pos is None:
pos = nx.spring_layout(G, weight="weight", iterations=iterations, random_state=seed)
nx.draw(G, nodelist=nodelist, node_color=col, node_size=n_size,
cmap=mcmp, width=0.15, pos=pos, linewidths=0)
plt.savefig(dest_path)
plt.close()
return pos
def nxGraph2kzip(g, coords, kzip_path):
import tqdm
scaling = global_params.config['scaling']
coords = coords / scaling
skel = Skeleton()
anno = SkeletonAnnotation()
anno.scaling = scaling
node_mapping = {}
pbar = tqdm.tqdm(total=len(coords) + len(g.edges()), leave=False)
for v in g.nodes():
c = coords[v]
n = SkeletonNode().from_scratch(anno, c[0], c[1], c[2])
node_mapping[v] = n
anno.addNode(n)
pbar.update(1)
for e in g.edges():
anno.addEdge(node_mapping[e[0]], node_mapping[e[1]])
pbar.update(1)
skel.add_annotation(anno)
skel.to_kzip(kzip_path)
pbar.close()
def svgraph2kzip(ssv: 'SuperSegmentationObject', kzip_path: str):
"""
Writes the SV graph stored in `ssv.edgelist_path` to a kzip file.
The representative coordinate of a SV is used as the corresponding node
location.
Args:
ssv: Cell reconstruction object.
kzip_path: Path to the output kzip file.
"""
sv_graph = nx.read_edgelist(ssv.edgelist_path, nodetype=int)
coords = {ix: ssv.get_seg_obj('sv', ix).rep_coord for ix in sv_graph.nodes}
import tqdm
skel = Skeleton()
anno = SkeletonAnnotation()
anno.scaling = ssv.scaling
node_mapping = {}
pbar = tqdm.tqdm(total=len(coords) + len(sv_graph.edges()), leave=False)
for v in sv_graph.nodes:
c = coords[v]
n = SkeletonNode().from_scratch(anno, c[0], c[1], c[2])
n.setComment(f'{v}')
node_mapping[v] = n
anno.addNode(n)
pbar.update(1)
for e in sv_graph.edges():
anno.addEdge(node_mapping[e[0]], node_mapping[e[1]])
pbar.update(1)
skel.add_annotation(anno)
skel.to_kzip(kzip_path)
pbar.close()
def stitch_skel_nx(skel_nx: nx.Graph, n_jobs: int = 1) -> nx.Graph:
"""
Stitch connected components within a graph by recursively adding edges between the closest components.
Args:
skel_nx: Networkx graph. Nodes require 'position' attribute.
n_jobs: Number of jobs used for query of cKDTree.
Returns:
Single connected component graph.
"""
if skel_nx.number_of_nodes() == 0:
return skel_nx
no_of_seg = nx.number_connected_components(skel_nx)
if no_of_seg == 1:
return skel_nx
skel_nx_nodes = np.array([skel_nx.nodes[ix]['position'] for ix in skel_nx.nodes()], dtype=np.int64)
while no_of_seg != 1:
rest_nodes = []
rest_nodes_ixs = []
list_of_comp = np.array([c for c in sorted(nx.connected_components(skel_nx), key=len, reverse=True)])
for single_rest_graph in list_of_comp[1:]:
rest_nodes += [skel_nx_nodes[int(ix)] for ix in single_rest_graph]
rest_nodes_ixs += list(single_rest_graph)
current_set_of_nodes = [skel_nx_nodes[int(ix)] for ix in list_of_comp[0]]
current_set_of_nodes_ixs = list(list_of_comp[0])
tree = spatial.cKDTree(rest_nodes, 1)
thread_lengths, indices = tree.query(current_set_of_nodes, n_jobs=n_jobs)
start_thread_index = np.argmin(thread_lengths)
stop_thread_index = indices[start_thread_index]
e1 = current_set_of_nodes_ixs[start_thread_index]
e2 = rest_nodes_ixs[stop_thread_index]
skel_nx.add_edge(e1, e2)
no_of_seg -= 1
return skel_nx<｜fim▁end｜> | for e in nx.bfs_edges(g, n):
n_subgraph.append(e[1])
nb_edges += 1 |
<|file_name|>rollup.config.js<|end_file_name|><｜fim▁begin｜><｜fim▁hole｜>import nodeResolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import nodePolyfills from 'rollup-plugin-node-polyfills';
export default [
{
input: 'support/demo_template/demo.js',
output: { file: 'demo/demo.js', format: 'iife', name: 'demo' },
plugins: [
nodePolyfills(),
nodeResolve(),
commonjs()
]
}
];<｜fim▁end｜> | |
<|file_name|>mod.rs<|end_file_name|><｜fim▁begin｜>mod address;
mod entry;
mod table;
mod huge;
mod page;
use alloc::boxed::Box;
use alloc::vec::Vec;
use sys::volatile::prelude::*;
use pi::common::IO_BASE as _IO_BASE;
use core::fmt;
use aarch64;
pub use self::entry::Entry;
pub use self::table::{Table, Level, L0, L1, L2, L3};
pub use self::address::{PhysicalAddr, VirtualAddr};
pub use self::huge::{Huge, HUGESZ};
pub use self::page::{Page, PAGESZ};
pub const UPPER_SPACE_MASK: usize = 0xFFFFFF80_00000000;
pub const LOWER_SPACE_MASK: usize = 0x0000007F_FFFFFFFF;
const IO_BASE: usize = _IO_BASE & LOWER_SPACE_MASK;
use allocator::util::{align_up, align_down};
use allocator::safe_box;
// get addresses from linker
extern "C" {
static mut _start: u8;
static mut _data: u8;
static mut _end: u8;
}
pub fn kernel_start() -> PhysicalAddr {
let p = unsafe { &mut _start as *mut _ };
(((p as usize) & LOWER_SPACE_MASK) as *mut u8).into()
}
pub fn kernel_data() -> PhysicalAddr {
let p = unsafe { &mut _data as *mut _ };
(((p as usize) & LOWER_SPACE_MASK) as *mut u8).into()
}
pub fn kernel_end() -> PhysicalAddr {
let p = unsafe { &mut _end as *mut _ };
(((p as usize) & LOWER_SPACE_MASK) as *mut u8).into()
}
#[inline(always)]
pub fn v2p(v: VirtualAddr) -> Option<PhysicalAddr> {
v.as_usize().checked_sub(UPPER_SPACE_MASK).map(Into::into)
}
#[inline(always)]
pub fn p2v(p: PhysicalAddr) -> VirtualAddr {
((p.as_usize() | UPPER_SPACE_MASK) as *mut u8).into()
}
pub struct Memory {
root: L1,
areas: Vec<Area>,
}
unsafe impl Send for Memory {}
unsafe impl Sync for Memory {}
impl fmt::Debug for Memory {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Memory{:?}", self.areas)
}
}
impl Memory {
pub fn new() -> Option<Box<Self>> {
Some(safe_box(Self {
root: Page::new_zeroed()?.into(),
areas: Vec::new(),
})?)
}
pub fn ttbr(&mut self) -> PhysicalAddr {
self.root.physical()
}
#[must_use]
pub fn area_rx(&mut self, area: Area) -> Option<()> {
self.area(area.prot(Prot::RX))
}
#[must_use]
pub fn area_rw(&mut self, area: Area) -> Option<()> {
self.area(area.prot(Prot::RW))
}
#[must_use]
pub fn area_ro(&mut self, area: Area) -> Option<()> {
self.area(area.prot(Prot::RO))
}
#[must_use]
pub fn area_dev(&mut self, area: Area) -> Option<()> {
self.area(area.entry(Entry::USER_DEV))
}
#[must_use]
pub fn area(&mut self, area: Area) -> Option<()> {
/*
use console::kprintln;
match area.physical {
Some(p) => kprintln!("area: {}-{} to {}", area.start, area.end, p),
None => kprintln!("area: {}-{}", area.start, area.end),
}
*/
let mut addr = align_down(area.start.as_usize(), PAGESZ);
let end = align_up(area.end.as_usize(), PAGESZ);
let entry = area.entry;
let p = area.physical;
self.areas.try_reserve(1).ok()?;
self.areas.push(area);
if let Some(p) = p {
let mut p = align_down(p.as_usize(), PAGESZ);
while addr < end {
let v = (addr as *mut u8).into();
let l2 = self.root.next_table_or(v, Entry::USER_BASE)?;
if addr % HUGESZ == 0 && (end - addr) >= HUGESZ {
l2[v].write(Entry::block(p.into()) | entry);
addr += HUGESZ;
p += HUGESZ;
} else {
let l3 = l2.next_table_or(v, Entry::USER_BASE)?;
l3[v].write(Entry::page(p.into()) | entry);
addr += PAGESZ;
p += PAGESZ;
}
}
}
Some(())
}
pub fn find_area_mut(&mut self, addr: VirtualAddr) -> Option<&mut Area> {
self.areas.iter_mut().find(|area| area.contains(addr))
}
pub fn find_area(&self, addr: VirtualAddr) -> Option<&Area> {
self.areas.iter().find(|area| area.contains(addr))
}
pub fn has_addr(&self, addr: VirtualAddr) -> bool {
self.areas.iter().any(|area| area.contains(addr))
}
pub fn page_fault(&mut self, addr: u64) {
let addr = VirtualAddr::from((addr as usize) as *mut u8);
let page = Page::new().expect("allocate page");
unsafe { self.add_page(addr, page).expect("add page") };
}
unsafe fn add_page(&mut self, v: VirtualAddr, p: Page) -> Option<()> {
let entry = self.find_area(v)?.entry;
let l2 = self.root.next_table_or(v, Entry::USER_BASE)?;
let l3 = l2.next_table_or(v, Entry::USER_BASE)?;
l3[v].write(Entry::page(p.into()) | entry);
Some(())
}
}
bitflags! {
pub struct Prot: u8 {
const READ = 1 << 0;
const WRITE = 1 << 1;
const EXEC = 1 << 2;
const RO = Self::READ.bits;
const RW = Self::READ.bits | Self::WRITE.bits;
const RX = Self::READ.bits | Self::EXEC.bits;
}
}
bitflags! {
pub struct Map: u8 {
const EXEC = 1 << 0;
const WRITE = 1 << 1;
const READ = 1 << 2;
const CAN_EXEC = 1 << 4;
const CAN_WRITE = 1 << 5;
const CAN_READ = 1 << 6;
const ANON = 1 << 10;
const FIXED = 1 << 11;
const PRIVATE = 1 << 12;
const SHARED = 1 << 13;
const STACK = 1 << 14;
}
}
#[derive(Debug)]
pub struct Area {
pub start: VirtualAddr,
pub end: VirtualAddr,
pub entry: Entry,
pub physical: Option<PhysicalAddr>,
}
impl Area {
pub fn new(start: usize, end: usize) -> Self {
let start = VirtualAddr::from(start as *mut u8);
let end = VirtualAddr::from(end as *mut u8);
Self {
start, end,<｜fim▁hole｜> pub fn entry(mut self, entry: Entry) -> Self {
self.entry = entry;
self
}
pub fn prot(mut self, p: Prot) -> Self {
self.entry = match p {
Prot::RO => Entry::USER_RO,
Prot::RW => Entry::USER_RW,
Prot::RX => Entry::USER_RX,
_ => unimplemented!(),
};
self
}
pub fn map_to(mut self, p: PhysicalAddr) -> Self {
self.physical = Some(p);
self
}
pub fn is_empty(&self) -> bool {
self.start >= self.end
}
pub fn contains(&self, addr: VirtualAddr) -> bool {
self.start <= addr && addr < self.end
}
pub fn intersects(&self, other: Self) -> bool {
self.contains(other.start) || self.contains(other.end)
}
}
/// Set up page translation tables and enable virtual memory
pub fn initialize() {
#![allow(non_snake_case)]
static mut L1: Table<L1> = Table::empty();
static mut L2: Table<L2> = Table::empty();
static mut L3: Table<L3> = Table::empty();
let NORMAL: Entry = Entry::AF | Entry::ISH;
let DATA: Entry = NORMAL | Entry::XN | Entry::PXN;
let CODE: Entry = NORMAL | Entry::AP_RO;
let DEV: Entry = Entry::AF | Entry::OSH | Entry::XN | Entry::ATTR_1;
let start = kernel_start().as_usize();
let data = kernel_data().as_usize();
let ttbr = unsafe {
L1.get_mut(0).write(Entry::table((&mut L2 as *mut Table<L2>).into()) | NORMAL);
L2.get_mut(0).write(Entry::table((&mut L3 as *mut Table<L3>).into()) | NORMAL);
for n in 1..512usize {
let addr = n * HUGESZ;
L2.get_mut(n).write(Entry::block(addr.into()) | if addr < IO_BASE { DATA } else { DEV });
}
for n in 0..512usize {
let addr = n * PAGESZ;
L3.get_mut(n).write(Entry::page(addr.into()) | if addr < start || addr >= data { DATA } else { CODE });
}
&mut L1 as *mut _ as u64
};
aarch64::set_ttbr0_el1(0, ttbr, true);
aarch64::set_ttbr1_el1(1, ttbr, true);
// okay, now we have to set system registers to enable MMU
// check for 4k granule and at least 36 bits physical address bus
let mmfr = aarch64::MMFR::new();
let par = mmfr.physical_address_range();
assert!(mmfr.support_4kb_granulate(), "4k granulate not supported");
assert!(par >= aarch64::PhysicalAddressRange::R36, "36 bit address space not supported");
let ips = par.raw() as u64;
// first, set Memory Attributes array,
// indexed by PT_MEM, PT_DEV, PT_NC in our example
let mair: u64 =
(0xFF << 0) | // AttrIdx=0: normal, IWBWA, OWBWA, NTR
(0x04 << 8) | // AttrIdx=1: device, nGnRE (must be OSH too)
(0x44 <<16); // AttrIdx=2: non cacheable
// next, specify mapping characteristics in translate control register
let tcr: u64 =
(0b00 << 37) | // TBI=0, no tagging
(ips << 32) | // IPS=autodetected
(0b10 << 30) | // TG1=4k
(0b11 << 28) | // SH1=3 inner
(0b01 << 26) | // ORGN1=1 write back
(0b01 << 24) | // IRGN1=1 write back
(0b0 << 23) | // EPD1 enable higher half
(25 << 16) | // T1SZ=25, 3 levels (512G)
(0b00 << 14) | // TG0=4k
(0b11 << 12) | // SH0=3 inner
(0b01 << 10) | // ORGN0=1 write back
(0b01 << 8) | // IRGN0=1 write back
(0b0 << 7) | // EPD0 enable lower half
(25 << 0); // T0SZ=25, 3 levels (512G)
unsafe {
asm!("
msr mair_el1, $0
msr tcr_el1, $1
isb
"
:: "r"(mair), "r"(tcr)
:: "volatile");
}
// finally, toggle some bits in system control register to enable page translation
unsafe {
let mut r: u64;
asm!("dsb ish; isb; mrs $0, sctlr_el1" : "=r"(r) : : : "volatile");
r |= 0xC00800; // set mandatory reserved bits
r &= !((1<<25) | // clear EE, little endian translation tables
(1<<24) | // clear E0E
(1<<19) | // clear WXN
(1<<12) | // clear I, no instruction cache
(1<< 4) | // clear SA0
(1<< 3) | // clear SA
(1<< 2) | // clear C, no cache at all
(1<< 1)); // clear A, no aligment check
r |= 1<< 0; // set M, enable MMU
asm!("msr sctlr_el1, $0; isb" :: "r"(r) :: "volatile");
}
}<｜fim▁end｜> | entry: Entry::INVALID,
physical: None,
}
} |
<|file_name|>vl_demo_sift_edge.py<|end_file_name|><｜fim▁begin｜>import Image
import numpy
import pylab
import vlfeat
from vlfeat.plotop.vl_plotframe import vl_plotframe
if __name__ == '__main__':
""" VL_DEMO_SIFT_EDGE Demo: SIFT: edge treshold
"""
I = numpy.zeros([100, 500])
for i in 10 * (1+numpy.arange(9)):
d = numpy.round(i / 3.0)
I[50-d-1:50+d-1, i * 5-1] = 1
I = numpy.array(I, 'f', order='F')
I = 2 * numpy.pi * 8 ** 2 * vlfeat.vl_imsmooth(I, 8)
I = 255 * I
I = numpy.array(I, 'f', order='F')
print 'sift_edge_0'
ter = [3.5, 5, 7.5, 10]
for te in ter:
f, d = vlfeat.vl_sift(I, peak_thresh=0.0, edge_thresh=te)
pylab.figure()
pylab.gray()
pylab.imshow(I)
vl_plotframe(f, color='k', linewidth=3)
vl_plotframe(f, color='y', linewidth=2)
<｜fim▁hole｜><｜fim▁end｜> | pylab.show() |
<|file_name|>ascii.rs<|end_file_name|><｜fim▁begin｜>// Copyright 2013-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.
//! Operations on ASCII strings and characters
use to_str::{IntoStr};
use str;
use str::Str;
use str::StrSlice;
use str::OwnedStr;
use container::Container;
use cast;
use fmt;
use iter::Iterator;
use slice::{ImmutableVector, MutableVector, Vector};
use vec::Vec;
use option::{Option, Some, None};
/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq, Hash)]
pub struct Ascii { chr: u8 }
impl Ascii {
/// Converts an ascii character into a `u8`.
#[inline]
pub fn to_byte(self) -> u8 {
self.chr
}
/// Converts an ascii character into a `char`.
#[inline]
pub fn to_char(self) -> char {
self.chr as char
}
/// Convert to lowercase.
#[inline]
pub fn to_lower(self) -> Ascii {
Ascii{chr: ASCII_LOWER_MAP[self.chr as uint]}
}
/// Convert to uppercase.
#[inline]
pub fn to_upper(self) -> Ascii {
Ascii{chr: ASCII_UPPER_MAP[self.chr as uint]}
}
/// Compares two ascii characters of equality, ignoring case.
#[inline]
pub fn eq_ignore_case(self, other: Ascii) -> bool {
ASCII_LOWER_MAP[self.chr as uint] == ASCII_LOWER_MAP[other.chr as uint]
}
// the following methods are like ctype, and the implementation is inspired by musl
/// Check if the character is a letter (a-z, A-Z)
#[inline]
pub fn is_alpha(&self) -> bool {
(self.chr >= 0x41 && self.chr <= 0x5A) || (self.chr >= 0x61 && self.chr <= 0x7A)
}
/// Check if the character is a number (0-9)
#[inline]
pub fn is_digit(&self) -> bool {
self.chr >= 0x30 && self.chr <= 0x39
}
/// Check if the character is a letter or number
#[inline]
pub fn is_alnum(&self) -> bool {
self.is_alpha() || self.is_digit()
}
/// Check if the character is a space or horizontal tab
#[inline]
pub fn is_blank(&self) -> bool {
self.chr == ' ' as u8 || self.chr == '\t' as u8
}
/// Check if the character is a control character
#[inline]
pub fn is_control(&self) -> bool {
self.chr < 0x20 || self.chr == 0x7F
}
/// Checks if the character is printable (except space)
#[inline]
pub fn is_graph(&self) -> bool {
(self.chr - 0x21) < 0x5E
}
/// Checks if the character is printable (including space)
#[inline]
pub fn is_print(&self) -> bool {
(self.chr - 0x20) < 0x5F
}
/// Checks if the character is lowercase
#[inline]
pub fn is_lower(&self) -> bool {
(self.chr - 'a' as u8) < 26
}
/// Checks if the character is uppercase
#[inline]
pub fn is_upper(&self) -> bool {
(self.chr - 'A' as u8) < 26
}
/// Checks if the character is punctuation
#[inline]
pub fn is_punctuation(&self) -> bool {
self.is_graph() && !self.is_alnum()
}
/// Checks if the character is a valid hex digit
#[inline]
pub fn is_hex(&self) -> bool {
self.is_digit() || ((self.chr | 32u8) - 'a' as u8) < 6
}
}
impl<'a> fmt::Show for Ascii {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
(self.chr as char).fmt(f)
}
}
/// Trait for converting into an ascii type.
pub trait AsciiCast<T> {
/// Convert to an ascii type, fail on non-ASCII input.
#[inline]
fn to_ascii(&self) -> T {
assert!(self.is_ascii());
unsafe {self.to_ascii_nocheck()}
}
/// Convert to an ascii type, return None on non-ASCII input.
#[inline]
fn to_ascii_opt(&self) -> Option<T> {
if self.is_ascii() {
Some(unsafe { self.to_ascii_nocheck() })
} else {
None
}
}
/// Convert to an ascii type, not doing any range asserts
unsafe fn to_ascii_nocheck(&self) -> T;
/// Check if convertible to ascii
fn is_ascii(&self) -> bool;
}
impl<'a> AsciiCast<&'a[Ascii]> for &'a [u8] {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> &'a[Ascii] {
cast::transmute(*self)
}
#[inline]
fn is_ascii(&self) -> bool {
for b in self.iter() {
if !b.is_ascii() { return false; }
}
true
}
}
impl<'a> AsciiCast<&'a [Ascii]> for &'a str {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> &'a [Ascii] {
cast::transmute(*self)
}
#[inline]
fn is_ascii(&self) -> bool {
self.bytes().all(|b| b.is_ascii())
}
}
impl AsciiCast<Ascii> for u8 {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> Ascii {
Ascii{ chr: *self }
}
#[inline]
fn is_ascii(&self) -> bool {
*self & 128 == 0u8
}
}
impl AsciiCast<Ascii> for char {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> Ascii {
Ascii{ chr: *self as u8 }
}
#[inline]
fn is_ascii(&self) -> bool {
*self as u32 - ('\x7F' as u32 & *self as u32) == 0
}
}
/// Trait for copyless casting to an ascii vector.
pub trait OwnedAsciiCast {
/// Check if convertible to ascii
fn is_ascii(&self) -> bool;
/// Take ownership and cast to an ascii vector. Fail on non-ASCII input.
#[inline]
fn into_ascii(self) -> ~[Ascii] {
assert!(self.is_ascii());
unsafe {self.into_ascii_nocheck()}
}
/// Take ownership and cast to an ascii vector. Return None on non-ASCII input.
#[inline]
fn into_ascii_opt(self) -> Option<~[Ascii]> {
if self.is_ascii() {
Some(unsafe { self.into_ascii_nocheck() })
} else {
None
}
}
/// Take ownership and cast to an ascii vector.
/// Does not perform validation checks.
unsafe fn into_ascii_nocheck(self) -> ~[Ascii];
}
impl OwnedAsciiCast for ~[u8] {
#[inline]
fn is_ascii(&self) -> bool {
self.as_slice().is_ascii()
}
#[inline]<｜fim▁hole｜>
impl OwnedAsciiCast for ~str {
#[inline]
fn is_ascii(&self) -> bool {
self.as_slice().is_ascii()
}
#[inline]
unsafe fn into_ascii_nocheck(self) -> ~[Ascii] {
cast::transmute(self)
}
}
/// Trait for converting an ascii type to a string. Needed to convert
/// `&[Ascii]` to `&str`.
pub trait AsciiStr {
/// Convert to a string.
fn as_str_ascii<'a>(&'a self) -> &'a str;
/// Convert to vector representing a lower cased ascii string.
fn to_lower(&self) -> ~[Ascii];
/// Convert to vector representing a upper cased ascii string.
fn to_upper(&self) -> ~[Ascii];
/// Compares two Ascii strings ignoring case.
fn eq_ignore_case(self, other: &[Ascii]) -> bool;
}
impl<'a> AsciiStr for &'a [Ascii] {
#[inline]
fn as_str_ascii<'a>(&'a self) -> &'a str {
unsafe { cast::transmute(*self) }
}
#[inline]
fn to_lower(&self) -> ~[Ascii] {
self.iter().map(|a| a.to_lower()).collect()
}
#[inline]
fn to_upper(&self) -> ~[Ascii] {
self.iter().map(|a| a.to_upper()).collect()
}
#[inline]
fn eq_ignore_case(self, other: &[Ascii]) -> bool {
self.iter().zip(other.iter()).all(|(&a, &b)| a.eq_ignore_case(b))
}
}
impl IntoStr for ~[Ascii] {
#[inline]
fn into_str(self) -> ~str {
unsafe { cast::transmute(self) }
}
}
impl IntoStr for Vec<Ascii> {
#[inline]
fn into_str(self) -> ~str {
let v: ~[Ascii] = self.move_iter().collect();
unsafe { cast::transmute(v) }
}
}
/// Trait to convert to an owned byte array by consuming self
pub trait IntoBytes {
/// Converts to an owned byte array by consuming self
fn into_bytes(self) -> ~[u8];
}
impl IntoBytes for ~[Ascii] {
fn into_bytes(self) -> ~[u8] {
unsafe { cast::transmute(self) }
}
}
/// Extension methods for ASCII-subset only operations on owned strings
pub trait OwnedStrAsciiExt {
/// Convert the string to ASCII upper case:
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
fn into_ascii_upper(self) -> ~str;
/// Convert the string to ASCII lower case:
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
fn into_ascii_lower(self) -> ~str;
}
/// Extension methods for ASCII-subset only operations on string slices
pub trait StrAsciiExt {
/// Makes a copy of the string in ASCII upper case:
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
fn to_ascii_upper(&self) -> ~str;
/// Makes a copy of the string in ASCII lower case:
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
fn to_ascii_lower(&self) -> ~str;
/// Check that two strings are an ASCII case-insensitive match.
/// Same as `to_ascii_lower(a) == to_ascii_lower(b)`,
/// but without allocating and copying temporary strings.
fn eq_ignore_ascii_case(&self, other: &str) -> bool;
}
impl<'a> StrAsciiExt for &'a str {
#[inline]
fn to_ascii_upper(&self) -> ~str {
unsafe { str_copy_map_bytes(*self, ASCII_UPPER_MAP) }
}
#[inline]
fn to_ascii_lower(&self) -> ~str {
unsafe { str_copy_map_bytes(*self, ASCII_LOWER_MAP) }
}
#[inline]
fn eq_ignore_ascii_case(&self, other: &str) -> bool {
self.len() == other.len() &&
self.as_bytes().iter().zip(other.as_bytes().iter()).all(
|(byte_self, byte_other)| {
ASCII_LOWER_MAP[*byte_self as uint] ==
ASCII_LOWER_MAP[*byte_other as uint]
})
}
}
impl OwnedStrAsciiExt for ~str {
#[inline]
fn into_ascii_upper(self) -> ~str {
unsafe { str_map_bytes(self, ASCII_UPPER_MAP) }
}
#[inline]
fn into_ascii_lower(self) -> ~str {
unsafe { str_map_bytes(self, ASCII_LOWER_MAP) }
}
}
#[inline]
unsafe fn str_map_bytes(string: ~str, map: &'static [u8]) -> ~str {
let mut bytes = string.into_bytes();
for b in bytes.mut_iter() {
*b = map[*b as uint];
}
str::raw::from_utf8_owned(bytes)
}
#[inline]
unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> ~str {
let bytes = string.bytes().map(|b| map[b as uint]).collect::<~[_]>();
str::raw::from_utf8_owned(bytes)
}
static ASCII_LOWER_MAP: &'static [u8] = &[
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
];
static ASCII_UPPER_MAP: &'static [u8] = &[
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
];
#[cfg(test)]
mod tests {
use prelude::*;
use super::*;
use str::from_char;
use char::from_u32;
use vec::Vec;
use str::StrSlice;
macro_rules! v2ascii (
( [$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
(&[$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
(~[$($e:expr),*]) => (~[$(Ascii{chr:$e}),*]);
)
macro_rules! vec2ascii (
($($e:expr),*) => (Vec::from_slice([$(Ascii{chr:$e}),*]));
)
#[test]
fn test_ascii() {
assert_eq!(65u8.to_ascii().to_byte(), 65u8);
assert_eq!(65u8.to_ascii().to_char(), 'A');
assert_eq!('A'.to_ascii().to_char(), 'A');
assert_eq!('A'.to_ascii().to_byte(), 65u8);
assert_eq!('A'.to_ascii().to_lower().to_char(), 'a');
assert_eq!('Z'.to_ascii().to_lower().to_char(), 'z');
assert_eq!('a'.to_ascii().to_upper().to_char(), 'A');
assert_eq!('z'.to_ascii().to_upper().to_char(), 'Z');
assert_eq!('@'.to_ascii().to_lower().to_char(), '@');
assert_eq!('['.to_ascii().to_lower().to_char(), '[');
assert_eq!('`'.to_ascii().to_upper().to_char(), '`');
assert_eq!('{'.to_ascii().to_upper().to_char(), '{');
assert!('0'.to_ascii().is_digit());
assert!('9'.to_ascii().is_digit());
assert!(!'/'.to_ascii().is_digit());
assert!(!':'.to_ascii().is_digit());
assert!((0x1fu8).to_ascii().is_control());
assert!(!' '.to_ascii().is_control());
assert!((0x7fu8).to_ascii().is_control());
assert!("banana".chars().all(|c| c.is_ascii()));
assert!(!"ประเทศไทย中华Việt Nam".chars().all(|c| c.is_ascii()));
}
#[test]
fn test_ascii_vec() {
let test = &[40u8, 32u8, 59u8];
assert_eq!(test.to_ascii(), v2ascii!([40, 32, 59]));
assert_eq!("( ;".to_ascii(), v2ascii!([40, 32, 59]));
// FIXME: #5475 borrowchk error, owned vectors do not live long enough
// if chained-from directly
let v = ~[40u8, 32u8, 59u8]; assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59]));
let v = "( ;".to_owned(); assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59]));
assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_owned());
assert_eq!("abCDef&?#".to_ascii().to_upper().into_str(), "ABCDEF&?#".to_owned());
assert_eq!("".to_ascii().to_lower().into_str(), "".to_owned());
assert_eq!("YMCA".to_ascii().to_lower().into_str(), "ymca".to_owned());
assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().into_str(), "ABCDEFXYZ:.;".to_owned());
assert!("aBcDeF&?#".to_ascii().eq_ignore_case("AbCdEf&?#".to_ascii()));
assert!("".is_ascii());
assert!("a".is_ascii());
assert!(!"\u2009".is_ascii());
}
#[test]
fn test_ascii_vec_ng() {
assert_eq!(Vec::from_slice("abCDef&?#".to_ascii().to_lower()).into_str(),
"abcdef&?#".to_owned());
assert_eq!(Vec::from_slice("abCDef&?#".to_ascii().to_upper()).into_str(),
"ABCDEF&?#".to_owned());
assert_eq!(Vec::from_slice("".to_ascii().to_lower()).into_str(), "".to_owned());
assert_eq!(Vec::from_slice("YMCA".to_ascii().to_lower()).into_str(), "ymca".to_owned());
assert_eq!(Vec::from_slice("abcDEFxyz:.;".to_ascii().to_upper()).into_str(),
"ABCDEFXYZ:.;".to_owned());
}
#[test]
fn test_owned_ascii_vec() {
assert_eq!(("( ;".to_owned()).into_ascii(), v2ascii!(~[40, 32, 59]));
assert_eq!((~[40u8, 32u8, 59u8]).into_ascii(), v2ascii!(~[40, 32, 59]));
}
#[test]
fn test_ascii_as_str() {
let v = v2ascii!([40, 32, 59]);
assert_eq!(v.as_str_ascii(), "( ;");
}
#[test]
fn test_ascii_into_str() {
assert_eq!(v2ascii!(~[40, 32, 59]).into_str(), "( ;".to_owned());
assert_eq!(vec2ascii!(40, 32, 59).into_str(), "( ;".to_owned());
}
#[test]
fn test_ascii_to_bytes() {
assert_eq!(v2ascii!(~[40, 32, 59]).into_bytes(), ~[40u8, 32u8, 59u8]);
}
#[test] #[should_fail]
fn test_ascii_vec_fail_u8_slice() { (&[127u8, 128u8, 255u8]).to_ascii(); }
#[test] #[should_fail]
fn test_ascii_vec_fail_str_slice() { "zoä华".to_ascii(); }
#[test] #[should_fail]
fn test_ascii_fail_u8_slice() { 255u8.to_ascii(); }
#[test] #[should_fail]
fn test_ascii_fail_char_slice() { 'λ'.to_ascii(); }
#[test]
fn test_opt() {
assert_eq!(65u8.to_ascii_opt(), Some(Ascii { chr: 65u8 }));
assert_eq!(255u8.to_ascii_opt(), None);
assert_eq!('A'.to_ascii_opt(), Some(Ascii { chr: 65u8 }));
assert_eq!('λ'.to_ascii_opt(), None);
assert_eq!("zoä华".to_ascii_opt(), None);
let test1 = &[127u8, 128u8, 255u8];
assert_eq!((test1).to_ascii_opt(), None);
let v = [40u8, 32u8, 59u8];
let v2 = v2ascii!(&[40, 32, 59]);
assert_eq!(v.to_ascii_opt(), Some(v2));
let v = [127u8, 128u8, 255u8];
assert_eq!(v.to_ascii_opt(), None);
let v = "( ;";
let v2 = v2ascii!(&[40, 32, 59]);
assert_eq!(v.to_ascii_opt(), Some(v2));
assert_eq!("zoä华".to_ascii_opt(), None);
assert_eq!((~[40u8, 32u8, 59u8]).into_ascii_opt(), Some(v2ascii!(~[40, 32, 59])));
assert_eq!((~[127u8, 128u8, 255u8]).into_ascii_opt(), None);
assert_eq!(("( ;".to_owned()).into_ascii_opt(), Some(v2ascii!(~[40, 32, 59])));
assert_eq!(("zoä华".to_owned()).into_ascii_opt(), None);
}
#[test]
fn test_to_ascii_upper() {
assert_eq!("url()URL()uRl()ürl".to_ascii_upper(), "URL()URL()URL()üRL".to_owned());
assert_eq!("hıKß".to_ascii_upper(), "HıKß".to_owned());
let mut i = 0;
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
assert_eq!(from_char(from_u32(i).unwrap()).to_ascii_upper(),
from_char(from_u32(upper).unwrap()))
i += 1;
}
}
#[test]
fn test_to_ascii_lower() {
assert_eq!("url()URL()uRl()Ürl".to_ascii_lower(), "url()url()url()Ürl".to_owned());
// Dotted capital I, Kelvin sign, Sharp S.
assert_eq!("HİKß".to_ascii_lower(), "hİKß".to_owned());
let mut i = 0;
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
assert_eq!(from_char(from_u32(i).unwrap()).to_ascii_lower(),
from_char(from_u32(lower).unwrap()))
i += 1;
}
}
#[test]
fn test_into_ascii_upper() {
assert_eq!(("url()URL()uRl()ürl".to_owned()).into_ascii_upper(),
"URL()URL()URL()üRL".to_owned());
assert_eq!(("hıKß".to_owned()).into_ascii_upper(), "HıKß".to_owned());
let mut i = 0;
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
assert_eq!(from_char(from_u32(i).unwrap()).into_ascii_upper(),
from_char(from_u32(upper).unwrap()))
i += 1;
}
}
#[test]
fn test_into_ascii_lower() {
assert_eq!(("url()URL()uRl()Ürl".to_owned()).into_ascii_lower(),
"url()url()url()Ürl".to_owned());
// Dotted capital I, Kelvin sign, Sharp S.
assert_eq!(("HİKß".to_owned()).into_ascii_lower(), "hİKß".to_owned());
let mut i = 0;
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
assert_eq!(from_char(from_u32(i).unwrap()).into_ascii_lower(),
from_char(from_u32(lower).unwrap()))
i += 1;
}
}
#[test]
fn test_eq_ignore_ascii_case() {
assert!("url()URL()uRl()Ürl".eq_ignore_ascii_case("url()url()url()Ürl"));
assert!(!"Ürl".eq_ignore_ascii_case("ürl"));
// Dotted capital I, Kelvin sign, Sharp S.
assert!("HİKß".eq_ignore_ascii_case("hİKß"));
assert!(!"İ".eq_ignore_ascii_case("i"));
assert!(!"K".eq_ignore_ascii_case("k"));
assert!(!"ß".eq_ignore_ascii_case("s"));
let mut i = 0;
while i <= 500 {
let c = i;
let lower = if 'A' as u32 <= c && c <= 'Z' as u32 { c + 'a' as u32 - 'A' as u32 }
else { c };
assert!(from_char(from_u32(i).unwrap()).
eq_ignore_ascii_case(from_char(from_u32(lower).unwrap())));
i += 1;
}
}
#[test]
fn test_to_str() {
let s = Ascii{ chr: 't' as u8 }.to_str();
assert_eq!(s, "t".to_owned());
}
#[test]
fn test_show() {
let c = Ascii { chr: 't' as u8 };
assert_eq!(format!("{}", c), "t".to_owned());
}
}<｜fim▁end｜> | unsafe fn into_ascii_nocheck(self) -> ~[Ascii] {
cast::transmute(self)
}
} |
<|file_name|>dex_to_bytes.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
#
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");<｜fim▁hole｜># 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.
data = open('output.dex', 'rb').read()
with open('output.txt', 'wb') as f:
f.write(str(map(ord, data)))<｜fim▁end｜> | |
<|file_name|>critical.py<|end_file_name|><｜fim▁begin｜>from JumpScale import j
import JumpScale.baselib.watchdog.manager
import JumpScale.baselib.redis
import JumpScale.lib.rogerthat
descr = """
critical alert<｜fim▁hole｜>
REDIS_PORT = 9999
# API_KEY = j.application.config.get('rogerthat.apikey')
redis_client = j.clients.credis.getRedisClient('127.0.0.1', REDIS_PORT)
# rogerthat_client = j.clients.rogerthat.get(API_KEY)
# ANSWERS = [{'id': 'yes', 'caption': 'Take', 'action': '', 'type': 'button'},]
# def _send_message(message, contacts, answers=ANSWERS, alert_flags=6):
# result = rogerthat_client.send_message(message, contacts, answers=answers, alert_flags=alert_flags)
# if result:
# if result['error']:
# j.logger.log('Could not send rogerthat message')
# return
# else:
# message_id = result['result']
# return message_id
def escalateL1(watchdogevent):
if not j.tools.watchdog.manager.inAlert(watchdogevent):
watchdogevent.escalationstate = 'L1'
# contact1 = redis_client.hget('contacts', '1')
message = str(watchdogevent)
# message_id = _send_message(message, [contact1,])
# watchdogevent.message_id = message_id
j.tools.watchdog.manager.setAlert(watchdogevent)
print "Escalate:%s"%message
def escalateL2(watchdogevent):
if watchdogevent.escalationstate == 'L1':
watchdogevent.escalationstate = 'L2'
contacts = redis_client.hgetall('contacts')
message = str(watchdogevent)
message_id = _send_message(message, [contacts['2'], contacts['3']])
watchdogevent.message_id = message_id
j.tools.watchdog.manager.setAlert(watchdogevent)
def escalateL3(watchdogevent):
if watchdogevent.escalationstate == 'L2':
watchdogevent.escalationstate = 'L3'
contacts = redis_client.hgetall('contacts')['all'].split(',')
message = str(watchdogevent)
message_id = _send_message(message, contacts)
watchdogevent.message_id = message_id
j.tools.watchdog.manager.setAlert(watchdogevent)<｜fim▁end｜> | """
organization = "jumpscale"
enable = True |
<|file_name|>builtins.rs<|end_file_name|><｜fim▁begin｜>extern crate easy_strings;
use self::easy_strings::EZString;
///
/// Macro to mimick Python's slicing.
///
macro_rules! slice {
( $e:expr , [ ; $end_expr:expr ] ) => {
$e [..$end_expr]
};
( $e:expr , [ $start_expr:expr ; $end_expr:expr] ) => {
$e [$start_expr..$end_expr]
};
( $e:expr , [ $start_expr:expr ; ] ) => {
$e [$start_expr..]
};
( $e:expr , [ $start_expr:expr ; $end_expr:expr ; $steps_expr:expr] ) => {
std::unimplemented();
};
( $e:expr , [ ; $end_expr:expr ; $steps_expr:expr ] ) => {
std::unimplemented();
};
( $e:expr , [ ; ] ) => {
std::unimplemented();
};
}
///
/// Trait for cohercing values types to 'bool', like it is done in
/// the Python's `if`.
///
pub trait Boolable {
fn get_bool_value(self) -> bool;
}
/*
Wanted to do this (but it conflicted with my other impls:
use num;
impl<T> Boolable for T where T : num::Zero {
fn get_bool_value(&self) -> bool {
!self.is_zero()
}
}
*/
impl Boolable for u32 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a u32 { fn get_bool_value(self) -> bool { *self != 0 }}
impl Boolable for u16 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a u16 { fn get_bool_value(self) -> bool { *self != 0 }}
impl Boolable for u8 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a u8 { fn get_bool_value(self) -> bool { *self != 0 }}
impl Boolable for i32 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a i32 { fn get_bool_value(self) -> bool { *self != 0 }}
impl Boolable for i16 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a i16 { fn get_bool_value(self) -> bool { *self != 0 }}
impl Boolable for i8 { fn get_bool_value(self) -> bool { self != 0 }}
impl<'a> Boolable for &'a i8 { fn get_bool_value(self) -> bool { *self != 0 }}
impl<'a, T>
Boolable for &'a [T] { fn get_bool_value(self) -> bool { self.len() != 0 }}
impl<'a>
Boolable for &'a str { fn get_bool_value(self) -> bool { self.len() != 0 }}
impl Boolable for bool { fn get_bool_value(self) -> bool { self }}
impl Boolable for EZString{ fn get_bool_value(self) -> bool { !self.is_empty() }}
impl Boolable for () { fn get_bool_value(self) -> bool { false }}
impl<T1> Boolable for (T1, ) { fn get_bool_value(self) -> bool { true }}
impl<T1, T2> Boolable for (T1, T2)
{ fn get_bool_value(self) -> bool { true }}
impl<T1, T2, T3> Boolable for (T1, T2, T3)
{ fn get_bool_value(self) -> bool { true }}
/// Similar to the Python [all](https://docs.python.org/2/library/functions.html#all) builtin.
pub fn all<I, T>(i : I) -> bool where T : Boolable, I : IntoIterator<Item = T> {
i.into_iter().all(|e| e.get_bool_value())
}
/// Similar to the Python [any](https://docs.python.org/2/library/functions.html#any) builtin.
pub fn any<I, T>(i : I) -> bool where T : Boolable, I : IntoIterator<Item = T> {
i.into_iter().any(|e| e.get_bool_value())
}
use std::cmp::Ordering;
/// Similar to the Python [cmp](https://docs.python.org/2/library/functions.html#cmp) builtin.
pub fn cmp<T>(a : &T, b : &T) -> i64 where T : Ord {
match a.cmp(b) {
Ordering::Less => -1,
Ordering::Equal => 0,
Ordering::Greater => 1,
}
}
#[cfg(test)]
mod tests {
#[test]
fn slice() {
let v : Vec<u32> = vec![1,2,3,4,5,6];
assert_eq!(&v[2..4], [3, 4]);
assert_eq!(&slice!(v, [;4]), [1, 2, 3, 4]);
assert_eq!(&slice!(v, [4;]), [5, 6]);
}
#[test]
fn bool() {
use super::{Boolable};
assert_eq!(3.get_bool_value(), true);
assert_eq!(0.get_bool_value(), false);
let x : [u32; 0] = [];
assert_eq!(x.get_bool_value(), false);
let y : [u32; 1] = [1];
assert_eq!(y.get_bool_value(), true);
assert_eq!(true.get_bool_value(), true);
assert_eq!(false.get_bool_value(), false);
assert_eq!(" xx".get_bool_value(), true);
assert_eq!("".get_bool_value(), false);
assert_eq!(super::EZString::from(" xx").get_bool_value(), true);
assert_eq!(super::EZString::from("").get_bool_value(), false);
}
#[test]
fn all_and_any() {
let empty : [u32;0] = [];
assert_eq!(super::all(empty.iter()), true);
assert_eq!(super::all([2, 3, 4].iter()), true);
assert_eq!(super::all([2, 0, 4].iter()), false);
assert_eq!(super::any(empty.iter()), false);
assert_eq!(super::any([2, 3, 4].iter()), true);<｜fim▁hole｜> #[test]
fn cmp() {
assert_eq!(super::cmp(&1, &2), -1);
assert_eq!(super::cmp(&2, &1), 1);
assert_eq!(super::cmp(&1, &1), 0);
}
}<｜fim▁end｜> | assert_eq!(super::any([2, 0, 4].iter()), true);
assert_eq!(super::any([0, 0, 0].iter()), false);
}
|
<|file_name|>views.py<|end_file_name|><｜fim▁begin｜>from __future__ import absolute_import, unicode_literals
import csv
import datetime
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils.encoding import smart_str
from django.utils.translation import ugettext as _
from wagtail.utils.pagination import paginate
from wagtail.wagtailadmin import messages
from wagtail.wagtailcore.models import Page
from wagtail.wagtailforms.forms import SelectDateForm
from wagtail.wagtailforms.models import get_forms_for_user
def index(request):
form_pages = get_forms_for_user(request.user)
paginator, form_pages = paginate(request, form_pages)
return render(request, 'wagtailforms/index.html', {
'form_pages': form_pages,
})
def delete_submission(request, page_id, submission_id):
if not get_forms_for_user(request.user).filter(id=page_id).exists():
raise PermissionDenied
page = get_object_or_404(Page, id=page_id).specific
submission = get_object_or_404(page.get_submission_class(), id=submission_id)
if request.method == 'POST':
submission.delete()
messages.success(request, _("Submission deleted."))
return redirect('wagtailforms:list_submissions', page_id)
return render(request, 'wagtailforms/confirm_delete.html', {
'page': page,
'submission': submission
})
<｜fim▁hole｜> if not get_forms_for_user(request.user).filter(id=page_id).exists():
raise PermissionDenied
form_page = get_object_or_404(Page, id=page_id).specific
form_submission_class = form_page.get_submission_class()
data_fields = form_page.get_data_fields()
submissions = form_submission_class.objects.filter(page=form_page).order_by('submit_time')
data_headings = [label for name, label in data_fields]
select_date_form = SelectDateForm(request.GET)
if select_date_form.is_valid():
date_from = select_date_form.cleaned_data.get('date_from')
date_to = select_date_form.cleaned_data.get('date_to')
# careful: date_to should be increased by 1 day since the submit_time
# is a time so it will always be greater
if date_to:
date_to += datetime.timedelta(days=1)
if date_from and date_to:
submissions = submissions.filter(submit_time__range=[date_from, date_to])
elif date_from and not date_to:
submissions = submissions.filter(submit_time__gte=date_from)
elif not date_from and date_to:
submissions = submissions.filter(submit_time__lte=date_to)
if request.GET.get('action') == 'CSV':
# return a CSV instead
response = HttpResponse(content_type='text/csv; charset=utf-8')
response['Content-Disposition'] = 'attachment;filename=export.csv'
# Prevents UnicodeEncodeError for labels with non-ansi symbols
data_headings = [smart_str(label) for label in data_headings]
writer = csv.writer(response)
writer.writerow(data_headings)
for s in submissions:
data_row = []
form_data = s.get_data()
for name, label in data_fields:
data_row.append(smart_str(form_data.get(name)))
writer.writerow(data_row)
return response
paginator, submissions = paginate(request, submissions)
data_rows = []
for s in submissions:
form_data = s.get_data()
data_row = [form_data.get(name) for name, label in data_fields]
data_rows.append({
"model_id": s.id,
"fields": data_row
})
return render(request, 'wagtailforms/index_submissions.html', {
'form_page': form_page,
'select_date_form': select_date_form,
'submissions': submissions,
'data_headings': data_headings,
'data_rows': data_rows
})<｜fim▁end｜> |
def list_submissions(request, page_id): |
<|file_name|>size.js<|end_file_name|><｜fim▁begin｜>import store from "@/store";
import { modV } from "@/modv";
import Vue from "vue";
const state = {
width: 200,
height: 200,
previewX: 0,
previewY: 0,
previewWidth: 0,
previewHeight: 0
};
// getters
const getters = {
width: state => state.width,
height: state => state.height,
area: state => state.width * state.height,
dimensions: state => ({ width: state.width, height: state.height }),
previewValues: state => ({
width: state.previewWidth,
height: state.previewHeight,
x: state.previewX,
y: state.previewY
})
};
// actions
const actions = {
updateSize({ state }) {
store.dispatch("size/setDimensions", {
width: state.width,
height: state.height
});
},
setDimensions({ commit, state }, { width, height }) {
let widthShadow = width;
let heightShadow = height;
const largestWindowReference = store.getters[
"windows/largestWindowReference"
]();
if (
widthShadow >= largestWindowReference.innerWidth &&
heightShadow >= largestWindowReference.innerHeight
) {
if (store.getters["user/constrainToOneOne"]) {
if (widthShadow > heightShadow) {
widthShadow = heightShadow;
} else {
heightShadow = widthShadow;
}
}
commit("setDimensions", { width: widthShadow, height: heightShadow });
let dpr = window.devicePixelRatio || 1;
if (!store.getters["user/useRetina"]) dpr = 1;
modV.resize(state.width, state.height, dpr);
store.dispatch("modVModules/resizeActive");
store.dispatch("layers/resize", {
width: state.width,
height: state.height,
dpr
});
store.dispatch("windows/resize", {
width: state.width,
height: state.height,
dpr
});
store.dispatch("size/calculatePreviewCanvasValues");
}
},
resizePreviewCanvas() {
modV.previewCanvas.width = modV.previewCanvas.clientWidth;
modV.previewCanvas.height = modV.previewCanvas.clientHeight;
store.dispatch("size/calculatePreviewCanvasValues");
},
calculatePreviewCanvasValues({ commit, state }) {
// thanks to http://ninolopezweb.com/2016/05/18/how-to-preserve-html5-canvas-aspect-ratio/
// for great aspect ratio advice!
const widthToHeight = state.width / state.height;
let newWidth = modV.previewCanvas.width;
let newHeight = modV.previewCanvas.height;<｜fim▁hole｜> newWidth = Math.round(newHeight * widthToHeight);
} else {
newHeight = Math.round(newWidth / widthToHeight);
}
commit("setPreviewValues", {
x: Math.round(modV.previewCanvas.width / 2 - newWidth / 2),
y: Math.round(modV.previewCanvas.height / 2 - newHeight / 2),
width: newWidth,
height: newHeight
});
}
};
// mutations
const mutations = {
setWidth(state, { width }) {
Vue.set(state, "width", width);
},
setHeight(state, { height }) {
Vue.set(state, "height", height);
},
setDimensions(state, { width, height }) {
Vue.set(state, "width", width);
Vue.set(state, "height", height);
},
setPreviewValues(state, { width, height, x, y }) {
Vue.set(state, "previewWidth", width);
Vue.set(state, "previewHeight", height);
Vue.set(state, "previewX", x);
Vue.set(state, "previewY", y);
}
};
export default {
namespaced: true,
state,
getters,
actions,
mutations
};<｜fim▁end｜> |
const newWidthToHeight = newWidth / newHeight;
if (newWidthToHeight > widthToHeight) { |
<|file_name|>media.js<|end_file_name|><｜fim▁begin｜>import Helper from '@ember/component/helper';
import { inject as service } from '@ember/service';
import { get } from '@ember/object';<｜fim▁hole｜> constructor() {
super(...arguments);
this.media.on('mediaChanged', () => {
this.recompute();
});
}
compute([prop]) {
return get(this, `media.${prop}`);
}
}<｜fim▁end｜> |
export default class MediaHelper extends Helper {
@service() media;
|
<|file_name|>LinuxExporter.ts<|end_file_name|><｜fim▁begin｜>import {Exporter} from './Exporter';
import {GraphicsApi} from '../GraphicsApi';
import {Options} from '../Options';
import {Platform} from '../Platform';
import {Project} from '../Project';
import * as fs from 'fs-extra';
import * as path from 'path';
import { Compiler } from '../Compiler';
export class LinuxExporter extends Exporter {
constructor() {
super();
}
async exportSolution(project: Project, from: string, to: string, platform: string, vrApi: any, options: any) {
this.exportMakefile(project, from, to, platform, vrApi, options);
this.exportCodeBlocks(project, from, to, platform, vrApi, options);
this.exportCLion(project, from, to, platform, vrApi, options);
}
exportMakefile(project: Project, from: string, to: string, platform: string, vrApi: any, options: any) {<｜fim▁hole｜> const cCompiler = Options.compiler === Compiler.Clang ? 'clang' : 'gcc';
const cppCompiler = Options.compiler === Compiler.Clang ? 'clang++' : 'g++';
let objects: any = {};
let ofiles: any = {};
let outputPath = path.resolve(to, options.buildPath);
fs.ensureDirSync(outputPath);
for (let fileobject of project.getFiles()) {
let file = fileobject.file;
if (file.endsWith('.cpp') || file.endsWith('.c') || file.endsWith('.cc') || file.endsWith('.s') || file.endsWith('.S')) {
let name = file.toLowerCase();
if (name.indexOf('/') >= 0) name = name.substr(name.lastIndexOf('/') + 1);
name = name.substr(0, name.lastIndexOf('.'));
if (!objects[name]) {
objects[name] = true;
ofiles[file] = name;
}
else {
while (objects[name]) {
name = name + '_';
}
objects[name] = true;
ofiles[file] = name;
}
}
}
let gchfilelist = '';
let precompiledHeaders: string[] = [];
for (let file of project.getFiles()) {
if (file.options && file.options.pch && precompiledHeaders.indexOf(file.options.pch) < 0) {
precompiledHeaders.push(file.options.pch);
}
}
for (let file of project.getFiles()) {
let precompiledHeader: string = null;
for (let header of precompiledHeaders) {
if (file.file.endsWith(header)) {
precompiledHeader = header;
break;
}
}
if (precompiledHeader !== null) {
// let realfile = path.relative(outputPath, path.resolve(from, file.file));
gchfilelist += path.basename(file.file) + '.gch ';
}
}
let ofilelist = '';
for (let o in objects) {
ofilelist += o + '.o ';
}
this.writeFile(path.resolve(outputPath, 'makefile'));
let incline = '-I./ '; // local directory to pick up the precompiled header hxcpp.h.gch
for (let inc of project.getIncludeDirs()) {
inc = path.relative(outputPath, path.resolve(from, inc));
incline += '-I' + inc + ' ';
}
this.p('INC=' + incline);
let libsline = '-static-libgcc -static-libstdc++ -pthread';
for (let lib of project.getLibs()) {
libsline += ' -l' + lib;
}
this.p('LIB=' + libsline);
let defline = '';
for (let def of project.getDefines()) {
defline += '-D' + def + ' ';
}
this.p('DEF=' + defline);
this.p();
let cline = '';
for (let flag of project.cFlags) {
cline += flag + ' ';
}
this.p('CFLAGS=' + cline);
let cppline = '';
for (let flag of project.cppFlags) {
cppline += flag + ' ';
}
this.p('CPPFLAGS=' + cppline);
let optimization = '';
if (!options.debug) optimization = '-O2';
else optimization = '-g';
this.p(project.getName() + ': ' + gchfilelist + ofilelist);
let cpp = '';
if (project.cpp11 && options.compiler !== Compiler.Clang) {
cpp = '-std=c++11';
}
this.p('\t' + cppCompiler + ' ' + cpp + ' ' + optimization + ' ' + ofilelist + ' -o "' + project.getName() + '" $(LIB)');
for (let file of project.getFiles()) {
let precompiledHeader: string = null;
for (let header of precompiledHeaders) {
if (file.file.endsWith(header)) {
precompiledHeader = header;
break;
}
}
if (precompiledHeader !== null) {
let realfile = path.relative(outputPath, path.resolve(from, file.file));
this.p(path.basename(realfile) + '.gch: ' + realfile);
this.p('\t' + cppCompiler + ' ' + cpp + ' ' + optimization + ' $(INC) $(DEF) -c ' + realfile + ' -o ' + path.basename(file.file) + '.gch $(LIB)');
}
}
for (let fileobject of project.getFiles()) {
let file = fileobject.file;
if (file.endsWith('.c') || file.endsWith('.cpp') || file.endsWith('.cc') || file.endsWith('.s') || file.endsWith('.S')) {
this.p();
let name = ofiles[file];
let realfile = path.relative(outputPath, path.resolve(from, file));
this.p(name + '.o: ' + realfile);
let compiler = cppCompiler;
let flags = '$(CPPFLAGS)';
if (file.endsWith('.c')) {
compiler = cCompiler;
flags = '$(CFLAGS)';
}
else if (file.endsWith('.s') || file.endsWith('.S')) {
compiler = cCompiler;
flags = '';
}
this.p('\t' + compiler + ' ' + cpp + ' ' + optimization + ' $(INC) $(DEF) ' + flags + ' -c ' + realfile + ' -o ' + name + '.o $(LIB)');
}
}
// project.getDefines()
// project.getIncludeDirs()
this.closeFile();
}
exportCodeBlocks(project: Project, from: string, to: string, platform: string, vrApi: any, options: any) {
this.writeFile(path.resolve(to, project.getName() + '.cbp'));
this.p('<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>');
this.p('<CodeBlocks_project_file>');
this.p('<FileVersion major="1" minor="6" />', 1);
this.p('<Project>', 1);
this.p('<Option title="' + project.getName() + '" />', 2);
this.p('<Option pch_mode="2" />', 2);
this.p('<Option compiler="gcc" />', 2);
this.p('<Build>', 2);
this.p('<Target title="Debug">', 3);
this.p('<Option output="bin/Debug/' + project.getName() + '" prefix_auto="1" extension_auto="1" />', 4);
if (project.getDebugDir().length > 0) this.p('<Option working_dir="' + path.resolve(from, project.getDebugDir()) + '" />', 4);
this.p('<Option object_output="obj/Debug/" />', 4);
this.p('<Option type="1" />', 4);
this.p('<Option compiler="gcc" />', 4);
this.p('<Compiler>', 4);
if (project.cpp11) {
this.p('<Add option="-std=c++11" />', 5);
}
this.p('<Add option="-g" />', 5);
this.p('</Compiler>', 4);
this.p('</Target>', 3);
this.p('<Target title="Release">', 3);
this.p('<Option output="bin/Release/' + project.getName() + '" prefix_auto="1" extension_auto="1" />', 4);
if (project.getDebugDir().length > 0) this.p('<Option working_dir="' + path.resolve(from, project.getDebugDir()) + '" />', 4);
this.p('<Option object_output="obj/Release/" />', 4);
this.p('<Option type="0" />', 4);
this.p('<Option compiler="gcc" />', 4);
this.p('<Compiler>', 4);
if (project.cpp11) {
this.p('<Add option="-std=c++11" />', 5);
}
this.p('<Add option="-O2" />', 5);
this.p('</Compiler>', 4);
this.p('<Linker>', 4);
this.p('<Add option="-s" />', 5);
this.p('</Linker>', 4);
this.p('</Target>', 3);
this.p('</Build>', 2);
this.p('<Compiler>', 2);
if (project.cpp11) {
this.p('<Add option="-std=c++11" />', 3);
}
this.p('<Add option="-Wall" />', 3);
for (let def of project.getDefines()) {
this.p('<Add option="-D' + def.replace(/\"/g, '\\"') + '" />', 3);
}
for (let inc of project.getIncludeDirs()) {
this.p('<Add directory="' + path.resolve(from, inc) + '" />', 3);
}
this.p('</Compiler>', 2);
this.p('<Linker>', 2);
this.p('<Add option="-pthread" />', 3);
this.p('<Add option="-static-libgcc" />', 3);
this.p('<Add option="-static-libstdc++" />', 3);
this.p('<Add option="-Wl,-rpath,." />', 3);
for (let lib of project.getLibs()) {
this.p('<Add library="' + lib + '" />', 3);
}
if (platform === Platform.Pi) {
this.p('<Add directory="/opt/vc/lib" />', 3);
}
this.p('</Linker>', 2);
let precompiledHeaders: string[] = [];
for (let file of project.getFiles()) {
if (file.options && file.options.pch && precompiledHeaders.indexOf(file.options.pch) < 0) {
precompiledHeaders.push(file.options.pch);
}
}
for (let file of project.getFiles()) {
let precompiledHeader: string = null;
for (let header of precompiledHeaders) {
if (file.file.endsWith(header)) {
precompiledHeader = header;
break;
}
}
if (file.file.endsWith('.c') || file.file.endsWith('.cc') || file.file.endsWith('.cpp')) {
this.p('<Unit filename="' + path.resolve(from, file.file) + '">', 2);
this.p('<Option compilerVar="CC" />', 3);
this.p('</Unit>', 2);
}
else if (file.file.endsWith('.h')) {
this.p('<Unit filename="' + path.resolve(from, file.file) + '">', 2);
if (precompiledHeader !== null) {
this.p('<Option compile="1" />', 3);
this.p('<Option weight="0" />', 3);
}
this.p('</Unit>', 2);
}
}
this.p('<Extensions>', 2);
this.p('<code_completion />', 3);
this.p('<debugger />', 3);
this.p('</Extensions>', 2);
this.p('</Project>', 1);
this.p('</CodeBlocks_project_file>');
this.closeFile();
}
}<｜fim▁end｜> | |
<|file_name|>BoundKind.java<|end_file_name|><｜fim▁begin｜>/*
* Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package openjdk7.com.sun.tools.javac.code;
/**
*
* <p><b>This is NOT part of any supported API.
* If you write code that depends on this, you do so at your own risk.
* This code and its internal interfaces are subject to change or
* deletion without notice.</b>
*/
public enum BoundKind {
EXTENDS("? extends "),
SUPER("? super "),
UNBOUND("?");
private final String name;
BoundKind(String name) {
this.name = name;
}
<｜fim▁hole｜><｜fim▁end｜> | public String toString() { return name; }
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.