学习Tensorflow之基本操作

TensorFlow张量操作

方法	作用
tf.constant(value, dtype, shape, name)	创建常量张量
tf.ones(shape, dtype, name)	创建全1的张量
tf.ones_like(input, dtype, name)	创建全1的张量，包含所有与输入相同的形状
tf.zeros(shape, dtype, name)	创建全0的张量
tf.zeros_like(input, dtype, name)	创建全0的张量，包含所有与输入相同的形状
tf.fill(dims, value, name)	创建值全相同的张量
tf.random.normal(shape, mean, stddev, dtype, seed, name)	创建正态分布的张量
tf.random.uniform(shape, minval, maxval, dtype, seed, name)	创建平均分布的张量
tf.random.poisson(shape, lam, dtype, seed, name)	创建泊松分布的张量
tf.random.gamma(shape, alpha, beta, dtype, seed, name)	创建伽马分布的张量
tf.add(x, y, name) 或 运算符 +	计算张量相加
tf.subtract(x, y, name) 或 运算符 -	计算张量相减
tf.multiply(x, y, name) 或 运算符 *	计算张量相乘
tf.divide(x, y, name) 或 运算符 /	计算张量相除
tf.abs(x, name)	计算张量绝对值
tf.pow(x, y, name)	计算张量乘方
tf.sqrt(x, name)	计算张量开平方
tf.matmul(a, b, transpose_a, transpose_b) 或 运算符@	计算矩阵乘法
tf.cast(x, dtype, name)	强制类型转换
tensor[层数][行数][列数]	张量索引
[start : end : step]	张量切片
tf.reshape(tensor, shape, name)	张量维度转换
tf.expand_dims(input, axis, name)	增加张量的维度
tf.squeeze(input, axis, name)	减少张量的维度
tf.transpose(a, perm, conjugate)	交换张量的维度
tf.strings.as_string(input, precision, scientific)	转为字符串张量
tf.strings.bytes_split(input, name)	分割每一个字符
tf.strings.split(input, sep)	按照指定字符分割字符串
tf.strings.join(inputs, separator)	字符串拼接
tf.strings.upper(input, encoding)	将字符串转为大写
tf.strings.lower(input, encoding)	将字符串转为小写
tf.ragged.constant(pylist, dtype)	创建不规则张量
tf.ragged.map_flat_values(op, *args)	对不规则张量进行数学变换
tf.Variable(initial_value, trainable, validate_shape, caching_device, name)	创建变量张量
tf.GradientTape(persistent, watch_accessed_variables)	创建求导数的变量
tape.watch(tensor)	对张量进行追踪
tape.gradient(因变量, [自变量])	对张量进行求导

1. 创建张量

创建张量的函数为

tensorflow.constant(
    value,          值
    dtype = None,   类型（默认为32位）
    shape = None,   形状
    name = 'Const'  名称
)

(1) 创建标量

import tensorflow as tf

scalarInt = tf.constant(2)
scalarFloat = tf.constant(3.0)
scalarString = tf.constant('Hello')

print(scalarInt)
print(scalarFloat)
print(scalarString)

tf.Tensor(2, shape=(), dtype=int32)

tf.Tensor(3.0, shape=(), dtype=float32)

tf.Tensor(b’Hello’, shape=(), dtype=string)

从结果可以看出，标量的维度是0，所以shape值为空

(2) 创建向量

import tensorflow as tf

vectorInt = tf.constant([2])
vectorFloat = tf.constant([3.0, 4.0])
vectorString = tf.constant(['Hello', 'World'])

print(vectorInt)
print(vectorFloat)
print(vectorString)

tf.Tensor([2], shape=(1,), dtype=int32)

tf.Tensor([3. 4.], shape=(2,), dtype=float32)

tf.Tensor([b’Hello’ b’World’], shape=(2,), dtype=string)

  向量的创建必须加上[]，将他作为列表传入函数，方括号的个数代表着tensor的维度

(3) 创建矩阵

import tensorflow as tf

matrixInt = tf.constant([[2], [3]])
matrixFloat = tf.constant([[3.0, 4.0]])
matrixString = tf.constant([['Hello'], ['World']])

print(matrixInt)
print(matrixFloat)
print(matrixString)

tf.Tensor(
[[2]
 [3]], shape=(2, 1), dtype=int32)
tf.Tensor([[3. 4.]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[b'Hello']
 [b'World']], shape=(2, 1), dtype=string)

(4) shape属性

shape属性记录着tensor的形状

shape的取值	含义
()	该tensor是标量
(列数, )	该tensor是向量
(行数, 列数)	该tensor是矩阵
(层数, 行数, 列数)	该tensor是数据立方体

(5) 判别张量类型

使用tf.rank()函数可以判别张量的类型

import tensorflow as tf

scalarInt = tf.constant(5)
vectorFloat = tf.constant([3.0, 4.0])
matrixString = tf.constant([['Hello'], ['World']])

print(tf.rank(scalarInt))
print(tf.rank(vectorFloat))
print(tf.rank(matrixString))

tf.Tensor(0, shape=(), dtype=int32)

tf.Tensor(1, shape=(), dtype=int32)

tf.Tensor(2, shape=(), dtype=int32)

这里的0、1、2代表的是tensor的维度

(6) 列表和ndarray转张量

tensorflow.convert_to_tensor(
    value,          值
    dtype = None,   类型（默认为32位）
)

import numpy as np
import tensorflow as tf

l = [1, 2, 3]
array = np.array([1.0, 2.2])

print(tf.convert_to_tensor(l))
print(tf.convert_to_tensor(array))

tf.Tensor([1 2 3], shape=(3,), dtype=int32)
tf.Tensor([1.  2.2], shape=(2,), dtype=float32)

(7) 获取张量的值

使用张量的.numpy()成员方法

import tensorflow as tf


scalarInt = tf.constant(2)
print(scalarInt)
print(scalarInt.numpy())
print(type(scalarInt.numpy()))

tf.Tensor(2, shape=(), dtype=int32)
2
<class 'numpy.int32'>

2. 创建特殊张量

方法	作用
tf.ones(shape, dtype, name)	创建全1的张量
tf.ones_like(input, dtype, name)	创建全1的张量，包含所有与输入相同的形状
tf.zeros(shape, dtype, name)	创建全0的张量
tf.zeros_like(input, dtype, name)	创建全0的张量，包含所有与输入相同的形状
tf.fill(dims, value, name)	创建值全相同的张量
tf.random.normal(shape, mean, stddev, dtype, seed, name)	创建正态分布的张量
tf.random.uniform(shape, minval, maxval, dtype, seed, name)	创建平均分布的张量
tf.random.poisson(shape, lam, dtype, seed, name)	创建泊松分布的张量
tf.random.gamma(shape, alpha, beta, dtype, seed, name)	创建伽马分布的张量

(1) tf.ones与tf.ones_like

import tensorflow as tf

ones = tf.ones((3, 3))
scalarInt = tf.constant(1)
print(ones)

ones_like = tf.ones_like(scalarInt, dtype = tf.float32, name = 'ones_like')
print(ones_like)

tf.Tensor(
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]], shape=(3, 3), dtype=float32)
tf.Tensor(1.0, shape=(), dtype=float32)

(2) tf.zeros与tf.zeros_like

import tensorflow as tf

zeros = tf.zeros((3, 3))
scalarInt = tf.constant(1)
print(zeros)

zeros_like = tf.zeros_like(scalarInt, dtype = tf.string, name = 'zeros_like')
print(zeros_like)

tf.Tensor(
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]], shape=(3, 3), dtype=float32)
tf.Tensor(b'', shape=(), dtype=string)

从结果可以看出，对于字符串类型，0表示的空字符串

(3) tf.fill

import tensorflow as tf

fiveInt = tf.fill((3, 3), 5)
fiveString = tf.fill((3, 3), '5')
print(fiveInt)
print(fiveString)

tf.Tensor(
[[5 5 5]
 [5 5 5]
 [5 5 5]], shape=(3, 3), dtype=int32)
tf.Tensor(
[[b'5' b'5' b'5']
 [b'5' b'5' b'5']
 [b'5' b'5' b'5']], shape=(3, 3), dtype=string)

tf.fill()函数没有dtype参数，系统通过传入value的值来自动判断张量的类型

(3) tf.random.normal

import tensorflow as tf

normal = tf.random.normal((2, 2), 0.0, 1.0, tf.float16)
print(normal)

tf.Tensor(
[[-0.919  1.498]
 [ 0.896 -2.05 ]], shape=(2, 2), dtype=float16)

默认情况下，创建的类型是tf.float32

(4) tf.random.uniform

import tensorflow as tf

uniform = tf.random.uniform((2, 2), 0.0, 10.0, tf.float16)
print(uniform)

tf.Tensor(
[[2.09  2.812]
 [2.822 6.21 ]], shape=(2, 2), dtype=float16)

默认情况下，创建的类型是tf.float32

3. 张量的运算

方法	作用
tf.add(x, y, name) 或 运算符 +	计算张量相加
tf.subtract(x, y, name) 或 运算符 -	计算张量相减
tf.multiply(x, y, name) 或 运算符 *	计算张量相乘
tf.divide(x, y, name) 或 运算符 /	计算张量相除
tf.abs(x, name)	计算张量绝对值
tf.pow(x, y, name)	计算张量乘方
tf.sqrt(x, name)	计算张量开平方
tf.matmul(a, b, transpose_a, transpose_b) 或 运算符@	计算矩阵乘法
tf.cast(x, dtype, name)	强制类型转换
tensor[层数][行数][列数]	张量索引
[start : end : step]	张量切片
tf.reshape(tensor, shape, name)	张量维度转换
tf.expand_dims(input, axis, name)	增加张量的维度
tf.squeeze(input, axis, name)	减少张量的维度
tf.transpose(a, perm, conjugate)	交换张量的维度

(1) 四则运算

import tensorflow as tf

t1 = tf.constant([1, 2])
t2 = tf.constant([2, 4])
print(tf.add(t1, t2))
print(tf.subtract(t1, t2))
print(tf.multiply(t1, t2))
print(tf.divide(t1, t2))
print()
print(t1 + t2)
print(t1 - t2)
print(t1 * t2)
print(t1 / t2)

tf.Tensor([3 6], shape=(2,), dtype=int32)
tf.Tensor([-1 -2], shape=(2,), dtype=int32)
tf.Tensor([2 8], shape=(2,), dtype=int32)
tf.Tensor([0.5 0.5], shape=(2,), dtype=float64)

tf.Tensor([3 6], shape=(2,), dtype=int32)
tf.Tensor([-1 -2], shape=(2,), dtype=int32)
tf.Tensor([2 8], shape=(2,), dtype=int32)
tf.Tensor([0.5 0.5], shape=(2,), dtype=float64)

(2) 绝对值、乘方、开平方

import tensorflow as tf

t1 = tf.constant([-1.0, 2])

print(tf.abs(t1))
print(tf.pow(t1, 3))
print(tf.sqrt(t1))

tf.Tensor([1. 2.], shape=(2,), dtype=float32)
tf.Tensor([-1.  8.], shape=(2,), dtype=float32)
tf.Tensor([      nan 1.4142135], shape=(2,), dtype=float32)

-1不能开平方，所以计算结果是nan，即not a number

(3) 矩阵乘法

import tensorflow as tf

a = tf.constant([1, 2], shape = (1, 2))
b = tf.constant([1, 2], shape = (2, 1))

print(a)
print(b)
print(tf.matmul(a, b))

tf.Tensor([[1 2]], shape=(1, 2), dtype=int32)
tf.Tensor(
[[1]
 [2]], shape=(2, 1), dtype=int32)
tf.Tensor([[5]], shape=(1, 1), dtype=int32)

注意：相乘的矩阵必须满足矩阵乘法的规则

设置转置参数

import tensorflow as tf

a = tf.constant([[1, 2]])
b = tf.constant([[1, 2]])
print(a)
print(b)
print(tf.matmul(a, b, False, True))

tf.Tensor([[1 2]], shape=(1, 2), dtype=int32)
tf.Tensor([[1 2]], shape=(1, 2), dtype=int32)
tf.Tensor([[5]], shape=(1, 1), dtype=int32)

  在tensorflow中，向量是不能与矩阵进行乘法运算的，我们在学习数学的时候，都把向量看成了1维矩阵，但是tensorflow中向量是向量，不是矩阵

import tensorflow as tf

a = tf.constant([1, 2])
b = tf.constant([[2], [1]])
print(a)
print(b)
print(tf.matmul(a, b, False, True))

tf.Tensor([1 2], shape=(2,), dtype=int32)
tf.Tensor(
[[2]
 [1]], shape=(2, 1), dtype=int32)
tensorflow.python.framework.errors_impl.InvalidArgumentError: {{function_node __wrapped__MatMul_device_/job:localhost/replica:0/task:0/device:CPU:0}} In[0] and In[1] has different ndims: [2] vs. [2,1] [Op:MatMul]

所以，在tensorflow中需要注意，向量和矩阵不能进行运算

(4) tf.cast

强制类型转换

import tensorflow as tf

scalarInt = tf.constant(2)
scalarFloat = tf.cast(scalarInt, dtype = tf.float32)
print(scalarInt)
print(scalarFloat)

tf.Tensor(2, shape=(), dtype=int32)
tf.Tensor(2.0, shape=(), dtype=float32)

(5) 张量的索引与切片

按照维度：

3维：tensor[层][行][列]

2维：tensor[行][列]

1维：tensor[列]

import tensorflow as tf

t = tf.constant([i for i in range(25)], shape = (5, 5))
print(t)
# t为2维，取第二行
print(t[1])
# 取第一行第二列
print(t[0, 1])

tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]], shape=(5, 5), dtype=int32)
tf.Tensor([5 6 7 8 9], shape=(5,), dtype=int32)
tf.Tensor(1, shape=(), dtype=int32)

取某一维度的全部元素，使用:

import tensorflow as tf

t = tf.constant([i for i in range(25)], shape = (5, 5))
print(t)
# 取所有行第二列
print(t[:, 1])
# 取第二行第全部列，即第二行
print(t[3, :])

tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]], shape=(5, 5), dtype=int32)
tf.Tensor([ 1  6 11 16 21], shape=(5,), dtype=int32)
tf.Tensor([15 16 17 18 19], shape=(5,), dtype=int32)

按照间隔取：[start : end : step]

取的范围为 [start : end)，即不会取到end

import tensorflow as tf

t = tf.constant([i for i in range(25)], shape = (5, 5))
print(t)

print(t[0:5:2])

tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]], shape=(5, 5), dtype=int32)
tf.Tensor(
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]], shape=(3, 5), dtype=int32)

(6) tf.reshape

张量维度转换

import tensorflow as tf

t = tf.constant([i for i in range(20)], shape = (4, 5))
print(t)

t = tf.reshape(t, (2, 10))
print(t)

tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]], shape=(4, 5), dtype=int32)
tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]], shape=(2, 10), dtype=int32)

从结果可以看出4×5的矩阵转换成了2×10的矩阵

如果在reshape时，某一维度写-1，系统会自动计算出这个维度的值

import tensorflow as tf

t = tf.constant([i for i in range(20)], shape = (4, 5))
print(t)

t = tf.reshape(t, (-1, 10))
print(t)

tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]], shape=(4, 5), dtype=int32)
tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]], shape=(2, 10), dtype=int32)

(4, 5) -> (-1, 10)可以理解为将4×5的矩阵转换成了若干行10列的矩阵

(7) 增加和减少张量的维度

使用tf.expand_dims()可以增加张量的维度

import tensorflow as tf

# 增加张量的维度
t = tf.random.normal((2, 2))
print(t)
# 增加第一维度
t = tf.expand_dims(t, axis = 0)
print(t)
# 增加第四维度
t = tf.expand_dims(t, axis = 3)
print(t)

tf.Tensor(
[[-1.4346067  -0.69587547]
 [-2.1144965   0.55389005]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[[-1.4346067  -0.69587547]
  [-2.1144965   0.55389005]]], shape=(1, 2, 2), dtype=float32)
tf.Tensor(
[[[[-1.4346067 ]
   [-0.69587547]]
  [[-2.1144965 ]
   [ 0.55389005]]]], shape=(1, 2, 2, 1), dtype=float32)

从结果可以看出，增加了两个维度

使用tf.squeeze()可以减少张量的维度

import tensorflow as tf

t = tf.constant([[[[1], [2]]]])
print(t)
# 减少最后一个维度
t = tf.squeeze(t, axis = 3)
print(t)

tf.Tensor(
[[[[1]
   [2]]]], shape=(1, 1, 2, 1), dtype=int32)
tf.Tensor([[[1 2]]], shape=(1, 1, 2), dtype=int32)

这里需要注意，减少的维度必须是1

(1, 2, 2, 2) 不能减少第四维度，即不能减少为(1, 2, 2, 2)，但可以减少第一维度变成(2 ,2 ,2)

(8) 维度交换

使用tf.expand_dims()可以增加张量的维度

import tensorflow as tf

t = tf.zeros((1, 28, 28, 1))
print(t)
t = tf.transpose(t, [2, 3, 1, 0])
print(t)

[[[[ ... ]]]], shape=(1, 28, 28, 1), dtype=float32)
[[[[ ... ]]]], shape=(28, 1, 28, 1), dtype=float32)

每一个维度对应一个下标，从0开始

(1, 28, 28, 1) -> (0, 1, 2, 3)

tf.transpose()函数通过写下标的序号，把对应的维度进行交换

(2, 3, 1, 0) -> (28, 1, 28, 1)

4. 字符串张量

方法	作用
tf.strings.as_string(input, precision, scientific)	转为字符串张量
tf.strings.bytes_split(input, name)	分割每一个字符
tf.strings.split(input, sep)	按照指定字符分割字符串
tf.strings.join(inputs, separator)	字符串拼接
tf.strings.upper(input, encoding)	将字符串转为大写
tf.strings.lower(input, encoding)	将字符串转为小写

(1) 转为字符串张量

import tensorflow as tf

string = tf.constant([1.0, 2.0])
print(string)
t = tf.strings.as_string(string)
print(t)
t = tf.strings.as_string(string, precision = 3)
print(t)

tf.Tensor([1. 2.], shape=(2,), dtype=float32)
tf.Tensor([b'1.000000' b'2.000000'], shape=(2,), dtype=string)
tf.Tensor([b'1.000' b'2.000'], shape=(2,), dtype=string)

(2) 字符串分割

import tensorflow as tf

string = tf.constant('H e l l o')
print(tf.strings.bytes_split(string))
print(tf.strings.split(string, ' '))

tf.Tensor([b'H' b' ' b'e' b' ' b'l' b' ' b'l' b' ' b'o'], shape=(9,), dtype=string)
tf.Tensor([b'H' b'e' b'l' b'l' b'o'], shape=(5,), dtype=string)

(3) 字符串拼接

import tensorflow as tf

string = tf.constant([b'H' b' ' b'e' b' ' b'l' b' ' b'l' b' ' b'o'])
print(tf.strings.join(string))

tf.Tensor(b'H e l l o', shape=(), dtype=string)

(3) 字符串大小写转换

import tensorflow as tf

string = tf.constant('aaa')
upper = tf.strings.upper(string)
lower = tf.strings.lower(string)
print(upper)
print(lower)

tf.Tensor(b'AAA', shape=(), dtype=string)
tf.Tensor(b'aaa', shape=(), dtype=string)

5. 不规则张量

方法	作用
tf.ragged.constant(pylist, dtype)	创建不规则张量
tf.ragged.map_flat_values(op, *args)	对不规则张量进行数学变换

(1) 创建不规则张量

使用tf.ragged.constant()创建不规则张量

import tensorflow as tf

t = tf.ragged.constant([[1, 2], [], [1, 2, 3]])
print(t)

<tf.RaggedTensor [[1, 2], [], [1, 2, 3]]>

不规则张量类似Java中的数组，每一行的元素个数可以不一致

不规则张量中的所有元素类型必须是一致的

(2) 不规则张量的运算

import tensorflow as tf

t = tf.ragged.constant([[1, 2], [], [1, 2, 3]])
print(t + 2)
print(tf.subtract(t, 2))
print(t * 2)
print(tf.divide(t, 2))

<tf.RaggedTensor [[3, 4], [], [3, 4, 5]]>
<tf.RaggedTensor [[-1, 0], [], [-1, 0, 1]]>
<tf.RaggedTensor [[2, 4], [], [2, 4, 6]]>
<tf.RaggedTensor [[0.5, 1.0], [], [0.5, 1.0, 1.5]]>

同样的，不规则张量也支持普通张量的四则运算、乘法、开平方等

相同形状的不规则张量之间可以做四则运算、乘法、开平方等

import tensorflow as tf

a = tf.ragged.constant([[1, 2], [], [1, 2, 3]])
b = tf.ragged.constant([[5, 6], [], [1, 2, 3]])
print(a + b)
print(tf.subtract(a, b))
print(a * b)
print(tf.divide(a, b))

<tf.RaggedTensor [[6, 8], [], [2, 4, 6]]>
<tf.RaggedTensor [[-4, -4], [], [0, 0, 0]]>
<tf.RaggedTensor [[5, 12], [], [1, 4, 9]]>
<tf.RaggedTensor [[0.2, 0.3333333333333333], [], [1.0, 1.0, 1.0]]>

如果形状不同，会报错

(3) 不规则张量的数学变换

使用tf.ragged.map_flat_values()对张量进行数学变换

import tensorflow as tf

a = tf.ragged.constant([[1, 2], [], [1, 2, 3]])
print(a)
print(tf.ragged.map_flat_values(lambda x: x + 3, a))

<tf.RaggedTensor [[1, 2], [], [1, 2, 3]]>
<tf.RaggedTensor [[4, 5], [], [4, 5, 6]]>

TensorFlow张量梯度自动求导

1. 创建变量张量

  在神经网络中，有时候某些张量的值需要不断地改变并保存变化的记录，如神经元的权重w和偏置b等，对于这类需要计算梯度信息的张量，使用变量张量来进行处理。

在实际的梯度求导过程中，系统会自动跟踪变量张量并进行计算

创建变量张量的函数为

tensorflow.Variable(
    initial_value,      初始值
    trainable,          是否可被求导和优化，默认为True
    validate_shape,     张量初始化时是否需要指定维度，默认为True
    caching_device,     指定硬件资源，字符串的形式
    name,               张量名称，默认为Variable
    variable_def,       VariableDef协议缓存
    dtype,              数据类型
    import_scope,       可选字符串，只在从协议缓冲区初始化时使用
    constraint,         可选映射函数，变量使用优化器更新后，映射到函数
    synchronization,    提示收集到离散变量
    aggregation,        指明如何手机离散变量
    shape               维度
)

方法	作用
tf.Variable(initial_value, trainable, validate_shape, caching_device, name)	创建变量张量
变量张量.assign()	给变量张量赋值

(1) 创建多维度变量张量

import tensorflow as tf

scalarVariableTensor = tf.Variable(2)
vectorVariableTensor = tf.Variable([2.0])
matrixVariableTensor = tf.Variable([[2.0, 3.0]])

print(scalarVariableTensor)
print(vectorVariableTensor)
print(matrixVariableTensor)

<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=2>
<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([2.], dtype=float32)>
<tf.Variable 'Variable:0' shape=(1, 2) dtype=float32, numpy=array([[2., 3.]], dtype=float32)>

(2) 变量张量trainable属性

设置trainable = False可以设置不让改参数进行计算

import tensorflow as tf

scalarVariableTensor = tf.Variable(2)
vectorVariableTensor = tf.Variable([2.0], trainable = False)

print(scalarVariableTensor)
print(vectorVariableTensor)
# 查看变量张量是否可以被优化
print(scalarVariableTensor.trainable)
print(vectorVariableTensor.trainable)

<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=2>
<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([2.], dtype=float32)>
True
False

(3) 变量张量赋值

变量张量在创建时已经固定好了它的数据类型和大小，因此只有value值可以被修改

使用assign()函数来完成赋值

import tensorflow as tf

vectorVariableTensor = tf.Variable([2.0], trainable = False)
print(vectorVariableTensor)
vectorVariableTensor.assign([6.0])
print(vectorVariableTensor)

<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([2.], dtype=float32)>
<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([6.], dtype=float32)>

如果因为数值类型和形状大小不匹配，就会报错

2. 梯度自动求导

使用tf.GradientTape()机制来求导数

方法	作用
tf.GradientTape(persistent, watch_accessed_variables)	创建求导数的变量
tape.watch(tensor)	对张量进行追踪
tape.gradient(因变量, [自变量])	对张量进行求导

(1) tf.GradientTape()

import tensorflow as tf

x = tf.Variable(3.0)
with tf.GradientTape() as tape:
    y = x ** 2.0 + 4.0 * x
    dydx = tape.gradient(y, x)
    print(dydx)

tf.Tensor(10.0, shape=(), dtype=float32)

上面的代码计算的是y = x^2 + 4x在x = 3处的导数

y’ = 2x + 4

y’(3) = 2×3 + 4 = 10

因此结果为10，与代码计算的是一致的

(2) tape.watch()

