学习Tensorflow之基本操作
tensorflow
一个面向所有人的开源机器学习框架
项目地址：https://gitcode.com/gh_mirrors/te/tensorflow
免费下载资源
·
学习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搭建普通神经网络
普通神经网络的搭建有四种方式：
- 使用Model类逐层建立网络结构
- 使用继承Model类建立神经网络
- 使用Sequential内置序列化搭建网络结构
- 使用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)
GitHub 加速计划 / te / tensorflow
184.55 K
74.12 K
下载
一个面向所有人的开源机器学习框架
最近提交(Master分支：2 个月前 )
a49e66f2
PiperOrigin-RevId: 663726708
2 个月前
91dac11a
This test overrides disabled_backends, dropping the default
value in the process.
PiperOrigin-RevId: 663711155
2 个月前
旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。
更多推荐
0
0- 0
已为社区贡献3条内容
所有评论(0)