如果使用了tf.constant()函数来创建张量，在求导时需要加上tape.watch()

tape.watch()对将要求导的常量张量进行跟着，变量张量是系统自动跟踪的，所有可以省略该步骤

import tensorflow as tf

x = tf.constant(3.0)
with tf.GradientTape() as tape:
    tape.watch(x)
    y = x ** 2.0 + 4.0 * x
    dydx = tape.gradient(y, x)
    print(dydx)

tf.Tensor(10.0, shape=(), dtype=float32)

如果对不可训练的变量或者没有追踪的常量求导数，计算结果为None

import tensorflow as tf

x = tf.constant(3.0)
with tf.GradientTape() as tape:
    y = x ** 2.0 + 4.0 * x
    dydx = tape.gradient(y, x)
    print(dydx)

z = tf.Variable(3.0, trainable = False)
with tf.GradientTape() as tape:
    y = z ** 2.0 + 4.0 * z
    dydz = tape.gradient(y, z)
    print(dydz)

None
None

(3) tape.gradient()

默认情况下tape.gradient()只能求一次导数，因为一旦函数被调用后，就会立刻释放所占内存资源

如果要多次求导，需要使用多次tf.GradientTape()

(4) persistent参数

如果要在梯度带中多次求导数，可以在tf.GradientTape()中添加persistent = True

但是要在求导结束时主动释放资源

import tensorflow as tf

x = tf.constant(3.0)
with tf.GradientTape(persistent = True) as tape:
    y = x ** 2.0 + 4.0 * x
    dydx = tape.gradient(y, x)
    print(dydx)
    d2ydx2 = tape.gradient(dydx, x)
    print(d2ydx2)
    del tape

tf.Tensor(10.0, shape=(), dtype=float32)
tf.Tensor(2.0, shape=(), dtype=float32)

(5) watch_accessed_variables参数

如果要对变量张量取消自动追踪，可以设置watch_accessed_variables = False

import tensorflow as tf

x = tf.Variable(3.0)
with tf.GradientTape(persistent = True, watch_accessed_variables = False) as tape:
    y = x * x * x
    dydx = tape.gradient(y, x)
    print(dydx)
    del tape

None

TensorFlow 2.X架构

  TensorFlow是一个通过计算图的形式表述计算的编程系统。计算图包括张量（Tensor）和操作（Operation），其中张量是TensorFlow的数据结构，计算是TensorFlow的计算规则。

  TensorFlow每次计算，都是在图结构中进行的，即TensorFlow每次启动运行，都会维护一个图结构，为每次执行TensorFlow任务开辟一共运行环境，与外界隔离。

  TensorFlow图结构细分为结点（Node）和边（Edge），结点对应计算过程，边对应数据结构。

1. TensorFlow图结构计算

  Tensorflow2.X中，用两种计算的实现方式，即图结构计算和 Eager execution计算（即刻计算），在上面的张量操作中，使用的代码都是Eager execution计算，Eager execution计算类似Python解释器，边解释边运行，可以直接获取计算结果。

  运用图结构计算需要先建立图结构，再在图结构中实现相关计算

import tensorflow as tf


def calculateInGraph():
    graph = tf.Graph()
    with graph.as_default():
        # 定义张量
        t1 = tf.constant([[1, 2, 4], [3, 4, 5]], name = 't1')
        t2 = tf.constant([[2, 3], [3, 6], [8, 9]], name = 't2')
        # 矩阵计算
        matmulResource = tf.matmul(t1, t2, name = 'matmulResource')
        session = tf.compat.v1.Session()
        result = session.run(matmulResource)
        return result

r = calculateInGraph()
print(f"图矩阵计算结果：\n{r}")

图矩阵计算结果：
[[40 51]
 [58 78]]

2. 图

  图是TensorFlow的基础单元，TensorFlow每次计算都会自动维护一个默认的图，图中包括数据以及计算规则，如果开发者需要使用不同的数据结构及计算规则，TensorFlow提供了新建图的功能，tf.Graph()用于生成新的计算图，图与图之间的数据和计算规则相互隔离，独立计算。

(1) 创建默认图

使用默认图不指定图的结构

import tensorflow as tf


graph = tf.Graph()
with graph.as_default():
    tensor = tf.constant('Hello Graph')
    print(tensor)
    print(f"tensor所在的图：{tensor.graph}")
    print(f"图：{graph}")

Tensor("Const:0", shape=(), dtype=string)
tensor所在的图：<tensorflow.python.framework.ops.Graph object at 0x00000204AC91F3A0>
图：<tensorflow.python.framework.ops.Graph object at 0x00000204AC91F3A0>

可以看到图的内存地址和tensor所在图的内存地址相同，这说明tensor在graph图中

(2) Tensor结构解析

  在之前学习TensorFlow张量操作时，用于使用的是Eager execution计算，所有得到的结构可以直接的表示出来，但是在计算图中，使用print()并不能解析出来该数据的类型，所以这里有必要说明一下。

import tensorflow as tf


scalarInt = tf.constant(2)
print(scalarInt)

graph = tf.Graph()
with graph.as_default():
    scalarInt = tf.constant(2)
    print(scalarInt)

tf.Tensor(2, shape=(), dtype=int32)
Tensor("Const:0", shape=(), dtype=int32)

可以看到两种计算方式得到的结果是不一样的

Eager execution计算出的显示了张量的值，图计算出的没有显示

图计算结果中的 Const:0 表示：自定义或者系统分配的张量标签，Const 表示变量名，0 表示获取张量值时的标志

如果张量的名字没有指定，会自动分配，这里是没有指定名字，所以系统给它取名为 Const

下面这个例子就是手动指定名字

import tensorflow as tf


graph = tf.Graph()
with graph.as_default():
    scalarInt = tf.constant(2, name = 'scalarInt')
    scalarVector = tf.constant([2, 3, 4], name = 'scalarVector')
    scalar1 = tf.constant(2)
    scalar2 = tf.constant(6.5)
    print(scalarInt)
    print(scalarVector)
    print(scalar1)
    print(scalar2)

Tensor("scalarInt:0", shape=(), dtype=int32)
Tensor("scalarVector:0", shape=(3,), dtype=int32)
Tensor("Const:0", shape=(), dtype=int32)
Tensor("Const_1:0", shape=(), dtype=float32)

可以看出，没有名字的张量系统会默认分配名字

(3) 创建图

  在TensorFlow中需要指定图结构时，使用tf.Graph()新建图，多个图共存时无须切换不同的图，直接可以创建新的图

import tensorflow as tf


graph1 = tf.Graph()
with graph1.as_default():
    scalarInt = tf.constant(2, name = 'scalarInt')
    print(f"scalarInt所在的图：{scalarInt.graph}")
    print(f"图：{graph1}")

print()

graph2 = tf.Graph()
with graph2.as_default():
    scalarInt = tf.constant(2, name = 'scalarInt')
    print(f"scalarInt所在的图：{scalarInt.graph}")
    print(f"图：{graph2}")

scalarInt所在的图：<tensorflow.python.framework.ops.Graph object at 0x000001FCC03CBC10>
图：<tensorflow.python.framework.ops.Graph object at 0x000001FCC03CBC10>

scalarInt所在的图：<tensorflow.python.framework.ops.Graph object at 0x000001FCC03CB6D0>
图：<tensorflow.python.framework.ops.Graph object at 0x000001FCC03CB6D0>

可以看出创建了两个图，虽然两个图中都有scalarInt张量，但是它们是不同的，因为它们在不同的图中

(4) 在图中使用张量

  在图中使用张量，无法直接提取张量的数值，需要结合tf.compat.v1.Session()方法。张量的数值还可以通过tf.get_tensor_by_name()获取，也可以直接使用定义的张量。

import tensorflow as tf


graph = tf.Graph()
with graph.as_default():
    # 定义张量
    c1 = tf.constant([[1], [2]], name = 'c1')
    c2 = tf.constant([[1, 2]], name = 'c2')
    v1 = tf.Variable([[1], [2]], name = 'v1')
    v2 = tf.Variable([[1, 2]], name = 'v2')
    # 矩阵计算
    matmulResourceC = tf.matmul(c1, c2, name = 'matmulResourceC')
    matmulResourceV = tf.matmul(v1, v2, name = 'matmulResourceV')
    session = tf.compat.v1.Session()
    result = session.run(matmulResourceC)

# 直接获取张量
print(f"c1: {c1}")
print(f"v1: {v1}")
print(f"常量张量矩阵计算结果: {matmulResourceC}")
print(f"变量张量矩阵计算结果: {matmulResourceV}")
print(f"Session计算结果: {result}")
print()
# 通过get_tensor_by_name获取张量
print(f"c1: {graph.get_tensor_by_name('c1:0')}")
print(f"v1: {graph.get_tensor_by_name('v1:0')}")
print(f"matmulResourceC: {graph.get_tensor_by_name('matmulResourceC:0')}")
print(f"matmulResourceV: {graph.get_tensor_by_name('matmulResourceV:0')}")

c1: Tensor("c1:0", shape=(2, 1), dtype=int32)
v1: <tf.Variable 'v1:0' shape=(2, 1) dtype=int32>
常量张量矩阵计算结果: Tensor("matmulResourceC:0", shape=(2, 2), dtype=int32)
变量张量矩阵计算结果: Tensor("matmulResourceV:0", shape=(2, 2), dtype=int32)
Session计算结果: [[1 2]
 [2 4]]
 
c1: Tensor("c1:0", shape=(2, 1), dtype=int32)
v1: Tensor("v1:0", shape=(), dtype=resource)
matmulResourceC: Tensor("matmulResourceC:0", shape=(2, 2), dtype=int32)
matmulResourceV: Tensor("matmulResourceV:0", shape=(2, 2), dtype=int32)

可以看出，直接输出定义的张量，常量为Tensor，变量为Variable

图中提取张量的值需要借助Session，在TensorFlow 2.X中，即刻模式代替了Session

使用tf.get_tensor_by_name()获取的张量的数据类型均为Tensor，使用参数张量名+标号获取

注意：TensorFlow 2.X中Variable在图中的类型为resource，无法使用Session解析

3. 即刻执行（Eager execution）

  即刻执行是TensorFlow 2.X重要的编程环境，更加兼容Python。TensorFlow 2.X的数据以及接口，如同Python函数，可以直接传参、调用和获取计算结果。默认情况下，TensorFlow 2.X的执行环境为 即刻执行。

在即刻执行下，张量使用numpy()获取值

import tensorflow as tf


scalarInt = tf.constant(2)
variableInt = tf.Variable(2)
print(scalarInt)
print(scalarInt.numpy())
print(variableInt)
print(variableInt.numpy())

tf.Tensor(2, shape=(), dtype=int32)
2
<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=2>
2

4. 操作

  操作（Operation）即TensorFlow中的数据处理规则，TensorFlow 2.X中同样有两种方式使用操作，图中和Eager execution中。

(1) 在图中使用Operation

  图结构中保存了计算规则和张量，使用get_operation_by_name获取运行规则，该功能用于解析计算规则。

import tensorflow as tf


graph = tf.Graph()
with graph.as_default():
    v1 = tf.Variable([[1], [2]], name = 'v1')
    v2 = tf.Variable([[1, 2]], name = 'v2')
    matmulResourceV = tf.matmul(v1, v2, name = 'matmulResourceV')

print(f"图操作：{graph.get_operation_by_name('v1')}")
print(f"图操作：{graph.get_operation_by_name('matmulResourceV')}")
print(f"图操作结果：{matmulResourceV}")
print(f"图操作结果：{graph.get_operation_by_name('matmulResourceV').outputs[0]}")

图操作：name: "v1"
op: "VarHandleOp"
attr {
  key: "_class"
  value {
    list {
      s: "loc:@v1"
    }
  }
}
attr {
  key: "allowed_devices"
  value {
    list {
    }
  }
}
attr {
  key: "container"
  value {
    s: ""
  }
}
attr {
  key: "dtype"
  value {
    type: DT_INT32
  }
}
attr {
  key: "shape"
  value {
    shape {
      dim {
        size: 2
      }
      dim {
        size: 1
      }
    }
  }
}
attr {
  key: "shared_name"
  value {
    s: "v1"
  }
}
图操作：name: "matmulResourceV"
op: "MatMul"
input: "matmulResourceV/ReadVariableOp"
input: "matmulResourceV/ReadVariableOp_1"
attr {
  key: "T"
  value {
    type: DT_INT32
  }
}
attr {
  key: "transpose_a"
  value {
    b: false
  }
}
attr {
  key: "transpose_b"
  value {
    b: false
  }
}
图操作结果：Tensor("matmulResourceV:0", shape=(2, 2), dtype=int32)
图操作结果：Tensor("matmulResourceV:0", shape=(2, 2), dtype=int32)

可以看出，获取操作结果的方式有两种：操作名 或者 graph.get_operation_by_name(‘操作名’).outputs[0]

(2) 规则结构解析

名称	描述
name	张量名称
op	计算规则
input	输入张量名
ReadVariableOp	表示只读，不可重新分配值
attr/key	数据类型键
attr/value	响应的取值

(3) 在Eager execution中使用Operation

import tensorflow as tf


v1 = tf.Variable([[1], [2]], name = 'v1')
v2 = tf.Variable([[1, 2]], name = 'v2')
matmulResourceV = tf.matmul(v1, v2, name = 'matmulResourceV')

print(f"结果：{matmulResourceV}")

结果：[[1 2]
 [2 4]]

5. 自动图

  TensorFlow 2.X中新增的自动图功能，可以将普通Python代码转换成TensorFlow图，在TensorFlow 2.X中，使用装饰器@tf.function时，可以实现该功能，此时函数的参数即可处理TensorFlow张量

(1) 创建自动图

import tensorflow as tf


@tf.function
def add(v):
    return v + 1


print(isinstance(add.get_concrete_function(1).graph, tf.Graph))

True

如果删去@tf.function装饰器，代码就会报错，因为没有get_concrete_function(1).graph

(2) 自动图支持控制流

import tensorflow as tf


@tf.function(autograph = True)
def f(x):
    if x > 0:
        return x
    else:
        return -x

print(f(tf.constant(-2)))

tf.Tensor(2, shape=(), dtype=int32)

(3) 自动图中使用print函数

import tensorflow as tf

array = []
@tf.function
def f(v):
    for i in range(len(v)):
        array.append(v[i])
    print(array)

f(tf.constant([1, 2, 3]))

[<tf.Tensor 'strided_slice:0' shape=() dtype=int32>, <tf.Tensor 'strided_slice_1:0' shape=() dtype=int32>, <tf.Tensor 'strided_slice_2:0' shape=() dtype=int32>]

可以看到，数组中的每个元素值是一个tensor，不是数组中的每个元素

把代码改一下，就可以支持print()了

import tensorflow as tf


@tf.function
def f(v):
    array = tf.TensorArray(dtype = tf.int32, size=0, dynamic_size=True)
    for i in range(len(v)):
        array = array.write(i, v[i])
    tf.print(array.stack())

f(tf.constant([1, 2, 3]))

[1 2 3]

(4) tf.function多态性

import tensorflow as tf


@tf.function
def f(x):
    print(x)
    return x + x

print(f(tf.constant(2)))
print(f(tf.constant(2.0)))
print(f(tf.constant('a')))

Tensor("x:0", shape=(), dtype=int32)
tf.Tensor(4, shape=(), dtype=int32)
Tensor("x:0", shape=(), dtype=float32)
tf.Tensor(4.0, shape=(), dtype=float32)
Tensor("x:0", shape=(), dtype=string)
tf.Tensor(b'aa', shape=(), dtype=string)

(5) tf.function自动图

如果多次传入Python列表或标量形式的参数，默认情况下每次参数传入都会创建一个新的静态图

import tensorflow as tf


@tf.function
def f(x):
    return x + x

f1 = f.get_concrete_function(1)
f2 = f.get_concrete_function(2)
print(f1 is f2)

False

如果要让传入的参数都在一个静态图中计算，传入参数为张量即可

import tensorflow as tf

@tf.function
def f(x):
    return x + x

f1 = f.get_concrete_function(tf.constant(1))
f2 = f.get_concrete_function(tf.constant(2))
print(f1 is f2)

True

(6) 使用自动图调试程序

import tensorflow as tf


@tf.function
def trace():
    print("普通执行")
    tf.print("TF执行1")
    tf.print("TF执行2")


trace()
trace()
trace()

普通执行
TF执行1
TF执行2
TF执行1
TF执行2
TF执行1
TF执行2

从结果可以看到，程序第一次运行，会执行所有操作，之后仅执行TensorFlow对象

6. 命名空间

  命名空间是对张量名称管理的空间，TensorFlow 2.X保留了张量命名管理的功能，使用name_scope管理，TensorFlow 2.X的命名空间只在原生搭建图结构中使用。name_scope命名空间管理是计算规则的上下文管理器，即只管理Operation。

import tensorflow as tf


graph = tf.Graph()
with graph.as_default():
    c1 = tf.constant(2, name = 'c1')
    with tf.name_scope('namespace1'):
        c2 = tf.constant(1, name = 'c2')
        with tf.name_scope('namespace2'):
            c3 = tf.constant(1, name = 'c3')
            
            
print(c1)
print(c2)
print(c3)

Tensor("c1:0", shape=(), dtype=int32)
Tensor("namespace1/c2:0", shape=(), dtype=int32)
Tensor("namespace1/namespace2/c3:0", shape=(), dtype=int32)

TensorFlow Keras

  Keras是TensorFlow 2.X的高层封装接口，用于创建和训练TensorFlow特定功能的模型。Keras在保证灵活性和性能的基础上使TensorFlow的应用更加容易。

1. TensorFlow 2.X搭建普通神经网络

普通神经网络的搭建有四种方式：

1. 使用Model类逐层建立网络结构
2. 使用继承Model类建立神经网络
3. 使用Sequential内置序列化搭建网络结构
4. 使用Sequential外置序列搭建网络结构

下面搭建的神经网络以拟合曲线y = 2x + 1为例

网络的输入只有x，输出是a和b，最后预测的模型是y = ax + b

a应该与2接近，b应该与1接近

(1) Model类搭建神经网络

import tensorflow as tf

# 输入层
inputs = tf.keras.Input(shape = (1,), name = 'inputs')
# 隐藏层
layer1 = tf.keras.layers.Dense(3, activation = 'relu')(inputs)
# 输出层
outputs = tf.keras.layers.Dense(2, activation = 'relu')(layer1)

model = tf.keras.Model(inputs = inputs, outputs = outputs)
# 显示网络结构
model.summary()

# 绘制网络流程图
tf.keras.utils.plot_model(model, '../Image/TensorFlowKeras/model1.png', show_shapes = True)

Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 inputs (InputLayer)         [(None, 1)]               0         
                                                                 
 dense (Dense)               (None, 3)                 6         
                                                                 
 dense_1 (Dense)             (None, 2)                 8         
                                                                 
=================================================================
Total params: 14
Trainable params: 14
Non-trainable params: 0
_________________________________________________________________

可以看到，结构图展示了神经网络各层间的数据关系

参数	描述
Layer (type)	神经网络层次
Output Shape	输出层的数据维度，None表示batch，未指定则表示不固定
Param	参数数量，表示训练过程中的权重与偏置数量，0表示此神经层没有权重和偏置
Total params	总的参数数量
Trainable params	可训练的参数数量
Non-trainable params	不可训练的参数数量

(2) 继承Model类搭建神经网络

import tensorflow as tf


class MyModel(tf.keras.Model):

	def __init__(self, *args, **kwargs):
		super().__init__(*args, **kwargs)
		# 隐藏层
		self.layer1 = tf.keras.layers.Dense(3, activation = 'relu')
		# 输出层
		self.outputs = tf.keras.layers.Dense(2, activation = 'relu')

	def call(self, inputs, training = None, mask = None):
		layer1 = self.layer1(inputs)
		outputs = self.outputs(layer1)
		return outputs


model = MyModel()
# 输入数据的形状为（批数，特征数）
model.build(input_shape = (100, 1))
model.summary()

Model: "my_model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               multiple                  6         
                                                                 
 dense_1 (Dense)             multiple                  8         
                                                                 
=================================================================
Total params: 14
Trainable params: 14
Non-trainable params: 0
_________________________________________________________________

由结果可以看出，使用继承Model类的方式搭建，输入数据内嵌到了神经网络层中

以这种方式搭建时，需要传入输入的数据或者使用 build() 函数指定输入的数据的形状，才可以构建网络

(3) Sequential内置序列搭建神经网络

import tensorflow as tf

model = tf.keras.Sequential([
	tf.keras.Input(shape = (1,)),
	# 隐藏层
	tf.keras.layers.Dense(3, activation = 'relu'),
	# 输出层
	tf.keras.layers.Dense(2, activation = 'relu')
])

model.summary()
tf.keras.utils.plot_model(model, '../Image/TensorFlowKeras/model2.png', show_shapes = True)

Model: "sequential_3"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_6 (Dense)             (None, 3)                 6         
                                                                 
 dense_7 (Dense)             (None, 2)                 8         
                                                                 
=================================================================
Total params: 14
Trainable params: 14
Non-trainable params: 0
_________________________________________________________________

  Sequential类搭建的神经网络结果与使用继承Model类搭建的神经网络结果是一致的。主要区别在于，Sequential搭建的神经网络输出数据维度直接以数字形式给出，而不是借助multiple。

(4) Sequential外置搭建神经网络

import tensorflow as tf

inputLayer = tf.keras.Input(shape = (1,))
# 隐藏层
layer1 = tf.keras.layers.Dense(3, activation = 'relu')
# 输出层
outputs = tf.keras.layers.Dense(2, activation = 'relu')

model = tf.keras.Sequential()
model.add(inputLayer)
model.add(layer1)
model.add(outputs)

model.summary()

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_2 (Dense)             (None, 3)                 6         
                                                                 
 dense_3 (Dense)             (None, 2)                 8         
                                                                 
=================================================================
Total params: 14
Trainable params: 14
Non-trainable params: 0
_________________________________________________________________

2. TensorFlow Keras常用类及方法

(1) tf.keras.Model类

  Model类用于训练和推理神经网络，将神经网络的输入和输出作为Model参数，完成神经网络的训练、模型保存和实现预测。

1）compile方法

compile方法用于配置神经网络的损失函数、优化器及衡量指标等

def compile(
        self,
        optimizer = "rmsprop",    
        loss = None,
        metrics = None,
        loss_weights = None,
        weighted_metrics = None,
        run_eagerly = None,
        steps_per_execution = None,
        jit_compile = None,
    )

参数	描述	例子
optimizer	优化器字符串或者优化器实例，用于设置优化器	①实例：tf.keras.optimizer.Adam(learning_rate = 0.02) ②字符串：“adam”
loss	损失函数字符串或者损失函数实例，用于设置损失函数	①实例：tf.keras.loss.MeanSquareError() ②字符串：“mse” ③计算函数：tf.reduce_mean(tf.reduce_sum(tf.square(error)))
metrics	训练和测试过程中评估的指标列表，可以使用列表也可以使用字典组合	①列表：metrics = [‘accuracy’] ②字典：metrics = {‘output_a’: ‘accuracy’, ‘output_b’: [‘accuracy’, ‘mse’]}
loss_weights	可选的列表或字典数据，指定标量系数衡量不同模型输出的损失贡献度	-
weighted_metrics	训练和测试过程中，样本加权或类加权评估的指标列表	-
jit_compile	Bool类型，用来设置启用优化机器学习编译器	-

2）fit方法

fit方法可以指定训练次数，保存训练参数等

def fit(
        self,
        x = None,
        y = None,
        batch_size = None,
        epochs = 1,
        verbose = "auto",
        callbacks = None,
        validation_split = 0.0,
        validation_data = None,
        shuffle = True,
        class_weight = None,
        sample_weight = None,
        initial_epoch = 0,
        steps_per_epoch = None,
        validation_steps = None,
        validation_batch_size = None,
        validation_freq = 1,
        max_queue_size = 10,
        workers = 1,
        use_multiprocessing = False,
    )

参数	描述	例子
x	输入数据	①Numpy数组或数组列表 ②张量或者张量列表 ③字典 ④tf.data格式数据集 ⑤生成器或tf.keras.util.Sequence
y	损失函数字符串或者损失函数实例，用于设置损失函数	①实例：tf.keras.loss.MeanSquareError() ②字符串：“mse” ③计算函数：tf.reduce_mean(tf.reduce_sum(tf.square(error)))
batch_size	int，批量数据尺寸，默认值为32	-
epochs	int，模型的训练次数	-
verbose	int，训练模型的输出日志格式	①0：只显示保存模型，不显示训练过程 ②1：以进度条的形式展示训练过程 ③2：每次训练为一行
callbacks	回调函数，用于训练过程中执行其他的功能	-
validation_split	0和1之间的浮点数，指定训练数据的部分数据为验证集，若输入数据为数据集、生成器或tf.keras.util.Sequence时不可使用	-
validation_data	验证数据集，为元组格式的Numpy数组或张量	-
shuffle	布尔值，设置打乱数据顺序的标志位，steps_per_epoch为None时不起作用	-
class_weight	可选的字典，在训练过程中衡量损失函数	-
sample_weight	可选的权重Numpy数组，用于评估训练过程中的损失函数	-
initial_epoch	int，用于指定训练的初始训练次数，在恢复模型训练过程中，用于继续之前的训练过程	-
steps_per_epoch	int或None，设定每个训练过程的训练次数，若输入数据为数组，则不支持该参数	-
validation_steps	指定验证步数，当有验证集时有效	-
validation_batch_size	指定验证频率，当有验证集时有效	-
max_queue_size	int，只对生成器或tf.keras.util.Sequence为输入数据时生效，生成数据队列，默认为10	-
workers	int，只对生成器或tf.keras.util.Sequence为输入数据时生效，处理数据时使用的线程数量，默认为1，若为0，则使用主线程	-
use_multiprocessing	布尔值，只对生成器或tf.keras.util.Sequence为输入数据时生效，默认为False，依赖多进程	-

3）predict方法

predict方法用于对输入的数据进行预测，获取神经网络的预测值

def predict(
        self,
        x,
        batch_size = None,
        verbose = "auto",
        steps = None,
        callbacks = None,
        max_queue_size = 10,
        workers = 1,
        use_multiprocessing = False,
    )

参数	描述	例子
x	输入数据	①Numpy数组或数组列表 ②张量或者张量列表 ③tf.data格式数据集 ④生成器或tf.keras.util.Sequence
batch_size	int，批量数据尺寸，默认值为32	-
verbose	int，模型的输出日志格式	①0：只显示保存模型，不显示训练过程 ②1：以进度条的形式展示训练过程
steps	预测数据量，若输入数据为tf.data并且step为None，则预测所有数据	-
callbacks	回调函数，预测过程中执行的函数功能	-
max_queue_size	int，只对生成器或tf.keras.util.Sequence为输入数据时生效，生成数据队列，默认为10	-
workers	int，只对生成器或tf.keras.util.Sequence为输入数据时生效，处理数据时使用的线程数量，默认为1，若为0，则使用主线程	-
use_multiprocessing	布尔值，只对生成器或tf.keras.util.Sequence为输入数据时生效，默认为False，依赖多进程	-

(2) tf.keras.Sequential类

  Sequential继承Model类，因此Model类具备的方法Sequential类均可以使用。Sequential是针对具有单一输出的神经网络而生，通过add方法叠加建立的神经网络层，方便、快捷。

(3) tf.keras.layers.Dense类

Dense类用于神经网络层的二维矩阵计算，还可以应用于卷积神经网络的全连接层二维矩阵数据的计算。

def __init__(
        self,
        units,
        activation = None,
        use_bias = True,
        kernel_initializer = "glorot_uniform",
        bias_initializer = "zeros",
        kernel_regularizer = None,
        bias_regularizer = None,
        activity_regularizer = None,
        kernel_constraint = None,
        bias_constraint = None,
        **kwargs,
    )

参数	描述	例子
units	正整数，输出层的维度	-
activation	激活函数，可以使用字符串或者函数	①字符串：‘relu’ ②函数：tf.keras.activations.relu
use_bias	布尔值，设置神经网络层是否有偏置向量	-
kernel_initializer	卷积核权重向量初始化	-
bias_initializer	偏置向量初始化	-
kernel_regularizer	卷积核权重矩阵正则化	-
bias_regularizer	偏置向量正则化	-
activity_regularizer	激活函数正则化	-
kernel_constraint	卷积核权重矩阵约束函数	-
bias_constraint	偏置向量约束函数	-

(4) tf.keras.layers.Conv2D类

Conv2D用于搭建卷积神经网络

def __init__(
        self,
        filters,
        kernel_size,
        strides = (1, 1),
        padding = "valid",
        data_format = None,
        dilation_rate = (1, 1),
        groups = 1,
        activation = None,
        use_bias = True,
        kernel_initializer = "glorot_uniform",
        bias_initializer = "zeros",
        kernel_regularizer = None,
        bias_regularizer = None,
        activity_regularizer = None,
        kernel_constraint = None,
        bias_constraint = None,
        **kwargs
	)

参数	描述	例子
filters	整数，输出数据维度，在卷积神经网络中，此参数为图像的深度	-
kernel_size	整数或者两个整数的元组或列表，设定卷积核移动步长	-
strides	整数或者两个整数的元组或列表，设定卷积核移动的步长	-
padding	图像的填充标志	①valid：不填充 ②same：填充
data_format	字符串，输入数据的格式	①(batch, height, width, channels) ②(batch, channels, height, width)
dilation_rate	整数或者两个整数的元组或列表，设定卷积的膨胀率	-
activation	激活函数，可以使用字符串或者函数	①字符串：‘relu’ ②函数：tf.keras.activations.relu
use_bias	布尔值，设置神经网络层是否有偏置向量	-
kernel_initializer	卷积核权重向量初始化	-
bias_initializer	偏置向量初始化	-
kernel_regularizer	卷积核权重矩阵正则化	-
bias_regularizer	偏置向量正则化	-
activity_regularizer	激活函数正则化	-
kernel_constraint	卷积核权重矩阵约束函数	-
bias_constraint	偏置向量约束函数	-

(5) tf.keras.layers.MaxPooling类

最大池化层

def __init__(
        self,
        pool_size = (2, 2),
        strides = None,
        padding = "valid",
        data_format = None,
        **kwargs
    )

参数	描述	例子
pool_size	整数或者两个整数的元组或列表，池化核尺寸，分别表示水平方向和竖直方向的尺寸	-
strides	整数或者两个整数的元组或列表，设定卷积核移动的步长	-
padding	图像的填充标志	①valid：不填充 ②same：填充
data_format	字符串，输入数据的格式	①(batch, height, width, channels) ②(batch, channels, height, width)

(6) tf.keras.layers.Flatten类

Flatten是连接卷积层与全连接层的过渡层

作用是将上一次神经网络数据“拉伸”为列向量，保持参数不变，只改变数据维度，作为全连接层的输入

def __init__(
        self,
        data_format = None,
        **kwargs
    )

参数	描述	例子
data_format	字符串，输入数据的格式	①(batch, height, width, channels) ②(batch, channels, height, width)

TensorFlow 数据集分配

  进行神经网络训练任务前，需要进行数据读取及预处理，将原始的训练数据集数据整理成标准的训练数据，当数据集数量较大时，既要处理数据，又要保证数据的读取性能。TensorFlow 2.X针对这两种情况分别提供了接口，数据结构化处理的接口使用TFRecord类，数据读取接口使用Dataset类。

1. TFRecord类

TensorFlow为提高数据读写效率设计了一种二进制数据存储结构，即TFRecord格式数据

(1) TFRecord格式数据

  TFRecord数据存储形式为*.tfrecords，TFRecord文件中的数据是通过tf.train.Example Protocol Buffer的格式存储的，tf.Example是键值对{“string”: tf.train.Feature}形式

tf.train.Feature的数据格式

数据格式	数据类型
tf.train.BytesList	string：字符串数据 byte：字节数据
tf.train.FloatList	float(float32)：单精度浮点数据 double(float64)：双精度浮点数据
tf.train.Int64List	bool：布尔数据 enum：枚举数据 int32：32位整形数据 uint32：32位无符号整形数据 int64：64位整形数据 uint64：64位无符号整形数据

(2) 生成TFRecord格式数据

  将图像数据（.png或.jpg）转换为TFRecord格式的数据，流程图如下，该过程经历了两次数据格式转换，第一次由uint8转为float32，因为图像在调整尺寸的过程中会损失部分信息，若直接使用uint8类型的图像数据与float32的图像数据相比，会损失更多的信息。因此，调整图像尺寸之前，将图像转换为float32格式的数据，以降低图像在尺寸转换过程中信息的损失。当图像尺寸调整完成后，再将图像数据恢复为uint8格式，以提高计算效率。

import tensorflow as tf
import os
from os.path import join


def parseImage(filename):
	"""
	图像解析函数
	:param filename: 图像名称
	:return: 图像Tensor
	"""
	# 读取图像数据
	imageBytes = tf.io.read_file(filename)
	# 图像数据解码
	imageValue = tf.io.decode_png(imageBytes, channels = 3)
	# 图像数据转换类型
	imageValue = tf.cast(imageValue, tf.uint8)
	# 返回图像数据
	return imageValue


# TFRecord数据格式转换：bytes格式和int64格式
def bytesFeature(value):
	return tf.train.Feature(bytes_list = tf.train.BytesList(value = [value]))

def int64Feature(value):
	return tf.train.Feature(int64_list = tf.train.Int64List(value = [value]))


def getImageInfo(images):
	"""
	获取图像信息
	:param images: 图像矩阵数据
	:return: 图像高度，图像宽度，图像通道数
	"""
	width, height, channels = images[0].shape
	return width, height, channels


def processImage(imageValue):
	"""
	图像处理
	:param imageValue: 图像矩阵数据
	:return: 图像矩阵数据列表
	"""
	# 将图像数据转换为float32格式，取值范围为[0, 1]
	if imageValue.dtype != tf.float32:
		imageValue = tf.image.convert_image_dtype(imageValue, dtype = tf.float32)
		imageValue = tf.image.resize(imageValue, [28, 28], method = "nearest")
	# 图像数据转换为无符号Int，取值范围为[0, 255]
	if imageValue.dtype == tf.float32:
		imageValue = tf.image.convert_image_dtype(imageValue, dtype = tf.uint8)
	return imageValue


def saveToTFRecord(images, imageNumber):
	"""
	保存TFRecord格式数据
	:param images: 图像矩阵列表
	:param imageNumber: 图像数量
	:return: 无
	"""
	# 新建输出目录
	if not os.path.exists('../Image/TFRecordOutputs/'):
		os.makedirs('../Image/TFRecordOutputs/')
	# 保存的TFRecord数据路径和名称
	filename = '../Image/TFRecordOutputs/cifar10.tfrecords'
	# 打开图像保存
	writer = tf.io.TFRecordWriter(filename)
	# 遍历图像保存
	for i in range(imageNumber):
		imageRaw = images[i].numpy().tobytes()
		"""
		设定保存数据的格式
		参数：
			image_raw：数据格式为bytes
			image_number：数据数量
			height：图像高度
			width：图像宽度
		"""
		example = tf.train.Example(features = tf.train.Features(
			feature = {
				'image_raw': bytesFeature(imageRaw),
				'image_number': int64Feature(imageNumber),
				'height': int64Feature(28),
				'width': int64Feature(28),
			}
		))
		# 写入文件
		writer.write(example.SerializeToString())
	# 关闭图像保存流
	writer.close()
	print('已保存')


def saveDatas(imagePath):
	"""
	保存数据
	:param imagePath: 图像路径
	:return: 无
	"""
	# 获取图像名称列表
	imageNames = os.listdir(imagePath)
	# 图像路径
	filenames = [join(imagePath, f) for f in imageNames]
	# 新建文件队列
	filenameQueue = tf.data.Dataset.from_tensor_slices(filenames)
	# 图像数据存入队列
	imageMap = filenameQueue.map(parseImage)
	# 遍历图像数据
	imageValues = imageMap
	images = []
	for imageValue in imageValues:
		# 图像矩阵列表
		image = processImage(imageValue)
		images.append(image)
	# 图像数据
	imageNumber = len(filenames)
	# 保存为TFRecord格式数据
	saveToTFRecord(images, imageNumber)


# '../Image/TFRecord' 是存放许多图片的路径
saveDatas('../Image/TFRecord')

(3) 解析TFRecord格式数据

TFRecord数据解析过程就是将数据复原的过程

import tensorflow as tf
import matplotlib.pyplot as plt


def parseTFRecord(record):
	"""
	解析TFRecord数据
	:param record: 标量张量
	:return:
		image_raw: 图像数据
		image_number: 数据数量
		height: 图像高度
		width: 图像宽度
	"""
	features = tf.io.parse_single_example(
		record,
		features = {
			'image_raw': tf.io.FixedLenFeature([], tf.string),
			'image_number': tf.io.FixedLenFeature([], tf.int64),
			'height': tf.io.FixedLenFeature([], tf.int64),
			'width': tf.io.FixedLenFeature([], tf.int64),
		}
	)
	imageRaw = features['image_raw']
	imageNumber = features['image_number']
	height = features['height']
	width = features['width']
	return imageRaw, imageNumber, height, width


def iteratorDataSubplot(dataset):
	"""
	可视化读取的图像数据
	:param dataset: TFRecord数据对象
	:return: 无
	"""
	plt.figure(figsize = (6, 6))
	i = 0
	for imageRaw, imageNumber, height, width in dataset:
		i += 1
		# 图像字节数据解码，转换为无符号整形数据
		image = tf.io.decode_raw(imageRaw, tf.uint8)
		# 图像高度与宽度转换为张量
		height = tf.cast(height, tf.int32)
		width = tf.cast(width, tf.int32)
		# 图像整型数据恢复为矩阵数据[height, width, channel]
		image = tf.reshape(image, [height, width, 3])
		# 绘制图像
		plt.subplot(10, 10, i)
		plt.subplots_adjust(wspace = 0.2, hspace = 0.2)
		plt.axis('off')
		plt.imshow(image)
	plt.suptitle('TFRecord Data', y = 0.92)
	plt.savefig('../Image/ReadTFRecord.png', format = 'png', dpi = 500)
	plt.show()


# 解析TFRecord
dataset = tf.data.TFRecordDataset('../Image/TFRecordOutputs/cifar10.tfrecords')
dataset = dataset.map(parseTFRecord)
iteratorDataSubplot(dataset)

2. Dataset类

Dataset类参数解析

方法	描述	例子
tf.data.Dataset.from_tensor_slices(tensor)	创建数据集，数据结构为输入数据的切片	np.array([2, 3, 4])，生成的Data为三个切片数据
tf.data.Dataset.batch(batch_size, drop_remainder = False)	将元素分成指定组数，batch_size为每组数据数量，drop_remainder为是否把多余的数据丢弃	-
tf.data.Dataset.shuffle(buffer_size)	打乱数据集数据的顺序，buffer_size为缓存buffer的大小	-
tf.data.Dataset.take(count)	从数据集中提取count条数据	-
tf.data.Dataset.map(map_func, num_parallel_calls)	将map_func函数返回的数据结构映射到数据集元素，map_func的数据结构依赖于数据集元素，可以少于数据集元素，但是不可以多于数据集元素	-

(1) 迭代器处理数据集

import tensorflow as tf


def parseTFRecord(record):
	"""
	解析TFRecord数据
	:param record: 标量张量
	:return:
		image_raw: 图像数据
		image_number: 数据数量
		height: 图像高度
		width: 图像宽度
	"""
	features = tf.io.parse_single_example(
		record,
		features = {
			'image_raw': tf.io.FixedLenFeature([], tf.string),
			'image_number': tf.io.FixedLenFeature([], tf.int64),
			'height': tf.io.FixedLenFeature([], tf.int64),
			'width': tf.io.FixedLenFeature([], tf.int64),
		}
	)
	imageRaw = features['image_raw']
	imageNumber = features['image_number']
	height = features['height']
	width = features['width']
	return imageRaw, imageNumber, height, width


inputFile = ['../Image/TFRecordOutputs/cifar10.tfrecords']
dataset = tf.data.TFRecordDataset(inputFile)
dataset = dataset.map(parseTFRecord)
for imageRaw, imageNumber, height, width in dataset:
    print(imageRaw)
    print()
    print(imageNumber)
    print()
    print(height)
    print()
    print(width)
    break

tf.Tensor(b"\xa2\xc1...\x9e\x8d}", shape=(), dtype=string)

tf.Tensor(100, shape=(), dtype=int64)

tf.Tensor(28, shape=(), dtype=int64)

tf.Tensor(28, shape=(), dtype=int64)

(2) 批处理数据集

批处理数据集是将数据分组输出

import tensorflow as tf


def parseTFRecord(record):
	"""
	解析TFRecord数据
	:param record: 标量张量
	:return:
		image_raw: 图像数据
		image_number: 数据数量
		height: 图像高度
		width: 图像宽度
	"""
	features = tf.io.parse_single_example(
		record,
		features = {
			'image_raw': tf.io.FixedLenFeature([], tf.string),
			'image_number': tf.io.FixedLenFeature([], tf.int64),
			'height': tf.io.FixedLenFeature([], tf.int64),
			'width': tf.io.FixedLenFeature([], tf.int64),
		}
	)
	imageRaw = features['image_raw']
	imageNumber = features['image_number']
	height = features['height']
	width = features['width']
	return imageRaw, imageNumber, height, width

inputFile = ['../Image/TFRecordOutputs/cifar10.tfrecords']
dataset = tf.data.TFRecordDataset(inputFile)
dataset = dataset.map(parseTFRecord)
dataset = dataset.batch(10)
for imageRaw, imageNumber, height, width in dataset:
    print(imageRaw)
    print()
    print(imageNumber)
    print()
    print(height)
    print()
    print(width)
    break

tf.Tensor(
[b"\xa2\xc1\xfb\xa4\xc3\xfa\xa8\xc6\xfc\xab\xcb\xfb\xad\xcc\xfb\xad\xcd\xfb\xae\xcd\xfc\xae\xcd\xfc\xae\xcd\xfc\xae\xce\xfc\xae\xce\xfc\xae\xce\xfc\xae\xce\xfc\xae\xce\xfc\xae\xce\xfc\xae\xcd\xfc\xae\xce\xfb\xae\xcf\xfb\xae\xcf\xfb\xae\xcf\xfb\xae\xcf\xfc\xae\xcf\xfc\xae\xcf\xfc\xae\xce\xfc\xad\xcd\xfb\xac\xcc\xfb\xaa\xca\xfc\xa9\xc7\xfc\xa7\xc6\xff\xaa\xc8\xfe\xad\xcb\xff\xb0\xcf\xfe\xb1\xd0\xfe\xb1\xd0\xff\xb1\xd0\xff\xb1\xd1\xff\xb1\xd1\xff\xb2\xd1\xff\xb1\xd1\xff\xb1\xd1\xff\xb1\xd1\xff\xb2\xd1\xff\xb2\xd1\xff\xb2\xd1\xff\xb1\xd1\xff\xb2\xd2\xff\xb2\xd2\xff\xb2\xd2\xff\xb2\xd2\xff\xb2\xd2\xff\xb2\xd2\xff\xb2\xd2\xff\xb1\xd1\xff\xb0\xd0\xff\xaf\xce\xff\xad\xcc\xff\xa9\xc7\xfd\xab\xc8\xfc\xae\xca\xfd\xb0\xcf\xfd\xb1\xce\xfd\xb2\xcf\xfe\xb2\xcf\xfe\xb1\xcf\xfe\xb2\xcf\xfe\xb1\xd0\xfe\xb1\xcf\xfe\xb2\xcf\xfe\xb2\xd0\xfe\xb2\xd0\xff\xb2\xd1\xfe\xb2\xd1\xfe\xb1\xd0\xfe\xb1\xd0\xfe\xb1\xd0\xfe\xb2\xd1\xff\xb2\xd1\xfe\xb2\xd1\xfe\xb2\xd0\xfe\xb2\xd0\xfe\xb2\xd0\xfe\xb1\xd0\xfe\xaf\xce\xfe\xae\xcc\xfe\xac\xc5\xf8\xa7\xc4\xf9\xac\xc9\xfb\xaf\xcc\xfc\xb2\xce\xff\xb3\xcf\xff\xb4\xcf\xff\xb4\xd0\xff\xb4\xcf\xfe\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd1\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd1\xff\xb4\xd0\xfe\xb3\xd0\xfd\xb4\xd2\xfd\xb6\xd2\xfd\xb4\xd1\xfd\xb4\xd0\xfe\xb3\xcf\xff\xb2\xce\xfe\xe8\xee\xfe\xd5\xe2\xfe\xc3\xd6\xfa\xba\xd2\xfd\xb6\xd0\xff\xb3\xcf\xfe\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb3\xd0\xfe\xb7\xd3\xff\xa5\xc2\xed\x82\x9f\xd0\xb6\xd3\xfe\xb4\xd0\xfe\xb4\xd0\xff\xb3\xcf\xfe\xba\xb7\xc3\xba\xb8\xc4\x9f\xa1\xb5\xa6\xae\xc6\xbb\xd3\xf9\xb4\xd0\xfd\xb5\xd0\xfe\xb5\xd0\xff\xb5\xd0\xff\xb4\xcf\xfe\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb4\xd1\xfe\xb4\xd1\xfe\xb4\xd0\xfc\xbb\xd7\xff~\x9e\xcaEg\x98\xb8\xd3\xff\xb4\xd0\xfe\xb4\xd0\xff\xb4\xcf\xff\x8b\x8f\xa3\x89\x8c\xa0\x84\x87\x9a\x95\x9b\xaa\xb8\xd0\xf2\xb6\xd0\xff\xb5\xcf\xfd\xb4\xcf\xff\xb4\xcf\xfe\xb4\xcf\xfe\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb5\xd0\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd2\xfe\xb4\xd1\xfe\xb6\xd3\xfd\xb0\xcb\xf4c\x84\xb3Su\xa1\xb6\xd2\xff\xb4\xd0\xff\xb4\xd0\xff\xb4\xd0\xff\x99\x9e\xb6\x95\x9a\xb1\x92\x97\xaa\x91\x96\xaa\xb2\xc6\xe6\xb6\xd1\xff\xb4\xd0\xfe\xb5\xd0\xff\xb5\xd0\xff\xb5\xd1\xff\xb6\xd1\xff\xb6\xd1\xff\xb6\xd1\xff\xb6\xd1\xff\xb5\xd2\xff\xb5\xd1\xff\xb5\xd1\xff\xb5\xd2\xff\xb5\xd2\xfe\xb4\xd1\xfe\xb7\xd4\xfe\x93\xb0\xddZs\xa3k\x87\xb1\xb5\xd0\xff\xb5\xd0\xfe\xb4\xd1\xff\xb4\xd0\xff\xb2\xb7\xc7\xaa\xb2\xc1\xad\xb3\xc0\xa4\xac\xbb\xb7\xca\xec\xb5\xcf\xfc\xb5\xcc\xf3\xb3\xcd\xf6\xb4\xcf\xfc\xb2\xcd\xfa\xb2\xce\xfb\xb3\xce\xfb\xb2\xce\xfb\xb3\xce\xfb\xb2\xcf\xfb\xb4\xcf\xfc\xb6\xd1\xfd\xb5\xd0\xfd\xb5\xd1\xfd\xb4\xd1\xfd\xb1\xcd\xf8s\x89\xb7_Wz}\x8a\xb0\xb6\xcf\xfe\xb5\xd0\xff\xb5\xd1\xff\xb5\xd1\xff\xc9\xcd\xdb\xbb\xc2\xd3\xce\xd2\xe1\xbe\xc5\xd6\xc5\xd7\xf9\xb8\xd3\xff\xb2\xc4\xe5\xb2\xc7\xeb\xbd\xd7\xff\xbd\xd6\xff\xbd\xd8\xff\xbc\xd8\xff\xbb\xd7\xff\xbb\xd7\xff\xbc\xd7\xff\xb9\xd5\xff\xb4\xd0\xfd\xba\xd4\xff\xb6\xd2\xfe\xbb\xd5\xff\x9d\xba\xe7[f\x8e`8F\x87\x84\x9d\xb6\xcf\xfd\xb6\xd1\xfe\xb6\xd1\xff\xb6\xd1\xffgp~js\x80\x84\x8a\x95\x99\xa1\xb2\x8a\x96\xae\x92\x99\xad\xc1\xca\xd9\xad\xb9\xd6\x8c\x99\xbc\x89\x97\xb4\x89\x96\xad\x8c\x99\xb1\x8e\x9b\xb2\x8f\x9c\xb4\x91\xa1\xbe\xa4\xaf\xc4\xda\xe1\xef\xa3\xb0\xca\xa4\xb7\xd8\x98\xad\xd6t\x93\xcc`\x83\xb6iu\x95\x9f\xaf\xd1\xb6\xce\xfa\xb9\xd1\xfe\xb8\xd0\xfe\xb8\xcf\xfdip\x82u|\x8e\xa1\xa3\xae\x9c\xa6\xc1\x82\x93\xba\x82\x8b\xb2\x84\x92\xbc\x85\x92\xbd\x87\x93\xbb\x89\x94\xba\x87\x8f\xae\x88\x93\xb0\x8a\x92\xae\x89\x92\xb1\x8c\x9d\xc7\x92\xa7\xd1\xa6\xb8\xdf\x98\xac\xd2\x96\xaa\xd4\x89\xa0\xcdu\x92\xc9d\x85\xc1a\x82\xb7\x8d\xa4\xcc\xb4\xcc\xf7\xb5\xcd\xf8\xb5\xce\xf7\xb7\xce\xf7\xbd\xc1\xc9\xae\xb1\xbe\xa2\xa4\xafl{\x9dk\x7f\xads\x87\xb3l\x80\xadk}\xaci}\xacl\x7f\xaefw\xa7_t\xa7]o\xa4Yn\xa5Wr\xaeYt\xb1\\v\xb2g\x80\xb9l\x87\xbds\x8b\xc1w\x8f\xc2z\x92\xc3s\x88\xb3\x83\x93\xbc\x98\xa7\xc8\x90\x9f\xbf\x95\xa5\xc9\xa1\xb1\xd5\xfb\xfb\xfb\xcb\xcf\xdb\x98\xa2\xbf\x87\x95\xb5\x8e\x9b\xba\x92\xa0\xbe\x95\xa1\xbf\x93\xa3\xc1\x90\xa2\xc1\x8f\xa3\xc4{\x92\xbeo\x87\xb4m\x85\xb2m\x84\xb4k\x82\xb2s\x87\xb5\x8b\x9b\xc1\xa9\xb5\xcf\xb4\xbe\xd5\xbc\xc3\xd8\xcb\xd0\xde\xd4\xd8\xe1\xd2\xd5\xda\xd1\xd2\xd6\xa2\xaa\xbf\x93\x9d\xb5t\x81\x9fZi\x89\xe0\xe2\xe9\x9c\xa3\xb9\x8f\x97\xaf\xa6\xae\xc0\x9f\xa5\xb7\x94\x9e\xae\x92\x9d\xb2\x90\x9e\xb3\x8d\x9a\xb1\x8d\x9d\xb9cx\xa7\x8e\x9c\xbd\xab\xb2\xca\x92\x9c\xbc\x84\x8c\xa6\x9d\xa1\xb1\xb5\xb6\xbf\xb0\xb2\xb9\xaa\xac\xb1\xa3\xa3\xa5\xa3\xa3\xa8\x93\x96\xa1\x83\x88\x99tx\x8a9Gy1@s@Py7Is\xf1\xf0\xf1\xcf\xce\xd2\xc6\xc6\xc8\xa2\xa3\xa9\x9c\xa0\xa7\x8f\x94\x9f\x85\x8b\x97\x83\x89\x97\x81\x86\x93\x80\x89\x99dm\x7fz}\x88\x94\x97\xa9\x8b\x9b\xc4bf|KGLHGLbgragvS\\uALu:Jv->s\x1b)f\x0f#d\x0e ^1Aq,?t\xdf\xe0\xe4\xde\xde\xe1\xf1\xf0\xf1\x97\x8e\x95\xa9\xa9\xa9\x88\x88\x87lpx\xa5\xa8\xaf\xb8\xb6\xb7tx\x80\x84\x87\x92\\[bLO[\x91\x9f\xc0ox\x8fPUcgn~\x92\x99\xa3DP{#5p\x16(d3Eu*>t\x11#b\x15)g\x14&c/Aq':q\xa6\x9a\x9a\xa1\x97\x96\xa9\x9f\x9dwrv\xa0\x97\x96\x9a\x90\x90\x96\x90\x92\x9d\x94\x98\x87\x80\x84BAE\x98\x8e\x8e\x9b\x8e\x8e\x97\x8e\x90\x8a\x86\x89B@C=<@\x84\x80\x84\x8b\x8a\x8f\x8c\x89\x8c\x8c\x87\x8b\x8d\x88\x8e\x8c\x89\x8f\x8a\x88\x8f\x88\x86\x8d\x86\x82\x8d\x84\x80\x8b\x86\x82\x8a\x89\x84\x8d\xcd\xc8\xcf\xce\xca\xcd\xd1\xca\xcd\xc7\xc2\xc6\xcb\xc5\xc9\xca\xc5\xc9\xc7\xc3\xc7\xc9\xc4\xc9\xc9\xc5\xc9\xc4\xc0\xc6\xc6\xc0\xc5\xc4\xbd\xc3\xc1\xbc\xc1\xc1\xbe\xc3\xbc\xb9\xbe\xba\xb5\xba\xc0\xba\xbf\xbe\xba\xc0\xbe\xba\xbf\xbf\xb9\xbf\xbf\xb9\xbe\xbe\xb9\xbe\xbe\xba\xbe\xbf\xbb\xbd\xbe\xb8\xbc\xbb\xb7\xbc\xba\xb6\xbc\xbe\xb7\xb9\xae\x9e\x8d\xab\x9d\x8b\xab\x9e\x89\xb1\xa3\x8e\xae\xa0\x8b\xab\x9e\x8b\xab\x9e\x8c\xac\x9f\x8b\xac\xa0\x8b\xae\xa0\x8e\xaa\x9e\x8d\xaa\x9e\x8b\xaa\x9d\x8a\xaa\x9c\x8a\xab\x9d\x8b\xad\x9f\x8d\xac\x9f\x8c\xac\x9f\x8d\xab\x9d\x8b\xa9\x9b\x8a\xa9\x9b\x8a\xab\x9d\x8b\xa9\x9c\x89\xa9\x9b\x88\xa9\x9a\x88\xa9\x9b\x87\xac\x9c\x88\xac\x9e\x89\x9b\x89u\x98\x87r\x9a\x8bs\x98\x88q\x9a\x8bs\x9b\x8cu\x9c\x8cu\x9b\x8cs\x99\x89s\x97\x86q\x98\x89p\x99\x88p\x9a\x89q\x9b\x8as\x98\x87q\x99\x88p\x98\x88p\x98\x88q\x98\x87p\x97\x87o\x96\x87n\x95\x87p\x96\x87p\x98\x89q\x9b\x8cs\x9b\x8bq\x9e\x8cr\x9f\x8eu\xa0\x91|\x9d\x8fy\x9f\x90{\x9d\x8f{\x9e\x90|\x9f\x90|\xa0\x91}\xa0\x90|\x9e\x8f{\x9d\x8e|\x9f\x91}\x9e\x90|\x9e\x91|\xa1\x93\x7f\xa1\x92\x7f\xa0\x91\x7f\x9e\x90~\x9b\x8d|\x9b\x8d|\x9d\x8e|\x9b\x8e{\x99\x8cy\x98\x8by\x9b\x8e{\x9c\x8f{\x99\x8dx\x9a\x8ex\x9b\x8ez\x8b\x82s\x8b\x82u\x8b\x82v\x8e\x84v\x90\x85v\x91\x87x\x8f\x84v\x8c\x81t\x8f\x85v\x8b\x82s\x8e\x84s\x89\x81p\x89\x82p\x8d\x84r\x90\x86u\x90\x86t\x91\x87u\x8c\x82o\x90\x84r\x92\x87t\x90\x85q\x8e\x83o\x8e\x83n\x90\x84o\x91\x86p\x8e\x84l\x91\x87o\x97\x8bt\x80sb\x81td\x86xg\x89zi\x8c}l\x8f\x80n\x90\x81p\x8f\x81n\x97\x89t\x97\x87s\x95\x84o\x97\x87q\x9c\x8dv\x9f\x8fw\xa4\x93z\xa6\x95{\xa4\x94z\xa5\x95z\xa8\x98}\xab\x9b\x7f\xa9\x99}\xad\x9c\x80\xab\x9a~\xac\x9b\x7f\xae\x9d\x80\xaf\x9f\x82\xad\x9c\x7f\xb1\xa0\x82\x92\x81n\x98\x87t\x9d\x8cx\x9f\x8bw\xa1\x8ev\xa4\x91w\xa5\x91v\xa5\x91w\xa5\x90w\xa2\x8et\xa6\x92x\xa4\x92x\xa0\x8eu\xa0\x8dt\xa2\x8eu\xa3\x8fv\xa4\x92w\x9f\x8dr\xa1\x90u\xa0\x8ft\xa6\x94y\xa3\x92y\xa1\x8fv\xa3\x90u\x9f\x8dr\xa0\x8es\xa0\x8ft\xa2\x91v\x91\x81p\x95\x84s\x9b\x8aw\x9a\x88u\x9a\x89v\x9d\x8bv\xa4\x90x\xa5\x91y\xa2\x8dx\x9f\x8bu\xa2\x8dw\xa4\x90z\xa2\x8dv\xa1\x8dv\xa2\x8ex\xa3\x90z\xa7\x93{\xa2\x8eu\xa4\x92x\xa5\x92y\xa7\x93|\xa3\x91|\x9f\x8dw\xa3\x8fy\xaa\x97\x7f\xab\x99\x7f\xaa\x99\x7f\xa9\x98\x7f\x95\x85u\x9b\x8by\xa3\x91~\xa6\x94\x7f\xa5\x93\x7f\xa5\x93\x7f\xa6\x94\x7f\xa6\x94\x7f\xa4\x92\x7f\xa4\x91~\xa8\x95\x82\xaa\x97\x83\xa8\x95\x81\xa7\x93\x7f\xa8\x95\x81\xaa\x98\x84\xaa\x97\x83\xaa\x97\x83\xa9\x96\x82\xaa\x98\x83\xab\x98\x83\xa8\x95\x80\xa7\x94~\xa8\x94\x7f\xaa\x98\x85\xa8\x96\x82\xa8\x96\x80\xa8\x96\x80\x99\x89{\x9b\x8a{\xa0\x8f\x7f\xa5\x93\x81\xa1\x90}\xa4\x92\x7f\xa3\x90~\xa3\x90}\xa5\x92\x80\xa6\x94\x80\xa5\x93\x80\xa4\x92\x80\xa5\x93\x81\xa6\x93\x7f\xa8\x96\x82\xa8\x97\x84\xa8\x97\x83\xaa\x98\x84\xac\x9a\x88\xac\x9b\x87\xab\x9a\x87\xa9\x97\x86\xaa\x98\x85\xac\x9a\x87\xa4\x93\x83\xa3\x92\x82\xa0\x8f\x7f\x9e\x8d}"
 b'z\xe8\xc1v\xe5\xbdu\xe6\xbd{\xe3\xbd\x82\xdf\xbd~\xe1\xbd|\xe2\xbd~\xe1\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbd{\xe2\xbdz\xe2\xbd|\xe2\xbd|\xe2\xbcv\xe5\xbey\xe3\xbf|\xe1\xc1\x9a\xe9\xcf\xad\xec\xd8\x89\xe0\xc3y\xe7\xc2{\xea\xc2z\xe4\xbev\xe7\xbez\xe5\xbf\x83\xe0\xbf\x80\xe2\xbf~\xe3\xbf\x7f\xe2\xbf{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbe{\xe4\xbew\xe6\xbes\xe8\xbf\x7f\xe3\xc1\x8d\xde\xc5\xb9\xed\xdd\xef\xfb\xf9\xbd\xf2\xe1\x82\xe9\xc6\x7f\xe6\xc1\x82\xdf\xbd\x7f\xe1\xbew\xe5\xbf~\xe3\xc0x\xe6\xc0w\xe5\xbf|\xe2\xbf{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbdv\xe6\xbdt\xe5\xbd\x93\xe7\xcb\xbb\xec\xdf\xd3\xf0\xe9\xff\xf6\xfd\xe7\xf8\xf6\x93\xec\xd0q\xee\xc2u\xe6\xbd\x82\xe3\xc0\xa3\xe8\xd2\xeb\xf9\xf7\xeb\xf9\xf7\x9b\xe8\xd0u\xe5\xbf{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe4\xbd|\xe1\xbd\xa4\xdf\xcc\xea\xf4\xf3\xf7\xfc\xfe\xf9\xfa\xfe\xfd\xf4\xfd\xcb\xf5\xeb\x89\xf0\xcb\x86\xe5\xc3\xa9\xe8\xd1\xd1\xef\xe7\xf7\xf8\xfb\xe5\xf7\xf4\x9c\xe7\xd1y\xe2\xbf{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe{\xe3\xbe|\xe3\xbew\xe4\xbcz\xe4\xbe\xa7\xe6\xd2\xe7\xf2\xf0\xfc\xf8\xff\xfa\xf9\xff\xff\xf7\xff\xeb\xfc\xfa\xb0\xf1\xdb\xa9\xe4\xd0\xe9\xf9\xf4\xf8\xfb\xfd\xe4\xfa\xf6\xa5\xed\xd6\x82\xe2\xc4~\xe1\xc1y\xe4\xbe|\xe2\xbf}\xe2\xc0|\xe3\xbf{\xe3\xbey\xe4\xbez\xe4\xbe}\xe2\xbe|\xe3\xbe{\xe3\xbe\x83\xe0\xc2\x81\xe2\xc0t\xe6\xbcw\xe5\xbe\xa7\xeb\xd5\xea\xfb\xf7\xfe\xf5\xff\xfe\xf6\xff\xfe\xf8\xfe\xfa\xfd\xff\xbf\xf0\xe3\xc0\xe7\xde\xf8\xf6\xfa\xfc\xf9\xff\xe3\xf7\xf2\x9c\xea\xcc~\xe3\xc0}\xe2\xbfy\xe4\xbe\x88\xde\xc4\x84\xe0\xc3~\xe2\xbf{\xe4\xbew\xe5\xbdz\xe5\xbc\x7f\xe2\xbd}\xe2\xbf~\xe2\xbe\x9f\xdb\xcf\x95\xdf\xc9t\xe6\xbd{\xe3\xbe\xa6\xe9\xd2\xe3\xf7\xf0\xfc\xf6\xfe\xfb\xf8\xff\xf7\xf8\xfc\xf7\xfe\xff\xef\xfe\xfe\xeb\xf7\xf7\xfd\xf5\xfd\xfb\xf8\xfd\xfb\xf4\xf9\xd8\xf5\xe9\x93\xe9\xce\x80\xe0\xc0\x87\xd0\xb3\x8f\xc0\xb0\xa7\xe4\xcd\x8a\xe4\xc1|\xe3\xbc}\xe2\xbc{\xe4\xbcy\xe5\xbd{\xe3\xc0\x85\xe0\xc1\xb6\xdc\xda\xa7\xde\xd1y\xe3\xbe}\xe3\xbe\x97\xe9\xcc\xb9\xec\xd9\xde\xf6\xf2\xdb\xf7\xf2\xd0\xf3\xeb\xc7\xf3\xe7\xff\xfd\xff\xfb\xf9\xfd\xfb\xfa\xfe\xfa\xf9\xfd\xfb\xf3\xf9\xdc\xf5\xef\x94\xec\xd4\x87\xe0\xc5\xa0\xca\xb8\x9a\xa9\xa3\xe5\xf1\xe7\xbf\xef\xd8\x90\xe1\xc1\x80\xe0\xbbw\xe5\xbct\xe7\xbe{\xe3\xbf\x8d\xde\xc5\xc1\xdb\xde\xb1\xdd\xd3~\xe1\xbe{\xe3\xbe|\xe2\xbe\x85\xe0\xbf\x9e\xe5\xd0\x9a\xe6\xcf\x91\xe4\xca\x8a\xe4\xc7\xff\xfb\xff\xfc\xf7\xfb\xf8\xfc\xfd\xfe\xf9\xfe\xe8\xf5\xf3\xa4\xe6\xd3\x81\xdf\xc5\xa3\xde\xd0\xdf\xea\xe9\xf6\xf3\xf8\xfa\xf7\xf7\xf2\xf9\xf3\xc5\xec\xdc\x8b\xe1\xc1u\xe6\xbdx\xe5\xbe{\xe3\xbf\x8f\xde\xc8\xc5\xdc\xe2\xb4\xdf\xd5\x7f\xe1\xbez\xe3\xbev\xe5\xbdw\xe5\xbe}\xe2\xc0{\xe4\xc1w\xe5\xc0w\xeb\xc4\xc7\xf7\xea\xca\xf1\xe5\xc2\xef\xe1\xc2\xf1\xe3\xa0\xea\xd5u\xe7\xc2\x82\xe1\xbc\x85\xad\x9d\x93\x9d\xa3\xc1\xc8\xd3\xd6\xdd\xe7\xe9\xec\xf6\xe7\xe4\xef\xa4\xab\xb1\x9f\xc8\xbd\x90\xde\xc1~\xe2\xbe\x91\xdb\xcd\xbe\xd5\xdf\xaf\xe2\xd5z\xe3\xbdz\xe4\xbe{\xe3\xbe|\xe3\xbe}\xe3\xbe|\xe3\xbez\xe4\xbe{\xe9\xc2\x8d\xe9\xca\x90\xe5\xc8\x8a\xe3\xc4\x88\xe2\xc5~\xe1\xc3p\xe9\xbf\x83\xe2\xb6\x8a\xaa\x92\x90\x8f\x92\xa9\xaf\xb9\xa0\xb1\xbf\xb5\xc9\xd6\xbd\xc8\xd7\xa0\x9d\xad\x9e\xa8\xaa\x94\xbf\xae\x8b\xdc\xbd\x9a\xda\xd2\xc5\xd6\xe3\xb1\xe2\xd5z\xe3\xbd{\xe4\xbez\xe3\xbey\xe4\xbe{\xe3\xbd{\xe4\xbdz\xe4\xbd|\xe8\xc1}\xe8\xc3|\xe3\xbd{\xe4\xbc\x81\xe1\xbe\x7f\xe2\xc1t\xe6\xbd\x90\xe2\xb7\xab\xc4\xa1\x96\x99\x86\xa4\xb0\xa8\x9e\xa2\xb2\xa1\xaa\xbd\xa4\xb5\xc6\xa8\xb3\xc4\x9d\xa7\xb3\x8b\x9b\x9e\x9b\xc9\xbb\xa5\xd7\xd7\xc9\xde\xe9\xb2\xe3\xd6{\xe2\xbcz\xe4\xbey\xe4\xbdw\xe5\xbdv\xe7\xbdw\xe6\xbdv\xe6\xbcy\xea\xc0{\xe9\xc0y\xe4\xbc{\xe4\xbd{\xe3\xbd|\xe3\xc2t\xe7\xbf\x88\xe6\xb4\xa1\xca\x96eqI\x8a\x9f\x84\x8f\x8f\x90\x9b\x97\x9c\xa5\xac\xb4\x9c\xaa\xb7\xaa\xb8\xc6\x93\x9f\xaa\xa9\xb9\xba\xb6\xd6\xdd\xc4\xda\xe1\xb4\xe2\xd5\x81\xdf\xbd|\xe2\xbcz\xe2\xbc{\xe4\xbd{\xe5\xbez\xe5\xbdx\xe4\xbcz\xe9\xc0}\xe8\xbdz\xe4\xbcz\xe3\xbfq\xe8\xc3v\xe5\xc4r\xe7\xbd{\xe9\xb0\x99\xd5\x96S[0UcK\x81\x8b{\x84\x8d\x84\x85\x8b\x8c\x93\x92\x9a\x9d\xa2\xa6\x85\x95\x91\x96\x9d\x9b\xaf\xbb\xc5\xaf\xb6\xbe\xab\xc3\xbc\x84\xc2\xac\x80\xc7\xaf~\xc9\xafy\xc8\xad\x83\xca\xb1\x88\xd2\xb8\x83\xd4\xb8\x7f\xd8\xb9{\xe8\xc2y\xe4\xbfz\xe4\xbfz\xe4\xbd\x81\xda\xbb~\xd4\xb4x\xd2\xa9\x8b\xc4\x90ho=55\x1fs}l\x8f\xa0\x93\x85\x8c\x8d\x94\x8a\x92vqtS`XT]W\x88\x8d\x94\x8e\x8f\x94\x82\x8c\x87k\x85|q\x8a\x83f~x|\x94\x8d\x88\xa3\x9b\x8a\xab\xa2\x81\xaa\x9el\x9e\x8f}\xe3\xc5v\xd1\xb5q\xc2\xa9k\xac\x97m\x9a\x8bh\x8a~Y\x86vj\x92u\x8b\x99cpn9QK:qxk\x82\x8c\x84\x91\x94\x91mmo56:\x1b"\x1eCEHFIICJE=GDHMN567SUUhqpoyxenmIRQUl\xa8:CoB<Y:B\x86BL\x8564ZIQnl\x99\x9fl\xae\x8e^\x90e\x90\xaek\x91\xa7dl\x83[w\x97qj\x83lnsqgki421\x1e,##5+9A;KYQ2TD`\xa7\x8bG\x83jIycQyhKh[Nh{=KlHLx/0~,4z82x?=\x8dKh\xabo\xa5\xb9a\x94\x90i\x85\x98\x8a\xa5\x9f}\x95\x88\x7f\x91\x86j|yw\x8a\x91\x80\x9d\x9aMh]Y\x8ez`\xa0\x88j\xa4\x8ao\xaa\x8di\xad\x8dx\xd4\xacu\xd3\xa9u\xcd\xa6s\xc6\xa2p\xbf\x9ac\x93UY\x82\\Z}mXioM`lFOn6=u/AyG`xKclB?\x8eZ]\x99LSxXXyMOs]g\x8fo\x86\x9aa\x83w\x89\xc0\xab\x90\xd2\xb8\x8b\xce\xa4\x87\xc8\x9b\x86\xc6\x99\x86\xcd\x9f\x85\xd1\x99\x87\xcf\xa4\x87\xce\xa4\x85\xcd\x94\x8b\xb6o\x8c\xb5x\x8b\xb3~\x8a\xa5|\x82\x9a{t\x88zWhmL_fN`_Tab>4qA:n=;XOMbGD\\PNnik\x88arms\x90\x81\x80\xa2\x92~\xa0\x80\x81\xa2}\x89\xa9\x85\x88\xa9\x84\x88\xa9\x8a\x85\xa5\x8a\x88\xa7\x8a\x8c\xac\x87\xb4\xc8\xa7\xb4\xc6\xaa\xb3\xc5\xad\xb7\xc1\xb2\xb6\xbe\xb2\xb2\xb9\xb1\xa9\xb0\xaa\x9b\xa4\xa1\x8a\x94\x93\x84\x8b\x87\x85\x80\x97\x88\x85\x96\x92\x93\x92\x9d\x9f\x96\x9a\x9c\x94\x9d\x9c\x9f\xa8\xa3\xb5\xa3\xa7\xa4\xa4\xae\xa6\xa8\xb3\xae\xaa\xb3\xa7\xad\xb5\xa8\xb3\xbb\xae\xb1\xb9\xac\xb1\xb8\xb7\xb0\xb9\xaa\xb0\xba\xa7\xb6\xbc\xb7\xc9\xc8\xc7\xc5\xc4\xc6\xc4\xc3\xc8\xc6\xc2\xcd\xc8\xc4\xcc\xc6\xc3\xc6\xc2\xbf\xbd\xbb\xb9\xba\xb6\xb8\xbc\xb9\xbb\xb7\xbb\xbb\xba\xbe\xbc\xc3\xc0\xc0\xc5\xc2\xc2\xc1\xc3\xc3\xc3\xc3\xc1\xc8\xc4\xc0\xca\xc5\xc4\xc0\xc4\xc4\xc1\xc4\xc4\xc6\xc6\xc3\xc6\xc6\xc2\xc6\xc6\xc3\xc7\xc6\xc3\xc7\xc6\xc4\xbf\xc5\xc5\xbb\xc2\xc2\xba\xc8\xc7\xc9\xca\xc6\xca\xc6\xc2\xc8\xc6\xc1\xc9\xc3\xbf\xc7\xc2\xbf\xc5\xc5\xc2\xc5\xc5\xc3\xc4\xc4\xc1\xc3\xc5\xc1\xc5\xc7\xc5\xc2\xc4\xc4\xc4\xc4\xc3\xca\xc5\xc4\xcb\xc4\xc4\xc7\xc4\xc4\xc8\xc5\xc4\xcb\xc3\xc6\xc7\xc4\xc6\xc0\xc4\xc4\xc3\xc5\xc4\xc8\xc6\xc4\xc9\xc5\xc2\xc6\xc5\xc3\xc7\xc5\xc3\xc7\xc6\xc4\xbf\xc4\xc3\xc4\xc0\xbf\xc7\xc1\xc2\xcc\xc8\xc9\xc4\xc4\xc5\xc0\xc5\xc6\xc1\xc3\xc6\xbe\xc3\xc6\xc0\xc4\xc6\xc4\xc3\xc5\xc7\xc2\xc3\xc5\xc3\xc2\xc2\xc3\xc3\xc6\xc4\xc3\xcc\xc5\xc4\xca\xc5\xc4\xc8\xc5\xc4\xc8\xc5\xc4\xc8\xc5\xc4\xc7\xc3\xc7\xc3\xc1\xc5\xc5\xc0\xc4\xc6\xc2\xc5\xc7\xc3\xc6\xc4\xc3\xc5\xc1\xc4\xc6\xc3\xc0\xc2\xbe\xb3\xb3\xbc\xb1\xb5\xb3\xae\xb6\xb4jt\x80\xca\xc7\xcb\xc6\xc3\xc6\xc6\xc4\xc6\xc6\xc5\xc8\xc6\xc4\xc8\xc5\xc4\xc6\xc3\xc1\xc3\xc1\xc2\xc3\xc1\xc5\xc6\xc2\xc5\xc7\xc5\xc5\xc3\xc5\xc5\xc3\xc5\xc5\xc4\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc3\xc7\xc5\xc4\xc2\xc0\xc4\xc4\xc3\xc8\xc5\xc5\xc8\xc5\xc4\xc5\xc4\xc3\xc4\xc9\xc7\xc8\xa9\xa7\xa8E=VOHpIGs)-M\xc9\xc8\xcb\xc6\xc4\xc7\xc6\xc5\xc7\xc5\xc3\xc7\xc4\xc3\xc6\xc6\xc4\xc6\xc6\xc4\xc4\xc5\xc5\xc5\xc4\xc6\xc7\xc4\xc6\xc6\xc3\xc4\xc1\xc3\xc4\xc1\xc5\xc5\xc3\xc3\xc3\xc2\xc3\xc3\xc1\xc6\xc6\xc3\xc7\xc5\xc5\xc5\xc3\xc5\xc5\xc5\xc7\xc5\xc5\xc6\xc6\xc5\xc6\xc5\xc4\xc5\xca\xc8\xca\xa2\xa0\xa1=9GOJcNKg66G\xc8\xc8\xc8\xc5\xc5\xc5\xc4\xc3\xc4\xc3\xc3\xc3\xc3\xc3\xc3\xc5\xc4\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc4\xc3\xc3\xc2\xc4\xc4\xc4\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc5\xc8\xc8\xc8\xa0\x9f\x9fRRSRRSUUUMMN'
 b'Us\x9fUs\xa1[x\xa8Uv\xa9Zy\xb1^|\xb6^|\xb2`~\xb5c\x81\xb7k\x88\xb8{\x95\xc3s\x8d\xc0{\x96\xc9\x7f\x9a\xccn\x8c\xc0j\x89\xc2l\x8b\xc5u\x94\xc9u\x93\xc9n\x8c\xc4q\x8f\xc8p\x8f\xc8k\x89\xc4k\x89\xc6k\x8b\xc6l\x8c\xc6n\x8d\xc6n\x8c\xc7Vp\x9eTq\xa1Yu\xa5Ts\xa9Wu\xae[x\xb3d\x82\xb1f\x81\xb2a{\xb2l\x87\xb8\x8a\x9e\xc8|\x95\xbfr\x8b\xbfy\x92\xc3u\x92\xbei\x87\xbai\x86\xbdp\x8d\xc2v\x93\xc9m\x89\xc1n\x8b\xc2o\x8e\xc2m\x8b\xc2j\x88\xc0h\x86\xc2h\x87\xc2i\x87\xc2k\x88\xc4]t\xa1To\x9fTp\xa0[v\xa8`w\xa4_w\xa9j\x83\xb2n\x88\xb9c|\xb2q\x8b\xbe|\x8f\xbb\x81\x99\xc1p\x88\xbar\x8a\xbcz\x94\xc2{\x96\xc6o\x89\xbej\x85\xbcl\x87\xbem\x87\xc0t\x90\xc6s\x91\xc5n\x8c\xc2o\x8c\xc4h\x86\xc2h\x85\xc2h\x85\xc2i\x86\xc4`u\x9fUn\x99Zs\x9f`u\x9d\x8a\x98\xab\x85\x8f\xa1fr\xa0ay\xb1o\x8b\xb6h\x7f\xb5b|\xb2r\x88\xb9z\x8f\xbbc}\xb0h}\xb7n\x85\xb9u\x8c\xbfu\x8c\xc1w\x8e\xc1r\x8b\xc1g\x82\xbaf\x82\xbbk\x86\xc2k\x87\xc2g\x84\xbef\x82\xc2d\x80\xc2c\x80\xc0Ri\x95Wn\x9ah}\xa8Um\x9dex\x9c\x9a\xa2\xb1\x83\x8b\x9fbt\xa1j\x81\xafg~\xb2]v\xadn\x83\xb2n\x81\xb2]|\xb2cz\xb5e}\xb8g\x80\xb8r\x89\xbd~\x92\xc1|\x93\xc3i\x85\xb9e\x81\xbde\x81\xbfg\x84\xbef\x83\xbcc\x7f\xbdb~\xbf_~\xbdOe\x90Ri\x94^t\x9eTl\x9f_q\xa2w\x86\xad\x99\xa7\xab~\x89\x9bbq\xa0bz\xac_v\xael\x81\xaddw\xae^{\xb7`{\xb7]x\xb4_z\xb5d~\xb9k\x82\xb6}\x93\xc1n\x88\xbac~\xbac}\xbbd\x7f\xb8r\x8d\xc5l\x87\xbe`|\xb6`}\xb9Sh\x90Sj\x96Tj\x94Qh\x9b_r\xa7`w\xa4}\x89\x9a\xa5\xa9\xae~\x88\x9c`t\x9ee|\xa9h}\x9fct\xa5m\x81\xb4b~\xb4[x\xb2[w\xb4Zv\xb3^w\xafp\x87\xb6u\x8c\xbe`y\xb6az\xb6c}\xb4f\x80\xb7p\x8b\xbeh\x82\xb7az\xb4dw\x9fSi\x94Pf\x90Ng\x95Vj\x9bWp\x9anu\x93\x85\x86\x8a\x9c\xa2\xa4{\x85\x9ef|\xa0^q\x89\x80\x8b\xa2\x84\x89\x9dl\x80\xaa]x\xaf]v\xb3_x\xb0Yu\xaf_y\xb0f}\xb4by\xb6bz\xb4t\x8d\xc1cz\xb5f}\xb6r\x89\xbfl\x83\xb9[m\x94Kb\x8dMd\x8fOh\x91Wl\x97Sh\x95fl\x88^bh\x88\x8c\x97\xa8\xac\xb3at\x99z\x89\xa4{\x81\x83OF:s~\x9bj\x84\xb6]t\xadn\x84\xb4[w\xafXt\xb1]t\xb1`v\xb2`v\xb0j\x82\xb5i\x7f\xbcav\xb4_u\xaek\x81\xb7Nb\x87I`\x89I`\x8eSi\x91Tj\x94Ne\x92^l\x92p}\x92kw\x9b\x90\x98\xa7{\x86\x9bs\x82\xa8fnzcWDii{k\x81\xa9v\x88\xaet\x89\xb0c|\xb1Xs\xafYr\xadZq\xadYq\xadYq\xab`x\xb3e}\xb5\\u\xadYr\xacXi\x8bp|\x9blz\x9aSh\x90Nc\x8dSj\x95ar\x9ck}\x9fhz\xa4at\x9c\xb0\xb2\xb6\xa6\xaa\xa6\x82\x8b\x96\x80\x85\x96\x9a\xa5\xa6\x9d\xa2\xa7lh`p\x84\xad[q\xa7Um\xa8Rj\xa6Rj\xa5Sk\xa6Sk\xa6Tm\xa6Wp\xa7by\xaeg|\xb2Qb\x84\x80\x8b\xa8\x86\x93\xaeTh\x90I_\x89Kb\x8cTg\x91Xl\x94dx\xa4Xl\xa0qv|\x96\x95\x92\xb1\xb8\xab\xa6\xa9\xa7\x9d\xa9\xaf\x87\x91\x95e[Oau\x9fbx\xa9Ul\xa1Oh\xa1Oh\xa1Pi\xa2Pi\xa2Qj\xa2Pi\xa1Tl\xa1aw\xacGY|^m\x8cz\x88\xa1Pc\x8bH_\x89Qg\x90^q\x9bQf\x92Qi\x94Qf\x99DQcqz\x90\x92\x9c\xaa\xaf\xb2\xab\x9c\xa1\xa7uy~sno[t\xa3t\x8b\xb4g}\xabOh\x9fNg\xa0Mf\x9eLe\x9eNg\x9fNg\xa0Lf\x9dMg\x9d@SwCVxXi\x87I_\x86I_\x89dy\x9c{\x8b\xaaSh\x8eE`\x87Ib\x8ajz\xa1hz\xa6Ug\x95\x8f\x99\xa1\x98\x9b\x9fQMKNNWNh\x99`w\xa2fz\xa7Pg\x9aPi\xa0Og\x9dLd\x9bLd\x9dLf\x9eIe\x9dIe\x9c=RuCX{L^\x82@Y\x7fG^\x86l}\x9c\x9a\xa6\xbcgx\x98E^\x8aE`\x8adv\x9eas\x9fSh\x95\x89\x98\xa5\x99\x9d\x9fQKC=?AZo\x96Qg\x93`u\xa5Zr\xa3Je\x96Rj\x9cRh\x9cJb\x9aIc\x9aGc\x9aHc\x9a=QtCWyL^\x81?X|F\\\x83p~\x9f\x90\x99\xb5jx\x9aG\\\x86C]\x86Xk\x93m}\xa3eu\x98\xa0\xaa\xb4\xaa\xad\xac\x82~v;=;\x90\x9a\xadkz\x97`s\x9aZr\x9fJd\x94Qh\x99_t\xa6H_\x94G`\x95G`\x95Ha\x95>Rs@TuHZ|>WzAW|^l\x8dp{\x9bkx\x9cTf\x8eAZ\x82Th\x92u\x85\xa9|\x8a\xa7\x92\x9a\xa5\x80\x83\x80rqnSX\\\xb3\xb3\xb7\xa7\xab\xb8\x87\x8f\xa6t\x84\xa6[p\x9dM`\x92Yl\xa1H^\x90F^\x90G_\x90H^\x90>Ss<Qp=Qq9RtCY}Th\x89GZ\x7fRc\x88Ob\x85CZ\x81CZ\x86Ti\x92}\x8c\xabw\x80\x9b48@03AYh\x8aRc\x82^n\x89~\x88\x9a\xa3\xa7\xab\xac\xb0\xb4\x8f\x9b\xadq\x83\x9eQf\x95Lc\x93av\xa4Xk\x97?Ss8Nn;Pp8Rt<QvCW{J^\x81G\\~F]\x81D\\\x84AX\x82K`\x88iz\x9fq}\xa1@H`HSnm\x7f\xa5u\x84\xa5Qf\x8cNb\x86u~\x8b\x91\x95\xa1\x97\xa2\xb6\xa7\xae\xbdLc\x8eE^\x8eRg\x95Ui\x95;Oo5Kk7Lm6Oq;OtEW{Pd\x87>UwAW}CW\x7fAV~BX\x81J_\x87Te\x8cN\\~J\\\x80Pd\x8e\x9b\xa6\xc0s\x85\xa3J_\x80\x81\x8d\xa0u|\x94]l\x8b\x80\x8b\xa3J`\x8aD\\\x8cBX\x85Od\x907Kk3Ii6Ll2Ll9MpFVyBUx:Rt?TzBT|N`\x88?V\x7fBY\x82J_\x88Uj\x93E\\\x87BX\x85js\x92\x81\x8e\xae]o\x92bq\x8edr\x94Xl\x95Ma\x86G\\\x85CZ\x87BX\x84CY\x852Gf0Gg;Pp0Ki7KmDSuBUw7Os:RwBV|L`\x86=Tz@W\x7fBX\x81BX\x83=U\x7f?V\x7fO]\x86iv\x9egw\xa2GY\x80BV\x80G^\x8aE[\x88G[\x83DY\x84@W\x82>U\x802Ff0Ff5Ji/Ig@TuQ`\x81CUv4Lq4Ns8Qu;SwCXzCX|@U|BV~Pd\x87E[~CX\x83Rb\x88`o\x95CY\x81=V\x83@V~AU\x80Ob\x8aAU~>U\x7f<T\x7f3Gg4Hh1Fd0Ge=QqUd\x82R`\x829Nr0Kp0Or5NsF\\~AW{<RxBV|Rf\x89K^\x83@V}Qd\x86iz\x9cG\\\x82<T\x7f>U}=T}CY\x80AU}AV~?U~*B^/Gc/Gd+Ed/IiAUsARr:MoBSvUf\x87Ta\x83CWx8Nq8Ns9Ou:Pv?Ry?RvGZ~DUyBTz<Qy;Rx8Pv<RwBV|?Sy=Qx*A\\+B\\-C_)Ca+Fd6Kj:Oo?RsFXyBWu@TsRd\x85DWy7Mp7Nr9OsDW|<Pt>PtGX|N_\x85>Qx<Ry:QvDX}=Qv:Os:Ns5Gb>Oj>Oi1Hc*D`.Ed.Ge6JjBQr7Kk8OnN]~CTv5Km4Ln7Mo=Pt:Nq<Os@QvDUz<Ou:Ot9NsJ\\\x80;Os<Ru8Mp8Id=Ni=MhATm/E`5Kk)Ba5KkN^\x80BSv8LnBQsN^\x7f7Mn2Jl4Km7Kn9Mp=OrAOp>Ns;Ns8Lq8Mq>Pt;OqCUu?Pq'
 b'3S\x823X\x8cNU`\x84undo\x8f8c\x9f9a\x9f9Z\xa8,a\xa1.a\x9f0^\xa20^\xa32`\xa53`\xa63_\xa43_\xa33`\xa24a\xa15d\xa24d\xa53c\xa84e\xaf4e\xb26g\xb33a\xb34a\xb23a\xab9f\xa74T\x877\\\x93ORZlT;WXl6]\xa50b\xab6`\xa90a\xa90b\xa81b\xa82d\xa94f\xab5d\xab5b\xa95b\xa85c\xa75c\xa54e\xa53e\xa83f\xad2e\xb12f\xb54h\xb9/c\xb90e\xba.e\xb63h\xb05V\x8b8^\x97Z[`zZ1_UY<\\\xa5-d\xb73e\xac4a\xb01a\xae0b\xab2d\xab4g\xac6g\xad6d\xac5d\xaa5d\xa85e\xa73f\xa73f\xaa3g\xb01f\xb30e\xb6/f\xb9-f\xbb.h\xbd,h\xbb/h\xb52_\x965c\xa4sv\x80\x8b`4kU;O_~2c\xbc+h\xbb0e\xb81e\xb91g\xb32i\xb22i\xaf4h\xb06f\xb05f\xaf2c\xa94f\xaa2i\xae1i\xb11j\xb60i\xbb.h\xbd-h\xc1;s\xc2L\x82\xccCw\xc1Ky\xbe1d\x9c3f\xaasx\x85\x8db:lU0W`e7a\xb9)f\xc0,h\xb90g\xbc0i\xb61j\xb31k\xb14i\xb16g\xb24f\xaf2c\xab5i\xae3k\xb10i\xb21k\xb9/k\xbd.i\xc0.i\xc3U\x8b\xd5h\x98\xdae\x8f\xd0{\xa1\xdd2i\xa73j\xb0rz\x89\x92j8nT$a\\SB`\xaf,f\xbe.h\xbb/g\xbf1j\xbb3k\xb83l\xb56j\xb57f\xb45f\xb23e\xb15k\xb45m\xb10l\xb5.k\xbe/j\xc42i\xc72k\xc3\\\x91\xd7\x87\xad\xe2\x97\xb5\xe3\xa3\xc1\xed3j\xb35l\xb9nz\x92\x9dv@wX)j[LMd\x9f2g\xbc0h\xc01i\xc22j\xbd3k\xba4k\xb78j\xb79h\xb67h\xb55h\xb59m\xb9:l\xb55k\xb80j\xbe2i\xc27j\xc28n\xc3V\x8b\xd2\x93\xb6\xe7\xac\xc7\xeb\xa2\xc1\xe65i\xb87n\xc3gw\x9f\x8dg;qR/fVCUi\x86:j\xbc/j\xc63m\xc52k\xbe3k\xbb5m\xba9n\xbc:m\xbb9l\xb89l\xb5=n\xb6@k\xba=k\xbd9l\xbe7l\xbc:n\xbb=q\xc3F}\xcby\xa1\xda\x89\xaa\xd6y\x9f\xc89k\xb59p\xc5]w\xa8a?\x1bS5 O@(N[\\>g\xb10m\xca5p\xc65m\xc05m\xbe9o\xbf;q\xc1:q\xbe;o\xba<n\xb5Gw\xbbFu\xc0@q\xc1:n\xc17o\xc39p\xc5@s\xc8=u\xc6Y\x85\xc2f\x8b\xbb`\x89\xb5<m\xad:r\xc2X|\xb2tY;_G8SE+Y\\OKj\xa44q\xc96s\xc77p\xc27o\xc1:p\xc3=s\xc4<r\xc0=q\xbc>q\xb8J|\xbfC{\xc1>w\xc2:r\xc67q\xce7p\xd4M|\xd3Cx\xc7^\x89\xc5p\x92\xc2o\x95\xc0Am\xae=t\xcc9k\xb9sbZibQ`WBhWVS_u=t\xb2;v\xc4:s\xc4:r\xc5>s\xc8Du\xc5?m\xb9?n\xba?r\xbf=s\xc1=v\xc5@s\xbf0[\xa3<c\xad_\x87\xd3\x87\xaa\xe6z\xa5\xe1\x8a\xa7\xd6x\x87\xab\x80\x93\xb5Bn\xb7;t\xd2=r\xc1pdVe_L`ZKg]\\VZ`Ic\x80Ss\xa7>t\xc39t\xcb>t\xcdGs\xbd2P\x88<Z\x92Ew\xbe<t\xc8Bu\xcbEp\xb7"Cy4P\x86z\x96\xd3\x9d\xb7\xebs\x95\xcbn\x86\xadGPjck\x88Bq\xb5;x\xd2E{\xc4\xc2\xb9\xa6\xae\xa5\x96qme==;@@AGGKHPcDx\xc0=y\xd1F{\xd7Gp\xb6,<`7;UDf\x99@{\xceCy\xcfBn\xb30P\x80B[\x8av\x8f\xcb\x80\x96\xc5m\x85\xb2`u\x8fPXepq\x81Ds\xa7B{\xc7P\x82\xc5\xee\xe6\xdd\xa7\x9c\x94HB@((+44;>=CGNTGt\xacCw\xc5Et\xc9@j\xac*9T5(+6=PE|\xc3C}\xceM~\xc6h\x8a\xc6u\x90\xc5c}\xb49Mlbv\x91]nxbiheggGn\x95Jw\xb0j\x91\xc4\x81xr;2+.)$..-=>ATUX\xa1\xa3\xa3\x94\xb0\xcb\x80\xa2\xccb\x81\xb3`|\xa4?GTB3*;779]\x86R\x84\xc0i\x93\xd4\x8d\xa9\xe6\x9e\xb3\xe6cw\x9e+9HKWfCNOHMFGGFNf\x8cLi\x94Xu\x99B=586-;8/65,HIB\x92\x93\x8e\xe7\xe1\xe1\xed\xf3\xf5\xe4\xf0\xf2\xda\xe6\xea\xd2\xd7\xda\xb5\xb3\xb1\xa0\x9e\x99{\x82\x81s|\x84p\x8d\xad]w\xa2\x86\x95\xc0\x83\x8b\xadRZl5:?IN[>DG@CBAAGbu\x9b_v\x9cSp\x93QY`MRRNNIQNEdcX\xb5\xb4\xac\xd9\xd0\xcf\xe0\xdb\xd6\xdf\xdf\xd5\xdf\xe1\xd3\xd9\xd4\xc7\xd5\xd0\xca\xcc\xd5\xd4\xac\xb9\xb8\xb6\xb3\xab\xaa\xb5\xbf\x8c\x98\xaa\x8c\x92\xa6tv\x85UV[>>=TTa@CG=AG=AI_{\x9a[|\xa2Ox\xad\\{\xb0\\k\x89X[jNKP]WYtkj\x80~v\x90\x8d\x83\x89\x87\x83\x86\x87\x89\x8d\x91\x98\x95\x9d\xa4\x9d\xa6\xa9\xaa\xaf\xad\xb5\xc1\xcb\xb7\xbe\xc5\xba\xbd\xc0\xb2\xb4\xb6\xb3\xb5\xb7\xc4\xc8\xcd\xac\xb2\xb68=H\\dl]fq>FWbm\x81[n\x87Vo\x91Yr\x9dcs\x91gitDDFFEHNEETLGng]_ZS@=<GFMV[f_kwx\x86\x94\xb0\xb9\xcb\xa9\xb2\xc2\xa7\xa9\xb6\xa4\x9f\xaa\x96\x92\x9c\x8b\x8e\x98z\x83\x916?QDL]LSg8<L\x96\x90\x93\x98\x99\x9f\x95\x98\xa35<Ufl\x82]VY\\USsqsQKL=32_WOnf_QIG7-/706:>Hlv\x84\xae\xb3\xc4\x8b\x93\xa1pq|b\\eOJSFGPEIRQS^DDOXVb[V_\x90\x88\x82\x8f\x8a\x85\x89\x82\x7fIBKb[fB-\'dSKojia^`PGH8/*C94G85?)&>)&914JLTNO\\47@*).4.1C?BCCIEEI969504G@EA79FKLJPOJKJ\x8a\x81\x86rabkJ<lPB80-::=MDG-$ 7)$F1*H)\x1fV8/:,(#\x1f!+(/KIKA=;@;7FA??>?89;""$"!#\'%(!\x19\x19Q_hKY`BKP\x97\x93\x99\x92}y\xb3\x8aw\x99udQGBFIKH@A?61VF=dK>U3%N1$6\'\x1f"\x1e\x1a,)\'KE@VPGQLB2/\'*(%%((:?>588-/0!\x1d\x1bKSXKSWW[^lgk]HC\x99mX\x90gTK?9=ABIC@`YPeUGnP;oM:T<.>4)0/&51\'4+!WPBd`Q63\'+(")*$fhaXXRKJE84.\x84|y\x87}v\x84vnr_abFFb3#\x80O6\x95ye\xa0\x95\x88\xa4\x97\x8bPME.-$*\'\x1b><*\x96\x93\x80\xa9\xa1\x93\xa5\x9b\x90\xa0\x99\x8d\xa2\x9c\x8d\xa0\x9c\x8c\x9d\x9a\x8b\x9b\x9a\x8d\x99\x99\x8d\x9b\x98\x91\x98\x95\x8e\x99\x96\x8e\x97\x94\x8a\x95\x92\x89\x9c\x93\x90\xa7\x9c\x95\xaa\x9b\x93\xa8\x92\x95\x89fixC9\x93bK\xad\x92|\xac\xa0\x92\xae\xa1\x9463,#$\x1d**!A@1\x9a\x97\x86\xa9\xa1\x93\xa6\x9b\x90\xa0\x9a\x8f\xa2\x9d\x90\xa1\x9c\x90\xa0\x9c\x91\x9e\x9d\x93\x9c\x9c\x93\x9c\x9a\x95\x9b\x98\x93\x9c\x99\x93\x9b\x98\x90\x98\x96\x8d\x96\x8e\x8b\xa4\x9a\x92\xa9\x9b\x93\xb1\x99\x9b\x9ant\x87KF\x93eR\xb2\xa0\x8d\xa8\x9f\x93\xab\x9f\x93RNF*\'\x1fZUKwoa\xa4\x9a\x8c\xad\xa3\x97\xa8\xa0\x95\x9e\x9c\x90\xa3\x9d\x95\xa4\x9e\x97\xa3\x9f\x99\xa0\x9f\x9a\x9f\x9e\x9a\x9f\x9c\x9a\x9f\x9b\x98\xa0\x9c\x97\x9f\x9c\x95\x9d\x9a\x92\x8e\x88\x84\x9e\x95\x8d\xa4\x98\x8f\xa9\x91\x93\x8cZ`\x83A@\x98n_\xac\xa1\x8e\xa5\x9e\x92\xa9\x9d\x92\x94\x8d\x85YQI|pe\x9e\x90\x83\xa7\x99\x8e\xa6\x9c\x91\xa4\x9f\x94\x9d\x9d\x93\xa3\x9d\x98\xa5\x9e\x9c\xa4\x9f\x9d\xa0\x9d\x9d\x9e\x9c\x9d\x9f\x9b\x9c\x9d\x99\x97\x9d\x99\x96\x9d\x9a\x94\x9a\x96\x90'
 b'9|\xb19z\xaa9{\xae>}\xb2=\x80\xb2>\x81\xb3=\x81\xb2;\x84\xb4=\x84\xb7=\x84\xb7>\x85\xb8?\x86\xb9?\x86\xb9?\x86\xb9@\x88\xbaA\x88\xbbA\x87\xbc@\x88\xbc?\x8a\xbd=\x8b\xbe@\x89\xbe@\x89\xbe@\x88\xbdC\x86\xb8C\x86\xb7E\x83\xb8A\x83\xbd?\x84\xba<\x80\xb09\x80\xae9\x81\xb2C\x80\xbbD\x82\xba@\x86\xb8<\x88\xb4>\x88\xb6A\x88\xbaA\x88\xbaB\x89\xbbC\x89\xbcC\x8a\xbcC\x8a\xbcC\x8a\xbdD\x8a\xbcF\x8a\xbbA\x8c\xc0@\x8d\xc2@\x8c\xc0B\x8d\xbf@\x8e\xc3A\x8e\xc1J\x8b\xb4M\x87\xb1G\x88\xbcE\x88\xbeE\x87\xbb?\x85\xb3<\x85\xb2>\x85\xb3?\x88\xbcF\x86\xbe?\x89\xbd?\x8b\xbfG\x88\xbeF\x8a\xbcF\x8a\xbcG\x8c\xbdG\x8b\xbdG\x8b\xbcG\x8b\xbdH\x8c\xbeH\x8c\xbdK\x8c\xbaE\x8f\xc3F\x8e\xc2J\x8d\xbcH\x8e\xbcB\x8f\xc2E\x8f\xbfU\x8a\xa9O}\x9eG\x8c\xbfG\x8b\xbcJ\x8a\xbaF\x8b\xbdE\x8a\xb7N\x86\xad\x8d\x91\x9b}x\x8d[\x87\xa0E\x94\xb7L\x8f\xc1N\x8f\xc0N\x8f\xbfN\x91\xc0O\x91\xc1P\x92\xc1P\x92\xc1Q\x93\xc3R\x93\xc2R\x94\xbfQ\x93\xc2b\x94\xb8x\x99\xb3e\x8f\xaeX\x90\xba\\\x91\xb8^p{`}\x91J\x95\xc6N\x92\xbcT\x90\xbaI\x8f\xbaK\x8d\xb4N\x8b\xaf\xa0\x97\xa2\x9c\x83\x87|z\x84X\x8f\xa9P\x94\xc3O\x93\xc3T\x93\xbdT\x95\xc1T\x95\xc3V\x96\xc2W\x96\xc2X\x96\xc1Z\x97\xc1W\x98\xc5Z\x98\xc5k\x95\xb4\x8f\xa3\xb2\x8f\x9e\xa9z\x8d\xa1m\x86\x99cjk`\x84\x9cS\x99\xc9W\x95\xbe[\x93\xb9N\x92\xb9P\x90\xb5Q\x91\xb5\x80\x94\xa3\x9a\x8f\x8e\x95\x83~~~\x8eg\x8e\xafZ\x97\xc1Z\x98\xc3]\x9a\xc4\\\x9a\xc4]\x9a\xc5_\x9b\xc4a\x9a\xc2c\x9b\xc1d\x9b\xc1a\x9e\xcai\x9c\xc3w\x9a\xb4\x9b\xa6\xac\xa1\x9f\xa4w{~]]Xf\x8a\xa4Z\x9f\xc8Z\x9b\xc1`\x98\xbfV\x95\xc0V\x92\xbaZ\x94\xbac\x96\xab\x8b\x98\x9c\xa2\x97\x8d\xa6\x86\x86}\x82\x8dj\x97\xb4a\x9d\xc8f\x9f\xc7h\x9f\xc4f\xa0\xc8i\xa0\xc7j\xa0\xc5m\xa1\xc4o\x9f\xbfi\xa3\xcdn\xa5\xd1s\xa2\xc5\x84\x97\xa4\x8f\x89\x8a~wprphv\x90\xa6c\xa3\xc2[\xa3\xc4e\x9e\xc7^\x98\xc1^\x95\xbdb\x97\xbd_\x9b\xbcy\x97\xa7\xa3\x9c\x9b\xae\xa5\x99\x9a\x98\x94{\x93\xa3o\x9f\xc2p\xa2\xc7q\xa2\xc4o\xa4\xc8q\xa4\xc8s\xa5\xc6u\xa5\xc5s\xa5\xc7x\xa7\xc8{\xa1\xbey\x97\xaew\x85\x8f\x8b\x82\x81\xa1\x97\x8d\x9a\x9a\x94\x8b\x99\xa8u\xa2\xb4g\xa7\xc3l\xa2\xcbg\x9c\xc1h\x9a\xbdl\x9d\xbfp\x9a\xb6{\x96\xa6\x9b\x9a\xa0\x9a\xa6\x9c\xaf\xb2\xab\xa2\xa9\xae\x81\x9b\xae{\xa7\xc9y\xa8\xc9x\xa9\xc9{\xaa\xc9~\xab\xc9\x7f\xab\xc7\x7f\xab\xc7\x86\xa0\xb1\x9d\xaa\xb3\xaa\xaf\xb3\xac\xaf\xaf\xa8\xa1\xa3\x8f\x91\x91\xa1\xab\xae\xa4\xa5\xa9\x8e\x99\xa0\x80\xa5\xc0w\xa5\xccp\xa2\xc2q\xa0\xbdv\xa4\xc1w\x8d\x95\x92\x9a\x9f\x94\x99\x9b\xab\xaa\xa9\xbc\xbb\xb7\xb6\xb2\xb1\x9f\xa4\xa9\x85\xaa\xc8}\xab\xcc}\xaa\xc9\x83\xae\xca\x87\xaf\xc9\x84\xaa\xc1\x89\xa2\xae\xc2\xc8\xc9\xd2\xd1\xcf\xbe\xba\xb6\x93\x8d\x87{y~\x89\x9b\xa7\x9c\xb3\xbf\xbd\xb7\xb5\xb0\xa0\xa1\x90\x9a\xb3\x85\xa8\xcb\x87\xad\xc4\x85\xaa\xc0\x86\xac\xc3\x81\x8e\x95\x99\x9b\xa7\xa0\xb3\xbc\x91\xa1\xa7\xa4\xa2\xa5\xb3\xb0\xac\xb5\xb1\xab\x9f\xa4\xac\x92\xa5\xb4\x92\xab\xbb\x9d\xad\xb6\xba\xc0\xc1\xd8\xd6\xd2\xcc\xc5\xc1\x82~|~}~\x97\x97\x9b\xaa\xb4\xbe\xa3\xbb\xcb\x99\xbb\xd1\x9a\xbb\xd2\xa1\xb5\xc6\xad\xb5\xbe\xb1\xb3\xbc\x9d\xa5\xb5\x92\xb2\xc6\x91\xb0\xc3\x91\xb0\xc3\x8e\xa5\xb6~\x8d\x9f\x97\xa9\xb6\x96\xa3\xaa\x96\x9a\x9e\xa4\xa6\xa4\xc8\xc6\xc3\xa8\xa7\xa8\x9a\x9e\xa1\xb7\xbd\xbf\xd5\xd6\xd6\xd1\xcf\xcb\xad\xa8\xa3\x8b\x84\x80\x97\x98\x9b\xad\xb4\xbc\xb4\xbf\xcc\xaf\xbe\xd0\xa8\xbf\xd2\xa3\xbf\xd3\xa6\xbd\xd1\xa7\xbd\xd1\xaa\xb9\xc8\xac\xb8\xc6\xa4\xb5\xc9\x9d\xb4\xc4\x9c\xb3\xc3\x9e\xb5\xc4\xa2\xb6\xc5\x86\x95\x9f}\x82\x87\x9d\x9b\x9b\xa0\xa2\x9f\x99\x9e\x9c\xaf\xac\xac\xb1\xaa\xa6\xdc\xd5\xce\xe9\xe0\xd9\xbc\xb4\xad\x7fvpwoi\x97\x90\x8d\xbf\xc4\xcb\xb9\xc5\xd2\xb2\xc3\xd4\xb3\xc4\xd9\xb3\xc6\xd8\xaf\xc3\xd2\xb2\xc0\xd0\xad\xc1\xd5\xae\xc0\xd1\xae\xbf\xcf\xa9\xbd\xd0\xa9\xb8\xc5\xa7\xb7\xc3\xa9\xb9\xc5\xb1\xbd\xc7\x9a\xa5\xa6}vt\xaf\xa3\x9f\xbc\xbd\xb5\x98\x9b\x95\xaa\xa4\xa5\xdf\xd8\xd3\xca\xc2\xba\x9a\x8f\x89ne_aXT\x8d\x85\x81\xc6\xc3\xc2\xc1\xc7\xcf\xbe\xc9\xd4\xbd\xca\xd8\xbd\xcb\xd9\xbd\xcb\xd6\xbd\xca\xd1\xbc\xc7\xd1\xb9\xc5\xd3\xb7\xc5\xd1\xb5\xc5\xd1\xb1\xc3\xcf\xb4\xbf\xc9\xb2\xbc\xc6\xb3\xbd\xc7\xb7\xc0\xcb\xae\xbc\xbd\xac\xa5\xa4\xaf\xa6\xa8\xa8\xae\xa7\xc2\xc1\xb8\xdb\xd3\xd3\xa6\xa0\x9dzvqqjh{ur\x94\x8d\x8b\xa6\x9f\x9d\xc8\xc8\xca\xc8\xcd\xd3\xc8\xcf\xd6\xc7\xcf\xd8\xc8\xd0\xd7\xc8\xd1\xd3\xc8\xd1\xd1\xc3\xcf\xd4\xc6\xca\xd1\xc2\xca\xd1\xc0\xca\xd1\xbd\xc9\xcd\xbd\xc4\xce\xb8\xc1\xcd\xba\xc2\xcb\xc2\xc7\xd1\xb3\xba\xbf\xa2\x9f\xa1\xb4\xb0\xb0\xd9\xda\xd6\xe2\xdf\xd9\xab\xa0\xa0wroxur\x98\x93\x92\xbc\xb7\xb5\xbe\xb9\xb6\xae\xa8\xa6\xc4\xc2\xc4\xcf\xd3\xd4\xcf\xd5\xd6\xce\xd5\xd6\xd0\xd5\xd7\xd1\xd5\xd6\xd0\xd5\xd6\xce\xd4\xd7\xce\xcf\xd4\xcb\xce\xd3\xc9\xce\xd2\xc7\xcc\xd0\xc6\xc6\xd0\xc3\xc2\xd0\xc7\xc6\xd1\xac\xac\xb2\xae\xae\xb1\xcd\xca\xc9\xdb\xd7\xd2\xc3\xbe\xb9\x97\x90\x8e\x82uu\x9d\x9a\x97\xa0\x9e\x9a\xc2\xbc\xb9\xbc\xb7\xb4\xb3\xae\xab\xa4\x9f\x9d\xa5\xa2\xa2\xd8\xda\xd9\xd4\xda\xd8\xd3\xdb\xd9\xd6\xd9\xda\xd7\xd8\xdb\xd7\xd8\xdb\xd5\xd7\xd9\xd3\xd4\xd9\xd2\xd3\xd8\xd0\xd1\xd6\xcf\xd0\xd5\xd1\xd0\xcf\xca\xc6\xc6~~}\xaf\xac\xa7\x93\x8f\x88wsktrf\xa5\x9e\x97\xd8\xcb\xcb\xe7\xde\xdc\xc8\xc6\xc2\xba\xb7\xb4\x9e\x99\x97\xad\xa8\xa5\xb7\xb2\xaf\xc4\xbf\xbc\xb0\xaf\xab\xb3\xb4\xb0\xdf\xdf\xdb\xe2\xe2\xdf\xe1\xe0\xe0\xe2\xe2\xe2\xe1\xe1\xe1\xdf\xdf\xde\xdd\xdd\xdc\xdc\xdc\xdb\xda\xda\xd9\xd9\xd8\xd8\xdd\xd9\xd3\x92\x89\x8362-jd_}vp\x9a\x94\x8e\xc2\xbe\xb7\xe2\xdd\xd8\xe7\xdf\xdd\xe5\xe1\xde\xa8\x9f\x9e\xbe\xb5\xb4\x9a\x95\x92\x97\x92\x8f\xaf\xaa\xa7\xb6\xb1\xae\xb0\xb0\xab\xa0\x9f\x9b\xb8\xb5\xb2\xe3\xdf\xdc\xe5\xe3\xe1\xe4\xe4\xe2\xe4\xe3\xe2\xe3\xe2\xe0\xe1\xe1\xdd\xe0\xdf\xdc\xde\xdd\xd9\xdc\xdc\xd8\xd1\xbf\xbbrXS[HD\x92\x87\x85\xbf\xb5\xb2\xdb\xd4\xd1\xe4\xe0\xdd\xe4\xe1\xde\xe4\xe2\xde\xe5\xe5\xe1\x8b{|\x8d\x80\x80\xa9\xa4\xa1\xbd\xb8\xb5\xae\xa9\xa6\xa9\xa4\xa1\xb0\xb0\xab\xaa\xa9\xa3\xaf\xaa\xa6\xc6\xbd\xbb\xe9\xe4\xe1\xe7\xe5\xe2\xe8\xe5\xe3\xe7\xe5\xe3\xe6\xe4\xdf\xe4\xe2\xdd\xe3\xe1\xdc\xe2\xe0\xdb\xca\xb5\xb5\x88kl\x99\x82\x83\xd9\xcf\xcd\xe8\xde\xdd\xe8\xe0\xde\xe6\xdf\xdd\xe7\xe2\xe0\xe6\xe2\xdf\xea\xe6\xe3\x97\x8b\x8b\xa0\x95\x95\xdc\xd4\xd3\xbf\xb7\xb5\xcf\xc7\xc5\xae\xa6\xa4\xa2\x9f\x9d\xaa\xac\xa6\xb9\xb0\xac\xa3\x88\x87\xd3\xba\xb1\xec\xec\xe3\xe9\xe3\xe6\xec\xe3\xe6\xe8\xe3\xe0\xe7\xe3\xdf\xe6\xe2\xde\xe6\xe1\xdd\xe3\xd3\xd4\xde\xca\xcc\xe1\xd1\xd2\xe6\xde\xdc\xe7\xde\xdc\xe7\xdf\xdd\xe8\xe0\xde\xe9\xe1\xdf\xe9\xe1\xdf\xea\xe2\xe0\xd6\xcf\xcd\xdf\xd6\xd5\xf4\xea\xe9\xb9\xaf\xae\xac\xa3\xa2\xaa\xa1\xa0\x83|}\xae\xb1\xab\xba\xb1\xad\xb7\x9c\x99\xb2\x88\x7f\xdf\xc2\xbc\xe9\xe8\xe3\xe9\xe5\xe4\xe9\xe4\xe1\xe8\xe3\xe0\xe7\xe2\xdf\xe6\xe1\xde\xe2\xd8\xd7\xe4\xd8\xd8\xe2\xd8\xd7\xe4\xdc\xda\xe7\xdf\xdd\xe7\xdf\xdd\xe7\xdf\xdd\xe9\xe1\xdf\xea\xe2\xe0\xeb\xe3\xe1\xe4\xdc\xda\xe0\xd8\xd6\xe9\xe0\xdf\xa7\x9e\x9d\x7fvu\x98\x8e\x8d\xae\xa4\xa4\xa8\xa9\xa4\xb5\xb1\xac\xc4\xb7\xb3\xbb\x99\x95\xb9\x8a\x84\xdd\xcd\xbe\xe7\xeb\xe0\xeb\xe5\xe3\xe9\xe4\xe1\xe9\xe4\xe1\xe7\xe2\xdf\xe0\xdb\xd8\xde\xd8\xd6\xdf\xd9\xd7\xe6\xde\xdc\xe7\xdf\xdd\xe6\xde\xdc\xe7\xdf\xdd\xe9\xe1\xdf\xea\xe2\xe0\xeb\xe3\xe1\xeb\xe3\xe2\xeb\xe4\xe2\xe8\xe2\xe0\xc4\xbe\xbb\x9d\x97\x94\xc0\xba\xb7\xec\xe2\xe1\xce\xce\xc9\xaa\xaa\xa5\xba\xb3\xb1\xc5\xba\xb4\xb1\xa1\x90\xb2\x8c|\xe4\xd3\xc9\xea\xe4\xe2\xea\xe5\xe2\xea\xe5\xe2\xe9\xe4\xe1\xe3\xdb\xd9\xde\xdb\xd7\xe1\xd9\xd8\xe7\xde\xdc\xe7\xdf\xdd\xe8\xe0\xde\xe8\xe0\xde\xea\xe2\xe0\xeb\xe3\xe1\xec\xe4\xe2\xec\xe4\xe2\xeb\xe6\xe3\xec\xe8\xe5\xec\xe8\xe5\xe2\xde\xdb\xe7\xe4\xe0\xec\xec\xe4\xec\xea\xe5\xee\xeb\xe9\xde\xdd\xdb\xbc\xbe\xb6\xbc\xb6\xb4\xc7\xbe\xbd\xb4\x9e\x98\xee\xe9\xe5\xea\xe5\xe2\xeb\xe6\xe3\xea\xe5\xe2\xe4\xdb\xd9\xe0\xd9\xd7\xe1\xd9\xd7\xe7\xde\xdd\xe7\xdf\xdd\xe7\xdf\xdd\xe9\xe1\xdf\xea\xe3\xe1\xeb\xe5\xe2\xeb\xe5\xe2\xed\xe6\xe4\xed\xe8\xe5\xed\xe9\xe6\xed\xe9\xe6\xee\xe9\xe6\xee\xea\xe7\xed\xec\xe6\xee\xe9\xe6\xee\xe9\xe7\xf0\xec\xe9\xe8\xe4\xe0\xcb\xc2\xc3\xc7\xbf\xc1\xcb\xca\xc3\xef\xe9\xe6\xeb\xe6\xe3\xeb\xe6\xe3\xea\xe5\xe2\xe3\xdb\xd9\xe1\xd9\xd7\xe3\xdb\xd9\xe7\xdf\xdd\xe7\xdf\xdd\xe8\xe0\xde\xea\xe2\xe0\xea\xe3\xe1\xea\xe5\xe2\xea\xe5\xe2\xed\xe8\xe5\xee\xe9\xe6\xef\xea\xe7\xef\xe9\xe6\xef\xea\xe7\xf0\xeb\xe8\xf0\xeb\xe8\xee\xe9\xe6\xef\xea\xe7\xee\xe9\xe6\xf1\xec\xe9\xec\xe8\xe5\xdd\xd8\xd5\xe3\xde\xdb\xed\xe8\xe6\xec\xe7\xe4\xeb\xe6\xe3\xea\xe5\xe2\xe3\xdb\xd9\xe1\xd9\xd7\xe2\xda\xd8\xe5\xdd\xdb\xe8\xe0\xde\xe9\xe1\xdf\xeb\xe3\xe1\xeb\xe4\xe2\xea\xe5\xe2\xea\xe5\xe2\xed\xe8\xe5\xef\xea\xe7\xf0\xeb\xe8\xf0\xeb\xe8\xf0\xeb\xe8\xf1\xec\xe9\xf1\xec\xe9\xef\xea\xe7\xef\xea\xe7\xef\xea\xe7\xef\xea\xe7\xef\xea\xe7\xed\xe8\xe5\xed\xe8\xe5\xed\xe8\xe5\xec\xe7\xe4\xeb\xe6\xe3\xea\xe5\xe2'
 b'\xd5\xed\xf3\xd5\xe9\xf1\xd6\xe9\xf2\xe2\xef\xf6\xe3\xf0\xf7\xdf\xec\xf4\xd8\xe7\xf1\xd4\xe8\xf4\xd1\xea\xf5\xd4\xea\xf4\xd5\xea\xf7\xd4\xea\xf7\xd4\xea\xf7\xd4\xea\xf7\xd6\xe9\xf7\xd6\xe9\xf7\xd6\xe9\xf7\xd7\xe9\xf8\xd7\xea\xf8\xd7\xea\xf8\xd7\xea\xf8\xd5\xeb\xf7\xd1\xec\xf5\xd1\xec\xf5\xd1\xeb\xf4\xcf\xea\xf3\xcf\xea\xf3\xcf\xea\xf2\xd9\xf1\xf7\xd8\xeb\xf2\xdf\xf0\xf7\xf6\xfd\xff\xf6\xfd\xff\xf4\xfb\xfd\xe7\xf1\xf8\xd9\xeb\xf5\xd6\xed\xf7\xd7\xed\xf7\xd8\xed\xfa\xd8\xee\xfa\xd8\xee\xfa\xd8\xee\xfa\xd9\xed\xfa\xda\xed\xfa\xda\xed\xfa\xda\xed\xfa\xd9\xed\xfa\xd9\xed\xfa\xda\xed\xfa\xd7\xed\xf9\xd4\xee\xf8\xd4\xee\xf8\xd4\xee\xf7\xd2\xed\xf7\xd2\xed\xf6\xd1\xec\xf5\xd9\xf1\xf7\xdb\xee\xf3\xed\xfa\xfd\xf9\xfc\xfb\xf8\xfb\xfa\xfa\xfc\xfb\xf4\xfa\xfc\xe1\xf0\xf6\xd7\xec\xf3\xd7\xed\xf7\xd7\xed\xf6\xd6\xed\xf6\xd7\xed\xf7\xd7\xed\xf7\xd8\xed\xf7\xd9\xed\xf7\xd9\xed\xf7\xda\xee\xf8\xda\xee\xf8\xda\xee\xf8\xda\xee\xf8\xd8\xed\xf7\xd6\xec\xf7\xd6\xed\xf7\xd6\xed\xf8\xd3\xee\xf7\xd3\xee\xf7\xd1\xec\xf5\xda\xf0\xf7\xe6\xf4\xf7\xf4\xfb\xfb\xfa\xfd\xfc\xfb\xfd\xfc\xfb\xfd\xfc\xfc\xff\xfe\xf3\xfb\xfc\xdd\xef\xf3\xd7\xed\xf6\xd7\xee\xf5\xd7\xee\xf5\xd8\xef\xf6\xd9\xef\xf6\xda\xef\xf6\xdb\xee\xf6\xda\xee\xf5\xda\xee\xf5\xda\xee\xf5\xda\xee\xf5\xda\xee\xf5\xda\xee\xf7\xd9\xed\xf8\xd9\xed\xf8\xd8\xed\xf8\xd4\xef\xf8\xd4\xef\xf8\xd3\xee\xf7\xdb\xf0\xf8\xe6\xf3\xf7\xf3\xf9\xfa\xf8\xfc\xfc\xfb\xfe\xfd\xfd\xfe\xfd\xfe\xff\xfd\xf8\xfc\xfc\xe2\xf0\xf7\xd9\xed\xf9\xd9\xee\xf6\xd9\xee\xf6\xda\xef\xf6\xda\xef\xf6\xda\xef\xf6\xdb\xef\xf6\xdb\xef\xf7\xda\xee\xf6\xda\xee\xf6\xda\xee\xf6\xda\xee\xf6\xda\xee\xf7\xda\xee\xf8\xda\xee\xf8\xd8\xed\xf7\xd6\xee\xf8\xd5\xee\xf8\xd5\xee\xf8\xdd\xef\xfa\xe5\xf1\xf7\xf3\xf9\xfc\xf8\xfc\xfc\xfc\xfe\xfc\xff\xff\xfc\xff\xfe\xfb\xfb\xfc\xfd\xe5\xf0\xfa\xdb\xed\xfc\xdb\xee\xf8\xdb\xee\xf7\xdb\xee\xf8\xdb\xee\xf8\xdb\xee\xf8\xdb\xef\xf8\xdc\xf0\xf9\xdb\xef\xf8\xdb\xef\xf7\xdb\xef\xf8\xdb\xef\xf7\xdb\xef\xf8\xdb\xef\xf8\xdb\xef\xf8\xd8\xed\xf6\xd7\xed\xf8\xd7\xed\xf8\xd6\xed\xf7\xde\xf0\xfa\xe2\xee\xf6\xef\xf8\xfb\xf8\xfc\xfe\xfa\xfc\xfc\xfe\xfe\xfc\xff\xff\xfc\xfa\xfd\xfe\xe4\xf1\xfa\xdb\xed\xfc\xdd\xef\xf9\xdd\xef\xf9\xdd\xef\xf9\xdd\xef\xf9\xdc\xef\xf9\xdc\xf0\xf9\xdd\xf1\xfa\xdc\xf0\xf9\xdc\xf0\xf9\xdc\xf0\xf9\xdc\xf0\xf9\xdb\xef\xf8\xdb\xef\xf8\xdb\xef\xf8\xd9\xee\xf7\xd8\xee\xf9\xd8\xee\xf9\xd7\xed\xf8\xde\xf1\xfa\xdf\xed\xf4\xe7\xf3\xf7\xf5\xfb\xfd\xf6\xfa\xfb\xfc\xfe\xfc\xff\xff\xfe\xf7\xfd\xfe\xe2\xf1\xfa\xdb\xee\xfa\xdd\xef\xf9\xdd\xef\xf9\xdd\xef\xf9\xdd\xef\xf9\xdc\xf0\xf9\xdc\xf0\xf9\xdd\xf1\xfa\xdd\xf1\xfa\xdc\xf0\xf9\xdc\xf0\xf9\xdc\xf0\xf9\xdc\xf0\xf9\xdb\xef\xf8\xdb\xef\xf8\xda\xee\xf8\xd9\xef\xfa\xd9\xef\xfa\xd8\xee\xf9\xde\xf1\xf8\xdd\xee\xf5\xe1\xf1\xf7\xf1\xf9\xfc\xf5\xfb\xfc\xfb\xfe\xfe\xfc\xff\xff\xf1\xf9\xfc\xde\xef\xf8\xdb\xef\xf9\xde\xf0\xfa\xde\xf0\xfa\xde\xf0\xfa\xde\xf0\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdc\xf0\xf9\xdb\xef\xf8\xdb\xef\xf8\xda\xee\xf8\xd9\xee\xf9\xd8\xee\xf9\xd8\xee\xf9\xdf\xf2\xf8\xdc\xef\xf5\xdd\xf0\xf7\xef\xf8\xfc\xf4\xfc\xfe\xfa\xff\xff\xf8\xfe\xfe\xe8\xf5\xf9\xdc\xef\xf9\xdd\xf0\xfa\xde\xf0\xf9\xde\xf0\xfa\xdf\xf1\xfb\xdf\xf1\xfb\xde\xf2\xfb\xde\xf2\xfb\xde\xf2\xfb\xde\xf2\xfb\xde\xf2\xfb\xde\xf2\xfb\xdd\xf1\xfa\xdd\xf1\xfa\xdd\xf1\xfa\xdc\xf0\xf9\xdb\xef\xf9\xda\xf0\xfa\xd9\xef\xfa\xd8\xee\xf9\xe1\xf3\xfa\xde\xf0\xf6\xde\xf0\xf7\xe0\xf1\xf8\xe6\xf0\xf1\xe3\xf0\xf3\xe0\xf1\xf6\xe1\xf1\xf6\xe2\xf0\xf9\xde\xf1\xfa\xdf\xf1\xf9\xe2\xef\xfc\xe2\xee\xfb\xe0\xf0\xf7\xe2\xf1\xf4\xe1\xf2\xf8\xdf\xf3\xfa\xdd\xf4\xf8\xdb\xf4\xfc\xde\xf4\xfd\xdf\xf4\xfb\xdd\xf3\xfa\xdc\xf2\xfa\xdc\xf1\xf9\xdc\xef\xf8\xdb\xef\xf8\xda\xef\xf8\xda\xee\xf8\xe0\xf1\xf9\xde\xef\xf6\xdf\xf0\xf7\xe1\xf1\xf5\xe3\xee\xee\xdf\xef\xf3\xdc\xf3\xfb\xdb\xf2\xfc\xdc\xf2\xfa\xdf\xf1\xf7\xde\xf2\xf6\xe4\xf1\xf3\xe8\xf1\xf0\xe4\xf0\xed\xdd\xed\xf0\xdf\xf2\xf7\xe0\xf3\xf6\xdf\xec\xe6\xd6\xe3\xe0\xc2\xca\xc6\xbc\xc0\xbb\xcc\xcf\xca\xdd\xe4\xe0\xe1\xec\xeb\xde\xf0\xf7\xde\xf2\xf9\xdb\xef\xf8\xdb\xef\xf8\xe1\xf2\xf9\xde\xef\xf6\xdf\xf0\xf7\xe0\xec\xed\xc3\xc8\xc3\xcb\xcb\xc1\xdf\xe2\xde\xe1\xf2\xf8\xda\xf7\xf8\xdd\xf3\xf5\xdf\xf4\xf7\xd0\xde\xcf\xb1\xb7\xa2\x98\x9d\x93\xb4\xc1\xc4\xe3\xf3\xf4\xe7\xef\xe8\xc5\xbe\xa8\xb7\xaf\x99\xa7\x98~\xa7\x92w\xab\x94{\xa6\x96\x81\xaf\xaa\x9d\xac\xbd\xc0\xd3\xe7\xef\xdd\xf1\xfa\xdc\xf0\xf9\xe2\xf3\xfa\xdf\xf0\xf7\xe0\xf0\xf7\xe0\xef\xf1\xbc\xb6\xaa\xb8\x97t\xc8\xa1~\xd9\xcc\xbb\xe2\xef\xe3\xe1\xf6\xf5\xe6\xf3\xfb\x9f\xa5\x95>:$1*"jhc\xbc\xb9\xaf\xba\xad\x97\xd4\xba\x96\xc1\xab\x87\x9a~S\x98uK}Y7L0\x15XL:\x9f\xb0\xb3\xd8\xec\xf4\xdd\xf1\xfa\xdc\xf0\xf9\xe2\xf3\xfa\xe0\xf1\xf8\xe0\xf1\xf8\xe2\xf5\xfb\xe3\xdf\xd3\xcb\x9es\xc7\x89Q\xbc\x8ec\xc8\xb0\x93\xdd\xda\xd0\xf0\xef\xf3|rh8(\x18H6-Q</dL9mO4\xca\xaa\x85\xba\xa3{\x9f\x86X\x88kEY=$dRA\x8c\x88}\xde\xf3\xf6\xe0\xf4\xfd\xdc\xf0\xf9\xdd\xf1\xfa\xe3\xf4\xfb\xe1\xf2\xf9\xe2\xf3\xfa\xdf\xf3\xfa\xe7\xf3\xf4\xdb\xc8\xb2\xc5\x97h\xc7\x8bW\xc1\x82\\\xbb\x8do\xce\xbf\xb0U?2C*\x1bJ3\x1fH*\x18N0 T8%eK0{lH\x98\x8cdynS\x82{s\xcf\xd2\xd3\xe2\xee\xef\xdc\xf6\xfa\xdd\xf2\xfb\xde\xf1\xfa\xdd\xf1\xfa\xe3\xf5\xfc\xe1\xf2\xf9\xe2\xf3\xfa\xe0\xf3\xfa\xe0\xf4\xfc\xe4\xeb\xea\xca\xb5\x9b\xc8\x8d`\xcd\x82[\xc4\x83X\x94uY>!\x13; \x12>%\x104\x1e\x0fB,\x1cD.\x1bK9(NC-MK4wzo\xcb\xd5\xd7\xe4\xf4\xfc\xdf\xf3\xf9\xdb\xf4\xf9\xde\xf2\xfa\xde\xf2\xf9\xde\xf1\xf9\xe5\xf7\xfe\xe2\xf3\xfa\xe3\xf4\xfb\xe4\xf4\xfb\xe6\xf3\xf8\xe7\xf3\xf7\xef\xed\xdf\xc3\xa5~\x8alH\xa0\x8dl=+\x0c>3\x1cF<(:,\x1c\x1e\x11\x12,\x1e\x1fWHE]\\]z\x80|\xc9\xd2\xd2\xe8\xf4\xf9\xe2\xf2\xf8\xe2\xf5\xfb\xe2\xf5\xfb\xe2\xf5\xfb\xe1\xf4\xfa\xdf\xf2\xf9\xdf\xf2\xf8\xe5\xf6\xfe\xe2\xf3\xfa\xe3\xf4\xfb\xe6\xf4\xfa\xe9\xf5\xf9\xee\xf8\xfb\xf7\xf7\xec\xba\xa6\x87@0\x1795#I<\x1cTH/RE17(\x1a\x1f\x12\x13+"#qmp\xd7\xe2\xe8\xdf\xef\xf0\xe6\xf4\xf9\xe5\xf2\xfa\xe5\xf4\xfc\xe2\xf5\xfb\xe2\xf5\xfb\xe2\xf5\xfb\xe1\xf4\xfa\xe0\xf3\xf9\xe0\xf3\xf9\xe5\xf6\xfd\xe2\xf3\xfa\xe4\xf5\xfc\xeb\xf8\xfc\xf0\xfb\xfd\xf5\xfe\xff\xf8\xf9\xf4\xa1\x91\x81?3&93,J3\x1dN8$G2#0 \x163+&stp\xc0\xc9\xc8\xe4\xf6\xfd\xe3\xf7\xfc\xe3\xf5\xfc\xe6\xf4\xfe\xe5\xf4\xfd\xe3\xf6\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe1\xf4\xfa\xe1\xf4\xfa\xe1\xf4\xfa\xe5\xf6\xfd\xe2\xf3\xfa\xe4\xf5\xfc\xef\xfa\xfd\xf1\xfb\xfc\xf3\xfa\xfa\xf1\xf6\xf6\xd1\xce\xcc\xba\xb8\xb3ypl?$\x17?&\x189)\x1cLF@\x9a\x9c\x99\xda\xe5\xe3\xe6\xf8\xfa\xe4\xf4\xfc\xe4\xf5\xfd\xe4\xf5\xfc\xe5\xf5\xfc\xe4\xf5\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe1\xf4\xfa\xe1\xf4\xfa\xe1\xf4\xfa\xe5\xf6\xfd\xe2\xf3\xfa\xe4\xf5\xfc\xea\xf5\xf8\xeb\xf4\xf6\xed\xf4\xf4\xe7\xf4\xf7\xea\xfa\xfe\xe7\xf0\xecle\\F1(K;/tqe\xc0\xcb\xc7\xec\xf8\xfc\xe6\xf7\xfd\xde\xf4\xfc\xe7\xf3\xfc\xe7\xf4\xfc\xe6\xf5\xfb\xe4\xf6\xfa\xe3\xf6\xfa\xe3\xf6\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe1\xf4\xfa\xe1\xf4\xfa\xe1\xf4\xfa\xe5\xf7\xfb\xe2\xf3\xf8\xe3\xf4\xf9\xe6\xf6\xf9\xe6\xf5\xf9\xe7\xf6\xf9\xe2\xf6\xfb\xe7\xf8\xfb\xbf\xc1\xb76/!2-$poh\xc4\xcc\xc9\xea\xfa\xfb\xe5\xf6\xfb\xe4\xf5\xfb\xe4\xf7\xfd\xe6\xf6\xfc\xe6\xf6\xfb\xe5\xf6\xfb\xe4\xf6\xfa\xe4\xf6\xfb\xe5\xf6\xfd\xe4\xf6\xfd\xe4\xf5\xfc\xe3\xf6\xfc\xe2\xf5\xfb\xe1\xf4\xfa\xe5\xf8\xfc\xe2\xf4\xf8\xe3\xf5\xf9\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe4\xf7\xfd\xe0\xee\xf1\x97\x97\x8f<:/y}x\x9c\xa4\xa2\xc5\xd3\xd5\xe4\xf5\xf9\xe4\xf6\xfa\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe4\xf6\xfb\xe4\xf6\xfa\xe4\xf6\xfb\xe5\xf6\xfd\xe5\xf6\xfd\xe4\xf5\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe1\xf4\xfa\xe7\xf9\xfe\xe4\xf6\xfa\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe7\xf6\xf9\xee\xfb\xfc\xeb\xfc\xff\xe5\xf6\xfa\xe3\xf5\xfa\xe3\xf6\xfd\xe3\xf8\xff\xe5\xf8\xfd\xe6\xf8\xfc\xe6\xf8\xfc\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe4\xf6\xfb\xe4\xf5\xfc\xe4\xf5\xfc\xe4\xf6\xfd\xe3\xf6\xfc\xe3\xf6\xfc\xe2\xf5\xfb\xe8\xfa\xfe\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe5\xf7\xfb\xe6\xf7\xfb\xe7\xf6\xfa\xe4\xf5\xf9\xe3\xf5\xfb\xe6\xf7\xfd\xe6\xf8\xfe\xe6\xf8\xfe\xe6\xf8\xfe\xe6\xf8\xfd\xe6\xf8\xfc\xe6\xf8\xfc\xe6\xf8\xfc\xe6\xf7\xfc\xe6\xf8\xfc\xe6\xf8\xfb\xe5\xf7\xfc\xe4\xf5\xfc\xe5\xf6\xfd\xe5\xf6\xfd\xe3\xf6\xfc\xe3\xf6\xfc\xe3\xf6\xfc\xe8\xfa\xfe\xe5\xf7\xfb\xe6\xf7\xfc\xe6\xf7\xfc\xe6\xf7\xfc\xe6\xf8\xfc\xe6\xf7\xfb\xe6\xf7\xfc\xe6\xf8\xfd\xe8\xf8\xfc\xe8\xf8\xfc\xe8\xf8\xfc\xe8\xf8\xfb\xe9\xf8\xfb\xe7\xf8\xfc\xe7\xf9\xfd\xe7\xf8\xfd\xe7\xf9\xfd\xe7\xf9\xfd\xe7\xf9\xfd\xe7\xf9\xfd\xe7\xf8\xfd\xe6\xf7\xfe\xe6\xf7\xfe\xe5\xf7\xfd\xe4\xf7\xfd\xe3\xf7\xfd\xe3\xf7\xfd\xe7\xf7\xfc\xe4\xf4\xf8\xe5\xf4\xf9\xe5\xf5\xf8\xe5\xf4\xf8\xe5\xf5\xf8\xe5\xf5\xf9\xe5\xf5\xfa\xe5\xf5\xfb\xe7\xf5\xf9\xe7\xf5\xf8\xe7\xf5\xf8\xe8\xf5\xf7\xe8\xf5\xf7\xe6\xf5\xf9\xe6\xf6\xf9\xe6\xf6\xfa\xe7\xf6\xfb\xe7\xf7\xfc\xe7\xf6\xfb\xe6\xf6\xfb\xe5\xf6\xfb\xe4\xf5\xfb\xe3\xf5\xfa\xe3\xf4\xfa\xe2\xf4\xfb\xe2\xf4\xfb\xe2\xf4\xfa'
 b'\x90\x97\x9d\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x91\x94\x9b\x91\x94\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x90\x93\x9a\x90\x94\x9a\x8e\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x90\x97\x9d\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8f\x95\x9b\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8f\x96\x9c\x8d\x94\x9a\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8e\x95\x9b\x8a\x91\x97\x89\x90\x96\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8e\x95\x9b\x8c\x93\x99\x8b\x92\x98\x8d\x94\x9a\x8e\x95\x9b\x8e\x95\x9b\x8e\x95\x9b\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8b\x92\x98\x8f\x96\x9c\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8d\x94\x9a\x8b\x92\x98\x8b\x92\x98\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8b\x92\x98\x8e\x95\x9b\x8c\x93\x99\x8c\x93\x99\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8d\x94\x9a\x8b\x92\x98\x8b\x92\x98\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8b\x93\x9a\x8b\x93\x99\x8c\x93\x99\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x8b\x92\x98\x89\x90\x96\x8e\x95\x9b\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99\x8c\x93\x99z\x81\x87nu{houkrx\x80\x87\x8d\x8e\x95\x9b\x8d\x94\x9b\x8d\x94\x9b\x8c\x93\x9a\x8b\x91\x97\x88\x8d\x91\x8c\x92\x97\x8c\x93\x99\x8b\x92\x98\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8c\x93\x99\x8b\x92\x98\x8b\x92\x98\x8d\x94\x9a\x8c\x93\x99\x8c\x93\x99^di=@B:<<AEFRUWtuu~\x80\x82\x83\x86\x89~\x80\x81xsoqi_~}}\x8c\x93\x98\x8b\x92\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x89\x90\x96\x8c\x93\x99\x8a\x91\x97\x8b\x92\x98\x8c\x93\x99\x8c\x93\x99\x8b\x92\x98t{\x80TYZ11/##\x1f))!<7+LB3PF7LC5JC8NH=tol\x8b\x92\x97\x8a\x91\x96\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x89\x90\x96\x8c\x93\x99\x89\x90\x96\x8a\x91\x97\x8a\x91\x97\x8b\x92\x98\x8c\x92\x98\x8b\x94\x99{\x83\x86_cdaeegljjkgmkgmkgjiegihbfeurp\x8c\x93\x98\x8a\x90\x96\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x89\x90\x96\x8c\x93\x99\x89\x90\x96\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x8b\x93\x9a\x81\x85\x8bIGEKLI\x8f\x97\x9e\x8d\x94\x9a\x8c\x94\x9b\x8d\x95\x9c\x8e\x95\x9c\x8f\x96\x9c\x8a\x91\x96\x87\x8b\x8f\x8a\x91\x96\x8a\x90\x96\x8a\x91\x97\x8a\x91\x97\x87\x8e\x94\x89\x90\x96\x8a\x91\x97\x8a\x91\x97\x8a\x91\x97\x89\x90\x96\x8b\x92\x98\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x97\x88\x8c\x94iij]a^\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x91\x97\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x87\x8e\x94\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x8a\x91\x97\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x96\x8a\x91\x99\x8c\x95\x9b\x8c\x95\x97\x88\x8f\x96\x88\x8f\x95\x85\x8c\x92\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x8b\x92\x98\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8f\x95\x86\x8d\x93\x82\x89\x8f\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x92\x98\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x8f\x95\x89\x8f\x95\x89\x8f\x96\x8a\x90\x96\x89\x8f\x95\x89\x8f\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x89\x92\x99\x88\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x8a\x8e\x95\x8b\x8e\x95\x8a\x8e\x95\x8a\x8e\x95\x8b\x8e\x95\x8b\x8e\x95\x8b\x8e\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x93\x9a\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x8b\x8e\x95\x8b\x8e\x95\x8a\x8d\x94\x87\x8a\x91\x89\x8c\x93\x8b\x8e\x95\x8b\x8e\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x93\x9a\x88\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x8a\x8f\x95\x8a\x8f\x95\x89\x8e\x95\x88\x8d\x93\x89\x8e\x94\x8b\x8e\x95\x8b\x8e\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x93\x98\x88\x91\x96\x88\x91\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x85\x8c\x92\x86\x8d\x93\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x8a\x8e\x95\x8b\x8e\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x93\x98\x88\x91\x96\x88\x91\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x84\x8b\x91\x86\x8d\x93\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x8a\x8e\x95\x8b\x8e\x95\x89\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8b\x92\x98\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x92\x98\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x89\x90\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x87\x8e\x94\x8a\x91\x97\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x8f\x95\x8a\x8f\x95\x8b\x8f\x96\x8b\x8f\x96\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x87\x8e\x94\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x88\x8f\x95\x8a\x91\x97\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x89\x8f\x95\x8b\x8e\x95\x8b\x8e\x95\x8b\x8e\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x88\x8f\x95\x87\x8e\x94\x86\x8d\x93\x87\x8e\x94\x89\x90\x96\x8a\x91\x97\x89\x90\x96\x88\x8f\x95'
 b'?ISCLXDN[HR_ITaLWcNZgO[hQ]jR^lVbpVbpVbpWcqWcqWcqam~UbnSalS_lQ]kS[jR\\fS\\iHSbHQaEN]BKY@JWCM\\FO`IScJVeLYgO\\jQ^kR_mT`pWcrWcsXdtXdtXdsXdtXdvVcqUarS_pO_lN\\kMYiLWfGSaHQaDM\\AKXDM\\EP`HRaKVfMYjO[kR^nTbqVcsXdt[gw\\hx\\iy]iy[gw[gwhr\x82YdrW]ha[faXcX\\iP^kO[jITdHQ_BLX?HS3?:5A=5C>:FD=HF>JH@LKBNMDPODRPFTRGWSHXUGWUQ``M[\\[g|IWVFUTDUSDVSCUTDPQBNNYDC>IM?KR>IQ3@;7C?8D@=GF?JIAKJBNLCONEQOGSQHURGVSHWUJXXKXYT^aXd{KXXIWWIVVHTUGTSFRPEOPBHI:GA7E?5D>4@>7BB9EE>IK@KLBMNDNPFPRGQSGSULXZLY\\N[_T^gV]dglrr}\x90XbeQ[`X_bOVYIRSFORBNL=GD:FB8D>6B:7B<9D?;FC@JGCKHEMJFNKGOMHQNHROJUPKVQLVRLWTJUP[eh[i\x7fJTNIRMGQLEPJCMGCKG@KH>HE:FC8DA8C@6A98D;:E=?JCALGDOJDOLGRPJUSKXVO\\\\R^aS_bUaeVacmv\x7f`m\x80XclWcjVbkValT`kS_jR]jMXeLUcJR`HO^ENXHQ\\KT`PZhR]lVapXcrZet]hw_kybn|dp}eq\x7ffq~gq}py\x8d`l\x86alw^ju\\ht[erXbnV`kT]iMWcKUaIR_FNZGN^JQ`KTbOYgQ[iT^lWamYco[eq]gq_iuakwblxdlwdnyfr\x8aP`|bju`it^gt\\fqZdnXbmV`lQ\\hMZfJVcHR_JUgLYjN]oSbtWeyYg{\\j}^m\x7f_n\x80ap\x82eq\x85ds\x84ds\x83cq\x81nz\x84et\x9bEUs[jqWelSbfP^aMZ]HUWFRP?KG;HA8E=4A8>LPBPTERZFSVFTVFTVHTSHUPHUNJWPMYSKWPJWMCQE_k_]n\x978J^CQBCQ@@O=?M;=I9;G8:G87D56B44@32>13?/6A25A36B49D5;F7>I;@K>@K><F<;G:BM@T^TZe\\\x9d\xa6\xa0u\x87\xadARhFRDEQEEPCCNB@K@=I>:F;7C85@53>52=43<45?65B6:E:9E;9E<7B6;F=S\\\\fpp\x8b\x96\x97\xa3\xad\xb3\xba\xc2\xcb\xc5\xce\xd7\xca\xd1\xdb\xad\xba\xd0Zn\x9bBL?AJ>?H=:E89F78E87C56A63?41<2/:1/901;21>20;.6B7ITN`jh\x80\x89\x8a\x9f\xa7\xae\xbd\xc5\xcf\xcd\xd5\xdf\xca\xd3\xdc\xc6\xce\xd9\xc0\xcc\xd3\xc4\xce\xd4\x89\x9a\xb4Wq\xa0HTOKWQNZTOZVQ[YPYYLWUDOI2>30<0/;/.8//902=3\\fe\xa7\xb0\xb4\xc2\xcb\xd2\xc3\xcb\xd6\xc4\xcc\xd8\xc6\xce\xd9\xc1\xc9\xd3\xc3\xcb\xd5\xc1\xca\xd4\xbe\xc7\xd1\xbc\xc4\xcd\x9f\xab\xbdLg\xa0Ib\x97fmq^dfV\\]LUNFPF@J@<F<7B46B44@22>1-7/091/70\xc6\xce\xd8\xd1\xda\xe4\xcb\xd4\xdd\xc0\xc9\xd2\xbb\xc4\xd0\xb9\xc3\xcc\xb3\xbc\xc5\x9e\xa7\xb1\x8f\x97\xa2\xb4\xbd\xc5\x9f\xab\xbaQd\x93J^\x87Ga\x86AK<BJ<AJ<AK?AJ>?I<<F88C66B44@23>2+:*):\'GUP\x8d\x96\xa0\x8e\x98\xa1\x8d\x97\xa0\xa5\xaf\xb8\xb0\xb8\xc2\xa2\xa9\xb2\x95\x9f\xa6\x9f\xa6\xaev\x84\x98>Q\x829J{8S\x80Pr\x8f\x86\x93\x98AO;BO:AN8@L6>J4;G3:G46C03@-1>*/<)dsvScaguydnwZdnblv{\x86\x8f\xa6\xb0\xb9\x90\x9a\xa4\x8d\x96\xa1q{\x8e8Gu4Ew9T~[w\x8b\x8a\x8f\x99{~\x81BR;BQ:AP9@N:?L:=I:;G98D69F99F99G;eoy\x8c\x97\xa0\x9f\xaa\xb3\xcc\xd5\xdf\xc4\xcd\xd6\xb9\xc3\xca\xac\xb5\xbe\x9f\xa9\xb2\x94\x9d\xa5\x97\xa1\xa7AOu7Fn=Z\x81`w\x8a}\x80\x84pvzanwlv\x85nv\x85mu\x85s{\x87w\x80\x8ay\x85\x8e\x80\x8b\x95\x87\x91\x9b\x88\x93\x9c\x88\x93\x9c\x84\x8f\x99fow=EO\x8b\x95\x9c\xc3\xcd\xd6\xb6\xbf\xc7\xa5\xae\xb6\x9c\xa3\xab\x8d\x94\x9d|\x85\x8fJVl8LlHo\x9a|\x8b\x9a\x97\xa1\xa8\x96\x9f\xa9\x9c\xa3\xae\xa1\xaa\xb3\x93\x9b\xa3\x8b\x95\x9a\x98\xa3\xaa\x91\x9a\xa2\x89\x91\x99\x7f\x89\x90w\x7f\x85cjpZbiNV^IQZ`iqXblu~\x87\xb0\xba\xc1\xa2\xac\xb2\x8f\x97\x9e\x87\x91\x97cn|-7O\'0ILZgK\\g\x7f\x89\x8c\x8e\x96\x9d\x87\x8f\x97y\x82\x8arz\x82SZa;AFQW^=EN:AJ:AJ,5;BJSGOXFLXEKX\x15\x1b"FQ[JS]mu~mv~cjsPWb7?M6>M?FOCJT6:A-5=*07\x1a!)+19DIP\x87\x8f\x99V^gX`jV^iV]iT\\g>HPKUaIQ]FNZCKW\x11\x14\x19)3:3=D5<A:AH;AH9>C28=4;A2:B)373>@@FPS\\h>GQLU^!\'0^enp|\x87T_jU^iS\\fS[fR[ePYdNWcMVaLT_\x1e%+\'/6CKX\x1a\x1e%\x1c &17>NXcS]iWalXbn^hs_gr_gp_hrYbk;BI\x1e%-07?\\cl]dn\\bj\\ak\\ak[blU\\fQ[eNXbKU_<COIR]NWc\x16\x1a#!\'05;D]fs\\fq]gq]gs]fr\\ep[dnZeoFPY\x15\x1b"5;B5;BLUaX]c\\]bPXcQZdSXcPU_QV]OT[LQYFO[GP]JT_\x1d#-07@3;DU^jS]hS]iR\\hIR^?HS@IS?HQ.8A\x1a", (0LRZW\\e]^bXY_QXaQX`OT]OT\\RV\\QTZNRW*38/9@4>G\x1f\'/\x17\x1d%$,3-6=.7?2:D/9B,5=\'/4+27-26).3%)0#)0LQYPSZPU^QVbSWbRWaPWaMU_LT]JR[HOY'
 b'nz,|\x88>v\x82;cn,eq)r}8p{;cr.l{:w\x86H\\h%t\x7f=x\x82Doy=n{:ix8n|Bn|4jv*\x7f\x8aBv\x82>\x88\x93R~\x88Lbk0is6jt6\x86\x90Ris3iu(lx/jv0_j(fq/]g)ep3ix5w\x86Cs\x81ET_\x1foz8~\x88Jdn3eq3o}?mzCw\x84Ip|/{\x87:u\x816w\x839\x83\x8fHku4W_-Q[\x1fmx3u\x80?~\x8a=my/_j$mx5^g,\\e.do5m{:v\x86?t\x82G^i,ny6\x7f\x89Lmw;U`*_k7q~Jv\x81Ohs,{\x87=r\x7f2\\h\x1beq\'hr0QY*_h0v\x81<\x80\x8bIlw.t\x7f:gt0\x7f\x89KowAen9}\x88Om|?[g$q\x7f@bo5t\x80<v\x81Ax\x83EnwE.5\x14!\'\x11w~`\x8d\x95gv{=\x89\x8eGs|6iu1`k(`j.\x7f\x87Qkr>s|;t~6cn-N[\x1e\x84\x8dRoy>kt9\x81\x8ePr\x82DZc%eu1_l8v\x80B|\x86H|\x86G\x7f\x8bKDM(\x0b\r\rCH9\x9f\xa6\x84\xa1\xa4i\x99\xa0Yx\x88Gn\x7fDjzBixGu\x81UclLIS!{\x85:gr1DQ\x19\x9a\xa4g\x8c\x96Ylv:~\x8aIx\x87EMY\x1cXj)blJiqG\x82\x8cZ\x7f\x8aPo\x7fCUd@-63\x17\x1e\x19\x91\x97\x87\xa8\xb2\x8f\x91\xa6yl\x89br\x8brr\x89vn\x85um\x81vZie7F%v\x806fq0P]#\x94\x9e^\x89\x93Tx\x82C~\x89E\x91\x9d^P`,K])`j^\x80\x8bx\x8b\x98|z\x88ccwPQePFVY\x0c\x15\x1ebgv\x90\x9e\xa4u\x8d\x8fk\x87\x8eh\x82\x92k\x85\x96g\x82\x91s\x8c\x98dw\x83DU={\x84Aeq.cq-\x8a\x95S\x8b\x96S\x88\x94P\x87\x91L\x98\xa0gRc>.A\x1e\\mq\x8b\xa0\xa2\x84\x9a\x98m\x84~l\x83\x81cy\x81Ods(8B08I\x85\x97\xa9r\x85\x9bx\x86\xa3o\x84\xab\xa3\xbc\xd8f\x80\xa0\x83\x9d\xad\x81\x95\x9ebqW~\x86Jku2s\x836\x90\x97P\x95\x9cZ\x8f\x97Z\x9b\xa3k\x95\x9evViV\x16(\x18g~\x89\x83\xa0\xac~\x9a\xa8i\x85\x96az\x90e~\x96_z\x90J`h(;?r\x89\x92\x86\x98\xaa\x8b\x94\xb0r\x86\xb2\x93\xaa\xcey\x8e\xa8\x8a\x9e\xa2\x84\x93\x8av\x81[\x80\x89J\x8c\x94S\x84\x96J\x94\x9ea\x96\x9eo\x8c\x95w\x8f\x9a\x88\x84\x94\x8bk\x82\x85\'8=}\x95\x9f\x81\x9e\xadz\x97\xa9k\x87\x9cD\\sTq\x85`\x84\x95Tn\x7fHguk\x86\x97\x89\x9e\xb6{\x8b\xab~\x95\xb7\x86\x9c\xb5\x9b\xa8\xa0{\x84nX_:is;\x87\x90X\x8f\x98w\x8b\x9b\x96n\x85\x95g\x80\x98z\x8c\xa5\x8f\x9d\xb7j\x7f\xa5\x80\x95\xb2y\x8d\x9d\x87\xa2\xb0v\x93\xa7q\x8d\xa4p\x8c\xa6=Wn<Uii\x82\x96b~\x95g\x86\xa4\x7f\x97\xb1\x8d\x9d\xa8\x94\xa1\x96\x84\x91j~\x8aXpy6FN\x18dm7r}9\x7f\x88Sw\x82jm\x80\x92\x87\x8f\xa5j~\x9f\x9c\xad\xc8\xbe\xce\xe4m\x8a\xb1w\x8e\xacx\x8e\x9f\x7f\x9c\xafn\x8a\xa1p\x8c\xa6q\x8c\xa9Ni\x81,BWk|\x93n\x8b\xa1m\x8e\xaa\x88\xa0\xb6drkalBgr4x\x83@r}4W`(NW#hs2~\x8aAo\x7fPh\x81}\x9c\xa4\xbbz\x97\xbbq\x90\xb2\x85\xa2\xbfw\x98\xb8\x85\x9d\xb0\x87\x9e\xabt\x90\xa4g\x82\x99k\x86\xa2k\x87\xa4a}\x94/CXEQhy\x97\xacz\x9b\xb2\x88\x9f\xacLZB\\f(nx5{\x86Dq\x80=`k6CK\x1aPZ"\x88\x95Iz\x86Iu\x82a\x8c\x9a\x98\x8a\x9f\xa1\x8f\xa6\xa7\x8b\xa0\xa3\x89\x9d\xa1\x91\xa4\x97\xa2\xb5\xa2o\x85|\\tyc\x80\x93e\x86\x9cl\x8a\x9d3C]\x11\x1a+y\x92\xab\x8d\xa9\xbf|\x91\x93UcA`j,gq2\x80\x8aMp};hq:AI\x1a:B\x16\x82\x8dEkv2u}HcrAp~N\x86\x94co|QVb>`o=\x96\xa5m`s>[qJt\x8d\x84bz\x96n\x89\xa69Mh\x14\x1d-y\x87\xa1\x9c\xb4\xc7fyrSa9fp4ak.pz>w\x82>lv:W^0AH x\x84<fr(my1kv-v\x829\x84\x8fFp{7hp9QZ\x1d\x85\x8fMS^!bq/~\x8f^\\hkh\x7f\x90C[q\x13\x1f.^bw\x98\xab\xb6WiVN],co0ak/eo3~\x89Feo2V^.JR&w\x83=q}7y\x858v~;v~;\x8e\x97S\x82\x89JrxC=B\x13gm;EK"s}Amz4nxGdw_Mcg\x0f\x1e#ECT{\x88\x8cP`@Tc)Xe&^h,bl0\x84\x8fLdo0ck6QY(\x8a\x96O{\x85Et~<\x92\x9fZ{\x88AZg#gt0\x91\x9eYozDCM\x1e]i,LV!kt@ir;qx<MY.\x1b-\x15;=GDJN8C#z\x8aDq\x80<[e+jt6s~;y\x84Cnx;[e+z\x86=\x82\x8dG{\x86Ax\x83Bu\x80;hr4Q[\x1ew\x83:\x80\x89Q-5\x0blu@MV oy<ak/jp2dn37H \x1b\x1e(EKYDN=p\x80;x\x86BWa*do/u\x7f>q|:\x7f\x8aGhs4\x81\x8cH\x8b\x96Ru\x80;r};hs0pz>pz<v\x824u\x7f?AJ\x18jr<hq9pz@mw8en\'hs-ds@JP[\x84\x8f\x9dbocl{>w\x83Bhq:q{<lw5do.mx5z\x84F\x84\x8eO\x8c\x97T{\x86@\x8c\x97Q\x89\x94P`i2PY$n{.nz3S\\#_h/S[\'s|Hs~=eq\'Zg\x1afr2hty\xa3\xb5\xc5z\x89\x86_o:mx9oyBx\x83Dak*hr1Wa mw8t}Dy\x84C\x88\x94Lz\x86<\x81\x8cFGO\x1c7?\x16OZ\x19ht+ny3q{>=E\x16qyJ\x80\x8bHu\x83;P]\x12ku+LaY\x91\xa9\xba\x8c\x9e\xa4O^1kv8u~Glw8gr1Ze#`k(cm.lu=s}?\x94\xa0Xt\x7f7\x86\x92LPZ!bk8Zc*NZ\x1a\x82\x8dE\x83\x8eN^g2en=\x82\x8dM\x86\x93Q]h#nv-AUA\x83\x99\xa8\x9d\xac\xb1JX/lq7x\x80Goz:q|;dp.fr/kv6js:t}C\x99\xa5^u\x80>hs2bm,dn0\\f.pz=t\x7f@w\x81Bu\x7fCXa*]f/\x80\x8bLbm*hr2[^9\x92zy\xc2\xa3\x95ea2ps3\x82\x8aIp{9v\x81?o|9jx6^m-dn1nw>do/~\x8aDep.x\x83Deo5T]\'u\x80A}\x89Aiu.jt2fp2\\f+Wb\x1cq}0cn&\x80\x818\xb2n0\xf4mL\x9cN"gn+t\x84@bm-it2cp/We(R_(s}=kt>FP\x17\x83\x8fFfq.@J\x15OX"T^!bm+}\x89@p{3ny4ak*gq3[f"jv-kw2ix2\x94\x85C\xc4|T\x83W-]]\'s~=hs3hs1q\x7f8\\k\'\\j/oz7U^,8B\rnz1ep-DN\x18ku9S_\x19>I\tdp+eq*mx2[f#Yd$[f&lv5jt5eo5\x7f}D|o8_f(^f\'ku3s~<^i)x\x87<Wg\x1c_n,ny/Yc+MZ\x1cco+u\x80:w\x82=\x83\x8fGZf\x1eEO\x12GQ\x15mw6lx2ao\'Zj\'R^"dn/ny6Zb-ry?oz3`n.ak)]i(r\x81;Q^\x1cx\x87?Sb cr-'
 b'\x9d\xb4\xd1\x9b\xb1\xce\x9b\xb1\xce\x99\xb2\xce\x98\xb2\xce\x98\xb2\xce\x98\xb2\xce\x98\xb2\xce\x98\xb2\xce\x98\xb2\xce\x97\xb1\xcd\x97\xb1\xcd\x98\xb0\xcd\x99\xaf\xcc\x97\xad\xca\x97\xad\xcb\x97\xad\xcb\x93\xac\xc8\x91\xaa\xc7\x90\xa9\xc6\x90\xa9\xc6\x90\xa9\xc6\x8f\xa8\xc8\x8e\xa6\xc7\x8e\xa6\xc7\x89\xa3\xc2\x84\xa0\xbd\x83\x9f\xbcl\x96\xc4l\x94\xc2l\x95\xc3k\x96\xc3j\x96\xc3j\x96\xc3j\x96\xc3j\x96\xc3j\x96\xc3j\x96\xc3h\x94\xc0g\x93\xc0h\x93\xc0h\x91\xbfg\x90\xbeg\x90\xbee\x8e\xbc^\x8b\xb7\\\x8a\xb6[\x88\xb4Z\x87\xb3[\x88\xb5[\x87\xb7W\x84\xb5Q~\xaeLy\xaaGw\xa8Du\xa6l\x98\xcak\x96\xc8l\x97\xc9k\x98\xcak\x99\xcak\x99\xcak\x99\xcak\x99\xcak\x99\xcak\x99\xcah\x96\xc7f\x94\xc5g\x95\xc6g\x94\xc5e\x93\xc4e\x92\xc3b\x8f\xc1[\x8d\xbcZ\x8c\xbc[\x8d\xbcZ\x8c\xbbY\x8b\xbbX\x89\xbdS\x84\xb8M~\xb2J|\xb0Gz\xb2Ey\xb2~\x9d\xcb}\x9c\xca~\x9d\xcb}\x9f\xcc}\x9f\xcc}\x9f\xcc}\x9f\xcc}\x9f\xcc|\x9e\xcb{\x9d\xcaz\x9c\xc9x\x9a\xc7v\x9b\xc7u\x9b\xc6s\x99\xc5q\x97\xc3p\x96\xc1i\x94\xbeh\x92\xbcg\x91\xbbd\x8f\xb9d\x8e\xb9c\x8d\xba`\x8a\xb7[\x85\xb2Y\x83\xb0V\x83\xaeS\x82\xad~\xa1\xd5~\xa0\xd3\x80\xa3\xd5~\xa3\xd5}\xa3\xd5}\xa4\xd5}\xa4\xd5}\xa4\xd6|\xa3\xd5{\xa2\xd4{\xa2\xd4y\xa0\xd2w\xa0\xd1t\xa0\xd0r\x9f\xcft\xa0\xd0s\x9f\xcfk\x99\xc8g\x96\xc5f\x94\xc4e\x94\xc3f\x94\xc4d\x93\xc5a\x90\xc2[\x89\xbbY\x88\xb9U\x88\xb5S\x87\xb4\x83\xa6\xd7\x83\xa5\xd5\x85\xa6\xd7\x84\xa7\xd7\x84\xa7\xd8\x84\xa7\xd7\x84\xa7\xd7\x84\xa7\xd7\x80\xa6\xd7~\xa6\xd8|\xa5\xd6{\xa3\xd5z\xa3\xd4y\xa3\xd4y\xa3\xd4x\xa2\xd3v\xa0\xd1p\x9e\xcdn\x9c\xcbm\x9b\xcal\x9a\xc9j\x98\xc8f\x96\xc6c\x93\xc3^\x8e\xbe[\x8b\xbbX\x8a\xb8V\x88\xb7\x89\xa9\xd8\x88\xa8\xd6\x8a\xaa\xd8\x8a\xa9\xd8\x8a\xa9\xd8\x8a\xa9\xd8\x8a\xa9\xd8\x8a\xa9\xd8\x86\xa9\xd8\x83\xa9\xd8\x82\xa8\xd7\x80\xa6\xd5\x7f\xa5\xd4\x80\xa6\xd5\x7f\xa5\xd4}\xa3\xd2{\xa1\xd0v\xa1\xcet\x9f\xccs\x9e\xcbr\x9d\xcao\x9b\xc8k\x99\xc5h\x96\xc2d\x92\xbea\x8f\xbb_\x8d\xb9]\x8c\xb8\x8e\xad\xd9\x8d\xac\xd7\x8f\xad\xd9\x8f\xad\xd9\x8f\xad\xd9\x8f\xad\xd9\x8f\xad\xd9\x8f\xad\xd9\x8c\xad\xd9\x89\xad\xda\x88\xab\xd8\x86\xaa\xd6\x84\xa8\xd5\x84\xa7\xd4\x84\xa7\xd4\x83\xa6\xd3\x82\xa5\xd2|\xa4\xcfz\xa2\xcey\xa1\xcdx\xa0\xcbv\x9e\xc9r\x9d\xc7n\x9a\xc4l\x97\xc1i\x94\xbeg\x92\xbce\x91\xbb\x95\xb2\xda\x94\xb0\xd8\x95\xb1\xd9\x95\xb1\xd9\x95\xb1\xd9\x95\xb2\xda\x95\xb2\xda\x95\xb2\xda\x93\xb1\xda\x91\xb1\xdb\x90\xb0\xda\x8f\xaf\xd9\x8d\xad\xd7\x8b\xab\xd5\x8a\xaa\xd5\x8a\xaa\xd4\x88\xa8\xd2\x83\xa8\xd0\x82\xa6\xcf\x80\xa4\xcd\x7f\xa2\xcb|\xa1\xc9x\xa0\xc7u\x9d\xc5s\x9b\xc2p\x98\xbfn\x96\xbdl\x94\xbc\x9b\xb6\xdb\x9a\xb5\xda\x9c\xb7\xdc\x9c\xb7\xdc\x9c\xb7\xdc\x9c\xb7\xdc\x9d\xb8\xdc\x9d\xb8\xdd\x9a\xb6\xdc\x98\xb4\xdc\x98\xb4\xdc\x98\xb4\xdc\x96\xb2\xda\x94\xb0\xd8\x93\xae\xd6\x91\xac\xd4\x8f\xab\xd2\x8b\xab\xd1\x89\xa9\xd0\x88\xa8\xce\x86\xa6\xcd\x83\xa4\xca\x7f\xa3\xc8}\xa1\xc6y\x9e\xc3v\x9a\xc0t\x98\xbdr\x97\xbd\xa5\xbe\xdd\xa4\xbc\xdb\xa5\xbd\xdd\xa3\xbc\xdb\xa3\xbb\xda\xa3\xbb\xda\xa3\xbb\xda\xa3\xbb\xda\xa4\xbb\xdc\xa4\xbb\xdd\xa4\xbb\xdd\xa4\xbb\xdd\xa4\xbb\xdd\xa3\xba\xdc\xa1\xb8\xda\x9f\xb6\xd8\x9d\xb4\xd6\x98\xb2\xd3\x98\xb2\xd2\x95\xae\xce\x94\xae\xce\x92\xae\xcd\x8d\xac\xcb\x8b\xaa\xc9\x86\xa5\xc5\x82\xa2\xc1\x80\xa0\xc0~\x9e\xbf\xab\xbf\xda\xa9\xbc\xda\xaa\xbd\xdd\xaa\xbd\xda\xaa\xbe\xd7\xaa\xbe\xd7\xaa\xbe\xd7\xaa\xbe\xd8\xab\xbe\xda\xab\xbd\xdb\xaa\xbd\xdb\xaa\xbc\xda\xa9\xbd\xdb\xa7\xbc\xdb\xa5\xba\xd9\xa4\xb9\xd8\xa2\xb7\xd6\x9c\xaf\xcc\x9b\xa9\xc0\xad\xb8\xcb\xa7\xb5\xc8\x8f\xa3\xb8\x85\xa1\xb9\x83\xa0\xba\x8a\xa6\xc4\x88\xa4\xc4\x83\xa1\xc2\x81\xa0\xc2\xaf\xbf\xd7\xaf\xbe\xd7\xb1\xc0\xda\xb3\xc2\xd9\xb1\xc1\xd5\xb0\xc0\xd5\xb0\xc0\xd4\xb0\xc0\xd5\xb1\xc0\xd7\xb0\xbf\xd8\xaf\xbe\xd7\xb0\xbe\xd8\xad\xbe\xd8\xab\xbd\xd8\xa9\xbb\xd7\xa8\xbb\xd6\xa6\xb8\xd3\x9f\xab\xc3\x98\x9e\xaf\xcc\xd0\xdb\xb7\xbe\xca\x84\x95\xa4}\x96\xa9~\x98\xae\x8d\xa6\xc1\x8c\xa5\xc3\x86\xa2\xc1\x84\xa1\xc0\xb4\xc0\xd3\xb3\xbf\xd0\xb5\xc1\xd0\xb6\xc2\xd1\xb8\xc4\xd3\xb2\xbf\xce\xb1\xbd\xcd\xb9\xc5\xd4\xb9\xc3\xd5\xb7\xc1\xd4\xb5\xbe\xd2\xb7\xc1\xd4\xb3\xbe\xd2\xb0\xbd\xd2\xaf\xbc\xd1\xad\xba\xcf\xab\xb7\xcd\xab\xb1\xc3\xba\xbb\xc6\xe8\xe9\xef\xd6\xdc\xe4\xa5\xb3\xbf\x98\xad\xbc\x95\xab\xbc\x93\xa8\xbf\x90\xa5\xbe\x8b\xa3\xbb\x88\xa1\xb9\xb8\xbe\xc8\xb7\xbe\xc5\xb9\xc0\xc5\xba\xc1\xc8\xb5\xbc\xc5\x85\x8b\x94fmv\x94\x9b\xa4\xcf\xd4\xde\xd6\xd9\xe4\xcd\xd0\xdb\xce\xd1\xdd\xc7\xcb\xd8\xc1\xc7\xd5\xbf\xc5\xd3\xaf\xb5\xc2\x89\x8f\x9d\xcf\xcd\xd7\xdb\xd6\xd9\xe2\xde\xde\xd1\xd4\xd7\xa8\xb3\xba\x9e\xaf\xb7\x9c\xac\xb7\x98\xa7\xb8\x97\xa6\xb8\x90\xa3\xb3\x8e\xa2\xb2\x8d\x8f\x8a\x89\x8b\x87\x8c\x8e\x8b\xab\xac\xac\x94\x95\x98NNQ:;>qru\xe3\xe1\xe4\xfa\xf7\xf9\xd2\xce\xd1\xd8\xd4\xd7\xd7\xd4\xd8\xd0\xcf\xd4\xde\xdd\xe2\xbf\xbf\xc4TTZ\xf6\xee\xee\xf4\xeb\xe7\xe7\xdf\xda\xca\xca\xc8\xa4\xac\xae\x9d\xa9\xab\x9a\xa6\xaa\x95\x9f\xa9\x95\x9f\xaa\x92\xa0\xa8\x8a\x99\xa0A@+CA3USK\xb9\xb6\xb4\xc7\xc4\xc1\xbf\xbc\xba\xc3\xc0\xbd\xd6\xd4\xd1\xf7\xf1\xee\xff\xf7\xf3\xe1\xd8\xd4\xe3\xd9\xd5\xde\xd6\xd4\xd6\xcf\xce\xe0\xd9\xd8\xd7\xd0\xcfiba\xef\xe0\xd8\xe8\xd7\xcd\xdf\xd2\xc7\x9e\x9b\x95age\\eaRZXY`dW^cJSU9CC\x8c\x87p\xe3\xdd\xcd\xf4\xed\xe4\xeb\xd9\xd5\xe8\xd1\xcb\xe6\xcf\xc9\xe7\xd1\xcb\xe5\xcf\xc9\xe7\xd0\xc7\xe5\xcd\xc3\xea\xd2\xc8\xec\xd3\xc9\xea\xd9\xce\xdd\xd4\xc9\xc5\xbd\xb4\xb5\xaf\xa6\x99\x94\x8d}}jtvbx}kWbR:B6e`Z\xc8\xc2\xbd\xe3\xdc\xd9\xd5\xd3\xccl}e%:\x1e`ZO\xa0\x9a\x90\xbf\xb9\xb0\xd9\xcd\xc4\xb9\xab\xa0\xa1\x93\x89\xa7\x99\x8e\xa5\x97\x8c\xa0\x92\x85\xa9\x9c\x8c\xa5\x98\x88\xa0\x92\x83\xa6\x9e\x8d\x85\x84qTUCCF6;A4IN,FM+AJ+>J,:D)[^G\xa5\xa8\x91\x93\x95\x7ftzb6P.\x1e<\x19 \x1a\x18/*%[VM\x92\x8e\x7f\\XH51#?<,?<,;8&HE3@=,62"CA.AC+:>\'9@+09(LH\x1eIG\x1fDE\x1fAC\x1f>D!>G$FP->H%7C!/E&-E\'UMNTMIWQHyp_odSf[Lf\\Kf[Kg\\LdYJZO@QE7SG5WK4ZP;UM;FA1oaBj^?aX<_W=b]Da`Ga`G_^E\\\\DZ]IY\\I\x85xu\x7fslwkb\x8bwi\x97~p\x98\x7fp\x97~p\x99\x80q\x99\x7fs\x98~s\x93yn\x90vk\x91uh\x91sd\x8bpb\x86la|e[\x86qb\x82na|k`te[m_Wo^Ytc^yidvf`sc[qbY\x8awj\x89vj\x89vk\x8eug\x95yi\x96zk\x94xh\x94xh\x93wj\x93vk\x93vl\x92uk\x93ti\x93rh\x8fph\x8ang\x86lh\x80i^}h^{hawg`qb]gXUaROn_\\qb_n_Zk[U\x80hU\x80iY\x8cti\x80k\\\x87s`\x88ub\x85q_\x84q^\x85pa\x85pc\x85pc\x84ob\x84nb\x82kbze^yfayjg{gVxfVueWtfYrh\\kg[ebVTQDZWK_]U`^W{maoaVdUJ\x80ma\x83ma\x82m`\x80k^\x80k^}j\\zhZ|j\\{i[ygZzg]sbYN?8L@;rc[o`Xm^Vl]Vj\\UfZUeYScWQ_TOWSNKHCyi\\gWKp`T\x7fl_\x81k^\x80k]\x7fi\\\x7fi\\|hZyfXyfXxeWxeWwcVvdZcSK;.\'tdZo_Un]Tk[QhXOeVOcUN_PI[OHUSLNNFqbWn`TseZvdYvcXvbXuaWtaWtaVsaVq_Tp^Sp^Rp]Rm\\Sk\\UC82iZRgXOdULbSJ_QI]PK\\OJXJERGBJHBCD>\x8b\x82z\x8a\x81z\x8c\x83|\x8b\x80{\x8b\x7f{\x8b\x7f{\x8b\x7f{\x8b\x7f{\x8c\x7f{\x8c~{\x8c~z\x8b}z\x8b}x\x8a}v\x88}x\x85}yvonzpl\x83yu\x81ws\x81vs\x80wt~wv~wvyrqtnmllkghg'], shape=(10,), dtype=string)
tf.Tensor([100 100 100 100 100 100 100 100 100 100], shape=(10,), dtype=int64)
tf.Tensor([28 28 28 28 28 28 28 28 28 28], shape=(10,), dtype=int64)
tf.Tensor([28 28 28 28 28 28 28 28 28 28], shape=(10,), dtype=int64)