Search is not available for this dataset
name
stringlengths 2
88
| description
stringlengths 31
8.62k
| public_tests
dict | private_tests
dict | solution_type
stringclasses 2
values | programming_language
stringclasses 5
values | solution
stringlengths 1
983k
|
|---|---|---|---|---|---|---|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.util.*;
// ABC 6-C
// http://abc006.contest.atcoder.jp/tasks/abc006_3
public class Main {
public static void main (String[] args) throws java.lang.Exception {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = in.nextInt();
}
long answer = 0;
if (nums[0] == 0) {
answer = solve(nums, 0, 0);
} else {
answer = solve(nums, nums[0], 1);
}
System.out.println(answer);
//
// long sum = 0;
// long answer = 0;
//
// for (int i = 0; i < n; i++) {
// int a = in.nextInt();
//
// if (sum < 0 && sum + a < 0) {
// answer += 1 + Math.abs(sum + a);
// sum = 1;
// } else if (sum > 0 && sum + a > 0) {
// answer += 1 + sum + a;
// sum = -1;
// } else if (sum + a == 0) {
// answer++;
// if (sum < 0) {
// sum = 1;
// } else {
// sum = -1;
// }
// } else {
// sum += a;
// }
// }
// System.out.println(answer);
}
public static long solve(int[] nums, long sum, int index) {
if (index == nums.length) {
return 0;
}
if (sum < 0 && sum + nums[index] < 0) {
return 1 + Math.abs(sum + nums[index]) + solve(nums, 1, index + 1);
} else if (sum > 0 && sum + nums[index] > 0) {
return 1 + sum + nums[index] + solve(nums, -1, index + 1);
} else if (sum < 0 && sum + nums[index] > 0) {
return solve(nums, sum + nums[index], index + 1);
} else if (sum > 0 && sum + nums[index] < 0) {
return solve(nums, sum + nums[index], index + 1);
} else {
// sum == 0 or sum + nums[index] == 0
if (sum == 0) {
return 1 + Math.min(solve(nums, 1, index + 1), solve(nums, -1, index + 1));
}
// sum + nums[index] == 0
else {
if (sum < 0) {
return Math.abs(sum) + 1 + solve(nums, 1, index + 1);
} else {
return Math.abs(sum) + 1 + solve(nums, -1, index + 1);
}
}
}
// else if (sum + nums[index] == 0) {
// if (sum < 0) {
// return Math.abs(sum) + 1 + solve(nums, 1, index + 1);
// } else if (sum > 0) {
// return Math.abs(sum) + 1 + solve(nums, -1, index + 1);
// } else {
// return 1 + Math.min(solve(nums, 1, index + 1), solve(nums, -1, index + 1));
// }
// } else if (sum == 0) {
// return 1 + Math.min(solve(nums, 1, index + 1), solve(nums, -1, index + 1));
// } else {
// return solve(nums, sum + nums[index], index + 1);
// }
}
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using static MyIO;
public class C
{
public static void Main()
{
int n = GetInt();
long[] a = new long[n];
for(int i = 0; i < n; i++)
a[i] = GetLong();
long sum = a[0];
long ans = 0;
for(int i = 1; i < n; i++)
{
if(Math.Sign(sum) == 1)
{
long need = - (sum + 1);
if(a[i] <= need)
{
sum += a[i];
}
else
{
ans += a[i] - need;
sum += need;
}
}
else
{
long need = - (sum - 1);
if(a[i] >= need)
{
sum += a[i];
}
else
{
ans += need - a[i];
sum += need;
}
}
}
Console.WriteLine(ans);
}
}
public static class MyIO
{
private static string[] args = null;
private static int num = -1;
private static int used = -1;
private static string getArg()
{
if(used == num)
{
args = Console.ReadLine().Split(' ');
num = args.Length;
used = 0;
}
return args[used++];
}
public static int GetInt(){ return int.Parse(getArg()); }
public static long GetLong(){ return long.Parse(getArg()); }
public static double GetDouble(){ return double.Parse(getArg()); }
public static string GetString(){ return getArg(); }
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
total = 0
fugo = 0
count = 0
for i in a:
if(fugo == 0):
total = i
if(total > 0):
fugo = 1
else:
fugo = -1
continue
total += i
if(fugo > 0 and total < 0):
fugo = -1
elif(fugo < 0 and total > 0):
fugo = 1
elif(fugo > 0 and total >= 0):
fugo = -1
while(total>=0):
count += 1
total -= 1
elif(fugo < 0 and total <= 0):
fugo = 1
while(total<=0):
count += 1
total += 1
print(count) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <iostream>
#include <string>
#include <vector>
#include <numeric>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <stack>
#include <map>
#include <set>
#include <ios>
#include <cctype>
#include <cstdio>
#include <functional>
#include <cassert>
#define REP(i,a) for(int i = 0;i < (a);++i)
#define FOR(i,a,b) for(int i = (a);i < (b); ++i)
#define FORR(i,a,b) for(int i = (a) - 1;i >=(b);--i)
#define ALL(obj) (obj).begin(),(obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond,yes,no){cout <<((cond)?(yes):(no))<<endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(),(list).rend())
#define ASSERT(cond,mes) assert(cond && mes)
using namespace std;
using ll = long long;
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template<typename T>
T round_up(const T& a, const T& b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2>& p) {
os << p.first << p.second;
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
REP(i, (int)v.size())is >> v[i];
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
REP(i, (int)v.size())os << v[i] << endl;
return os;
}
template <typename T>
T clamp(T& n, T a, T b) {
if (n < a)n = a;
if (n > b)n = b;
return n;
}
template <typename T>
static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T>
static T LCM(T u, T v) {
return u / GCD(u, v) * v;
}
template <typename T>
static int sign(T t) {
if (t > 0)return 1;
else if (t < 0)return -1;
else return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
std::cout << fixed << setprecision(20);
int N;
cin >> N;
vector<int>A(N);
cin >> A;
ll cnt = 0;
ll sum = A[0];
if (sum == 0) {
cnt++;
sum = 1;
}
FOR(i, 1, N) {
ll next = sum + A[i];
if (sign(next) == 0 || sign(next) == sign(sum)) {
cnt += abs(next) + 1;
next = -sign(sum);
}
sum = next;
}
sum = -sign(A[0]);
ll cnt2 = A[0] + 1;
if (sum == 0) {
cnt++;
sum = -1;
}
FOR(i, 1, N) {
ll next = sum + A[i];
if (sign(next) == 0 || sign(next) == sign(sum)) {
cnt2 += abs(next) + 1;
next = -sign(sum);
}
sum = next;
}
cout << min(cnt, cnt2) << endl;
return 0;
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <string>
#include <string.h>
#include <bitset>
#include <map>
#include <climits>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> an(n);
for (int i = 0; i < n; ++i)
{
cin >> an[i];
}
int accum = 0;
int sign = 0;
bool non_zero = true;
int cnt = 0;
for (int i = 0; i < n; ++i)
{
auto new_accum = accum + an[i];
if (i == 0)
{
if (new_accum == 0)
{
int next_sign = an[1] > 0 ? 1 : -1;
new_accum -= next_sign;
++cnt;
an[0] = -next_sign;
}
accum = new_accum;
sign = accum > 0 ? 1 : -1;
}
else
{
if (new_accum * accum >= 0)
{
// new_accum + x = -sign
int x = -sign - new_accum;
new_accum += x;
cnt += abs(x);
an[i] += x;
}
int new_sign = new_accum > 0 ? 1 : -1;
accum = new_accum;
assert(new_sign == -sign);
sign = new_sign;
}
}
cout << endl;
cout << cnt << endl;
return 0;
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define repp(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define repm(i,n) for(int (i)=(n-1);(i)>=0;(i)--)
#define INF (1ll<<60)
#define all(x) (x).begin(),(x).end()
typedef long long lint;
const lint MOD =1000000007;
const lint MAX = 10000000;
using Graph =vector<vector<lint>>;
typedef pair<lint,lint> P;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(lint n, lint k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num)
{
if (num < 2) return 0;
else if (num == 2) return 1;
else if (num % 2 == 0) return 0;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return 0;
}
}
return 1;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
lint lcm(lint a,lint b){
return a/__gcd(a,b)*b;
}
lint gcd(lint a,lint b){
return __gcd(a,b);
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(){
lint N;
cin >>N; lint A[N];
rep(i,N)cin >> A[i];
lint ans=0;
lint sum=A[0];
if(sum<0){
ans+=abs(sum)+1;
sum=1;
}
rep(i,N-1){
sum+=A[i+1];
if(sum<=0&&sum-A[i+1]<=0){
ans+=abs(sum)+1;
sum+=abs(sum)+1;
}else if(sum>=0&&sum-A[i+1]>=0){
ans+=abs(sum)+1;
sum-=(abs(sum)+1);
}
}
lint ans2=0;
lint sum2=A[0];
if(sum2>0){
ans2+=abs(sum2)+1;
sum2=-1;
}
rep(i,N-1){
sum2+=A[i+1];
if(sum2<=0&&sum2-A[i+1]<=0){
ans2+=abs(sum2)+1;
sum2+=abs(sum2)+1;
}else if(sum2>=0&&sum2-A[i+1]>=0){
ans2+=abs(sum2)+1;
sum2-=(abs(sum2)+1);
}
}
cout<<min(ans,ans2);
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
long long ans = INF;
long long sum = 0;
long long count = 0;
for (int i = 0; i < (n); i++) {
sum += a[i];
if (i % 2 == 0) {
if (sum <= 0) {
count += (1 - sum);
sum = 1;
}
} else {
if (sum >= 0) {
count += (sum - (-1));
sum = -1;
}
}
}
ans = min(ans, count);
sum = 0;
count = 0;
for (int i = 0; i < (n); i++) {
sum += a[i];
if (i % 2 != 0) {
if (sum <= 0) {
count += (1 - sum);
sum = 1;
}
} else {
if (sum >= 0) {
count += (sum - (-1));
sum = -1;
}
}
}
ans = min(ans, count);
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
using uli = unsigned long long;
uli gcd(uli a, uli b) {
while (1) {
if (a < b) swap(a, b);
if (!b) break;
a %= b;
}
return a;
}
uli lcm(uli a, uli b) { return a * b / gcd(a, b); }
const uli mod = 1000000007;
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
uli _PowMod(uli x, uli y, uli _mod) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x % _mod;
} else if (y % 2 == 0) {
auto tmp = _PowMod(x, y / 2, _mod);
return tmp * tmp % _mod;
} else {
auto tmp = _PowMod(x, y / 2, _mod);
return (tmp * tmp % _mod) * x % _mod;
}
}
uli PowMod(uli x, uli y) { return _PowMod(x, y, mod); }
uli getModInv(uli N) { return PowMod(N, mod - 2); }
lint nCrMod(lint start, lint n, lint r) {
if (n < r) {
return 0;
}
lint a = start;
for (size_t i = n; i >= n - r + 1; i--) {
a *= i;
a %= mod;
}
for (size_t i = 1; i <= r; i++) {
a *= getModInv(i);
a %= mod;
}
return a;
}
lint nHrMod(lint start, lint n, lint r) { return nCrMod(start, n + r - 1, r); }
lint _nCrMod(lint start, lint n, lint r) {
if (n <= 0) {
return 0;
}
return nCrMod(start, n, r);
}
struct uf {
vector<lint> p;
uf(lint n) : p(n) {
for (size_t i = 0; i < n; i++) {
p[i] = i;
}
}
lint rt(lint n) { return p[n] == n ? n : p[n] = rt(p[n]); }
void un(lint n, lint m) { p[rt(n)] = p[rt(m)]; }
bool eq(lint n, lint m) { return rt(n) == rt(m); }
};
bool lineCol(lint a1x, lint a1y, lint a2x, lint a2y, lint b1x, lint b1y,
lint b2x, lint b2y) {
auto ta = (b1x - b2x) * (a1y - b1y) + (b1y - b2y) * (b1x - a1x);
auto tb = (b1x - b2x) * (a2y - b1y) + (b1y - b2y) * (b1x - a2x);
auto tc = (a1x - a2x) * (b1y - a1y) + (a1y - a2y) * (a1x - b1x);
auto td = (a1x - a2x) * (b2y - a1y) + (a1y - a2y) * (a1x - b2x);
return tc * td < 0 && ta * tb < 0;
}
lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
lint _sMod(string n, lint mod) {
lint k = (n[0] - '0') % mod;
for (size_t i = 1; i < n.length(); i++) {
k *= 10;
k += (n[i] - '0');
k %= mod;
}
return k;
}
template <typename T>
void vsort(vector<T>& v) {
sort(v.begin(), v.end());
}
template <typename T>
void vsortr(vector<T>& v) {
sort(v.rbegin(), v.rend());
}
lint div2(lint p, lint q) { return (p + q - 1) / q; }
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
};
template <class T>
bool exist(vector<T>& v, const T& val) {
return find(v.begin(), v.end(), val) != v.end();
}
template <class T, class Pr>
bool exist_if(vector<T>& v, Pr pred) {
return find_if(v.begin(), v.end(), pred) != v.end();
}
lint n_dig(lint n) {
lint ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
string yn(bool f, string y, string n) { return f ? y : n; }
const lint alpn = 'z' - 'a' + 1;
template <class T>
T sgn(T val) {
if (val == T(0)) return T(0);
if (val < 0) return T(-1);
if (val > 0) return T(1);
}
int main() {
lint n;
cin >> n;
vector<lint> a(n);
for (lint i = 0; i < n; i++) cin >> a[i];
lint s = 0, sg = sgn(a[0]), ans = 0;
for (lint i = 0; i < n; i++) {
s += a[i];
if (sgn(s) != sg) {
ans += abs(sg - s);
s = sg;
}
sg *= (-1);
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | #include <bits/stdc++.h>
int sign(long long n) {
if (n > 0)
return 1;
else if (n < 0)
return -1;
return 0;
}
int myabs(long long n) { return (n > 0) ? n : (-n); }
int main(void) {
int n;
scanf("%d\n", &n);
long long a[n];
int i;
for (i = 0; i < n; i++) {
scanf("%lld ", &a[i]);
}
long long sum = 0;
long long sum_eval_prev = 0;
long long bias = 0;
long long cost = 0;
for (i = 0; i < n; i++) {
sum += a[i];
long long sum_eval = sum + bias;
if (sum_eval == 0) {
bias += 1;
cost++;
} else {
if (i > 0 && (sign(sum_eval_prev) == sign(sum_eval))) {
bias += -1 * sign(sum_eval) - sum_eval;
cost += myabs(-1 * sign(sum_eval) - sum_eval);
}
}
sum_eval_prev = sum + bias;
}
printf("%lld\n", cost);
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n;
int flag[100005], k[100005];
long long a[100005], sum[100005], ans, b[100005], tot[100005], ant;
int main() {
int m = 0;
scanf("%d", &n);
scanf("%lld", &a[1]);
b[1] = a[1];
sum[1] = a[1];
tot[1] = sum[1];
if (sum[1] > 0) flag[1] = 1;
if (sum[1] < 0) flag[1] = 0;
if (sum[1] == 0) m = 1;
if (m == 0) {
for (int i = 2; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = a[i] + sum[i - 1];
if (sum[i] > 0) flag[i] = 1;
if (sum[i] < 0) flag[i] = 0;
if (flag[i - 1] == 1) {
if (sum[i] >= 0) {
ans += sum[i] + 1;
sum[i] = -1;
flag[i] = 0;
}
} else {
if (sum[i] <= 0) {
ans += 1 - sum[i];
sum[i] = 1;
flag[i] = 1;
}
}
}
printf("%lld\n", ans);
} else {
ans = 1;
for (int i = 2; i <= n; i++) {
scanf("%lld", &a[i]);
flag[1] = 0;
b[i] = a[i];
sum[i] = a[i] + sum[i - 1];
if (sum[i] > 0) flag[i] = 1;
if (sum[i] < 0) flag[i] = 0;
if (flag[i - 1] == 1) {
if (sum[i] >= 0) {
ans += sum[i] + 1;
sum[i] = -1;
flag[i] = 0;
}
} else {
if (sum[i] <= 0) {
ans += 1 - sum[i];
sum[i] = 1;
flag[i] = 1;
}
}
}
k[1] = 1;
ant = 1;
for (int i = 2; i <= n; i++) {
tot[i] = b[i] + tot[i - 1];
if (tot[i] > 0) k[i] = 1;
if (tot[i] < 0) k[i] = 0;
if (k[i - 1] == 1) {
if (tot[i] >= 0) {
ant += tot[i] + 1;
tot[i] = -1;
k[i] = 0;
}
} else {
if (tot[i] <= 0) {
ant += 1 - tot[i];
tot[i] = 1;
k[i] = 1;
}
}
}
printf("%lld\n", min(ant, ans));
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
*a, = map(int, input().split())
ans = 0
if a[0] == 0:
a[0] = 1 if a[1] < 0 else -1
ans += 1
e0 = 1 if a[0] > 0 else -1
S = a[0]
for i in range(1, n):
e = e0 * int((i % 2-0.5)*2)
n = max(e*(S+a[i])+1, 0)
S += a[i]+(-e*n)
ans += n
print(ans)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n1=int(input())
l1=list(map(int,input().split()))
total=l1[0]
Num=0
for j in range(1,n1):
if total ==0:
total=total+1
Num=Num+1
pretotal=total
total=total+l1[j]
while (pretotal*total>0) or (total ==0):
if pretotal<0:
Num=Num-total+1
total=+1
elif pretotal>0:
Num=Num+total+1
total=-1
elif total==0:
Num=Num+1
total=total+1
print(Num)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mod = 1e9 + 7;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
bool posi;
long long sum[n];
sum[0] = a[0];
if (sum[0] > 0)
posi = true;
else
posi = false;
for (int i = 1; i < n; i++) {
long long sum_t = (long long)a[i] + sum[i - 1];
if (posi) {
posi = false;
if (sum_t >= 0) {
long long t = (long long)a[i] - sum_t - 1;
ans += abs((long long)a[i] - t);
a[i] = t;
sum_t = (long long)a[i] + sum[i - 1];
}
} else {
posi = true;
if (sum_t <= 0) {
long long t = (long long)a[i] - sum_t + 1;
ans += abs((long long)a[i] - t);
a[i] = t;
sum_t = (long long)a[i] + sum[i - 1];
}
}
sum[i] = sum_t;
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python2 | # -*- coding:utf-8 -*-
def sign(x):
if (x > 0):
return 1
elif (x < 0):
return -1
else:
return 0
n = int(raw_input())
numlist = (raw_input()).split(' ')
sumlist = [int(numlist[0])]
count = 0
for i in range(1, n):
sumlist.append(sumlist[i-1] + int(numlist[i]))
while ((sign(sumlist[i-1]) == sign(sumlist[i])) or (sumlist[i] == 0)):
if (sumlist[i] > 0): #i-1,i番目までのsumがともに正
numlist[i] = int(numlist[i]) - 1
sumlist[i] -= 1
count += 1
elif (sumlist[i] < 0): #i-1,i番目までのsumがともに負
numlist[i] = int(numlist[i]) + 1
sumlist[i] += 1
count += 1
else:
if (sumlist[i-1] > 0):
numlist[i] = int(numlist[i]) - 1
sumlist[i] -= 1
if (sumlist[i-1] < 0):
numlist[i] = int(numlist[i]) + 1
sumlist[i] += 1
count += 1
print numlist
print sumlist
print count
print numlist
print sumlist
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ans = 0, ans2 = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
bool check1 = true, check2 = false;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (sum + a[i] > 0) {
sum += a[i];
} else {
sum += a[i];
for (int j = 1;; j++) {
sum++;
ans++;
if (sum > 0) {
break;
}
}
}
} else {
if (sum + a[i] < 0) {
sum += a[i];
} else {
sum += a[i];
for (int j = 1;; j++) {
sum--;
ans++;
if (sum < 0) {
break;
}
}
}
}
}
sum = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 1) {
if (sum + a[i] > 0) {
sum += a[i];
} else {
sum += a[i];
for (int j = 1;; j++) {
sum++;
ans2++;
if (sum > 0) {
break;
}
}
}
} else {
if (sum + a[i] < 0) {
sum += a[i];
} else {
sum += a[i];
for (int j = 1;; j++) {
sum--;
ans2++;
if (sum < 0) {
break;
}
}
}
}
}
if (ans > ans2)
cout << ans2;
else
cout << ans;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
long long n, a;
long long ans;
long long bef;
signed main() {
cin >> n;
cin >> a;
bef = a;
for (long long i = 1; i < n; i++) {
cin >> a;
if (bef > 0) {
if (bef + a < 0) {
bef += a;
continue;
}
ans += bef + a + 1;
bef = -1;
} else {
if (bef + a > 0) {
bef += a;
continue;
}
ans -= bef + a - 1;
bef = 1;
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int ans = 0;
bool is_positive = (a.at(0) > 0);
int sum = a.at(0);
for (int i = 1; i < n; i++) {
sum = sum + a.at(i);
if (i % 2 == 1) {
if (is_positive) {
if (sum < 0) {
continue;
} else {
int target = sum - (-1);
ans += target;
a.at(i) -= target;
sum -= target;
}
} else {
if (sum > 0) {
continue;
} else {
int target = (1) - sum;
ans += target;
a.at(i) += target;
sum += target;
}
}
} else {
if (is_positive) {
if (sum > 0) {
continue;
} else {
int target = (1) - sum;
ans += target;
a.at(i) += target;
sum += target;
}
} else {
if (sum < 0) {
continue;
} else {
int target = sum - (-1);
ans += target;
a.at(i) -= target;
sum -= target;
}
}
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | // This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
#![allow(unused_imports)]
use itertools::Itertools;
use proconio::{input, marker::*};
use std::cmp::*;
use std::collections::*;
use superslice::*;
fn main() {
input! {
n: usize,
a: [isize;n],
}
let mut ans = 0;
let mut cur = 0;
let mut positive = a[0] > 0;
for i in a {
cur = i + cur;
if cur <= 0 && positive {
let op = -cur + 1;
cur += op;
ans += op;
} else if cur >= 0 && !positive {
let op = -cur - 1;
cur += op;
ans += op.abs();
}
positive = !positive;
dbg!(i, cur, ans);
}
println!("{}", ans);
}
*/
fn main() {
let exe = "/tmp/bin9E3C21E9";
std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}
fn decode(v: &str) -> Vec<u8> {
let mut ret = vec![];
let mut buf = 0;
let mut tbl = vec![64; 256];
for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
match i % 4 {
0 => buf = c << 2,
1 => { ret.push(buf | c >> 4); buf = c << 4; }
2 => { ret.push(buf | c >> 2); buf = c << 6; }
3 => ret.push(buf | c),
_ => unreachable!(),
}
}
ret
}
const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "
f0VMRgIBAQAAAAAAAAAAAAIAPgABAAAAqLRBAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAOAADAEAA
AAAAAAEAAAAFAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAA770BAAAAAADvvQEAAAAAAAAAIAAAAAAA
AQAAAAYAAAAAAAAAAAAAAADAQQAAAAAAAMBBAAAAAAAAAAAAAAAAAGjtIQAAAAAAABAAAAAAAABR5XRk
BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAANw7hWlVUFgh
UAkNFgAAAAAglgMAIJYDAJABAACXAAAAAgAAAPv7If9/RUxGAgEBAAIAPgANEANADxvybRYFAGCSAwAT
gR27ezgABgUPAA4rBQAALSFP2EAHoHUDANvs+84gADcGDXkXB2PCPjshuBgtSDQAN8EGsm4HAwQ3MC3y
+5awyDUAUOV0ZDdMK0KekG0HQyQKAAW2GWwEN1EGAACEBTt5EABSb6cwhIR94BYAB4EAAAAAAABIAP8Q
dAMAHqwBAAJJDQD//wfyUFjDAEFXQVYxwEFVQVRJg8z/VVNJt7f//4n+TInPTo0sAkiD7EhIiTQkA0wk
CBPhTJv7b3cHKPKuDlQkGEiLlCSAPRP3/o+8bQ/IDYwkiEQkIEj30EqNHCD/29vfQRwrTY17ARNcJBAE
/ugNAaQMSIXAWvs193R+TItABCqJxzpg77l21wtYSQHFBypZS9q2fWsbD4nR86QEwRJ0gLa1bfsJzgLv
F9kKEbR+tvtuO0iNOTxFQsYEGABhc0xDbhvs2YQ+i4yg+h/upm//t+9BicSCTNXESESJ4FtdQVxBA15B
X5/Hdv/DVUyNDbYBA0wNfwYVoBw1Am8Nv3cNQbhwAYzlUw4IFAVkd/a2FbojXBgyE99QAn6hB9t9t3t9
bARijiQYiXwkDAxjVQT7szvDWwbDeIsUtdVIMe0x7O32budd4/y//y7k8BUAAZJc7e7b7VcDizeNBU7C
AmMN2Ytqv3337UUxyRc9BwsA3gJh4maQFweAfwgA7dv223QJCDj/JTaMImQ8PCVg/wDcb2bsAXUcC2gg
38ZACAEt+79rxicOucgAZkgPbsFkZg9/BDIYNzcWHPFnER+ED3tvj8dVEA7wgexo+4//PmxuOD20RJwF
pAuD+AMPwv6Et4W3CxVIsjv/FcyLiRz22G0LC4sEiesWuHjAY7IVlhYgiRS6t9+/D5XAiksIhMlUDGUY
nCTwMojvEX4WyviDwxBkADHMhdG6t48wgTg10g+ELWENfrDbvyCJ1oA4K3UOKcb/FIPBATH/DLvgFrwK
P3BmLt397bc3Pzn+dDTTBDkPthhY0IP7CQ+HO7r/1jERQ+hJ9+CyAg+ADRN9idjG3ihsRMdAlnPM6RLH
Umv/GgAIQw/vwPPHDQXbcO/vhe1uBLG5F0H74T/hQnMcpknZAhXmiS0/Yfuc35StFMVFiawkuF0qT2Mw
bAhkLDzgl7ZduabrIO3FASgPjMcIYWy2bQPEfzsrZ8ZTCEIXYbwZmRAPhLcUWyPASjXIBxXd8fYfCooI
gPkrdCIELXV9QoP6Adu2XZgXY3Qd08IQwFqJh+77/dfrZ5CxARx15+MKf7+sfgvJaDEPL/o5A5z3fwkX
Lxw4MAtcSGvJCkC2A+8J70f4C1+J2ywp2XHP6Q9x5LL2aeMB11BPx5MJ2T4Qg8JO+gIOx95+nonSN9Fx
0E5BvWDhCU8RKniEPouEDAPGYxyAvCYAdTJ/EsL4DEgJGusU/xDYGj4V8Yikx0ywEncNR3hNheQslEyo
4BBJi0XX2v4IxZ/BScHkAxWkrkumbmFCuvR46AdF1rPd2Fs473MjYcoLAyxtR9pyt8JsbMhwjxBNFSrT
jT3ZTAAk7sgCC9Ik0WTDzjZMACS1ST2cTMnZUBisQKO2hM2UMInKigdKtzfcRMvQgPIB4u2IRH8HFt4k
MfbCKyws/Ewp6UNh1k440w51Md8wDOzrOEEc85jCCNFPyGS39id1HjgBScfF1+lIh/9crI1csSbk245w
DyiEAg8pFnAMAA3yRWCEpw9QkI8tPPhRjWQ2aaAMNYUofGyBA8v1qA49NnIjjsGn1nz7lUgFCh0Bbez3
GUxpUBRYBCl0am2Tb2snBGASaFhAUtt2sBLnDF+8B+0ChAyA/dowFASJbKRAYiO1gHPNhKSw2ccGJ+An
EISkndjCFraWkYwAbOwjz7ArRIwwQ+TC4m+E644xhkouUYzZTu8YS7CM7nQnoA7pnYYG2QjuCCHJ01YJ
R0qrte2sXlukbQX8GryfMQ6vNqy59DFj5YWN4Af55OzZ0KJ+aA7Y++YCuS/TGcCR0gYDYAxOI8zA2HZG
th/HxlwAM5jIaYM7bXHcJrDttkHcPsNkTaFwabDfGbZw23gCU4DlC8JgB0iNhYk9G70Psa6YBwEbLY10
Rt/GdrfbcFhPXPBkK/JyGhBwjEt3EEQ8623HA+eLc+2a+LoLhfYzC5ZDNA0lDDKFjHtMjIzt7W6Edv9Q
OHMDAYpAbrquoUAhQU0QB0QTPARkc2AfCArO8kCubxaS56AwQGi/biw27JX2gCcD6wr3w+APxw8QqZwQ
SI2HFoyzZ4dG6gtIkwSy3cjdUBVQGAFYC5yAqYqF7C1HpiTD79zbCoI5jqMA4AwPC0gUdB25bkiIiYtq
WxNVMfZmD10iNH84rsOL8BD64oHE0Fv5XcNssh3PwG22CNepQHzf360Xm2m0g20VxXMGdIfd7ggYYgww
AkoJXsx7DXYF3oXAXxIVCcrDb9KH8QFAiLTfGNoCz+XyQAjCOAWDKdwlEIRvS60wslAic7bbhqsMYCf0
ZwtoA5ADYZhuOwQUWMiTA55u/+w2+0hfsgGIlJVc+NiyOeyz7xBcGLJEJDCvLE+4kAMQwEsLrNvQ8PUx
0uuuY3CWeEQzwVPvZuCSFDBstUJhbITt0LkdZL7GMIlRxSVXdq25MReQOxE0zAbyHYllEJy++on/Doxn
YxSjnpz4r0tYPwaD9Wm+xr8Nbo9Ro8fGI6UND9oPg3yzhVehEZ4HsKAgMsggkIDMPk93agRgUEDHOsEZ
vzJnAOtfxDgHrUTblfFu1/l+42C/jXA4vwut3r9B/9a/BwwYHIQvfilQIACWsNy2NhA21Pap1H/2+PB1
32gCdFW+AB2/ILquuSLZXL2eg7hhBSm6OER4mNMQa6Kh1yaNRfJZIMVZVri9uV19LEyLDGQ9GYQLvwT7
T0ZHF1Z/jw/0xwBtYWluy76xbxBcBfO1Av1AQziBJUcbbdY8xeKE490IzDgpjokokgOBAwJjQ1uJgCAL
W6h9EBoBY/COpoz06a0FDHgIAh4QKwIAB4MwSEbQa0CYGwgM2VBVa99VfDngMXBdcjgCYwYmTfNYRYbA
rVsIVWN7e250FLvdwNWEILy2dQlBeyDM69rht9rcQyBJNX8EQX0uDrR2BCR8HGI8/M7C0wSCU98iAwja
flrTSX+mNYNrMjDvbzDqAryX7osFwCsDdWkcMLnlJFT4AEw1+2DtatRcEQ5b6yIP37bUkyQOsfDVL5YK
UVDkSDdml/hP2h4xdnSXfHJKdgi+RsayAXLrdU+oOC9Af5ORe3zuHnI4D0oc3eACZHwdozy7vkdA3cwA
vgFybHeaEEgqMNZ3kXCbkA45qnAYlkRQtlvSPNt7JhkgtT+ETHIyiaIQoyXPyZPrJ0vRuyFWsAQBbQwO
0hzZnWJQMR6/AWkR9NTRezR8Ir9V+pi/0AaMXfPd8wUOi24wiam/tfrpQPbFBNoHg8kIiUswCD07frV+
yth0Cto4swOCCTSzGgSpEbf/xm9ZicGQSMHpBw+NUDCNcFc8LLbCbuEvtUADsULQQYhQ/6rAA25ox0fX
yNB11GkMJL/d7vYLVinPhv+BCXMtqdR2CGO302C5ApTfYzbjcDre3ChZdolrMCSYr2DPbnG+gB07nM/P
g/SRetL3ifuLBp4S4qWxjqRhAQm+yHYYTWGjBc9gErHLm37dbnN9gGPnRAXCUYf4ddNurEQkAbg6dFEz
7oFtF5R0RwlUp+ci9C3W2sT8DMAhK/kDdCvQnmLwEzhJVwgEbKWtLc0YBC8oYQRgDvFkoNxrQONwClIv
zOBBnsDYtycoHigolEwpjMi0TU4pmzNhbFIx6idDykIi3m4HGygyEUNxEUtwEVM4p9sxpADJE7XzEINt
pU00Eb3hQQQZuSBHDggNE8Zwe6HBYBFqKeTCIPQwHeDs8BUyyCBXwNDg8sXYAPA+Q8EASELDK2oHICEQ
YqNhGRpQQL+bY7ubWCxFic4CxFrKAve2vXqaMlNqexBCKA9jzxarUws4EBtCds42A2oLIBcYtoBYbTqL
OWxBCG7WiFn9c4m0IGOG9ws3+HUSgHiAdQxKQwgBMcCP7UN3YBiHjR4IqhVNCDqwidt5IANxKEM/ZWMY
DH5QHRIIAcAQ/c7iE/AFytKAIBQoADsCN4z64q9I/IRDGIVF/Cq/bgNsAQwWUIPV32DkbhLbC6lvI8ng
hgqTCZhAFcM2gQR3k48LP7sCK8Au3YfMi3idcIkMlhwILUXvuw4BFuxig2Cg5BY3q9mQh9AIpO8f68mz
AXnjZwJUf7pmgA4YgWD09RMgAXIBoImT8LGJ4A1iugIC1voPbPdNQgLz4GgVwDUtruyW7HjsisRjnnAA
MtlKmQIhzoCPxjCaoJk+YFk9IAFnqvBnwDPOCIxwKJTZlAd3mAHMgwVHLn1caOdT/QQ0F1G2SBczjd13
hckMoqb+FiZwg1Aovim5KrznnHNZOgVGXFQKUyxSpP1JQ8ME6DOLbgNIQc4uzOiJ4cAaVQMWWDPgHBAa
YW2z2cHGiMd0AQvAAACMl72P5zpKNpJi3O4CyYHtz+QYZOk5EdgQUd91AtxCyCuBbBqmuOAwUhKI+1Bn
keCQv8e4GJSEw8FiR8p1IcUW2l+3O0BtNYD5uir/UBggIUDXhaOwAc1Yjx/jFSMoWwlQQYP8O1ziCO8U
XIX/Ah4J+Is1QghQhG9EibTPOknBchwZdxLC28kD5CWWa7AyhZwCeSS3UbcGQgppIw/gQMYRfXtgJsbN
5dYFQANMEANIGITWfKgwp41UfARGD9kPY7AhEP9RGIWNjCRgZwesoDmYNwtonmzZyDrsXxee7KOQMiYB
w6TDBgYTGmavj01t7YS3dDRkR8D4Y7DoCNMbJ08bnWzwa6Jfp9sWLNxxJ2JgRQMpMH8KEttm8ALmRNrk
LrUjmJj1LMA7JzhEsLkWtDCoBQtB8YbbDkUVfG5+8rQCH+xP+Jw8HAos2EWE/2YB7Ug5bO//7esPggst
b0kB7Egp63Wa6Rg6d9x0RjVYvE9XXkQkKI1GjmHRxT3DHfqORbMs3jCesYixiYcwdUYtRxjI4ViEJ/1A
O0KJRFY3A04YUE18up0L3xdshSxTmJ5T3gRnaAjsthgDd3NHKE+/nxWRAwQVaqgCBx1yDUKbJyV6TIuB
O64oxJ4xdWSgOfxtW8K2iwRgyxbuAuLzbLDP0T47TiMHFQsjG/Y9lTZo7l/YH4RmsJUtGkmNQAGiFhr6
f0+NFDRNjU7/MducQZgMUEHqF4HJeSPrR/+w2RfKs+EBSTneOyIPS799eCaJzzYsHIPH0PsKnR2ChUG7
aMMdrM81cXtrRtA82XQRdAQcjALtf/vfQHwcAYPnP4nKg+Jk+d92Jkw50HQmFm//LWrwV4PlP8HnBgnv
GPByIXP/vzwvAIPgP+spweIG6xIx7U8g+GVvD3PfEwwJ14dyLOtuVn/bVn1WBxcSJNcJxwaZiWa3hBEA
ux8rkj6eOHNENRjvIOQrfjvcDfn+ATAcjDZ7eHc/LPBBgLO/D48UqvDkhgM8DLIw+CEPG27TdCEcdBwJ
3AoBhvd9o3V1YDvVwH0V6QuQIBt1XzAbkbIbJNiJWmS7wdlNCnUTd/sWTTeg1KXt9Uv/6Ypo28eOxi8p
4JV4FxxdIrSgYI0F1l+xhYaXGul0O1opJTjXUn37UK8tNJL4SffiLz+qmTotNn0PugHHIQjtVC8S3wNr
xGItmv8nW3ihhX+UwU0p/kkp9JQ+yHUXhe3bW4j+zPdLjQw8swsKsr8TvY4NnTM4hMAkxiLNci2jBBgN
L1HoXoR1V94gVo7ZIYOeSIUV8xdmCxvuMOwEJhx9AJbwYrNoG6ahqjciOPgNEHgy3EGKtoVgjQsRlk35
/NnqmrabM0j32gXeFYlEblNd2J5/SowOVDwCDy68cCsnJB8/33RLO34B9rE5OugClArAkkcn4ba3yywB
1R7ddHYTLh2zNNuEmXMfDNHZasTGyA7hpHFtwtvPusxoRne5weAwx41Hl1D738b4m3x/jU+fuKn/ADuM
vL0qGnIRDL+4yRm15rHft0Kdzw92U+kLMe1Jf8g2GeuNSwxzuOsuMUc2CrHJHy3s4McJNoHCks8Q3y88
244NiPcB0K/YHYoOZ9u7NRWICR9cuq75KA8Kw6q7gxLc69Ffs4EmrC0LQo265224djzww5eJ3ZZd63An
T36ZoaOJo3EH6/jFEM0gclPNvDW7EBubhFzKdOK3TUEIjwa+6IH5XyQCNSPjQBA2BgY716PRTgt1/8AH
yb/jYCwE6vxWKuwC7f3bYEVAJAsh/DwueBMeEzYYOGRUZDgxWcctu3QLYQFb/IcFuo5JJZKgVeTSHSC0
mOElKokVShcF2GxCT+rCAjHnbhmQy7qeAnICAoENJxkAxP7qJeczLqTALpCvB00B7dWA+xlgRWNMhQ3Y
6CWDOMoNZLgPYtBrWQADBNWkNhZ6UpbJrQe4S8yKHyMeuAgA2V3Ipg340nRIx+BJD0eTwj8aBuBuM8H/
AB9s4NZYOwoxD3QfEg0CHV23XNVSdeolBETYCnVLwIPjkcvTI6sNPNy1crMQclg2YNnvjQpvAFp3SvNd
IG2oIcc9AR/F783UyzniVqADxgPbxBRoxe3dCHDATgl7Ccoer7ddCUk3dsiT53YNuKuafqV8YVdzqIEv
1QIleBv6ptJIA9r6tzUW25AswrT5fwGczrldS0Dty4DBnfKd7G2hts8UHLfDRY1tApvBQRE4/l0qfmMT
S7hw6xuQywH7ZGBrE2Lf9ld2NPybgl9vifNJ/8M6QHQTTTnccg5sY2xvegQxOkJcQe8Z4GjgEwux2BQb
/jAZay7hS2skvEFsSWVbRCvcYMovwExvaAstU7CJLk65c8dh2xYmyUw+Oe/5bxCWb2E2bjrRf+tuEWw7
nPu40UbRpbhC7N2HI53pqj+GGgsvFFz5idiNSPAfz7ChYdt3azTu3wUEPrJMcoSNwsXVPnABH892yiVm
hjcgC4fULxr/a4K2JeNzlC+fTAItoCEW0CuTeIKYEIIWaO/ZInQOxoOML91brzt0S8TdxuDdw6rhC8uW
EIfhXDRdGOmhLG33WwzSfQNoLQo0vUXIL/SzLbBVdSL6yjVi9yACHdsmk7Ywx8cO9mFrlugc8KImpyAp
ktvotlgXOz9ZKTLhIRfS12nI+k2X+gGSJpAnp8MBvYI2IA36/83ZoUkb1Sx18vU5IS2DHFwKOfZtnMSN
bXQSikMRHdiyFoZPAvA5crbxx6Fq1Qh0F1/EM20cshxBBU5vKNzDYsODhcfwJ+cJXBgsFkc59hxMigmE
BuJHKyhLFvc2QBZ2kCUlcCIMB32BV8gijS3svRyB9m1uBdYGd8EbKPjpNou7bgEa0RM9U1D7FRlAzroR
wCyrpUBODuRClIAnA/IZeVJGaFUB+QwgTUxUeQaQkzwqIUd7crapdD4tFCgDdGEkbLd7B/28Uat0Tw0g
xCT3DnJy4Lw8CcSj0Bm7444uJorr7S3FvCq3hPsaBhFvsCutELQKYLzzQ3VAeAyTOFgttNUMLpxyx0Pk
yRac/puQLFt6UHjb2ER1bskhDg0NMOu3FfQ+hH6cCR59AtqNRv8CvYIuNC6KlTZ+2sBwWXUnG4bB4wbf
gtVbLsiWBnIMAFsLAjsRKa98IcJKP3v7TcEqQITteA9myonvLXPS69xxGtq6SOcYG3pwwl661Wo7xaeA
/aio6xBX7rIHgMIRllAY3BeH3AorXuXPGaKXfK4ZGTLrK7BdJesuwiAZ4wykbbGP35worca5JV4HFYbQ
tx0SK98yerhbpZUqoGt1LgtPGwYuPTHSwu8SAMgGCxfGCdD0QN5NHVs0EW0ocHCvK21r1tB1EVb+E5Vd
A0Ch1Eqfekrk3mj7tvFXtRQLjWpE/RIxjXKFLtzedf4ac3bCqdSD+vtrz2yxH28Wv4wLGoLtQGTJcA26
HcQuZePYD4Bt/gGz1mDs6HOpMz0wGySxUPsGRIHhAPgPWQCKPUYbALkTRME9BwbgMN7ZQAjPE9OYraFL
by3B6Qbb8H+ELed2F+oLsI0V1pqRtjTE/gPuiBf4hS2njQ25dIsM8QW4xw0Oo8Euf9sl6OiUhSgcYPzk
3dkZPxpOhneZln8HEAgY5iWHlP9oM9A4T2LBielVEAxBzyFJtl86LpSNUUU5/3gYif6KJDEE2P22K+FD
K/Z/txtL1wdNKAJxCOY/NtCJaktHgf3hP/9EHXB8bDe9S0QaCMVBJ/BtuP8j5gZECc4fRUIfSfbvAwo5
eOcd6zwx9o3vFj7ZwEN3vMHl8+58dUnrXO1lrlGUHEFzvh02WuOTDCvrPjE0JeVtSL1b5jEJ/oH+jM2r
St2wZq8qdHCXdXCqRPuOpf6hWMEZqfzpwwIlChFhA5pCaWE730AJxbDFpBgOgWDA3E72LaAQIwsmdzqY
wciRU0oIYA1TDBaSm0s+LPTkLPB+fsPdt7+XhtQnT8eXz5cCYCqWMuxQITh5UUgkxK5DwnCeUEh2Rvf6
OOseETgzH3wb6lsbItZ0BNrrAjHAeglBkGzmjUQArgfxm42bAAEhePHu1a/aOtzX/K4zuRAkWX58tFIr
n1/1tyJUPz2jvvSsUsVS/QjIIzC+K7aJ3jDVbPdU3A6J7wz0w7ZgjbwJE8YJEAnYalUdI/UOUGwW/EI2
CLAQxEJQgG+KC7iKYWEEJLptE8QTUYs+AkbU5hQaLxobNNfxA0KIsUv+GMMvwy9b2mLVb0RQTNcCFYM+
avYXB2Zt2ABKGWYYeD0mRcMFB8OVdR0JuqIL2EyuAfaDDtH93b4VxwIFBCGLcxAgSe22uWOuDZInUeAk
qV4aFQ+33YB8SHUjITwkvwgOnQuCxsnXfIDFqM6Z1rKqUNAbxQuIn+/GdCq+xYBHGakoxkcYgdtt4cjB
T+x/EPzHPujgXW8EYQi4TIldYYAI4tsdx0J42IpB9DEGKAB1uG53QABIxgBOR0tDQEDJKN4GQBj/4O9k
21gzMWgjOQJBH257uWLGSOnyKsjmfvyLTjD2wRC8MD1PCyD91qXajIHx997ITPdBuyezX27pVasQB9Uw
/hIgfOH/SbhLWYY41sVtNEw7cqQCAN/7W0WByIdIweoLacIy/QUW+InxKQy3QegCacB7FGJr9K0PCBFr
2GTlE8kY+W5v9wRBZkL5HPwKSf4BurmFvvxusvUFF20vUGJ3M9pjfi8fwjRsy4RCyMoTyr33jHS3EkUJ
DEo9TP7VSjQDlzRylqbuxi9tEIDCMEL5HP8Y/56kCSjVMSXPQoDbW0gYyF9dBIDhO1FkCWjxMI1xVx1R
yo2mJmTRwWh11bb1nrA/S/hmkD/550BtnYHLT1c3A0HJAtIkAc+UQMfRjcYkYDd50Ua0jRSnK0nA140W
gG5THLbDOvITay/z0iR82NAwIiHxogUEUEONbqbG/vAAupnGxqai8PAEHEG5sk12vwIW1t62AlmvVoYl
QUDZb88dDSpB1D6nx7mQ0HJtqS+Nx6gNLf4oj74ZT1zs3NgGBr/yF8dZw0k0smR/D18XaMAxULcQRzDH
R8ClikFsLnUS1++6Z1g0VYNQXjQgRIpfObqh3m1ufbDHzssGSb4APsfdQIAfRInZ6yA/vCmgHxtuookP
n4XS3TQduL30xQVRR3iLZygDfzDo+j2EzznnbjPc6EmgC/SvZYlPKEXTJEWS7W5Q1BmJzIMzPL+rBu0l
Ifl0WSg+TEuUCrBfKFzMKeJowQu2PyfcQwWubrelLUwl+3QEjWP7Nlhoa24jG2E/N+VtCXeBsAnaIGhA
dmC3i/39dEVNjWUgRV0AIus1wMs2VzdwEvtLd7TVSbYveesTMds//XPAEGqX+GvKQS3rHxmKIXFzXRzK
HhOB+mcLXTW01Q9X/+ET8X2JzRSd2yD1+SB3DaGfLrFgzuej9uAyLEEXbN+edIAA7TJcGc3B7QYp6+EN
4W7Z6wQZLXIZvgKgWXA7HPsMSSTrHf9DzQg9NduuHDMEb91+W+I0QvYPPeYETAHGF3Q1oe1v1Df+6mlJ
izTyTHPOPwsNettB6Xh/ZdtIOBj/dXSAfzgAdBV36xjPLtDix4w58tZYOQHjLOgb3EGzAbEBOTJBTEg0
cAHwNgg+PT2QDkr4ngY9wxyJE/ISBWudOoFGoIR01p8ZUA0Sw6C/3+xISAmPQao7SNNEJCAGyYjIkyi/
snXuqYETF+fWe3xaYhm4upBPaDgJqK02LJcmwF5936nO5SAcHygOMAY7i9wa80UjWwJ5SHaMeM5kTEzQ
YAJ3DOxJDDixNnzSSmAMHqALN+kI5gByNiWIno+BARAY7/isuWRCYPnv/f/IgDwKB57/u2gEDn0Y6xQA
/+tgwweBICZ/teviidGdwIFYQB81FhB5INCNARoPsSExBCJ0H4J3wu5hryhP5bDZCAuAgxU1Bl6JfHQU
DcFDbgijTCplcWE+QM9tydCyXxnUz3+NXGymxfMC1dqMvqkG//Z0UkSLQzBFb50BRYXJur9UhJ7LQa23
RPJNAfnxQrT9QfbABHRAMOr3dHhJdbe01Cj/s+VyA/4Dc260yRQ9ru/pqDhWiu3d2mY4d2dPAVVGLbAj
2hmiP3XAAIM7rjWIX+U4igZCN57Ud67qKcU6zEG0ATQ6soutRTQpczwoV7F3H9Sa+lM5CTH2WqmbartI
MyniDB0FwYwlBGeeHQ3JBxXRiw+6TW0tEE/8btkHAt1Zd2vhA2LjCwETDwbpe4MlchI/bFYP2+gDt+7t
bnYPcN3UBHPzOFXjA3Lkt2l2ux8S5O0J4xjbYtwItxG3XeWG2+ID++PWBBCUopVi3E7BGa/Dbwku7QHO
GgTTN8welnhWYHQha48MF//AzdUCDaNWgGQmLbxlgsZBbtV15Wvh+iJsW3DxwdUoOGGGowsnfwlTCI1C
QgPd8M92PkwIdXglCAfwU/TCyiY4PAO3D0XIOzYBrWBbywqNOmMEHqjhtoFayDX3VdVALBAeRJF361QC
4fN8Jui2j60tShk0k8cGMLZGbetzin2IDS4GAQS2DRLQhO6n7XOQ5FKMa6ftPe4Id7v9pzo3r0jR7RjR
6sRhd8miSG8K/3Qap7paaqlgNCIg2+gswPjncDqyi2s0XW0I8A4P+K8cYbzVtUxOHFuvg8cBQwn44aLy
tDqvWc7FvlvJ/1Nt6mqtpWTsc38sSdHvwqWQnxSGbQ2u6+gTNBfOTmYih3x1QXhrF7KiZkGPT/W31dwP
e9LDVUrt6xEoNCx8MYmEin2IWhdCoVo45LGrw7AQq2FEz0LOsCNB6UXwEnQThyJGAtycUXUBBsJWKmcZ
/13VKLxbAvJbTpyvYBAMZoNPn4wB3QqnEfppIPgZMBliKFQF5j8jIGQQMKhMvQcGM3xMNdUwBjGYAGhQ
T4U8wgJ/kfkRchQyno1sCwGjT1LWAvdYOLSw/b4H6qr42tGUq7l2Dh89eX8ScDBZQJz3PW1PjQwFF2CL
N5Z108YBVCHB0cn/Qu/jhQ1o5aMH53gVSPjBB57gxvo9WD61XYrtDd85ynRKIF++xwLipdgMw376UOIf
PNQ66hZtTRtESxqJb4UDtzlBHGsrRAnbPstvozwCOx1IQQKD4ArlCv0c6zrNZQIloBDBQ23kAh720BNF
/so6c8UJiP1u5dOJ2I11OInk6PZWDIrTCcMbgfuqhMTDBECTv5YWajNzMknp6vn2/hrdbv1J0tM8fOks
a7DBAeH2TSh0I2FOYemgdWDwoWD5GihthLPo+nY+B3gSggIuYgZvBCdPflB3DLSGvIbEe6AVn4b6kOn/
3wfdOYGmAuf/ehM6MgEIdAbv/8KMQHsX3+r6/z1+Am3JtiLn/xwygONgthFf/4D7gFvHJwts1O4A8HXk
r1opDIsCh22BRds57oMRE1BolocTVEbyc1g1xdIT+Eux/m/UEm44P6YMP8c9f7nWVmrrykLxhwTetgWM
R4bnD1KMCl700AKZeIhYD23B0Df/RPcMRG+E58mThXeFf4X+z033sA2/Xk/bBwLjoevOCU9eEx4G60/G
QiYAxqZcMHbiAdhk8Bz/5hmEJU//Tz7JU+WgQFtMab/VVuI5+k/W8BHAQYtNOEqwxRJrA8vNKKsbuIaD
+9N2DIqecD8tFMjhAcXrEASBK5oxcsDo+/DSGYxyQG8YtH0gSf+DwLaXKEx10OdBtgHrSkWLZRmYwLA0
Gy/RCo5twBnULk0XbSgicCBlvQ/Dz206BBrO5s8DA0SJGoUYWVaeNtaM3YXfRfED+E3/VMKWwLBtoTZV
X0jw/+A/gezYBydAJ4fAZMgW2OBUgfSVDwEPwEablXJFpP8P8cuq7oC45UUxwN9a6htL/wY8B79/Gp1Q
gtfwrlwBdBZMZT0pgdjctwt13esGME3C2kblHpWOa4et6BM8DR6mQ96TB+C6sW3qTcjRiPABhGBR7wJs
BIAo8Nk2wNi4a/LPQ7AI8b89fA7KREHxDQ3WdAh2CYq3QW+NF8B8n8rUbg3QHWgcNrExVU4B7fZayP8W
vzF9FBz3Ble6Qr/6SPvCdePrRXwuwFPQehqdWqRLOr/dElbYEgwHrxGE0ngTUg2wAB4MKBDA4XajKT1C
KQH3EXEBANsmgGXS+DsQRCxRBk9wA5zBAkGmyCRtjQfgg+YHUKMO+aJXDW/8+HQOAAgbDZQqUBBneXNB
S+Au1QnK13IxI/AH7ALNdSAJHDlj5hIfdkeC7vIiQWp1EHtB86zbWoPmwAQMG0SaZ3/ILScsch6+Ag0A
x7jFmggQPh++BIfeAKI+q0d8V3QkGIldVEBQjEPyTUGAnjhYIAzBOqguyO0BcXDvA4BB+M4QeD+gzIAn
VGfHnqABDojSsOKzLiAXmCbxOCNkkLiEzAWcMFlVDDpQhcghyEk8NRA5nCDjQnXHliJHDkwkEFBsWLIH
f/HDnMYLSpbkBpawJAf22McFqDeQA5A9iwo2pzeQkt+yqMSH9/BZjGJSflmAkOTDsplPbADYySCXMICI
UJ9yMpBMBARfsAIpQn+jJRgYP8n3Ra9oR5stfiVGKK5g7XgCDhGw88QovrQ1qzqLMwoA7KBULWr6+Zl1
5zbVj3YYi7mhDESKurEBaMWEeYCl6yey2FGQ38yJ3kwf27X1Rjjsf/BHKGd1mL5cON7oFIXuY0SFwB3u
LgX1AfGE4EG8i6xuFTA3xnY3gFpjAdyeQbUEHL59guuplYBWjGkSm4brnniA3QBtg57+Pz6ttXDTQobm
AouWDFdeW9p86fHT6r0PjUowxleZCh+k3YZt8fvGH0WNPr57/zBsyN8MA751qrYQIjSbIBsShyFikaG/
XSqkul9080m9RtzVSXcVk5vgc/lLNiM+GYRwUPEYzaACLxgQxh0o8VQKqRF2FV10CoY4qxvs4a3D6cYI
TK7eEelsgUeDwu8PRfxvH+CCwDCo9kfNeg+oIEEGIX4KSByl+SaJXslIjOKMj8iQ/Akhn84pxg+3xnyT
ENv+E/afBApxMjJCjAaf+dEkuuRUZ4wGj7snJy9IngdIs9tMja5Kokk6jz5KDmzIS5A/N9oNSZSOd9C3
nB58CySOZsPm7Ng9iY1Hg9BHsgVjiyCXXEZtBgiiYCk5oZ5V25SUQIzvWH3xNQgA30i4GiCSxlKVDOj1
67JiFAYIkojdDlaX4nIQ8ErKDHoYIG6wsAMqg1rvOd8APItYZPssS0gLtTqOEoti91pXVwCTYKNuA1UI
lbGrsQENwEuDPlD/GMbpFNDKMGs/tte5Td34h0TpBoiLD/yX+8VTtz1G6GY/oXUpDvSjBWJ2at78S6j9
5hocGzXhQoVENAh1Cgq3SrAeBIt1FZAY4G5g1ATfR/C5AV83BkGiSBgS2FpEyZE0Iy7ghsAmHTIPGh9f
bJEmGeAgyhJO2C5jXYTZUJThBBA8IPwGmMzeQf9UDAgOAMaWgEv9IlFXEYlq1DCMUcFAmAU6+Akr8DGC
phA4gUmc63pTNJPQXyh/3OPEhARCQ2eWIHKU0O49Qmox20yBrzwf9q3ZHJiJH3VNOeVzNYF+1bdHdB13
i1QdGK7DEP1S3LqIyFPrO/I563Yy668hMCyAi8maCBDZbB6wIT7B5QQtAC0IalGFn4p1AjRCAyck2rVY
ZFkxGU6iWNDO21ItyKCHxRMQDx9vgw5gHUyVyRiIbwMkLyqXh2FGyQGQh5+av9TrDo9QQbh+OveD+R53
SByD4B+6dC4KeURncCvAi3nMum7kT4VYe4m4QFx1B4sLHKLwagS5oS6jCN9ebP4A7GdyHbgedYDsXcNE
j0AmTne6cjzTJUM3uTpwuwQCTLQj+FQe21AE8sHgukKB20YVmRt9HhGoHaetX4vw8E/hsOwIGp+K+wTB
8GyxjvjLT6HKASBgQV4Alii0veh3Nb+OX91K0CccMAiPeR2/tXK5AQYqFQsUCEU4Bt2OLf1NjXYCdTML
wkT3SaclAYAejc9mhynyP/3Co91QFUgsyEs4NBN17bfwm/i5oXdM0E05znWxds5fulV3Xc1YsFUF/pAf
jVn3G1+91CQMfNkp0XknNNri09I7LMOJUDhMf7uD5pbECCInDgIJ2iJc7O13D4ghNAFTwXW/LcUgBzv7
1AL1QdGekMgAcuTbkNSQMcqWQR6mABqQz5CDPJmzI5Gykj3IPpkJIOslzHgHC/0FnsjGqCBY62CNhhBV
/1V5u7U9BEpyUwziBf2Wm8u2wwsMRh8UHwwAOWl7o1xeMQcOci76JTLntuNCfT0einQgGClZj+LP7Sly
FQrLSAp2CkGG8d+IG3rrFx3IAQ+9yIPxHEKH2raAAgUHGv23/reAjZhX9E8IiXcQxkcUBfhAv9XaYwVm
iUcVKUcXSvVrJCpeTDwtnhUrRj1itE7fZAQvAEyJ1nMBIh+f6TAhvltRJByA3UB2DiUBMxWWS4KE/ET2
LP8LJwpSO2HdaEHoqQ12ugtG4E8YyHNhH1MOeYAVkZX/MfSjgNEPBcUzIydFoAMrDjjwSFn11DCOqSg1
gD2QYr/seG+LVS+I3DB5jIIfBbO3883ARQ02WzgHdtkvgcb9KyMAcwKPiwCHDFgoCxIMkA+2cAKPSEyJ
xuBuixF/A0lnx//h5AACQe/uUoUCH8gBKYIPHwDvOZBMEHangYA8mQh3cYEhlEoer5TfCwcLIiVXJkLU
YlN8Be359phxNDdyDIZAcUgHGqJv3BWpQRCAQ3U863A3iHYynwHue5MMJNwgg3w5XgYOB7OCg81gO3Q2
NjtAz4C6mhR7xCwRfXb24XA8yQcVEXFEGIiDv1cqFxIxBIhADVgI3gsiwgMBDtWwRnHCITpJUPRUnGAz
JpAJToCNIi40ijTTznQm0ECIXpsOAQpf0bDuSBLI6VLlL9yR4wlmd0nGcsd3bSAJOmFf80HgMEMIUW7J
aCRRnzxXZ8/qw6iHfZGfjQw+MaLBBmgp+iTvBEL0v8LyVryAPAEKf1GtGtQBiZZEW+RucwFNs4PhgrrJ
qO+v9h9MiDYD6szrhUq+bUWtr2PdEuJJ/8WD7fci1BdV3aTpqm11qfZVzBzpiebX7razDT53VsEJ4ghL
nC6xAfkShlZcuspDAtxGiP+71sYsGf5GEBCie/9hYSF6jTx//49mjgkDIXo9AQp/jt2xLMb47rIvVRDp
UdD94bcPQYoUHp469wUbo++IGai3QCUwDFnBwW/X/j9ErVjPZ0qsXkwBiBoGpMs/884774evQq/3dhXO
OzH/XlAhCdFzoZ9t4hutoWDFAZgDKcIxwEKOELK/z1T8OlhxOMjMkFT+R/R0ehUYjnDGl+GCOFLlcUkI
mbv77UbVOewFwwjDdQwJdldDVgBwAH4uv35QTC+IfB/+CHUrhNtDUywgSJaVag59D9BXggW3pd2pqesC
bhxCkaSmxfdk1yo2ZzHSVxFAzCgeAjCUQMyDEVZA6p95+D9QvPtBtQHQGkSIawjGQwlbQLolS9h0eOPG
ANhcC+LPwhr1Jdr+X8GLUDCKSwn2wgR1dYGE83B369ENGz1rO40GD0TxllRsoABwygIzAcQA6PagMXRB
qiKO8BeIQBO3gUORl5AC0MYKEqaclhqADb8Vsf9B/1YYglkZSXPAFk0lMaGJAy8swRulSw/HEEAgJNoZ
ECNMDlu4bb9UcjRAinA4GQACSBDnou6acmAVZECI1ymcCgNBMGqWyLviERFg7iQjAFuyDbG5VlLca4Lc
CFnMvZb/L7kd37LYo3C9nVWLjZb9Fa815YjwoSUGhI/FxJavUD8DJV4DcwQLBBH2sN3vcxVSBIgUugFt
WcMUV90SNIkDCCIhNvftW1GAHcnAiEwVJD8MgC72qW1ZBZwuPdxzMCcb+2y3GuEPJ+CJwTY/Di15sGaA
BTYGugNbcti2IBId8CwMOy15kAsGB7oEQgQiCV9/ehMattsGAk4QA1aeVHQ0An0IqDWuI1AIQ8UpTnN9
OEW8XTRDnz/pTyChgYaPXz8ioWAQIZ+DCDmUsIlEIosidFpZQZ/rOxynW1H7QOv1hVyH0pEiAV59UwgS
UCy1ikjQROkWpYpl5+wIidSIUY0cZonyENIsITVW1UmfOiG5E1yFQaAHhhfS30jSMgOLSKBQUslkesig
jrug9tSZEo0VRKBI/mBIFCEIihkiyC6ATSFV2xLiJG91GwuJeQS30pKFak9rEFbAs14u8WhbBOrQwmAf
xcMOaNcvy3YoqRBPjwfk3khXIIaLu4wOwUXip4M4DwODQSEZ1UbRu5GgOnpXQii+IkLFhyDnHGCM1010
IHhgNXrTCKhFgwbAJkSTUfyVvDhA6yK/AdRvo/bjTCtkgSf06kBMEuDgSOtgOXLpoCvqgGYuphcSgg2N
o51ePA8GdEsVDk4kRmutgi/gxgK28sUXgLGi4aBH6HRHBbSgVHJO3ooczfIeNSRECcAF6vuKpj4fQgmN
4n1FpuUd9JCsUbnAa7VGqo2iASbzFRP1MtfFFT1zwmGwojeAHSox7X9tSEAb6BJtyAM4RhY/BE8AZ1GB
ift8ZeKf+iM3aETBSmMEuLTqOwFuLkiLQGAJENATjZNUXDLBWC+AD43S2kVgxNMAL/btSDtcJHQVD4MR
O94ULUjgDtMdTDtkQbYB6SAWQiEgGQ8D+EgDXCQIOone6fB1XSHMKSx7HDIwWgc8Hj6MUoozQYSEpek2
j05Cia5NHxxxAV/chAoYw1gipkhCbeL4fE5njF4Ldao9rL+QoS7pFpbDHj+zqkeoHQWOq7Nl66LNAHVU
tyCrEeaGctGA22+1ARmn6cLdwkPQlAKPGNPo+w+NsRlqoVqXrzyuhlB3PKggUV8ws6IHq/jdC5C7gYH9
f11MATfk2LsCEAAIC1hobwSguyTbNhMOhW1ABLZtPE4r3cczIH9dT7dlszYbMlUPqSyS9et0GR4n4Sdz
C6h/Gv3vsyTUFSJIFSsSFn4QiwHe8N2iogGL4OoGiF0WkJCvAyBBcMoimyL/4MA3WYeFcId4CVgdKyIJ
n+aE/N1+Swh/KYM+AXQHBX4Q+obBG2pNiw+5OwQLBh8Bt3MOiEy5+XgMLrVh1l2B+bMxweoabAU0QFLK
s461DBZ7BFnS63/YdYEJudxOuEkgsn3gXqlY/+E4xC04DLLFPssP4InKRz3KY7AMylSSxutLDtu2Nx0S
GvApDDNIcmE4BsOgXWCqSAxSPBwUChGwL7ShhIjlQ7QJHCxPo4FUhD9m2KgpGvJ5KXTEqkmRgfBdbVSk
XoN1QUGGGbls26aYB2ljxhwXJFe3W4MGvNl1V8ADEUdnESxAzUe1V93Z3dswZgs4AQEqaqS9N8BCuAEw
iwTDUhZ8L7DzCTjmcjsl47+BK9gSGghAAgxBL71NKc4NlqhVlTeMpl830F7BNhI1Qxw3QQWtDPw4HC9y
zHUOQLQtcWsbKM1JOugDRVkXYKBUEg7pQAXMbn9yv+sckA5wAYR2sgPWvsEdobut7b0gF3kGO8C5rCgu
nwWgX0Eo4InxPt42aANhjRwx9SDjc17IzWTBKZ8UFB93puuWgoc5lMKf0MuaNgOZnAE80ECqmN10nxt1
Abl9/1YDVmAcor7pTA9G8U0PvtpA20fpCuUQaxnnAfdc8AOlaybRfRgiGoj2ME+NfGk+iPixepTWp9P/
FbYobWFpaDna7yXmYO5J1W8JuvVQ9YMEtmYUhE1w6+PlixysaBHA2BCMNhUCjwQRAtzdLW5yMh9lAmav
w1saGr/HD/3NPVbaa9sqSvkk9U0joeDXwTFze+r30M0dDsGwKdabKfQE2H5u2xcB4EDIKBRrBTV5q/gL
n0sEB0IEN3KZdSdWAU2DG+osQsDQsVCVwNr+Y4rAshOWQrnSgxMKQ9i+ZH7a2Vss4Pm60pQpxjvSP8B2
sgXPKfum0+tOQQel0ZlL88+QCRsWOs/uF9g2uegX0M93cwQ1I8Xdh88gn4s66DfPxd5cdmy5Me2DhU5J
OdHeg3Ah8NFN7j1MiWyEFzgY8LlkSYP+zgf08XBoRpD5uEXXDd7nWuEOBw5fMWL4aYNCPmP8KsHuAiYK
E/HVkszEyfB7Ru1qs6vlY3fEX5QVb17J2xVXB28QEOrIHS9XyX8A0ahQjWOZiG/XWecKPA8J7z3u2YaM
GAMKAvcZwa3ruvRR6gPyUfsD8/2hRyJudO1OWvPl8v3TNd1t5wdW4A/Dxhz2M9Z03esM7hzo6VAFDBDP
2McKBM/ZdrDLxg4HGQZ128pt+07XDfkl8FTJYcGKdN1g3VjHIP5gxCDmAe1c98sQzBxbVs3YYAA4E5WS
ZmwzV/Ssemf30+gF556x0goC2mYDQoS/2cksXRQHEyXoXE7b8HZu7FzWcNtpFfPzaQWRsab1zkcBE7oR
TC5U6VHrOrdzEd1v1CzVljnz4zUUm+5Z4rRWwRTI68gRGztOIY10Hpj41haMoMefTjCcXy8BPA+r8kl1
8EnbxzFWHKrGlUhM07Ftv6ENAoIuAAfxKeExUftYBEvX7/P+g+YB+34jGwdqyy330upBXIyMz04p3h0B
XC1sAcIB/7oX2i0Y327lCiwXCe0vGGA825ADCgL1Lxl7thRQBcUKBF22BePNLw4HGQbmAjCCdS/CumfF
kcdonI1qJ2d0w3jGzujWCgLeL8nLeML8WkTkWi+4WuHBCVd0VN6GVG8FyBjqL2bOdQSaio1bMOsaM/nu
RG2cCD4vOSQv+kYmqrEdyi8bCUUXy3c7BxB7GnsaK3bRQmMVQyDLa8hdbjsBQzAHczhTQBehhloMqifI
c8KwFhK0S2Duc9QYLOpXhWfw6/MN41xdF/Zpns7o3qLATfUyEyNp4ubIJglLORBAFCUzQGMTcIqTol20
HNEsYYcAqfcWDLHQDLhmXz1JGx2EDQd2CMVtfFog9vncVdUVRmfLdhwEdorvA/5QAYTbeQtCRPPCHtgH
HqPyn22II+dNqfj9l5YEQooME4D5AlRsS+cFtt92dE0EBOhtsh402eBEL0GgKde5KfsdGNgAzqo9y4oJ
gPvwMlbBbxt9CPQtbJuk7P1FN25MkB9suOkNQ41tW4sdXgTtbRXn+SyDPwygbU0MsCVMFYkavT++gbtB
+oXtP7NNAIDhg2D3igU+biMuLfb2nTFrjIDBcBQwcjN+IQ0QSb7gT4Rih4bNtmMZww96Agu6+BJtGRdj
OUtMBAK7unO1xTBu2ZNu24obpDt2ASWA+21t0SkDSPcgGQNuTZcE+7Kb4I1rKwt3EujAciKUG9luCQjj
/jjuDCbpHoANlHVeZgOeQbER6wc3bkQKLWAJNd2Ef4hQl4gxQAjzVYow3bmJdzweg4eXLTYYKTnGdG6w
olCiboYFhk51kOzbVog4CAJwCOtgHrEJYwuz/aqQlBVi3dixhidYCFxHBk9cevdurLQ4OnMH62kGcmR2
bOZv2zYEMAJ4UQ4PVHZcZAANYDkB8Nizu+9dwykqd/x3OHNyJm8gQjwXA8in/GQAD01XicdIidYRq5VA
rp8qFxtOPWZC8avWEC3cMg9MYPA/B2TBYNnw8Un3a8BMyHOCbTjScLN2z2NXu4AAitCbmlQGUBvrcZBm
etZOG5A50HAtGnhYP6l/qyEpwfbBB3QSm9By5ek2oJZ7Hw27Iw7df2EJpgaYCwwGTIXZdOkgc/LZb4i7
D4A8BgB4sTPCdfE6BQQgz7/paVMDjLR0Mb5WzJmobcdAcK/RaBdf17SNhr8lLi2zJ4DFbkm3ALz8SE5I
ItFs2tTqQIqazXRC23VRzS45bqvFcK9IYulMbcz0lCntdHnBa4cp0YjI3eXgLaB0cZDRJm/uvAgTkHIg
Ch1bUovlCXopeX89aUvSXAKpDtd1fCDZbNPBA3Nuvbt5ut/XVjZIcHNCJAJJvqX2Iz2NSx8NcA0sG0nt
vWRu0+sThhJoSRea4nUFOb4V6xcV/3cX6lcQlDtFBAazAusCswMPt0wkWAhHwApmCkQGX9phoqdwRIg9
iF8Ri6o0BNsEJAwSIgRcghYDhR75xAw8JtFWaV0PXCWgFXXj8uOQgJcKAbS3TPC/Ao69kGpx4hFJuRwS
8ElpHb9iAl/hb0cgBK9DikQ8BZCA7nwJS43HXYAFwhFITS7WJqeQXUli8zyLDyQgXIhUPFACBoH4/+sf
TLaKBpt8XBRicf7AzQXwktvHBDy7DSJLZAkF+WJKdV0YWADfLjBbwARaAlBFBGwcRvt1bADrw5du9nV0
SNCA+mQtczmeIfoueJKNFLtrymQoyA0KuBn7DY9hhEEkLbmt4Wjgv/Z4ID9L9GUUc5CJwe3A5JAdxegE
cHlX1xjFBi1a1azJhA0bnz83bsgoEqx2/FEcQtAKcsn3XPjulKy5JgU8CnMIBGtEDEl4iwom5wW3YFyj
+AB01yXSBAyrkt0tJFTJV/VzAlIJFcgoq18BOmvIRv4YT6IfUhA8jTVJb4rCFllKDRwcBu6BYFuIxgMJ
YRAgUV/8xedaeAXMCuPncB8sejLqV3yAfCm9VXgrNAh0PAmddTJIBcOiNy32QDAENnsS7S6edQ5GyG2y
6wwNeoNUsdhwxNBwDASAE6Re39hQomgYT+9fUoUUPKz3/+D1Q3ag7oduRgUqGX+keYA8DJtbCJtAvgNX
MwlZGUoCQaQEvwNTsU3vmjf8Ph4Z0JLvzhR11jbgSgpbzd2QWvjIgA/PKcf+x5KC7Ujv3xP/TwY0NlLw
eQoHDweSggBPV14BDcglBxk/gxScCwhQyrTr4eSSgh2WIF5QB9LuD7kJ99bB7h9hWXHwwqOMAH/rbHRu
McAYf6BeCDpih+kkz4MoCGXmRgyqM4MLNoYn3QsqFyeyQBgBOTMkCaslD+QVHGssboxFKAgP3ygfAN/A
ATdBgD6YdwtW9YDj9ixLXfuGcVpXSO1cTVEYRrphQCX3GSDnhlUbTRsHFxDBi+qaaFts4RDBGLj3QPC1
XbN8UZwt29XvRDc5dCZG0nUbAQnoJbcIbTHJyyLUdR5RHxh0EU+1fYnDiJUYRyhbwAB4Aegqli4pWLBW
vx8PUMYlEe2heBx//w/VkIjaFcGfUIlqZM8Lc4PSZTLkChAgAYpeC9oPAimPOkVuMGKCfteEoseI1B3I
GFp4C0Xun2FH4A+KwaKtex1qgtk2oi0JGLUDDY+yj7R7efvpEqq/9BWbFCNXPQp+ba5F1agQjXwv8UIt
PNxBvL8AIChyp6LtgAZJHroYkWsqagcW5htjx6JTjiO/KFpAV9EyYDEXxC8YRbftQBADAM9AILI8EB0q
Uv+N7mvve7XHxzgIWaQKzW6UgUxnexXYFoVHRbkI1xN0/zZBOagriLq/SCq0JcdzzBMSvuHO3CKm8UpF
YBDGtVH0N184EBOJQxmJSxwYRK/wqsfQzHAbARv9EUMwxkOAReMpkgPCCTOOLmwTs7kfH4kFcReZPUIG
H/xCBGpCuBnLPRNVQA40E4kEahAom+ijYpEqBsdXjCygEaBcmCKiTioaAdkYNQPoMI7wsgAPFAuhvsLS
VfRSNUn2aU05/gDwp8ikmnwa6yOwBjnK/yyeGigCRrFfgJuWeIHBt/lCH3dfBLVsLZ8kgoGqRdCgwThO
iAyV6x75wTwmgBds2nRTh/5RbS2CdlUC9S7Aw61W57wSo8OoSIsMPvXNKGl7d4Hez/aocARAMo+bfe3R
9/+KILhIUyC5lehzUE3+ERDMHkBrMQQh6mHHvgjqI1VuKw0+t4wAgRDEuqDjRkBIDva216SEEiCmrVnr
PFgCGcJFcY5UFaMvSN6v2dYE8Y98uO4C49xBIeAhQrjlBItothj1C3i/G0Arhh/cOdNZfSzfWEQLYayz
hw1IpCLGhI36BWdAnFD0jbT94ox1DfgeAT+WFwE/3AUN4EXp0fjt+CiWA+0LhPaefb0AY1AUfiZ/7nep
Paw4I4M8DzV/KRpGqh6/ApZ6nJPxtC6Is6KNXAwB9b4RbUMI/xAFG60Hw3NHjSXMWQIGMftMdx9B/9ST
BYs4XTJmzWQKS2x8ekGyqsO86eYfsAnLPkR+Z3dRf+mkqNjPtLQtmFXVMHPog76vm3ApAtFAlEiwUIPB
cYpqOwWRDktS0DhKnYuHYDOqJKIkDWx0TwqYpzRJ9Lb0zM7QiFyIILR8sxQfPhQl34tUWDHbJQv4nid+
+RlEr6GBIBAwd0VVXCCA8HI/PFuU9+vHyCQ31tYPkAAwbMZgL0yLSccCXWMhwt15TInyfTqUKapH8DFO
xeu/cWkQ4jTCKdpJ6kkPQ9UBw3JVsmBa0RhNpu2r9P8BrRKlsOgUzWQgYX9jSi/HKbpRvGkOG8SxA2Aj
Y9MrOfvBYw8bf9+omKdUJDBfAEhGTUNLSQHWgVCACOce8mhFvSLPPXwNFUNUNDDLOEUOYAY9ZHrYljbm
6wYp9HLzuyACiHGIZwFYlxXktJlABVknX+yCaSUQeHrEXIzk4DnYLa5PflDBAtpQ/rYAYttYug1SvA6o
JtDkxEK8cmAWDpFVRgGPKCbkYMN8DcfKtBDUz7Uel3AjdwvpRxAEBMdHoYSBYsz91iqXgAp0bs76iWzQ
ARweVXmqqj6qbsX5CDzwYnDCy+pmx7cBk7pLcOgUioxYFGYMjrwiDAwQ3Xo8J4kf/qgNHoUN/0LVQY65
DbgMxVsSJmp0KAMMgahhTGhJIopV3VSRWA8oJjQX6yL8kAdlBNu+OC2fUGZg88wB5Slqa2JhthkXnO3E
dvI9WSAL8DADSe3C7RIhQVAHUVC1eWgDHURv22FwXXEHiWlwjnSYGeugJebDnPMIEegI3CqugQnpBAyC
vxy8jWXYisY6oHbfgtBeMOLzpeok3CVeDI2DC1iexkoI2eKnlrQ7O8UAeYtdvjf6oBG2Mdstev6Y9ToM
lNcrYIcJVKdGMFEJUR2zeFeYeO4iIFA9kf0iXzhgREXwEb8oC3jZMFIzJWQ68cIC+O78IjQ9+8eOxc17
sLULU1VsJjcHRhIgliMj+fNEyYp6dHn5iscKHoBCPZBhcE25B0kSlvwrBkmguIOBQL4uSVd2yH4BvwiW
v0inuOllzbFmgNYCJKe/IhywtyIcXwqOXb8iAPNDw56wJ4nfSYiiNkpwtwVo0tlDW8gEt2wFTd1pEAo9
GXukMgO/GFIMdCG9DX1BeBi+ckEf9tnBWsMg6wlzEb8YriMqOEIPAkDD+Le2sPuODEYIQcZGEAz+R6Df
tkEQEQNOFEG8Av2CcYsYGBEPnOJTHcTy57k8WBkBjCQvHQqlpP4//yVwCiO/iN/qW8IRL7hWjaXFBhtO
w76JSmAfP4A/AnMIFtHDiluJ+49QqBaIbD7qXIvBczQFNHQTNqzV2ff7fS+FPuAt++oJIwBST0kfPt1k
6yQQLowJwoN7ZrZXN4R0Cr0QsVJZV2DTBgVoCA5oPlOFBDg2livECNBhCkyw/1DViQrMGF0vx+xAKYBX
Sw+oaVLULYDfcQYSbsQxqIP5CZhAzE0oFhavvwvqJFrk8/vtAT290VwPRceYij77ArF8SAxICA+GDRBE
is0AYAgAEhgo1A79QY1HvjwXKRr8AyFapAeyF31DuhtyhclNy5JBgtYg1lHGUNaYQe3BDdoBcyYN7D5d
6zKrHu6JnxspX9VIQO0Kj0HCZh8SF4rZ6VFhZ6Ji21BRYVBCrcW6bYgiEAFFAGENYawb65p4eR76gAYb
OGFuAcNaCmF9/8XO1dDNTWKMUTP8YkRtt7HzFHhRThADFnasRG2fCICoNkNGDbfB2QqoNpZBYvFGMBXf
McCgfQBQwz4hPEIPtlG/PBl2noh3lx2Ax/z/GkG/poNVP2n7K0Ao9cqFLEG2yKGEJ/OPYWOLopJDQhsN
Y4zV3NUQWgoBvUn/xgphrSQCtXpJ0NANvnQjVRi12SGpeBldjY9hIgZH8gwMAQNQbTUgDotTSPFOv9u7
zSQUS6dLCHYKowhFHIxkbGBNEIsfUGyOBexV80yqrbyvFsHAXAeuiBsA3qzpYRs4Me37wO6M9d4sj4zM
OABkAO1u8Y1tThAGA04QDlLAlxKLcxgRkfzggpYQf4vbpuSAjUIu5n1cXguggZr5GNW4gv+xKAboEOUP
jU0wjVVXCIuiRR4QEUSgZ8W41A6eVC2/gV+PchglgSbQMlzX1ISdEJZyfOhblXiL3odTLukndkG7PjGa
gEZLz2n+oT7Gm4B7UDqA+l8Na41K0P7LdoNzch4HnxpzBYDCqesP8DaG2Qy/pHsQ44nR8L40VlB+Zffj
D4AV93TLULoPc6oRe2e+RjBOuIFiYinbUPFDwI160BZyIAg622Bmn2QQDb/dGPVNCmXX6mll4L1AnCIg
IdBzpkN6F2IZ3kG5ZuqX5mN/ZgQ4PGWMNo1w/hyNzLbdtlDJ+mQEBGMOC7+gNdvOYgRhxsctzjB7Ijzh
ZIhna9hvEMzFc6XreukxNTTUQpsFuA6s/3QsXMoIrMhNwsLBGNUXD21uIPA4F0BTjqgIRLW+NAMiUlhX
phv2K8BZoY9h2FQ01aWqdPf4/7Q7wPYZGzcM15bshBcyRUKYBNvdShSEIwwEWuGBGMEoPmdbUggbGEte
hlnOY7C7hh2cjA+FTXUZZnEk7QZHP+uX/UNrBSxZSFFP4FXtWRe3tuGNbPPt0gjJ7oB7RQADk4oGpE1/
QZtYAHpPZXEqfwg6ZAsneBg8hZVYaSAtI/OpwjGIYQMVIdkQSMKPYez8CNjFOnuDO5ZkNy2IKYCxWhOw
nk5E9AyZqRODgQOvG/uF/UGD/0NIlAlTE5gSDtmNuTbUQUBe45XkHoLPpjYEKc9kTGpwdErTMcuS9GEc
x1RMifAwmv0dhqmBx0kBxnOp6ekkGwJBUv0Iqr4IY4AKt/KqqAIYyY6HZN8yFg1XXFm4HxBe2DNmB+br
FqBI1inoDA7AAofsQuw5SiJXZgIBhAHpCdQCgUfqVp+oRwBi1h1yaLnCqv5IJ6VFAgBMdiSCVsSwN3Bp
yKfoZCnu9ww0rqOLRDYJNj78Yv4tyFAl03ew6wNMifJtm0AAHPBF8hNsN2ei0vF4CRRWQVQBOISKKQ0c
qTZ19ww3E//rFHkCRbTkpJoNKbM4KCDVB0FYAgCwDB5JlIPMyFUs5YAwrVDsBUSqgVvjRQmLmvoPuNiI
YB4bTpaJ7QVKUY7JdhsIBtHevU26dXUSRhVBsgEYdwrrf1HZGSCKIndMrmH/VhQIBNA8CXdqJkBAsYGj
N2anCoBS1YZfK+qQbYO35QiAw5r7Kxn+YNvBfHAxGNMR2esnw+5uD9JWD0F3X3UIJARN3VFUAcJyHVam
ZgQvBsp2Eb98RcCsqkCGJlV8ja5Mp0yDtwkWFrLTQssXkcaAh+i10xGQCluwNYqGaAqOFrWtIMiAGhD1
7fbhFsuE0kyRhwwUEAMN5KBoG6Zg93AsNIrbt3emmj5TxKJvnymmL6Iv7EEXX5JS/3Xsi0CNHUXdIE07
mCA2ajVxNNKq0QlaFaTjqrFtKfQde/N58LNt25b8ERnLH8NAGoIB5agbugHWAFPRGZz1XJoIL9rmbt1N
QR9mWP94wU1F+/6AFYlBfBoBv35m/vcCQG3bWg8S0RjJBd62HW1WBMLAAY/OQNt1MOi4bZvykDxPDwJf
CI7XthdS4EbzkEMbyMEKvucr3Co3FxAIiHUyGB+WIA4L4BirIEEuxzAdnBRUGWxY1QvcdGQeCA9IArn9
DeF+AZG6AA+tv5ZoowGYgk1nyGNVEYAu4JOaWs22XBRFXuUCTVGEE+0kRQhr/kHs4nOVJnbLMfYBSSKa
32MrFtWis/khTI8EaveTScaV4g/CdAURLIhBYoomiahhbDugiNEa2TsawInoBFT8vWZEs4jvNhlGiUQX
oEtm6z/QicEmoDJJY8XzTUQncxQ1c8pa6uoYO9iJ15J1Mo4xZsGi3U0iZirqCfohR0QbC5V03G+IG7yz
wIQs1rRINuhvrN3B0ZJs67l1UMOKGhVVjDg0sXvpWZZSzYux43M5Iu1u4AEXPPtZsbUEWRi4vAIJIEEA
HewX4riAGQhBgIZJ/fVBuhoVH9RuLvitoYPKAUG87LO9AeoX1BA/GvhBN5aKH2hMD0O//nUPRvsbXLrz
BxpD8vMCdTtMOcHA469AMAOGjUKf+05FrXZyNwZMaYJaKNAYMBnQRXgT1QGa9+VxKxvHFpj9//bCATra
CDZzyRbaiWQmNBj8x3uDqp35CKZ3JLugeGvo2pF/xP/oJeNmuop1bPHsOoEC3FfDtDBbKfkxFnZ0O+lH
w1bh9yxs1OtIRoMD0HEPkmHdd1HNoD1q7RIrke1mgs1u2H9hCYF8HwAuGEWjFwh3FDUtJaU9ANiw467Y
cUmBOdahSHYjn4+ZIgZG9EKWtItLkKP2VLREiQOAvsgbJgS1dy/JE5bLChViUHSPiAW0dBA/ln8GIdkG
oKN8bff8ice5RgEaosr+PSpBDVfEyH2W8Mh4v/q7D+qgDgLvifgsQaXAE/tyBQgu1FxemMdXPiNGB/B/
hcEmJWyUiJ4w2GwmYYOtUe5jRL34NgrGHW3vHDcEuAIoEKgPmUerk8BBShLQwaJPqFDUQaN/xFJJoBqI
OoEvabAxAEO3ZjQ7NhnAGYaBGS6gSuQGBF9QNzBMxdjvSALbAEggxSJORzx89AWcbCQU3hh8RXcHqyKL
A7kU2+6GJYJY18kECW1B7Lr8WN6x66LYnkHbf1QnjT2d6SJJgAKHHRh1ohJMXBoJVbAV/4towyvdoPtI
RAUfND1BtLT5AZsH2xJLSzNIPklv8bi1CXFrEASxF6dzEJWJ54ezFQcwgiqgBfDbJjnpN5mxOcHGrb0X
CSJHAloGO83BftGbVCCbgHMJYQfrXFwgLhmaFTr1bU21CVUDGT44gEetsWW+NfIGz+iGLKK/S8BDogHu
JfbBdhq5GlDeGtwq+kuTBEx0M1/Ds18Fm19KvbxDzVvyPDtSBPFDEBjDLMEVYtK08YANXLDEtnYclj77
FuWj+gPmzWl3luuuMcCvDegmBDV4PpNgggbUdEdqlS2HLBuPav1q/VUHtEhgLI/V1V5L7kBpIecoFAvW
RTNaE3ysoB22exQQ4f2XvBWSSQZhS6ioCEEmGXp6RvEJewgLtEjyikQ+NOLuVVsoJN8ETAI2Eibse/1Q
KAwTzGvrh98Qks80HJwWONiEIXwZnDzPc8mQTDbavNrfgsgFMt/mCU8FwRG/6X8Y+lkwLhObRI1a24cF
bRd2Wp8HdlqDggHhv4D7gNNbCV+wGi7eQtN/A1iyYHVgbg05lQV0m/KywYKBY3OoZJADSK6WyEw4WAgd
SP+njtNId1/4D5P/9WoCcMgaACwpdHhikuBfrHJIiefTPBmwL1Egz5TE61wnUFOPyxhKC3UXc0ouCFAg
dlncBmRkwDEeGAxFCBqwAhA/CW1lkz3DTTM2Qw5pawnP3TxIB5mQHAxzptkhfUhf4HCV1bjritIginDS
/1N6DmAEkEK/Hxj0QqJjrMYSQa3iCw0Q4AefpYcRjUXDOZ94aY5Es2DJMR5srip4IMBAu/5H8YS4hN+3
BKuZ2V1LCN8P5kF1MzsLCVQIrMQ4yohkD7DMDxIbsg1ujHIErOROGorhIVEIGnRSA0vkSg1b/0xMJAwa
wnU/AeCMRCUqINHlcRbgwwZM8jSjHB0wFqNqsWgKrRvikP262FIwoc6NiTBSNjYQYiLp0S0shN0nY0a1
9yK+7tdnUBmhuDMd6QZXKBZ2lFr6TsnunsUFJKGjEPUvAguObEC+yRwDXBBSHdlhw40QoSGhkQ3YgE+d
C3sozg5ZiUQQX0YtnojICYvqoscftoCWmU7SyWqh51GLsEXqC2oKQ494YOqizCPkRJ1iA1X/82TdbmSp
JYUsb+yAcyRHduIQvKeEF8Ky/qm/LtEPjISwqTio/+PkhVAZqXlHOCEvhBoIGaOD11JCtQoZTokCGYdk
qT4zROkAchf9NqQd3TVwRKWkIeSj7PaIKHaKJcG0YCF5Yb/do/T3pEuqxSbVpLQT9w3VkWiQE0jyolEt
l7UhEwr3/8c/TrebTmOkfesb0Osxd4FMBFL56yMIyQ4HYZ9Duusa6g2tDHqaDPgCtrBD2H016SDtLMnQ
7kVtgBFI/zpIPNKwus0xwA2iyiUHiS5NKw6iuvVlUVsxTW4QSWFRi0UcFU1BiEXu63n9SyIaL4sKA0uk
OTcGCDQMQ39AMGjbLQRfxV4EtPcVWOFiF6ErgK5bZcVUpVUWWDTsS4RObBHdKPZTGGtMQzziBCCNDzgV
hYjUnQfQwgkzGEEJMMNEhTlgeBiE+ttIqYgTrjHAFfLkIA8zbi4wp/cCQWirMS5lQKgWbMsVfEohg1oN
rS0GjTSDrTrtsQQGtUUtsX1YBrUXsTGo/xYgCBKHUgEk0CMrvqZA4SSZwCC2r+pajiCj6scEdYVtA4Rl
MKJXKCKYvtLl7XSBwSFrNDIvGypx94Ib63XUAm1Ehe91fnrEBlPR/OWridnAtP2OEUTIVKXRElGWvtRQ
0etzMZUWVXV1gOa+ABeJFi2JYNdk5PRlQKWiuxw+DZZQdx+lnT/wMoILiyABA67cXyPhngakdXlN/HHV
wD5OIXS6l3VcuCTcdXY+rUt1OHgTba4CPuGmYqMaQ7tDDPtfpmIeue0UP4QY/whjprtFhOR0L5ki4JBF
J/Q/EKjFM2RPiP2mxCvS8BJYyANhqFTJAwSOXg4/YahMAbyQV6jFqMUIGLWFP2HhCNFAF0s0JDQS0LHE
F7ldqBgJM8IveYE8ZT5EKXsgkbKf4RtY5R0NpaU0wIIRHYUpHaUghlRAY+FiAOFA5QkKDotAhhd46I4R
pDoEuF8FX84gLqvpZtgBOEgU7KVrGLW5XMhA20FLrZQWfQkUAeEtQMb/UW0qaKAgKxMQNVsROElNYHAU
fAa0BJxLXCQww4coYcckLRAA6GSxIPxnrJEAFsYNlkmJh8sSwiSt5B72jFgQjaSx6R07WAUrkrOsxlwB
4wcHngZCicb/jaRTQutkPdGwYUyoNbjmL0YHRrx8QzlSyqXJJAMnHbNkOgyjFMrv6T2wHmBt/yUjdAyM
YQzrKlOPLiWpkg1GsoEXGH+zxnU/du47C28YwQCbD0P2EYHBusw2PFqfWsiqJZU8ZSWoYFfYclVK7gA6
rWwKDQzLcEBr0L+GVAKEgyOqQa4FsnYmqjeYVk3JEdYYeWyY5mXDqnqrmSrzycEKYGb1OqzZEnqrlS2k
I14Ywa+sdkiF17oDfWwhz0tIO7u3PDwCYAs1jkuVQcQ75F5Y1wZ2aP4NYnA6v4MExmhXjkH2xAF0F/cN
QgEdSbvQ7VHvYU8eldLLORZiAG8IFtShNpDgJUVMie97FQScXirNEAQkoZKOBPFPYA2Lc+8PsA1AInVe
8Fo6XUDgIHU/FFOqBwhj74DrLasLHXcni0Zb0jkCTSK7twMAV0FQvUC8FiORGgErCZYjEE1hwM8Q6azG
FAmB2B6wEmkUOfVAYtOwvjwxX3UNEy3rgcXJYsCU9fwEMRmQQ56UrLkYChazWTxzcpBMkBAesHhwXoyt
61DRSUca2M1V6zVNEgMJDhA5XekETwkrwcZeCElOIeAjOExkjyxYBJU4aklBkXikt9HiDElAg3GYOADH
GklbfkyJDllpgM22PiU4oFcpCziTQG+Q68i5G2yi0iIMABYIW78kdBD6SIn5BHRxAFoY8slKTHVB8R+l
v4WtP0xm38iuoU11lQBYagJoSbQq+AVvQ/F2OxJ1NLCmqEVcE6HGsmEslm5PU08TyQ24Kla7NhMcsMxZ
qa8Vw1iPSlAjIGcFD3Q5/xo2KzgyC3Mp+2+fFexqR3AX97rrDQzgqWEW2SVkEHgkHItH2kg2pZVANOzg
rt8eRZCo0mgY0EHAQ5c2f4hEnV50DnQV7RsQpxniKUGLbjA2Chf8Kd1zSEnHq4VGYAvwyIi/Nc4XGEs2
wwzKfFSraoGtlH3/HllhWiBy9c6cYxgk7MmzjWD8rw5LRgZbQeY1j7ARIfgifn1r/YBOyUN9cicksYoY
MAGQ163iZVSv6yniYBsSgsNB8xPzZw45hIf8/mwD6jEqrdV3sVHJoYSg6oekI+QhVzL+/3ojgBAEmf6D
iiEk5L02LAJFAAOvuTK4ioXw/FnRHIFSK/ogLrHOwCcwWXBQKkJ1R08BF4YmURwkrEWdoku/3Cu0TTVT
EBAX8AMvKUw50QWyA0Ja4lBvB4EKSY1CRpWBah/RtFI+2tubKgzeBnWKBAvAQf0NKAHldQSYPBF3Y8UF
gk1otTP6vwJuGfVgkxUCF0wfkc0FkYcncMczASObzANwzAbVd2DcXGBlRCQfYjawINE6g7O74iCBS56x
jBkzSAaFwYADRedM1VOJB8YxwC856d7OLOJnQC/ytECNcgn2MMgdcp8IAXK/DQEn9DQb1dZlax3gKNru
cAkg6rMGeXYPI2DirDIDhxlAuhuToetGF5Eu1kzIs/cbBBZnL0BcAlZBCzGIJYglsMARUPBhBErvS7O/
i4ASsLUQZ2t24KWhxkl0jXXQI9TQgr820AzUBnLHoR6oWIvjMSyUieoQdIrTvrtjFQaozLcLfHQR7REc
ZgqpNApG8AVaMJYB0XQKyYobgQsnAY1qkfArNZ6sLbQzwzsAy+CcMQ2bgFItFva0iyatx0ggxE406R7w
kS1rK/4xMU12wL6qXDYsqTt6AJSwQ3V0TwA0EfAx+m5eRHxBsX5YJGMgxBA+8bX07IVKbDAywtBvQvDi
AqYo4UN0JAIbJBKITIkL3RoWxuiZMAQn99i/ETRVRDs0eS3rPAG5ha2C91T/QoN7DEWFUkBwVbXHwiZv
CfWR16ORr+E3nCx448MBjXfQg9nWqu0Rgoa4ywOh1nROJWobUd1LASECeUHbNkbQiL9YSCQeRNsuIEVE
IQtHJYquAgvhJ7nDPoLJXz8gTWcmqo7gH2NGt3BEHbDDR3e4yOteFtunRRg+c8EXDAx+FzB70YnPmuu0
vOsxMf+xrkX1QGcfEi8IXBHt0Qn5JDNgEyjYbU5fMijYKiBCvgIFYxPbEK/f7OIjyL5gr0VzMODXQo5E
yqkYvuBT8sA7dr7rHQIADBmMLJ8/6RYWGQSP6DQG3AwCjgnTBTACg8Y/NqyAk/JkHeRBk2bIID80xkHH
LMk6HSk+NC0Mdoc/8Up9MD+ISDsmFzOz7ksQiDYZMOcEJKXMOATiCFcQpiwgYVBATgJCsZgoXY1gMgn9
Vrf7kUeKwhDabD6Rg9GvgyVB9mv2KrkJ0S86YT12fzl1eIswcWA1ufQUBzdwmyJ2Hmt1PboPq9i1ejmJ
9zZ1I0iCQxY9ySyvWLZEcLiLMg40iGAB3HoAwy99GRSLuy/LMcD04yAF/znZWrkMBDoYPOMbFLj8B+4E
aqkxB8PMBGrBoF42FQfApagFDd+zARZUimcMuAlG2YcBydx0u/R1udDAmqhKhB/nHSEeWdm39zetvDBF
4IYPXwrQsBaMmWKPq2sLYUEwVrp2uRCs8CK3PD1NlEQRm4sMT0CDVvo4gH9Byb+gxQMADa97SldQYWDb
Xk8gB19iYCn4tBLOyb1OKBgKSHakwTnYETBGi9inzkKVRkBdFbw2TCg70geICqWgCbuxAAtvHPTm0HRT
KfDkBKIb9cZM78fgdkcPLDp9/3QrQFw5K8j9LvkBRDjLdegEZVTBVtfy+IPncNcWqLhfVGeouvxMBW2/
Dcv+EIi6rEFeWxGMbSjfHXdMyKi4EexIvQEA9a/Fq3IFndgXY3BjEH1vDe0J2/UHbAXdRg/zDBw5S9hG
ACNEkNSgCtUL4t/cuGmBzgXhFK0J3c1GBitoxU/fCoiWxh4zr3ZK1TfC4hEWQQIxxjHJr99h92POHb1K
3g0Aj97pGgSiIUTHdStEIGcZRkU8DBGKBfXJ2/ZFKNoIQ9y3Lb/VHZV7HTUHdyjrHxKF4YVfMcApK9q3
FoyzdwvxT40knnRsJSqsCmU34y4sNEADXMdkzHJV9refurYFDb2gSYAaSDt8JBg2NgoDMZBCo9U74djf
M93/FS/RInW/CD2nBy4QxZxX+/VMiw2DFeiISTdykAZMaxRtxinmJmfmCt20FDHFIqVEFTui4GQQk7zc
vgXjwg9iKyw8D0gDFgUPKCARqIniMcU0vxxDi4Ilu/sPUK1wCUcvL+o4w08DWRQMGS3vFfFhU4QIartN
rkqQWorggDq87OPwjAdKGSwGwLk1RKXZBtF+HFwcKYgYb3hwyWk6GnZD78gBwSnCyGWM7qPLH80dwSnB
8UZ1k+lZdtb3D4foDKKTKOsQf4UINgyLP60Bz3hoRByBtHUwAcSQXjv+RTEfsQS0wVMnuzxFHHJGkO8h
7uo9SdgSYo858PzzjVYEtwtdINMWm4uKQvYkA11j1YZtghEJmn+5C1Cj+3BBxkVBRcIYLdAwiAxAIFR1
RyyWMB5BAOvbQ4KIUcAeCYJgQDS/QRyqAyCH0I4VjMxJhsMTEDoWLlFRDDjDd9pzeFiCrerBdzkevhgA
OOj/e1AivxI85MgK/+HAPMJHyrXXBQ9M1gpAYQEHayo3Gr/GPfSOFbQKpj/pJgUjiAUPZTQWuO8fgkuT
YuODkeBf8TBFddrdN9GkIIYdwxUzQEOMIJYTkRHiksM+JCx8YWF6CGAkZwcewXLIWgOT0jaW7MLaeQ7B
RkcKzjBYS/bALVEKzkguOexrRFJGPcvLLblkSJKSJvG34R1nwdBG3jHJSKQpCsEzFUcwkOpAfMD3jVis
2xCWoi0sSsMwFolHQW04FsEuoMJILlEBwepB1l6BD2TBFIGMLbJBZcd78plis2amwLll4iEAIw/BLBCA
tsoHMQ8dFrPfavfhZwanCwFylWSxHeR4lwawG//BWHTpyYLROJOTHIP5/wU3oQY2FzNE+ijU7Pj/Cazk
DeK3QAVpS0UUwoiBtCUsRiSQD2oT6MnQcHUpFRMGxajAjcMN7BKIE7nAueyPboCEVg6RVXUHJYWIzxcS
SUt1fMCFCrpGEgf7dmIRI8Fd0UN1WwY3UtASY9tD0SjfHraQQs8ndubLKJbG5wHM3UrIIB5Ie72814AV
YlisIwt3A/bsGABZ66Sdf1pMdXmi0NVtEX6cP9B2wTZ2H1iwX+jGA1y+diK+XdGxTRpSHTluODIgZxH3
GguSO4s4cyzzx2OiFTiL+PfmcBvvvKIqaiKGFTQEMABmQ+jK/7iKU5SbNQpKEQ1sEMj0S1RP5sSxgUKK
BA5NuoqFFt/FVzY3/RqivQEY5bo9QCnoY4GqRc/CoMSFLXgJitF2FC4W/kagrqgNVkxRxLMJiy4E0M/B
X2BPMBXYaUcQ5iD29MjjBnLbGYWEZkTtCLKJdLMjBB2CprA5LUjRscpFxkxiCp5oL3h7mAqOKfZCpCgf
03wG/xaeopsKBUSJwNrD8L4WDOJitxM7quF1tYwMmQKPMXVbGBCkDS8uEmJQ91BCvBYPoEwERAYprYLQ
FR1Ajhehe2pYgw8WpwmV1LBNJaQPk6GHEQ1Siyj/MEWBiSEDiCYEiBm9ZkDtmbAPyNQC0FhFb1oNqCBE
QLtgVbAxBr1AYgwE24cftGABDcajkryNKvZJlqwkmAel5QroEltC/8QVlaICw0XiGQRnXZzqDBqun065
7YICyB5Mc4JA0B0Q0pVMQ4JSNQhQBocAxQ5aidaPKVEMgAyk7nZ8YMEhG93cCUlNcioCmhACvwGTHWzb
lEplA1fGlilzBI2gpeMs6/FACxVLFMunGd2L7Se/0XM7SA0L+C/ThYOIuzQuD0E6tbYQFbqDdOAkcctS
C6mIT3Kx62d/Cfq9sN5/OfVGyRKg9zA39jnWU4b26NOUYOzZhU03CXTbA5zdi6zaKuhoWLcsxVhomlAm
UhTSxooKFr6gpnQZTK0BRYTn0cNF40HQBAojHYpg4yXvAcYdytHTUtFbRMEAMEAEglmMGghYACLCsRaj
gScVcwnTRQky8uMzxBYKvWsaDtsXqBlxHDJGD4TSB4voD+/JToH9BsqtiJ4korhacoi4QYyckFbGzLjX
QnsjZNjFEwZDMBjRQQHFh2t5NUY0+uU/ifhSdzrioahFcdwbRmxFMXPS5QQI933E3XNBHFOQyTog6GtN
OsM5SFRD0XfGp8UjWUPB98cr6ahFd8NAEZqIeHO/zsUvERE7YSgx/xNGwnYn1uVHCf0goIdhCFK4oITD
WKAIt3QvqcjAEhEvKfWj8IcLh3XKciGSxsAKAaPzk84g6IcI93Pfq2+0JLD42I4s30k2K6MmSuAO6UIr
cjyn6BYODt4oNx2BW2SMOd6s0+ua3s5mD3akhYhiWnE50TtGwS0oLxwxGlscjLEMuewZdBcD4G+7SV7z
yGKy2kiJlCSI1EALo857iw3ZzpjweBMo8pKnIIYZGlwUREPQQAaONQSNGhZhEXrNQSuoBYMqCgVFLcCH
UsOyIwBhACoe8EmFrmgl7yTsXxAvmw3IKiN4KzbYRQeE+v6D/wzeRyDoBcVAdNlKdtFhBdFwzaj/uYhm
OMp0PTupXOqQRE/IdPC2GECiHkCcTycDiG9HGVi261HshDRRT8gJ6oDq4ePH/cmsOc7WyFzZmSRguSX/
RA0kymHIHkWcXyu/Lib6BtGKA3M+vfTE1wMRhFkf1cUi4kQbgoNQIDrca2b3NiCYNDO69IbgVvw9csIp
0BqI8K34AJDLlZ8DNV9aL1U9EE9LX05mCf4ZkO7BdH4lrcw9Wk4AALc7Ec0OE5fOhihtv5txdQMCEi10
DUGBO19OThTEMn4yzpEMtyBA8QkExA3D/G+fvQRiQb0EygR0eat7BL8BGbLdf3LR0802A5bmk5H9AwN0
QgM7kQE5QAL+B6M7hAI4CzYCgE0BAhENqN24oNhSAtUrj88R2DcdiMVjQAF57+nxWmoxqogI7XUYRewg
tlUAv+K3UOrQpnSuRRvRGo9qySocJ18GFDGICjg2UR1ASxdlwTeoEbskcSRXnw2J/rODFMSNeuPNfh9w
A7ZTvx5B4wHYcjRbmHTi1lojcNsEZQhUecIU13SOCFA0QFZd3dxIUI3vrjk+LxY41TXdGzYWXOZPUAs8
3xvyNkYgCVB8HFR2TLZEZGAX1j13u2BPQej6ln7MnbInohIVMdZFGJKtxaUkDCMpstEeqNZF3OeSdsyo
YOo9GsyRamBsEEvAyGxFiUAptuvuQ4x1HRrUko25XEe8IG/y7tdmqBetPh/cTboDURuwRvJJMXMH3O8k
0z0dSEHZLWIEMdKD5dTqi1tTpPkaUT7VSfRNtg0OMzx3PeYs8kSy/8GBdYLrRzHtTYnWQfsluxGL5gwf
0M2o8C9SAa7/I8cpqnK/7PIJ+vDNm+sanrsRfmzFidcI+kUHb+zRHWnTkR7LQnJWUDUXeVL1yRGldV9S
kGH8EcZO20GKQwI8ySKVgvGNawLrSiNZsbYIHmgjM2Kyay90DmTSFiH73SLvO1IV0C5jmgEZkAEBAf9K
rsdAzoZEK4G0kEA/rlDxEMUFXDABICDQlFUXLhgrJOkgEBeIXh5Jdi8rmgBeJOG/OINsE0R4cyEzoIoV
YyJMVWJEHPryVAWBIdfErBgZFlkF1GINPNQDKA7gCkVbFSj4Zg9B6BgRTwtNN9ExEE7WMbXStngPhkYk
J3ByjBUaR19CWMHMUpfNBGtAGlYDA92qCLslVmPPSjOxxAZgHlf75xKOR+e4Yu5J7WV9uUogHVIRfT8k
oHAs6dLxznM7UhGx1YDTBCPgjCwH0xcW4oybing/GYfPg/+Y4CK461e2TSnyeD+73eFNCjbQJvMaGMZ0
D8w2KmKoKC7oRIcLS8EUVLs//P9qekIPjUerL54e62GQ7Fl1F/HDcz+o0rEd36JVvXhFL72NQd+DQxSt
xPgPxQfDt9sSpY4a4BHAvwwacvCX3rbJFKUHI3a7b8aD+QdyuTxxJPAX6q/Q30+8wAgUL+EB7oPmBHTC
nTt039ZnoMDxD+nB/pJVxDdHGVitZAsFJt9p1zqBWZeJ3wnxmpWSPfD00ZSxcrzXRjIH2Cbf5gwl7WzV
dsERK/EJFVD1+sgiTd85LkiJnDwmkRBOVW5P2AU0uspCyvGNiW9dLruFCLVfB0cYRyBnKG0hYLkDdzBX
n80SISERb86BxMg7rJeMCBzr5JUSe1uCK2rQ8fr3iY5DKOIahOcScQFY2AnXHFn5sVZVoAWoonkESQgY
fjACSBINN+6AEDCBPbs9/sAKUFlAPb+xIgDNBrDLDckhnRN0YSOXEKTehxiysWERt3pImwRMKGhQtxmw
sWEGC9y9QEhYsgNIQjgElDACn0gK4IFhhBHfaFMLQBhkZSVIUwRHiNp0DVJ0m0DEXIwEPTkEgnYQ2HQm
49FC0bmwj2C2e/sByVm6IP8VEybrHCU2micDuDUa6FIWtRY92xvGZQFkMQrrHfXtHnkoDCUw/SgV8u/O
+n2zWw8pFBhHQBgRTAAQ4S50fwQkruIFomHQ+wJ1EbAgGIF5CktgZBB02tzfoELCCG4P6AYQJB8IjUhF
tcEg99b0EVshosWJUlnFrkoSrDnWPEGuiB2KdWYTwiBoVj2ycBSRvsdDCOedoVTUiIQve31FMaIDFc8e
fWxYBYI9AAF+VDOAHgTP63ELDA1TfAXc5aqFKvcUZP4GLKAXAkGhKBAMchaBxyOiGBMqIUWGL8aAgBA+
HB/RWmAiMvrtD7miERcUJ/I8RrgLwDq3R0XalkikB4YZD1adGxR8UJzbbKrWcw8/HCIBtrn6gDlLqZ4Q
fy1BuCIASTfYM7hnUbhd9QUsFCPYRGFGuk0xhC4A9M2eCHO2diBnA4V7gMxIjYva6DEo3geioOS2IrfN
DgG/GBYIFxRF1cQJhV8bixTx1r+JB2u/MP9mdrYEARfDZiBq2kZEG0m/tSK7JziooAPYiRS+AYgnZ2M8
txl02QiQsd2Ls28vthd4BuFsbIdG2ix8SgbY3avpkGhrepAbv1BTtwCa7Hu1kNo/BaPQMQbQ7AFNeDdw
CUU00XtoikCEDczm/mAwxkA4AEXaVA8RoNztiVA8bFhAIYmiaAYR1T+CDUMkadsOWCOpHVgELTcHALGM
4JwZIXKB4pFBT78wuBArgiNElRlB3EQEJvYBBiuCB6zHBUwFZsFZFQz0WArigxXkyagiABSUkMk7A7AE
IGYwEHYSuhQKqCJ24Ax+PEAecnSn9c0EchQyhUphBHLIAHgooZBXyE7Lp5CHXMn6p3yp9IVMIQ/PA0wj
45Ack79QDF2nitkp2FBTKiglqAhAHskKN3KsDJ9xpooGIC7rLigYvi+hZmNQLCwPYEPiBztos4EUxpZ7
GHBfGoNYECpYsyIACTeCYDcnFQ4JdaOa3GTdCwFB/9cNQBdAEBBlMiiBDjCpOxYuJRYfWxjl1oot5RBY
/hb/skUII4LDb22hCAf2LQgqK3Dagm817MzhE22IPn3sSf/EtN2bVSVNIxeOoGPn0f5iAbmt5okUUlnA
2xHFMCDdjCGxh+0qHRyFsR51ahrcEQIGblwx0u8YhZvlQz0f8LuPirFxjHNKHestbYQcYDcgte2tYKEe
dWa05XVDC/5rM6rv+cHNAexNOfxv+bYIcefORS6ssFuEqFhZUkWxzlVYiD3dKLNXHoB3a5Uo2c48Vn4Q
Py/7tjEcQE7eH3fulrCQU8gkYmmxAbbZpu8dW+slN4Id7MgxdW0zdGTmCOLdwJdH3KhyYCPIBMVM9koW
FN9vcZSFwC/GzVURqeLrF9VX4EbgM9boINoQgOgKKOIFSCcRsNznBNgxqSLD9OYL6CXNEVQEqCS+AYno
QIgOkJweECAY0TI1YKmIL4qTagj+4BhQDAxwv6I/3UPe/YsKIN85SGMgC0XffcdI998c+OorOcj/36uw
9QGYsIizP/gv+YgDMqC//6mEorEx1x+cwoDiN/UBv9+9wIDihd/SvgcgUfCJyB6JjA7sjsEX1es/OfDv
LtsHxZ3mQE5WN4BB4SpSnVlFXWMYQNRwFB0RDHUSBUTBRQas+qAawPAeh6EL3gsDihvPRPQBrIoGBhSj
ZUBxENeBB6hyEIpIj1UHxFIgTwGiIj8+gNhB1IXSZfQLA2jnz3vdoTCXQdDdi09JVCQIRjWdIEr20KEi
AFkQY1xYBb+oqM1U0VMAr/tUUYGX3V1kSCGbKYjdsAyJCBqy+/8CdlnB56GGRMGQocgICBTdHWkGlHi0
G4SLEIToPOlV0TuCKWXjAQBdhACSJtfdPk0j9KOvbaCrkUDzKPf2qwSfFOJPCAt1YyISehZeC10AHCQm
Dj6F+4A9QTsW4kJQ9qtf3QUqDgEeVSAMidXfrIoeWyRpsAHDog3NNhGGff/i14lPDIOdoPLstgBEkjhg
c4mxINhjGPyueLbwSgDiYGCPnxBayIEfA5LhQWJCHbx+oCIk8/BZJDs9M64KDWW7EzoMOvU/Jr4p9FQA
Caj5FQK3BdhAOmYbXIha9Yb5ASSwIrjbADd1QJhcBQLaEcESRhe/D+iT1THdnapM5Q6/DzgBCwnFwS1E
uAhvUKzf0RkFD13y9//TSLk1uEX/ZJewcNmUEBHUdTxqTWjAFGcpTC4ielkRenVQ0UcUk6xZU/0KHhJk
Mdu249g5ef6DT44CPs746oByYhALGfAAdLC8X6ghVLTVTK2JelGtWPyldinAvUTBdQTELXgIGDCkCP7v
AXMxMfZ0SAVtKFvluAjY4X8sbGZ94xjrk0iLIG74QfW5CYFFz40eBAIFnQj4CtDSBimACN80EEACYjIv
GKDx+4JvIBYPvTGt6TwMQa7KmnY7oaJg7FEXnwYK9BKGPwDqbEC1vI1Z62jsDlc8rXDodhWlnikD0ASk
F3DSC+KJWHhZMRwHCP5VQNbH/xJJDpo48SYxpLbBTprgxDHthJIrQFUD0AkVVBwlU1BNhBfWPiOitwEj
fTgKKk537n04MS3Mq11kYnMlVwcVZ0RoOzYQyXYMY9qdDDAEPW3P4OXwvI5RNVgCPwVc0jUKMIhLC9aA
SdwiILoOmyGCY+wfbKiAdVKkJkD01yKy3wGCQYzwkBnbbNyUGXDsCfg9iHyyqE1GKOjsiadCML+Q2Bgf
q3zmiL8h4roeUC9kPDu/Id6hwcNYR02IScI5fcuYVNwV/3V+6ywfQV1vf4oFs4GIvZlmA/KQBn4GTmuC
DECNbjYkHZA/vdTeAS2nb0gjI+jnEMHXU4Ur6OsngqXcU40i/5OLCgo6q/rAD7fXNEgAQ1QMx5EaOxW6
MazFQNfu4T1lqiJvbcYDE7z9BqEIejewhIu8gja8nTyF7gezBTDn6mINRJEaJ0RxxjainQIVZwQJwL/2
PaBOueQpirMEghHUDfYPAQJ8RPjG3heAPzAg3E/ktWrhh08Fr5xgQwjGMguN0ScBfhGJSxR9IPBDKuKP
RIlcJGgwgjghdmEz2sMKItJmJw7khMBYO32pngKIhbxKmJ5/7xgjC7PfBfXmAdV0EIGgJhT+P2Z1bGx0
CBUd6EQ3lAdhgPsF1C/gAi1zjrbTnZFu0WgKQU68qAWtjIgGT49VUxhcy265eER1btXbBtcnphdSAYcv
UIhAJDUNADUwIPPu7gGCFiCw7wyK6ocqFvg8A3cKPPAG7YyihqLDQxh2iHIFpbaxN0g3SrmlMLAIMJIv
qGWkrwwAkhVFTwG7M1jjc/cQCwSakwzJgJ8CCAFfLZZQjACbLHwLWEEvhkmkIgAkAhJG/yyMQCsY9DmJ
gAaseEi26egxiGpH4infOPXqORi1QlyqE4twjutZQDNB5H2xQYyoreVDMS4N7gsl/1Yoip4vBHUrEBs8
ilthP5IHolJ2a0cBXKFoP/+ZwwKgg/eGpO2h8j1GRUE3jAEU3DXx6iDF6W2zE//O2BC4YhQkbDxJBL9i
g37/KaubYFQU+WXEm4Vy5MhuJSzblZaulkG0rBhRxMKKhD8vLAqCQGHlIsiH8HcQsBMKACJRwwI4dSai
YC7PGjPJCGrCjJnXvoA6hEiR1xAgflSSF3OLahhFdPwJQEySUE9oEAy3/9WK9mEv2gKiqeNIBSRBOIKD
/mNEJGTcpC+8ChYfKaMiAP8IYukbAM+KGI1D/U7I3hGFi9voAkgPQgcjagSVd8jsd9LNdm8XhgWIL4TA
D7ohkC8wCpXT+wFzTxAElBC4tfeqhjlQG9BSRsCmJkVYw+xRaNiaGuz0pKRDvYgYDwjqbpLKUFxmCQAh
UthDeYqYhnADI6gXf4mCo7Fgf17E1z5OIX0DK4RIyu6hlbLiQeWhIlRzZGM871MNPz4KNZDcVlt4rjb9
UJwda68vuP8AfxPoIKIt2r+Q8ciEidYcb6u5Bj1C2MnrEYdD0M3gDRvB4CC5l2OJ7z27dZTYWA8ff4H5
TFUv5Bewf01MnZ/toH4ITCFmP8YHA8P0msCqnxip7A8qPvF0eKPXSb3Jqm0QlArFUoOC3Y3k3nQGieKd
Ki5BfXIm6yF4ixiCI0R9k/RcDO60LQEF61k3Ihfqj7EuiLCK1arMihTQo4okpOqaC/pH7tLBbzZ1m4of
INMQxgZT7sAYNFbUvxz/nzqLn4B67vD0BQb6DiwetBsMCu/5SBiRiQEbFCvfOBOyi0bJPbbW736gOoue
XnWnDViVaOIlPgVIVkAQDlIJ4mTbuygMiVAUERENDCTfbAfrFgOcAosOi4lOAYlWRKkGEO+v8C32AhzB
4yAeDh5IifDMYmEFHlp0ymIG1K6/HCsJKCRQfxqAHkWU5caDS0uZGVQQYxBK4MyAr6RSNVmUtsGKaBji
+IPVhvfwEoB8PKTwUbjkaIOahJ0v8ADH6baq7V6W+IrABwqEGLBBGAc2uCtqhU3ISVtq1ZMk+CLJh1/4
k7IgE2ZJaDsjXw1fhWa4hEFbQVwDXVOQ6J5JSxgDptXqcJHEO6AY3sCuAI5P/wrrDBFuG4x5DwJBpwZM
nCthQkDSislVFJIPD4KKXHywikfyDCJFJuiwaEw1gQ5DWGWVBcxFH1ZREYSdIoxKTln/nSLDoOIYqVcQ
bwAdVhFPEDqDU0jPiwfYx1WwkADN9SYpOq+/0Sts8Fj1/Tcb7WyAbgMgOtUHCE7yWLxRYdaECIpDD4RX
WAx7DoCcFDCCMtsJduZkBAxoBtvvqYgG3DB56Axi4CQKBgy6D9jFaqDlDNy98r77756CswgYH8HoBiQf
DMCINOK7bYTxPwPOgCsNO1YQP73raa9zLCbgtfdGYA8M4CY7M/nARqJnDTMOuQMNOeztNR4SDPApDCQe
yIE2Dg+57xmSAEV5MZoKRjhwMk9mEORBCJGjM0ybQZOcPEKbIDBAqGBlDz8kLJAntpAi/wwBwnuLH8//
mgAYIZOagoTUsV/x/D9AHgCL7+OPIvAvUQexECqD/253HbACreJdWwdFvEhjNLoTtv1N2//miMNesA/D
sQqJyAcJAsuyLMsLBgcEAwWQArosDQjDPzBDBYFZv9rtSkCBqUAUdwVQnyyAvgpUCbRc//84ggZGWdXF
DfAFynb4XogiMiSXUD8DCB7CIE0DLzgBaMNYkbKgL7+jgj8IVGCKB91r2lGBqrsALr8EwUngwqXIl8r5
OEl8gtcbvhbpZphApOiN1CegkA3yDwVd8PlJDTk692b7VcVATVD3qyNUdGwh6ESLMOYiGoC4IlD1FMzJ
veDRzy1c6rslgWxlNXZACs//w1YbQAHAVD3s9ZWLRb15lkKQc4NAso6poGITnFCo9jb5IrAj1M3vJlri
+pYjBYEC9nV6H+821GFUqxBrxZcGBQeho/knJOxsJCDT+fG2bwRkCHvv6zE+hjQ74QMiTYUdIrEUqp51
rUgf9avy7yIYMhiiGyT2DEnBVW5W3+YguGv/TIoXIg4JoTj/FzPbYWBI7DgdKwUmGlVmJawjVA996Abr
b1T5WYVKM1Vjg6Zt/MX9d28h1F0lBXVJ2WGx1xDFc56kK355CFE9yM+W6OuEbW83AryVlbMbMdtKXdAU
HTZYV0BySAA80RF/UJ9gN4lqCJ2eAKKCBNWI/XBuBKwD37aMLAAmAKXWQ4K4neDXc7oRpRYADxEZaNFy
WDF2B0QGLWhI0YAcgAeBAhETYHrLOFJRsWz5TTVoa4UpswLQmihFM2A2rlf2MgGYKin3u2SKNqx6XWh0
ciCi2O1owSbraiIGAEACPDAxSYw3umGl5JvuoNOUswzyxWtpDgZXxENRBVu8qBSkShgwfw6JyhVrQwgI
RT0svAACQ7iFpFh+8C/wlJDqJh8VTYy2iIZIFp9fPwsankFeCMgZw18oEnwtOvAr4gSIxpW0DwfAEeAg
nA+hYUdt9TlkE/r3qQ2uHh4h4A4yi1YYbg3GYFDxNK2oEKCHFQ0OXImMVM2IsbmNkzKoCBlF6ktLDsZA
1YpHPwAl+OABdQZ86yEp4Adv9xV/khtY/wi6Tr0QVos95fIJJk9WQRsLeTNAzZIiQJysJ8OV/PvVxIcB
HYgAsRBIjYBATVI+GNNu0oylVn8LC1wFdA2YLN4VBky2GLsiy64Hk2pSdD7R2KeRDgBkncb80RE/8cq+
wJE3nCSQFQwAZobQeKA7RXYEYBC2Ag+7god0sF1go6gnOjciyheeZ2DxAZWJ/jcUiyBFB2AkvJOqOl83
FjwJIJyK6jr5MMFcuoezDwBaVxilhdARi450Cg38v1kIESCG+BGxSxCNPYM4ASNzJQhwb+x81oAS3tq+
nwvYQVz89MfCE/rWZu6y7MZb/CkVyhKDdUW8dnQYVHABO/0s0J17qh6aXNh3kL3GIggRJGy9CvYVs+c5
lEjsSkWBw4xLE9w1BhB32BiIAUWDvLMqUcoLAAdU06UoOFyUwMfw4ScMAmzD0+yPIgAEZEvYBYX77wSa
8cHCYk+5nHQKYQE/NMmAaAfQif9Gaw9RT5Mcp0wZrw/6AKoRZ0iNpKAadmT+KI4YyxRi0CURIGXETthY
aIhEYIgNHzfiAzvhtN5NQYsu8cGtobomNF4QHR3DAg4jbH1Jw4f3rIBcpusIE01YaOgMOzVBG0U9BASP
xYvPtUiJ4YqcfIgoVk8oIJIEw4CxVSGiDqjjMm1IUlEviedaLEhF/TH9blkNRSeqO1SECrfegCgC09rq
AQBCNYHH0EG4HA9R0o2IMVitVYuU6yO0EW6IqkilMNZQzR5adFhIBNAGNYPqVBioPzZcfez6yAEBNlCN
ehPme3mK5WBG229kIAC0qRgp97cIVYuIKkioAPXbDLEPo81yIqF2sN8N5EiLbwHZSf/IIapQxE9z3k05
1HgADaiFQMxDWNSNeJ9xczfng8AE9QECPVgE3cUd0ZRBOhxm/nTcgD0AtEzvMPta56po+HKp61B5kFc6
jR0jqPg5xgx4775t1tcefwyJVDFMCHTSTFiQGooDNosUqHUn3AyCH0yJOuk1MHeUylAxXuBMi1TqhSoI
OzES6xAJ1S+ML8hEicsvDCYVdCAVJ65gABSy2e0FLVQywixd7hW1oEssOwrbDydUMsJ/AOxJuQK5WBBs
rylRDyhBHQAtTCceoFohRQjD5mpRS4qV8hOgtiiwRMS6InpR8uveAOj7gJY2HDgUdRTHGesyRcFRN0CT
kcaV/usoF6CWfefBNcbnDE6KGnQYD1125oqIFO8nCc6J9Y9IQrUd7LUkyJ4QgtgquSP//LmoWkKozBCj
vUZGzLnZFBNpw3g8JF94bmmhKhQcZmlDCR+qGJub3z4JJUiwERbGAccF4DAkxrJwP3PbMckjH2fR0RTB
KZMjcCvjDIKBZ91DFxVvUW0caPzW66dhdFAL/JD+SEsYwGgqyD5L1kHtaCDtGCoBbAcZMHKZO5DrC7nO
enKvLICjEOGFyQ3b+f4WLAxnPC4DuuPwgrZEQQDDMBU/QAXJqOqIylCZbklFOs3QM6BIoc/Uggj4Dhjg
ZpBjLLtKMJB/I4NCCIilFm4DShB6D3bJXdXArdPPRFVMf8JHJIF20gMsb04BpDtE8FY1arpV71gZ6ug1
/Is7IXhkEIt7FTyL25AAP2LoVl3Dzx0RBqjOYoNSm+um/vA1/uXZVPK5oturgK4J6UVjsYqflgEG0aEI
yapq7CPagD4vGtpBHUTo1OhgwEkM1Rv8DAeyAUUvdAJlNwugJt8BRQcxg85QxnEGBvwqN8jXRxchmaAH
GKuiibgBp8G6d0381gJMiwEJswJBtqVsYADABVQx0sj3x+CjFdjD9LEGgPkGmm27AvgEt+t29Ck6A2kW
AhKNoq9vO6QR2ywCBUL4VaQAHsNtC6rdUv0HA08QUw5dUAXuQB82k/sWYh+kTwvocCjcRmz7HLamKQdJ
Kgex+Gbve3QwSIslLa9hAL/JYEkQUaAAyWCXAROJion03uzCiA4DiI1KQp1A1AtWHw8o9CgrgIWYPgJP
/2q2a/ZEiIzvBIiPGyxmFygIiJJ/tGIMwNURHQ7Keg12kN0UiAEPEF0QAngCg5wQMA8Qy+V2sHJdMANV
IE0QRdFQlIQAudMFiGcXiguzg/kJfEHFLyZcJDnIdTF0UKx5WJiwlSyTKGgdWEQvEUm1xQHMg7keCOQ7
iR+LAGpSRSq8KGJfR/d1LOlCL3ou6Q7iJ2AYWNxwsYCVJvSvhmZntwaHioXAEOkoVUrYw2B1flwsfA9r
RX8wdWInSAIcAaATdVNuXRAIIJ+KoQNh9yLo9XUz9AzCC6p/CfQoI6qTl3ABYL75+N3g8Hv4ArwHtIzo
wIQCBuAseDzpUL9uB5LgECYEzCqe1IhFu94UY2tMQ8hXaLGwL5YfTJQKDC/JGmuCu1sEmXUutwyVkEvY
CXvg9jp0SilJqxoi2ihfIDs8a1OU8bMBCA2hQF/WVAS8G779/2vwDkZRpukfzQauhtoVTdPf9ucD4YVR
8YHEyAFHPBw3QQYZ5H8PYPERZJBwAMGKHcggvdkDgPtlDygYScOeIA8oMGU1tYcAeWzgHCC+emokTPYh
FzFcOsCQco1aRCTOAWw/+QRAiARJwBCEIzSqSjW4CWOg91YgGgxelAMPkgWaIIpEBnQvwMBRIwBLqCv4
UgZH9kACuAXCAL5EFTQtpOABclW0sB+EGBAXKlnHwuOJp4OoLxZWI3hrAuoU9QFcL3XnAmIwokXxWOhE
7I8B1sF89Q88LJjfb8fFL8Z1UOtSEDrsdMki6k8veS51QqJ0F+s6ugniQC/ub/Z10TG2lQgKK/0/veJI
QS1B/Hcp/Y7YxYov5Qi8IGNdHQx2B2QI+wwSrigK/YQWA1WHLwkBh5eh4YWCv4nakGQDAYkASlXZA/EN
R0MvAZEgTQ9E+S+AXhfZvYKfGOt2Bb13KuLoCTcFjQrF2Mi/G9s2UzeQ/AfyUNh8RJfi9w+2UHQZ/QHo
EPt4QyY5xXdWzrxp/Qs+qhu4uW6A+gZJegS4vW3RdCc0MrmHHWTBcaGIB7Szs//msCC6OEB4BE/tF3tY
UQ+G3I1LRTzY7amo8CmHEwrsm5RtsW0C1ZuV6pvDjcLGIudKuZwB11MA+LSLqgu8CL2Qb0BhVmWk4wMg
QbIj8RreBrp2TwOoTQvVyGe3rEUxuqw9z8C3fG2pAnICVCWxUWF/ttvCBFALp0yR67G5Br3gWIQvqUsT
4ItSFI4gFh9yuKcgNhNrI/HMHSAHYS0CuonYHft06zaRi0k0cQHvBOEIGPFIEJvCLv/rGhsCzrXRjIAl
eWQ8RDxwEJVSAeEaLRcccSx4EdGqO6V+aATsIj90S2kVdazd3Y1A90op6tjosGCQRbULlM4qwMWEOdnV
KEoQPLmv1pLQt8V1GetST1IYiK8IXnQ7tXwq1BVcdgvdd9UxKiw1iHI4as1yHGlG1sK+RNbcw/bdomt0
CAfiNEcbxdiGIHspx4HYeJQiXlsQEw+coGgqCXQy4ofrUAMETJ/0EmPDJNOfVU35CW5cIIgVFNsaYfAQ
ZxABGDsCBBOEboXADaGqFw0FVZ4FAAeMJEjiU6ZuJKozwAuiARgSAXwLyEwggGGzCDQgCPBDY13n//87
EH9QQebeBRR4kYxYIeTdBysCAue1icMawpTBidgEw8PLAUSiJefmEHEWhKX4sSKYo5IkGojgSZbPWtR0
cCNQgH9vxRavj8rliopXEKqLVOCNSvt5uRGLRDiCai9wzLfY4SpHGYzHdGC2EBWAYgFhr90o8AakSWMU
FTf/4g2IXlF/s5CAS0X0c1N7VtAuUmUQQuvZxopNx1DZQHgBGfhTyF/npDEIICHrzAKAqQA2cq2lYGAL
A4pEQRyWWsTb+DkBIrRwisZSGIBw3fp8f9go+BZFiMGfCAxZw7ABCkm9fRMCCDHAWb8ovUCNKU6KRjkd
GgneKMrHBgU6ErS72Lpj9dt+ByWyvN/hFnJQC2y4Cd/8bgFHJNoGHRxBik06gGuFiLf5Ohrrw9CLaT/Y
7UGPS3S0GXSrOMh3Xi60gqcXIQyM4f/hwtFW0RiQ+uxtC2oq5XQXKhpgG07oBKlMv3I8xgRKQNHug5C0
jBG6bRPikB+LdV+onyniB7AMTWD32q8TvwcvPCr/IBDdAuKJU0QpswLkNXfcogeAwh7Sg+LqD5+OAcQ5
1oAT4mmF0hJFsdI2B/peHa8COBD1KR0R3WZ/iwrZ2XQJgDkuDcldEKRZWjKH5EDlxbtKANDi6794N1GC
Jr3Di75sWwKg92uTuxrND5DfNTxjo459dBJvKxBwLogaC7CFjH2TWh2ACQgGIIlwVU8Aak3hioFrK3DL
MkMJovYTTxOhQYpOjUVgqOjZsNj9Cs5ELYMcD1BxDwSg7oJtHzH/3BUQEb1APACeghoKgOCXMg6WtxmB
+y4BxADeZXQFvVDVWHFGomDjEJgEAHj17VxHEAMBCeMrFTFC+0L6nYXBmrZW/wNdMv3IpqMBH1Gpr9ly
sAQNh37aDv7YOIU9W9LwCC/rKyxeEUdyAk1aiooVNBGiAMAPNlG6/ByoIEcWuyT/4ywhCIbUimLwsfwO
EsfBarjx+rklLKtVHI693f/lj4PASXeGx0qwKJdMAXNZiVUI2oVJQRN8RggO7G7AlzVBiE4YCEURBE0h
FsXuAmdGGQROKb9QEOg+RjjrIQkIfS6C1qKfJkWLOgvouf9OSpxoqghfwOnHA8s9gN0mfolOZlYQzQg4
XweaIGIY/cWw/vIw65pzRhIK6YtFgIjXwb8VqOaE5zOXaHpfgtXU4Hto3z4YkUg0Z88+60wlUmrhBwA4
Mera5pIr7GVQ61FNAjnChkCOUgJIVgADHwoSwkExdFctA8N6pP/HAAK35RlRc2SG1cZxKG2DYshgGu9K
jAQBCeT2iVgJRHGPCnYbNJVG7sZBLQOIr+/YDyoSyJQfIJ09QLnTEigeLghGMoU/MEIggsWbQ4i6hUTF
8l84JGIsKjwwfy8AVxBPf0FwnpOgEF8jC+BjwIM9tniCG4DPkYCtANZ59JB4jgxZAIKAhwD+apJLoJCT
V8lkHEYU26AMC//I+4qGVSVVDAqiWBEcdCpttZ0FUNSHSQ7GkKALHxEW+H4IBixlFW6phlXMqupF0N/s
ohtRNeN3GO+DP4sW+gKjB8ZHIHoiLpMikgVPshDBIxAxUngiISuKlUMPnUu1RD39z814pFqoPsMW7od2
vCwv6R4BFwUerhdXd290IPqJw3czCHV0uYgDUNDyKEz8UesBGAzbom5QpbpOR+CJA1CvcRwU3raUYffU
P5FYgCRFCai3WsVJwYfbmKEouzddZOg7CdhiASsLleyUoXLdju9vfGqbtkMPF9YdGBMo9KM2fPUX66gY
POrgdSRiCxbUxE9OYOm97ETJGCCzXwjqpsGoz0ByPdN3fdWwsckIR2ENYWOT7RUctlFfIIzqpd7pDGrt
dlxlwB1UhPYVynYPUbFZu6Mcdc8BjOpD636Rn3ZiFzAIUUNZGWGfot2ZFesRJ4Z1+Oi+AuB0PVdjskuI
OgHlDFYCN0Bkb26JLA6tQiju4HwOpEMQATlndBjA8O89EEmwEoqMQA8I3O1jFnBaNcSEbINVmNmoCIxB
gueIyPexdFuRoSQWNima3HPJlRc4MdUCPnQlyOvbhxlECNxLF5LA8BuxPVY7BWW2BtbDH2shUHT3p/jB
cFvDtjCAO6A86rUBLGFFtLtQFRDFlkU0KajQECj6YJMFjWgiAtEnRAuDzGwiR6KGFWIBBdH7CzmwbEMB
BQPOAQBFFf+GLfw+6MwPC+zoCGEfaCo/GqJsKxoCf3ug+k0IQkPunwMnO1UDsSRMGUf7BNCqMIAYDQ2g
plYTNQSUIRbgEjyNbivzfTE4SHB0Or+LQ1puQOSgJ/nL/9Cjd9uOLhBJA/AldeHrEn//CwAj0sHnBE0B
900p52DrFAH/txECxoK2m/BCTQ4LuimndepIT/cFkSPdpflzG5p0sG5LOt09HlpyHAvISXo9eHQ9GawM
oJAERf1PxAoBz0FvELGqHfZ+IP8hBT1Wn1LRAQAVoSfFsY4iP+UxgIgVBKptqFO0dA7b0yhNsAjgSQ8i
HQk4oSrF5G0gOsZCsWwG0FBBvK2jAj44RVbdAisAJOHL6zjP5xBEE+ht1xnDidb6M7ExSE/T1t0uHQ1W
omLrcZA93WoIFO5xjrDbtkAPgzzezz7YE/rbFlRzFgKw0Q7+QIdjRcj/5006FPC3uemnIUxMXPTfugrG
KFbVQbMFQY1F9xu9dUB3hh0cvEGTXDWJD31lHRMc2B8TKtq+l+p0TUQ0acNGVU0FLcqEEd9TweBNQx5D
6D4BtWY6ROc/fUGGil6I7EEJ/b4I6ACAOg1MlIHfszSD4jrrP7pvRTzMi0J3vZvrFDFWxGVNeOk5c7GK
7mXbDArFonY2lBs2ixXR7ogqH9sNqdoJxangZpDU6oi/AYcwQb90trz3S6JPlg2FrxNBsAW4Fzq2oYrG
FT8ZPIrbISy4CkXqSO4C72gruAlLWE4W6SB4SYLheZAgamg0gjK15ojc7heLHcqvHxli9/RkLypnPdeu
5/1qtvfMUI9nZ0G+I6puCfmSRW08ckJGJpCacnJgQXTXUt+3AVrJgmgjPlNaQdQ13D64SZ0eAa8atmFa
IGkiGgGjqBZEWiv/gGh76HNAY+hbwIPwHELRSgBRBTqAPOQhOgMErgQgYLGSwxoQLRReXQ1M6N0Eu03F
Mf80Jb4pDXC+BmyY+KNaAeBuOBK1D5foUgL0OfhVIp2agLdZEI4LjjHJsQmikU/LvywPOPGG/1JFOCwp
de1oIGB3D2qCwrWIx0/d3QJoWasizbBWFTO/cLSm+GgFZveNaKtUamGgE+xUAN5tFcWIluw0AUwQvazF
ngohed62NrZI4Hmn13/SCNulMNUWjGYJ7zd5Mua6h8zd7L9VVuMCubIHcvvyv9w2ojPIAaYAf5MX2SQ/
3+W/CTlykqh5wArCBuzYkRp4MNt0KdfmpU44SNC6qAEWREu7anYhREuFusmCyE1XDbs3WRC5SQ28Ow0/
BgsivS804P4iNxZEvCIYrOwGC70WC8tIZOM1AcDeh2RjYIU8AKCrR9cDqV+zBI74x0CQ5ViCMSy5zbpB
ZaBialP/5R37kyoA2+tdvnVFA+vbu4tGiVmNDJ1HMO0B8aLg0+2DREBjUbDlxkZCCrYnurbrAQZIDNmz
IxF1RsRC+Vixv1oRf6VnvntU8rliswIVEkcHi0ZfWNDHL2wkIKDFDCIOIf2tWJwKDBe0odRDACqJDgWw
DJYBUC4F0U8EgTplInoJqpDitMoBAFkEIYu6RQcBC6LuzP3Bswqfxf/uIITAhRAGj5Bc60D4ISJh8IP5
KxshtRIXlmxICcq56wJMV0oI6InIsssgZER0sloiTkZEmyg/WiKHJSmCQ76mDIoiGBFkl0BVwBYWpiFQ
/YDD3odaEkBNgAh/ilVdqk76tgfSpKgeiYMBI5/lBb0iJkC54o0iTFj+i3cERRCK6CwMygT68Nh8JSwA
eFkDm6PdYRRiOBXDUUy2KFQ0iWlJXcLHgDYXYyIAegNqRwkR9VQpbkLQBOEIpgMIQ4YlaLn/anOmamqR
D8hXGd2gptoYALkWfYFK9OMaqfsUls530G0UQB+hGxCuA+BYByS71McQBuQZkBG3EoP5juzIMoMhZRAN
X/OZAUYLtiUcFTxP1xRJfA0MC25M9g7b6cYbYJsNUnk+UwWEDRdEBESop4cME/dwvgZnDQlMWA3JnhTA
ChcFNUXVJHq6DA0ZDjNUEIIEwmByQE74/9bPnBiiX1xyJAcBEAEGAaKQgF6SREyIr/wiCrWo2IsICMCs
QDQWMQwgIWVf8agaQ0APT71tjClKdAS6IgKnqnbwgGcCrCYeQUsAJ+kPaAwotiHjFDhAl4wIODDOEagJ
cAzXJkje+wIXGKI7JHxSYgFchDpSFZrAwgjUWTYHEYdWnisworttZSUmLl4IAxCeALEk+OrqxQkQzZF2
oGAS6hQtrGLuwBzpknEziw00qnqV671NBmUqAhUQFx9WFIsEP184sKIYF2YUq5Ki30KK4ks+FSq+Ad9M
CBSwnYAEMVlQ/1gUPQtm9WEn0EWVIcKWivQAL5iMLoThNqmgR3A5A3pcWdRQP3GYhkU9osc/oaBBiu4g
KwSwBAy3exSDP4OFexWhZiIk9mFFDVYQqU2LNj032SPFQxPHQwiNQyIHZ0EwVOpZUEFso4EhGwcwPlXR
W3jhExGPwVIS9Y1esP/gd6Ju73cIWv4ozIJQMQHCMYYTRMH+4gNgTxfZDCT/Xpjn/chhrmh8/hjXDZBD
omW/UU8riLEodVgPDQLBKUi4r8OqaiFBn8KFikEBi2lFCN1BhUbDZXfBLsBcDbVNIU0BldQqitiIDihU
4ajh4KlgezsoJ23ZOlgFB6vRc2SSDCyQe3vpMexdJJN9APgjRjHiYyBazyshJum1ZHBVMFgFe2fkbAj5
q69khS9AENtaOzccdTNlxyraTAUeD0VQxara8OOaYBXsNskVOocxwH4hjIgGr2dR2xYA9V8vKVj8KLxB
pRBJOzoSKtYfCnAQKfkBLU+K5oQLNPHxWyupsYZGUS449gwYqwIMOf02URt+SRtELJQfLRLiJoBglrMM
iegHFnWEl3Mpf+Vt0aK2PwPNFNoNO8MjVFvrdEl3PyygAYt6VqFzLYlRXTaQ6D0OZFENYk6OirKBDMjo
6DdMFIvqD56oNQjg4Xc5ef2obwSuc0NMAR0tC+LChUBQVgBlAA5WxBO5LCtqNWIOzwAeAMX8LNQABmFs
oTBtyeAvLADhQjgNV5lhLLBjcFhRqwV2YU6DJRUEcjcFK06GQkJih4o2O9RFiwdKDckQtvtlMx7raTsG
hlsCdSG+DfLZIWw394brbTvKYXeGDRxfdH5Jv5N1Tb5FFxpUYCwD+RAB60+HHRnCQ4Z1V3t0xsOptk0/
bYiNSv+8olHmO0nN17IiyGD/YP5GEYO0BvcVC6uiBC91AUZEH1l/awBCL5/xg8xzFG8PRqLJEfvPH2xs
CBIABR4mvzSBJToEd1/CH9goStX9cL2bWYmOkkTGxi6XRVMItL8Qv1Cs6RrIIVL4O19ZNUwgGDtmf1AA
SAWHVY+4P2IhUTHDLwh4wqIPHKIB9BHFkIBjiMUZ1AkYGE8hsaiIECkZBKeg3BUFeYBY0BMeK3lbbMks
QomCbzsY4nVQDKqKUeTkSqJBIRBgNZKPxrUB2xMVAXnWvEEBQSJJIP9B6yBkPy8HAhSwAdsGeBD9smgW
0RoMIR9svQaIGN0PMDlB9kaaGQ9o96a/TgExXJswN4nDBjEv2MCOzbZKWLizPhCZqDKLkmqQIrrQEEas
TPytQSZ70hxONEGKVjj3akhEk6QYHiFFdESIVK6eTR1GwajvaBA+kiKKk7HHsQFNiIBJww1S9YrAsHrp
RmUogk5eWEXwpoXrE4nDv9jFoCpTJonYYQvfSQh15cWoBSjshAeBgMSEtAGg7AkxGsKkHuuw8eRF2IsP
tvKrTEYINhZj7u5fXEPkYcvyk8+wo2GJRtRXpLoXogxgyQHFs7upJIAukB+t5AHkATJZb6IBECABtCxi
HyVfhHzqsgGXoQGiFiBf1bQB4fIwpN9iVsIQw0a2VvAzrbsLIPyIhwSAzwE0bCrqr6yy/aABAJAj5KNI
34egAUtIRW2nft8QUZMCYJNvyFMEUt/XsAEFu4UBl2PQM5Kvkoraep8B38GyqgepkAGc9FgFLVOfKBU9
AkCrQkUl04uQgP5HIMZHKAL9IIFBAD8A+ZKif7ZYIkmeQj6OWCJxWCIgjxUADxi4AVRLoli/HOMPBuAB
Nr2LN6j6NvlIHyRRugE3aweiGNgD9Z0Bf1LIi0i/d51bQqLYr32/EJIHARLFiw+/2buFBMitAZtzvzai
ACSKHf6EnL9Z8Sr5wa8BiwfiwUMXMUhXPybsGo0ISE8h8xFtVIEdC5U9LICBQghumA7YLgi9OzmwGG2N
BXAAaRDMtUCeI5s6GMQPkO8IG7oxshgMdgB5BqUJ54yVG2DfEHwxCscYETYgnxOrZiyveEfYV5BKGPbs
IBywbBU5lzzrVhUN2MMGKbzrQBUczzNgk0EqFREFFAioOSBctA3iQDDIdNhZBAMBH39jSARDVf4SkOhI
EJ063jTYJRNwO9JMJ3UQiLoLaQ7IswYQfxGjHoyA9DV6lLNDkTr11063w35e9BBgugRFV3yFkbGOAtaz
Kc2bqYB8JAXMU4qt0JGCXOo8ynYsDCmgX9U8nSAbC1gE3xqNU8CGYLQkp6SvPJnogDWw6gTbBL//sule
QMvEXb8oCI59qCnpu5OQvE0kEfRN35UEKQgHVIJwohMAdAd/NgM7kLWRMzGqTBLnpTDlti90fRIJLVTE
ou9YQLJVNNuMM5a6By4Yu+0iJfR4CfNYCPK3FtBkhUX1s3qA7Saw86NQMKbz9GUH+K+KRwFv8+ySAe4K
ZQWxYuZMIlWErICsjFu1Hq1NUV4QHWUgoBCINfsfAC0CTbQrQYB+EQAtPBAgWJxvVqhwwNyBHCMdaK9L
LXAJbcVebrbrHWCyx+s9EzbQhbSBdFtLJxVsLbCZoAY26nkLk4j/FJL/FZJRIgD7QABTQc6vS0wKGBhB
UH3u5pqIVNAnMj0dmAwUnwQECwE9sgziCdSYLCI2UA2K95Q8PrmJBV06IH7EhrU7S/c93PdHyMnVPqMP
kcIPgCEXzSC2x9XSuhFnj+p0X4BwH+GAEHfQFSNQwj5n39zXUbQ+qj9TwUUdClq9KPaPNXpUvOjkU8G+
7dsVMcAplE8rB3IOyiBuRI52ZoYQ4hZE2UNQhpwV3F1eiywkcOFsiceurHgQdBAydWrhBuFgLnRhiQgX
9rBbB5DHCvVOvXRDBw4iGMQrkIZEA0BdKw3uDdg+txmH0uhSck8FsEFBCIOWmMIgYsKYkBUcMqpPPE8Y
VbwgA1dPIA8hH2FPIkZPIkLQhFiPx+IOgi7cTJPHQyhhSwQzIadOVRZigaM7sEPM4Ic5oAhc6U4iAKAm
kAJfzAtUta8D/1N0fZAAEHeyh04iRDQrA8ks7SBG3KgSF/t1MP7ufyGi0t51Bk05ZSh2EAqgyhHAcnGg
QtESUNcdWERiZ1XBML8AFjgY2x//QQbzQQ8HcUGi5AxF7ARAx7lQAZMUsbu6a9Bf0EQsJtCrbz7DXoqD
Ua9BOXk4SccoIgbRW7FxexBw9ccaukiqqC0V+wNHOC0E1LLs3Ha2SFVQemEcxwHwjSpfiAbrDKp2uD0G
2leXTEtG6lpQKZLqyMhLVIoFPcHK819CsCDFCEkPpykaW1IDGnhYogHCewNDGAHpCTi3pWWxGNkk1JtC
1CKeFAWRkky28auT8jz1geGi/+VRokHRtmXe/LazFP9MHglnP/Zfq3JFCXSbAQpAhCd1Qz/PByHC/yoI
g/kJdRNyY3UjFbGaYh8RIN2YQG+7kgnIQhdFRRcWAHx9fRD3JUnRCcVKTADG5DGQADreR9KBqGRVrzX3
9/G4jR231qQuO4sFzw/HikHEhS39Q8oakKMRy7plImi3AaFDr5tD8YJOAs9CKUsMQ/W+CXmEcYZHIgQo
AJChoEtEcQBN0BEaDO8cnKnoRMhAB70oYCnCCw7LnlS0BzOrx0o4VDSkohdEQTCJhKtHTypqr6dkCEE1
S7OlIggM/WkZFDjKbQhoTkCOerpT5IMcFDKwzgF0ezM5eyuLO6moGyAPIz87ixSxFAG+xVT0irh5YIH5
MAkqtxgQj5TDFONtzrj1UUbpU0BtY2b3OA8ZG08K6EU6FUU+f0AuTEZA0UUrTURalubZEUggI0lMwhMa
CroifX5cdK4REw60SaK3hbeZjtAFHSc97nAbSKIIwS+AnDhbdgC3M3bTGi0MHKt0Mgo+uP9FfVCcgA4h
BEYABAlFi4T/opgwKh4PH//8wB1yEnbFSfsJVtz+BR0ggHs4AnQfBTkA9/aMigdE/N5BPB5GipjAPZ/S
wghsVOU4XCSfo8JQMRV8zaPiLS0AoWPeTiRVLBtzSaPexU5qNmd1mOufzw4WbQuybrpGhjgUZIraqkMF
Q6KUFdQLEkUeeiPiA6ldkUc2b8ZDGQrg9wWIQxg8AiBHdSlyBHXrq2EBdC34R488FSMAGAXtnjlGOEFG
js9QUIEPM0wB/q1XrMq1i+qEp2fVBAxWR4QU1CUtijvqgzLB7yCHC1UdtxQfZUjqOFZ0i6hGxaKxg5j3
d9Pt+h7iIJVBgeYvSQnWeAReCIjxO0WEb+IILHBFLvP88keZYmQvFPeFDw+FzyR65wL3uEVM6x3v/QNq
W9zESWFWTQH3LRLEkx5BtANzP4xd4hLoi2ukKf3wrhYJUxSrPBr4AXUPO0kBuv76d0b0uYf2wCxFQ0EH
SHeSngX+u0Z/R8j0KB51dIoFkwBB1roH8LaEdwtjDFpsEGpMKrWAOumDIAadOCC92IFEsQJ+N1skBKeA
GIqBagh2JL08NkWVokLTtBAOnREUQwVxK7XNnwe0AjcCWIjxsVCRwe7wj0WyCA75RIgnRIl3AW73BQd7
TTCIRwciIGYSClkUlwVvCKLCCo5cndieeULNhjRCUc07pxzZjSzjOIqn+D2ClgTVHGBOWBwyKA8frzhG
5JUcQANGRDwgSCAPOUboKYCx8s8v9dVuFURynQHIBjJIlzCZ7HYc5O6AxkM3gAsDKknAugRAqQp/dk1g
UxCm2sApwVC8RQLXGypMAYFGRPc7Skjb1FMHAWhiRvh9JkluG4w+ACMRRVPAUFEy7BinNUoBsHiJJ116
9WB0YnxJ59IBkaYD103XO2KQPqacRFA5XsHqBYpD4iCJwdrwcHJQXwXUCFoB2AWDlGVJ2ImuETU9SbN1
KWdEqJhB1IsQuqdLABxidHQQdwK2VlTeAvKIHO8DhcGbVaIIRV90fgjrakXkJDUQAVG+RIpDCmJvG2WT
Ve6EV7UY0kU6DA4uDDgyJ7jv71v1qv/SZ0MiAGQrACZRkqFGkR0LOGacxxZWLYxx32VBEKRsvwRfEzRY
UVDASApyPAZPAU3rAgVvVZR9p3IrAVADoki0IKjacBZPNStOy9WquLB/78IdFtaCKj0wzznq4bAvSRu1
TUdxISpVO0N0LEAwjBenTsJ3hOoM5ktsISjxVIFbOE8FakQtDTEAMHZsFApyQZ2kQuhMDFR1FHEwpU7x
wE3ZH10FJ/h9TvhMYlbJKOr/TLWH2oYB0SysPoxqCaqOQSkgB2RB9IllDxHihs0RtMD7TfcJrChcxWgq
Fs+TUPBYN0rrW89MIPglakEEiwmLUgMUvALYeQuQBG4IdRGIFxQMit/CfrZWBIlGAaQdC1tYZlwhHKot
GUAPg/hiFCOZe0ZyfamiBZxBmLjD+02iRRP/SmwYjCLAsic/bJ9hxYQHiEj5AG0C0ezLeEljgiWrqLkf
iiJcROxRS79VJIgOmM6krQSIvl8W0OmVZk9IAQs7GRfPwghPXP/HMMgB72GsC0K4QH9L9ExoRAPS9+gz
GxyNfukoJICM1XWErY0Up99p6fgDIWBF2U2bSIls4f2xhA9zAkiLbUcQHlGwTbNLRz0jCAd0B0PW62j5
Np1reYyDZXInNjAYAfsqTIl8e0nBwqUo+TLrwANiA3tA8JuWjBFAEI71+ynoAzgxZ0L0CGJHoClDTx8o
FoZE0X6o5nvjE78gi8YAaU68xIo5RjoQtUjMFDpJzwIDPD81Tz0soEucimYCmgMN2IA865kQKyxC4mER
QbJ2b+gmEnbrPiRsDVA1oI4DCwco+SuTaTYMpw0cJABqJoJqtmQBTdqsTB8JbkoKgDaad4/8InZcAzJ4
HDIovhBmULskBmHs5CPwEiirSJcdARAEKYk7j4GwgJKvTCwgCEDfLBtRkTjXJtxjASI+qRAcpj4iJTpR
nCKKQ/xUTKJYaZVxVcUCesuwopEKTIaPQZyoGiSVUEaCYlYUgIAuI1h5Oo8wkwd5srUBUNoBURixgE7C
Lj28Ua21sAF5yOCXzpcCKxXFAhqctbCTcTYes3QP2zwmYAFtmBiyQDO3zZLRcDDpMw8NxRpkAbd3FtBH
ehf+UYfrIMdhZF1dZF9gIXuqS6oBLqt1tq/ihQ0B628W87sAVL+sCasGO3VV68ZICDqAves9J8lih5zw
POUKjMAfFQ92+l50PCJACBoG/zFCYAElT4sygJb9HE8L6CDAMDzUJjxPKJAPAAFTDioL6BAxTwvoIRz8
OjPyOk9SIacApjaaZAAQ/zo6Qj7IAk8BUkwHIBGP0zUfVfOM+GHejR0ZPc1gOXxgVfQxPSI+AVYeCbHb
lg0FmFZFV44RJ+tcOH5WScyBNQZkbEIoKDNagAGAIwc/4k2qaP8rK0CTAvKfDRCzsRrvs9UZkiq6RN83
Isl0jTBFDXkPGYCuFNEcNg4DRZc9A1G6N3hr5Iw4VhHfboBo/2GEO8aDwUMhiUskxkNYNrNtuItJixAp
LA12hI5WIQZ+Wv1ecayKnlt0Tgn3O+HncB8tyAanG4nY087YSARSrxjZHImtii+ZJXM0ACAARlMkRDRK
8v8IiQZ5NyI3njDgBPKnN0QA76fklTxINxM3VnxRCDkgSTeqehhCr5RYYcSRWKzN0/RIIYjDh+zrQ4+E
23QQTYQrdnxedBmCWRGo8BaQKrmzE0yJ6FAC2ILsV03eA3zsEKAaHknHRg7tbVuqaBCyPinrMcAeCT6i
aBPMnxvwT/Q9WF9BKWRZQkkB32EV6FzSH7M5Xz5iCyCHSFnVJPgwiiUVkDUL9G+Z4xVmW31XXOueiJKr
AD9uSTUUXYrqdIJ3uGo3sFmJJddXvQsLHMUoXOl0Mg5GUeo0z1lgnIyOUVWwj1GZjxEN2IG+K09swuhh
+WBsUZkkAaNfLEH+KlE2ixlFNEAMAhkwCk8QsxOiXchYUHUYDI4coxvyR2xSsCfJJwWnpAA0id8KoyhJ
h29KXmE0H4Y0IQdKJiirMDjISQ5a+ls4DjNJntFJilvNH8CNo8seyK6N4jIrvB8WdiEvk2q7Jh4ERh/d
ICkfW6cKozZKIR+THCDkGNAyxUKOPJIyWxpUMjwqiylXHxAyAjB6CLsGMh8lEwXyXS5XGD2EV9wwM9Iw
HxAgeQUeLUaTXJX/MDAfRSrkRVxsFCTAqMcfklfIIe/gxi4A/B05wL22BhXmLwwJBQ/XLu/ADqHAjZcl
7+Cm5JJJ0NDAyCuQScC5LhiKgEzI/5KoYlRvgqieBNQSKYxEvEXJhNvIjwEiRsRkqsejBtWQKE2xgBAR
DwFh6m0FUIyCW8eharemU+9UrBkZIwmoBtpwgYiFABEVolxUHDzAGKlqV+88WXy5V6KIC81scutNAwHb
SC983qSKeCswXltBA5AkFkohyz5SzgIGSDwEdWe2UQjMFZNYrGJkH4UguQgAMAMXuzNcVIcLt4HEfMG1
TUQjsQaLFH5qiRqoO9kRKxRYGxGH/RPWHb4QADgEJF8FK5ML2saqqigE4Js7AGYHN8ETZ4MpIBYWwSIA
fSJIJIMr02dBESqtqnIEEwB4MB0HgyJemdQBYERELKolAYD4tmB+EB8V3J4AjhAPCImUFrGTgMi0t6Ki
GX81L/MSRTHhQczirU5SRgGMpKrYQ4nAL6j9lh8UG2UcAwlmnh0BPwclCWgrRwPs3UNQaRaJaEVmkBFL
AuCXn2U8Po+qLpBZ6XUJgLGIiYIgE/dd2tSn6PBMsR5lZPCT6ppQxdEOn/gAHyyomDLa3OuMJXwDEueq
h18RbQMJgFhLvj6MNYSEwcC4gvBMOEKN3Xh5KC2mx4t9SAhdANC7KsqEE+oquDTKIn+HQ0EMqz87KFgW
NmiNZYBZI4Aw1jAAjvA7OpXDikU4hMRm+d5UMAuIIU0odV11tDACf+JJ15EKXFBBcUhUARtFbDnwN8l5
i032FtHVD7ZKyi7GIWTwAXW/6zR/mgt6iDhnbQg1ECyIeIdIKPm0GzMExBxCo0yLUPyYAEYqdTdC7QUS
jB/GfEqzCALYGfaf8B4PVXJe028hWAGcvSolvUX4BaQee2M8weMZvYayFrdjHATbMs4mSkZDBGYuQ8Ke
UE9iZu9bZ4JlBA1JDv0hDmwY8F3rFx8461VEWiosvCRbxARM12DbuOBGRL8DJ4cGR+EDOAgRiqYnaOTc
SSYAYxRMiyzopigbGT4BGnoIQLHM6xIUpMGiT+hRw6rq2EeLaFwIN9SB+gGWaHkTjxTx0CMBzGDSh0Eo
6CFcEgwbxGiT2nDCgyANpTdmkU8FxIBJDAmVrCaMKLEffEaBgmRk5TmEjPDwyXQvca3CkJ6NhewxwCp0
rV6KJy0bpAJT1oUWIgEj9awBlelkUTTwDGMI+oDlFzw9mIaEtiE2eFCQLJFTOsBuozE4IgqFtFXwA5Tk
tKQhIsgDSwmYLtuEdQHkybzVICUJMCBonnfOIBf0JQQiGITZAmYEvEEjaQGdYAkVl3wgIt2TZwcjekAA
Kel/CLaMgFCPRp3BEyBcF8sPaCAFQVc9KLsBcIogtaQg+GFY3/T+/zckoIgFdk1IFdHE8OD4IGIHLgsJ
Z/kmEEUSvVocVkXsGAABHUAEAmIjBLw/6AiaI5yHhwJLIyp5zg4k95cZSTndGMAJeH13GBleIFoGUQ8y
iHpW7xlFI1CygEc4Pb8VAyDkeFD0WE2DwzBi4ZFoooaVIz0fg7uQQI4cAB/pHwHFlxUeh2cBw4SAZWZh
aIEInuSuyYwk2CchB8IhaBjGAyZMIGBJxCCcHCSKVyIwPVaFjIp/UnGkYOEH9nDGHWuzYM+KW9SMJyiL
JAjiI9PPYosdY40qNRZEDKs3WhXxghhlQxfESe0gII9NjCh39gAgAEAZDU0B/QXbX4TDNStAfokS3H89
9UOZjQl3WOs+dQ0As1+v0ydcs7tb4ofXAydJie4JykMAugPA72EyCrFNQIN9NWuKPyrqEhQ+bQEvYUHH
F+ssfxNA8P21TCwzdRG4hr03mFD11QdfJyUXEgSzY/QFEPtkcOyGgC2aSIlq/AESAAuMHJlpLJNxIEYi
ak3sSQWxBYlJ7Y2Ktor5+w5AAK2BRXqJKAIeQIuNNeOoqAA4N4tRwQboxcW2a/yrLQi3PfAi328/AmCI
IbjVQjvYqMRMJPNMfE0pCFw1qve/62EE8a7XdSPrPp9B4YBieMBtzzbGdCUidB0Hb6MIMFEoyA9HjKI6
idw/C26IEHHr0ZAZYEMKAYj94BH1agxI4tPpChWRMKAI0tOxTC2WFVUFH1MAnbETmnoZIxkAFhgevyQP
WEQfAWls0EOKKr9UU4Obgkkcv41DD5nbO4qi8Kq5SCnEFuR4KiJViZUBlAvKGUoOp4wNaFaechTqoGFB
dGXgUlIAH5N/5mCQvD4FYbuB1cipAD1SBcepHyKSAylk+1YQrIIFwIVX+QrgNFdPIAghRi5gKGZiL1j0
aSE3CDAbsawAT68AetX1iCV6UT6eJwHcCpP/0QaQiBoSUf9h1BDx+fD+Io7VAXlujqgg30UAoZYsCgwg
ZKLgFq5NkAJ1Y6AfccoMfQB6bqYFD7C9bTj/gH2DTDIWEkV9RUFswyVFK10gbw5Ct1deBzHJFm6mxVIB
y01jDlCt4IuCru7KcQa7W25VEDYYuZtFnaOAYVCJA9F19AugSQLKdzvBAlUNB2HgNTHCIljk1RMADgx+
BCTghYEBE79EifdJCOiu8VQfIpYE4iBB6tRc39hMUJxtX96nF3IEmiofVucoEgewKDhBErxrd0XBkWMj
zBHlEaRHupG8I18VGBI6ER/oLujYXOcdIpE8hUCKO3gBRhGgh7zob7aCkFTUGC8CXhiujyNwkbyQgawK
EHQT6CFYBQZ6cBXwVitySAIxwAqGfCHdgHkBIPi0kBFkxIQDCJ4kLJgcIpwhqWAgGAkVnBAQnQiaZqQg
E3I4Ew+CVPAJHHQ6IiQAmoCBQKfcWIYj7Vov5AjYkhoJVsaFQ9lwSGrSb4OzNXUoWFgc3A9CE0YFyXyP
VZ414kRSoEJyh1gLFAWUwfvjWg5K0NV1D74KQLGC64A80CYqznREV11gYFkBjj9EWiJ4a3u6OcCDgks3
rYAVgiGLQRMtgAYNAUOTBRSmn47UIPRlcjz5cfyjIp4EAnJc0Ed4A5+WTGKydEyLXRUyf9Svd11IY8i+
+zHAmwKAiRDwEBVr6lbBjnqsrHNMKlptQDtybGbqTRDdCFwgqInCnd8fooJkO6C8LotD+WPT7IREQ+5L
cQiiBHVFLUtLRkS/XV/9BS1xW9K4E6o4dGFM7+2R7MceJ091XMdDOETYDYJmL/N/ARCs2Q7En78+Ta0Q
JRrIFx9Jk6hoI4IUGo1gdwTUQBqFfwFkOhyi4uudMb00CkMpBcBVqIkASoANzn2Iijukic1NsXDMCIVd
290Hi4YGE1skgLVJCCCPi+euqBaiKUnpdoIhdBDH36QPgM0qj18Ji1OyC1W0OFpUEVtfFuFDNlv/Uyhb
Vicap6gYOWGiwlU7fon9GaptBRjIo1BOolFEqgolW0dUbP6Jywx5angOXyyoD1o9wx9EpaAfBICLEIB7
fCN0b+4b1CO4gSgOFnMkHklGebmCDsbBN+vLh8cD6DthE0k4ZpCY1d+2cw7ZmDOxpDy6KXhrZ7+/DiuJ
0FtdRACHSH1SvAtQQ6UOOv/TIBgAESu0Iu8oWlUcWMOt6KOp7spAdMNFgwrW+zGZK8JBN0fpbKtMbRxS
VOxBHCT4T1C4XCyqFJbpTgiKX6VQCItQMaB2xBGwUBisAyjzbAggKGQtBlQXCDCOCIM4GFSJUEAJhV+N
scOQVWdUic85pAt7oNH2WK8IzKxFhTtwJp8lIIdFGAh/G3S/QhLB4Z/QOUdbiYpnQw+XQQJCW88u48LD
Zn8XIsJyAQMW0LuJRjXCD5Mlj70CFmGNj6+NdcYvI7IAEAAAOs25UH4fNgX4x0QtdaAI8ABmMRsEpvgI
N6oFEb9MehJGLRVEAUfMNLsRxTZmdvxn6lQIBC8uBcQeFAcO9xZA22aDDOj4xnQ3EgJle7svD4cuF3yf
7N1i+84Pt1QsZs8EVh46dkRPWDZ1yUTN6kmNIgMtexFbgboFi0knB4X4iQL4odcN6IPn+KtHbVhRRYop
+Yl81nFDHYHBx8HpAw5BSdA4UsXQXHccY3z7W1B+5zn6d3RFFRx3ievAAt1bGdHT4wvgCv8XHlEs5cCG
5JBNQv0CFDthQffDAOkvlQjgdUegvEQJ2QZ3CxWT/113dk2dahXb21X2QYM6HCqRdhtEuQssWtAMUrXu
sIV7+iZPIXwnQUCwuu/mZn+MjkvgncdET5AvCx1FDC3CBkEPX6hwv2n+CXRBB3S5iHgHdq8j/5DMIux+
wpiZeYOLrYXDlBD9sQ042l/R6oXQdfrRB4Jje3oEwnan17vfXMU/AzK7AABLVHUARWsgeENreo2hdXTI
Mf83qApLnwcTSol/qwC22e7aUkQpydPiSTT0+1addCuFwmZ5fL0M+O1Ze7dlD4nXcffXIfiNBktVtA4P
SBlr3wzucuU6LDf30kEhAhiz3UKRQUkYpEWWFQ8qGgJ+POM7U6UNd3y4AA5qkAc6OMBgc7DLz8DvLHik
xEG8D5yYDwFoDb/aCaBCFGUksRR/8B153xO4eZC6AeFcAWe0mGNN1jUITBZ3INCUaDdew0bzYx3lY8Kc
9/EtNNDy0jvIa8BUUkR0cXRj7szUxaKCb6mXEIPGRLRVcbOyxtUaIKL0b0s14PBuFfy3AXtlOgq+KHqw
0amo1mY3Kv//4h9iCtq3W1v4+AH7IMhLuYLga3TQe5AjeAvt0FqwjXVnv7PbhkLQlLRBRQnhOW+3d+P4
c2b4vAF6B3x96IM/ANSOIGZZsfffg8DtApd/TxhNAH9mfqiIC3IURwDIcyykD0Q7c7xHp3Tnog1/XEZf
ARF330cGXsMPDX8JSUiDIQE5qEg7QzzWcGxzBRsPtgS4luCF8G6tDmNiTPeYDXX6bwvvwflMMfbadzkE
qEyJjYWNYxR4tKLsG4FxLMZuj8C/BpABFkUNwfh3PHb+8cCNSv8hyAHCoPB7/0xyBy72xBBq5MFmCPcW
tA0Jy4Hh/zgbllqJGZV7OzsPgr39qQlfpXkKjUhHzgHGSShS9QvML43g7C+gEJp0JAitewfcxIWFXzAr
TYnGR92CR0FlO2m5+h0W0BIUD58bDQW16hwjh3MsiA20CC8Sk2yjvKo+eAKbjEnbdduC2BTCi0jwQCix
ZAqgEPHYEBQwLCW/KrEY2Q3syTHSJoMYGBgVb58W0SsRGMTzEZcowVUk1gH1BVupA87Vue80K6BHjiUH
Dt5DGTjikNuhYhXETIijoy/I8TBMkH0ECx0AsfCG0dEDhQ8i9MMCiAgOfv2E1rO/sNAHSgtrwQj2QwEg
GEQN/w1bSLoRQgghhBBCQch43NgOFgUpXNHoYvtH1AqzxOIFSCkG5YpidjnRNV9I0P8QPfbDA3QficF/
W3oENBPyeYNiUewaVBIcdetVKgAXwCupYoy44XgS8hjmLdCAYHcyNim6vQsAq/oDsVGLE60CUS3njPK4
IedumBgDQj8JRI1gQQWNgBiLs863QAMphFh9xpLdtnboDJwp96MBw/+3LVHBTSUBAytQwDXX/cHgCAnF
D/8IyAgFN3tbZdAzZjnFyYcC+4vYu8WKOdAPh9oyTCnqDzgUsQ0d7QOGhW2Ja+pp66DtxxMF/NygkNuO
hh3YBhEkbInB+q+pBUWw+gsR2o5GHHtm6Ld8E0ig+HUX4MHtzQE+gbdpJQutdw0m4uAmvG7h+x3BD1QI
SrRtbuhG6aU1bHAJnB9J7QWdClKDWwQ/H4MjO6g9VYMrUeoQdXthIS/AtcHqDhT4HswWwFA/YPLNYNhG
QUEe5+BCRBTG5f4OE3gQCEjHQQiLjYiv8HkQxkGslflpGMwFEDmVO7RM9pVNSxKV5/o5Aro9fdWrZvQJ
ifYKutoMiPoUjTk56ZwRDWEGYh86hzkJrhBQCIAqEQWq3YPlPeoPFcLMdR3zWFDxVxskLiTkRGYRAIPi
lu2w0GfDV69QAwaWk7MRqEMWWQYHWU5ORjdWCQgAODkZK1oMcp1zT4OKYRbjpQodFmIbULe08Rj2+oBu
QNihITCPFMSZCljsczHAAN7QvW9fEs21Yv2D5kqfC6FLQkP/WwUb+gIOrHPuVCcgqQwb9xxYN3lcrg0b
9AaEbvJTsw5Z6SW47uuzDx5dJ/EiWQxTwo8PiorsM12JMsKRkcIRXOYtwyBjXTn1vOEQwfvkA3ZSdEO3
XkiJ9RF0K7Njd7MBURezEnQTk+69iOCwDLNfbQS0KXLWnr4T0RjA9kVMDUS70avaJvGpfP2YROrAiyia
BHailqBofBQIhUMEuJRkuG68CYBZtI0VNXLT6xQioEHbWjDgoNgw3hMxD4YfS+3oht1CHsQg7pI0Wf+F
jW62K7c0Tmb3xgAQM2iwQYHh8uapQkHcFkjvzOcHoC21xPZBKfww7bb+Joyw7tfcBRB0ZBGuhQcJEjbF
DUNTutYB9+F/6aWuVHOZCKoLOfGPdJDqB414CInObwHGC01qe+kNRpKVAUbFjLbBstjg1mCK2q5KgIjS
Yo1NDogTL1XtAlTNvuBuuinBWprGAznOWhgbRbGBBdv/2OzCpI0W/g+f/gQIBXwJYCbliA6ITls02y4l
RgMGAluvdp4RH1GOp5MoQRAYQoRsPm9QaiS8iwM+YE05Iip1gI0McGKJikPPyuL9BaKyNuKEgOUQdTmN
oRDRoeScxj4bDVJmxERwWmyfqYjZJAjWh3BB+CZaqYhVVZ/Fd6vrgzh0oRVtbEeBwi+qUK5gplZVMOEq
wqYZ6QhVU9/SOWhwvXwU0HUAP7DNvQCAe3YIb3aQgfoK2p7VAAHtirwLCEEo7M8zhI6B6v7vewH3Dqj0
86vOichy9XG6be7zJfLmBYQCsw22Mk72wIb0PIDJ5/nyEIkCgsAbfug5wrBaMghaQf/PVoeJlwIYr8GD
1+2GgPh9hTL2wgRWiq7T8LELW5wCKUUAEAtNAcXOBWPbyYHQsx0FvAjYRUfThVYNTIsrQTnIgNndMgx1
6TnKD0TQbrhzi/fehewWuA+DdzFK2PbAbc7dMPQcRRnftg4RclhtlZNNldgpO6PTK7V2jqql94AIA21G
6ldqgaBQF8+WcqgeBmi6DujhqC693WcASiUO+EvvDfjGRkGR+qhE7qrQeozrpeurcmoCgION6O5rFITD
0uFIBay8JfHrUbyqZunxG4SNQleat5HNJe7uYJbl7uZOZ8EkDsLCgyHfHeuGTxDbWIEw3xEJfFoV4OLX
jYE1t/DW3iPSjXcX8WAfbqHWoJN+CqnQOl3LvYvSBuoBIep2mXiCdOlApMD7NPeNeRXRgrCY95K8BaoH
TKd/psjBiaACgyQvmKIiAwIURAX4TWqFWAgVGv1YGoT1x3nEDQSBbbdaetBIg+BC76/adqvdQQTxQleA
ATbQCxTxfZs1Ieix+GKWogTWeMgpBmDY7edxCo1BBgEADdtv1+APkQQRxkEVQQMHAlxrdqwATogINksJ
hw597IOID5umOxUg3EsAscfr5zwZkO7blNUwKgsGAwERDA+6AoFRgn/QBJlMJIC4eBM8iHjMrshGg9et
cL60xky3PHiieAk14EzgSAQ8Re+NkDQVwLk8MWcZzt1C9kZPTIlUOCocJAoyFfSzyiNIb1CVBzb9D4Wx
qHbEdzhTQB9ECI1ux95QCMHi8AnKKuh1OQN+36iBVq8VAABvEEEAHgSJ3mD5mBGkaC1OUF+xOpG7AYOw
LV7nB0BbU85FA3OS7Xa7XRAIa/IEY/MWa/QEW/V3t7TbDlP2BEv3OPgHQ/pBDNsCO0P9nQdT/kT1F/A2
yrZsBezoAuUJ69+21NYJHdo4Q/IROPjEpSBwDcNEAysiuq2DCfk1e8d6KoBvzhn5QwO2bbOZFBjxc/xI
yALRa2637Rt7/0rHDQH+BxwGNGptdwHKIgHXBg/fYQFMFcvDGCVOFQX+h0S4cYADganqbwMtIN5B9+ce
ju3e0PRpwvH/ECnHJffj6HChyRIpMYH5ORY2HQLUJ4c0Jtnt8IwCR/gPOBlRtQCNSLkKz/iLCGYXTeDw
SYsIIlyJARBBb6hYggEH2neR2+06vhAIb/IEZ/MIgai7FNNf9Qxf2Ay73WFXQwtX+QRP+kN9hNDtB0f7
N/xH2wHYRbTmLkYMGjM4CgG3ELQkA6nKPUec4WFDNgNEOtIyIINm6BqLyE9/OVegHh62Qi4EyC7ANvCJ
opLrC9B9j+NjQD2hfDqIjA2LFM8Efd2Dct5XRK5UVN72UQdkIlCNEEzbhg1cwQGhSf9Mz5MBGgEZhG3N
R4Sue3LmiR+LVb6FhHZNLGH35mNO+A/hEIRtqyiM6BTAi4EGsBsxk89EflW0jA51lMA9x4MCBxqg3qiI
IsVhsHNNhG12g1IBtJ5Pi/WGiA0Pvwb+ZkNBDIjVzv6/L6/ZNLAGQf5C/EP8GmWwQQX+BhxEEdjMRTn4
BwYaBXyD+AJD1kFgBhwK7Awd0zWqGqYyQtu5xl78a1B5DQeF3OWa221A2c4Kf86Pc72zyfaPdP4j6j5i
laCWORSdmYrABVeJ0Vbu9m1qSAsJCelMETOgkejY1HxmkP/NfAtubWnUVQpuBJnGDDHbAReAZX88weOt
CthwKoMJzVWXo6r1P6jJLVeDXgO7QXCwiUsQFXQvKiT07cbaQKeJ2M7vH3scKs54ElB0EBOJYEHhkzuJ
GFuNZgR6QqD/TYnP+9rkqHr9VVPlUOw4UbxUA2pApCSQESSCDvHRuacALtPkdfp4FjkKIBiGHANAJpYN
bsbqHrRA+TGkKpu52Y1Fjk5KVKHkLCAYAX9BWkFbdVyDtYIQtyWLRJZsHtwORJ3bdhi7bvG5AAbX5U8x
5Cqgjog3DYpdGHtC3hRzlIHEqVEMpAJBMAsCIhctauvoEqmLENoEA3iC6GqJ5nArlFcLAJyA7QiYO6AG
PBtO0bd4UXRNvhIcKC+0mjy37vAkNxtIEDDk6wzRMGkwPBQ4Cpoq4CD4UO0FXwvGHEANG/bYg5NAMIXP
lCRQEsGH324+QD4PWAJi2mboj92CiOmBvKB/RUxGdD8h3EW/ULJlDf//0zLh29iOTYwA542kYAIAACsC
In0LHg8/B8ixu/gBdCFFEGZmIBnkYScQAhjQRUNACTcGPAQ1PgGijrwj2qiGAmuBRWQMgX7BJcokUPOX
bD9EFdq2QEQFZNTY7hcAcKP9QYH8//9DEbwEFWPCdAnh0VVngo7NWDjz4diiYFZB+TIWmiCILXuNxRgV
PKMgO0hQw+9hbKMGQF5aZov45wgC5t4QIT87AmiVDD/oMWpEve8FADajiMNIIL59Ix4EO9g4XFhQWA2E
B343m0FcmY9OPUBaYRkErAMwXmyAHA9l0o9jZ+ggw/ijn7kIk80GqxjynVdW0cBs43m5WNJ7WLdVhIu+
MocHs0XdEFyJEjwjlWURKCjshJunqogxjvlUdAL0c3VCuSgNiHpB8Ek0aDHA75O+TzgoHJkiMaCHIqAZ
BKACV1HM2Bx0ElU0YHAABHBkEI3BLliAezoyih1XBBuwzCmwC6TOXLCImRYxELLBziBECDmUVynDCVDB
jQNMVMwI4KyemgHBEkVMDuiWJAKzBwgCvECSCLRfi0UEQjwCVcgBkoQ3ovcGr1jvRMaJBxGvoQWRSJdg
9lRRuBEKA1wL/kcFP+c1RmKNP+chAOsJqQXoMedLizTU33GIJ3RDWQKebOKSUS4F9KB9X3XfCXC4JyoL
/fvMj7pCQLxCuWRv9cNcnNzzpg+X65LAOBzYC77CPZOVMys0gEzyDyj0LjUf+1M4FX2RQYPGxVY5dOEJ
d5hPoZBMizdMi7KeQWgGi4swi4ufJtBNwERjnXWD0u4AsbyFlA3oASDFdpsxAwenUChiVGc9jURcOOeV
hk8yDDQOJueJ6gS+ANIiElC8+LVEhFAWq1ABzzLRyLQQCZSfnG2AEh+hhckrsJ6Fi5WjQIwDA6ynAkYB
+er4i6IDvcHlBRUsqiZfdwIPIAv4SDtXN4XoC+oRCAOsCvgi/JC1RIm0SAxoHOsW5I8Gg/jkkSlHUHsv
d30EAaEKH7NhdEFg7d8XFuCFoE/ri02RVRj/omAQKDGMCIhUTMEQkIIQrJ6Q9WIUjHBZXpA7jMlexjPw
SIvU+AG+S6jg7CQAAhvQSAOLQL3pfZeAffYpkMBBWUFagkiLrMEngiHM64N9bIM4UjKQ6RUECY6oCsT4
F7JhEsVuX80En8z+Ek1tHHqNNkk5VSAPg0jQrM8sTRCJEaE2CeghXukXr8JTIAfIX0FYMThAUBtn8NEA
nnExFJUyh3AIvATgEOsXn4AQgYloqHflIIIgD/cDCoZUHV+O2gjgcH3yQ2HW1/uRHYsEAaffifJdEgAM
4x3pn9IDjG2VcHWSDGoS0kMaizHSjZh0iwr4XgGUXhicqHwukb3YYWqWdWBk2HOPM1eBaxDuQeAWe7TE
rRSE0k5FbRyIUGxYwp/fwUiiA6FIBEFg9+Dp8UNYAfx0K2oG6DZYWm+yDsCUbUjghIcN1shucUL/SByo
EYphUQITEq4bEk1feBVDE2aGEuFPKRBMOBEBLtNdJOp+cCChDUhuKHhfh/wbuSeoXxAuBkOLQMGQ+Pi7
SPVwqtFb7CZMGvfxMkkG6xCNuhRIUf7Jww0Yqk8z3KAVSfHRv1Gr60M5wHXgSWvEmqADlkwDcPVow16G
Cvrhk4AG+G3uw5Gg4khwb87gqA3BJyzK6wixbx1VgEgDGE050CRUtg22InRCaeB06MYbF7ikd+CnegZp
2YsKTmzFmKHqhLRuAwUFt0/Ma8B+Adgcc0XQ/okA96CrvSByAVFsugTU7QudTQNDOclAVIh2Og/MAlzV
ruAsDA9xBQRbjCN/CNjQyPUGSimO+5alwkglYMf6ZUR44FbKzP8jO15h/AEIukiDvCSwHjWweOOZdTGc
JMx5cCi6AN0bTCiq2ZWwciFSwjY+6OAvXTVOW/AZ5aRbEAaCV7/baLMvARN0UUiLYy6I4n8jqhQPiddA
wO8ERBKXqJpzdxv/CcHKFYDhRvHgobGVClqqcJ8YcsElGhEmqkf+AdTvW91BiHgBZZ/sJ2WC/v85y3Wv
PxbX6t9qVi+eLmRlYmbHQGqIwiWTxkCpvUAQ0SQKoi0BjfbQVLTxhdkBQSTC0nTYGBDNyaYYiMMBYAKD
cYOu3TRWB5/6/fY4agFqOSi6XvnYmJFgZoKaBkIJqk9HqBBMJDCLfA3HDptphcDJqQ+JnjTgKhIQ5uHh
40KIrKlFmuSvhJLQCFm1qhgWC2csEOD3vLahH3D0YRhR/lubL7CKPhTLvi+YA08CeAKgbB6hql4bUKiI
/ZRBjMAbxVdT/B56Ac2odhQwWB8ow4nyjYK1xVgRDCHRkHj2h1lXoTqDvKl1ZvURRiAsVlKMsBAOW1ZQ
LjygGyZcTZkUiw0aKigCNysQlwHHItChvr2UDnjARk4BvbZGQe6DUmegLc6YxCMqJzwAInGjLXRgkw/i
7G5Dg87//ZlZS97uHEsMAzI46xRE/zIQQaUgg4OeLNE77FbwRDM0kdV35+vWaQ+TOPb31vFEOxJemmTE
mL0Kr74RcHAwKuib6ukx0oAlCDgvnnFoIrqWn881FvQaolrcetgGUzQXvh0VbVvtF4wMA8NMdm8tAUbC
T4H6QLV10AvCk6DWnGjQCEi9BoMI0E2a5DABBuFoAgzyXneREDD+7kV1PEWW1UgVR4wPOkFAMIuz2C0Q
Ft+s3xqbOoSfDSTWh5/fSIul1oIFxGfnUazUCBqZywkXiI5Al8AgoXRCRQUjFerlaHiB9vzx7i76BYOI
AMMgZB8v69ZigWBBmsGbydNpaa6q2sLtsGQfP0UNWoiJ+t3ACYdEtVio8o3yeEUTqu0G8BqMIJNETn/q
Ed4TSoM8MKedpkj5SoscMBO2CQQtEU0qqJMQxJ85QvsLTg7SExidErPQAU428IEFczAedkxDQlY4EKGn
hN9+dwH8gW+GApz8hcBQUHUq/6lYKBM5j0mX/Yjwo+/LieFrPIrsBB8wCUCfY+hrk54E0ogAPrS+Ft6G
cTMQ0AwEMUJxM6gRnQjps5MdrF6tgf6gNZzSuYmiJjyi6/UjIB7Q9l8IGERPcEWkGZUABDDhJA4S+hh0
xkIjH1WH8HRMDXCHF8AfDhE3LnYJgzsFrXuc2pHgclwYDtE3akOfTokUM2YOWTvrozNKx12ndYgwVMTm
m/nlD8AT+IrOFuK6tCEQoyio3eMRFCToEABskUgJ3EF0JEhUQ1YrDF1pcHj36PoWuNuANU8CIM6Dzf9Q
OTkb+4QDIagGiJhiDyw7eBQaaAfrTFUu1dwPSAdSBEUelCRQ2GOSizjaLBsLpB2MJEVorJyB4Qmhj6Pq
vrQTWkmJxKA3rDAb/fYB2aVoJ7Inask2ngsvHrCZK+gkH3SwSAh2RLH+zY17ATLQK/Mt29zfrLiD7hh6
qp4lSCOw3QmIVm6eKn5QCqDYe4rC2r1AHkACLw2YSg+3AQudmMlPOevcsfS4IeKWVE/V///27wQBZ0fm
Bi2CgBGATA2LScDsexX5omBKJhIPKrYJWN0uBhCsCLqnQLeTOH0IAhqWVTBVsVFN6etRwh1GsWO6dfVZ
7wJB9B3aiJd4jAgiJsQneFAUalP8nLSw+IMYSHWkKhgPFaoIeyDEZkEIVx0giBJWKKAMQxgQCcTomb+Q
PImAbhJSXrgHHJCIEWlxXl8O5LFPCpoANTXkUUyJ7VBUJaTwpgCH2QtaWTS9I4z0S3YFQnIBAO5E3plC
VBGgy6llAr4Iu0+LEAkrIIod0Kz/6PxTIqBEmBCBKlDQdBmHUaZRtCpe9kuLejIETsQTBlJcmASVgEKG
2xUbIaDnmlMY7UbgUce3TJXCeYgUNACIEDXtEjSr1zGD+koeDLtRLmswPMQtGo8CfY03poJop2rwW1Ci
lpqIOywcsHMND4QekTCFdKbzBCgCExFGQNWMx61UJAgrOBEp+zeJEHefRqI3AI7S//9D90DxE2GfxIBM
bguiIOAUwYJRIrqIAWI8yS8q2lJ/QC4EBRRJ4EFWTCWpTwG7vjHJjU2joSliQGMRULgcjmIsgoWiW1Ks
H9VJ6IhMibEDVkB8NFQpbNcRUAAY1UE3anBfpWRUUwigjo5o+4Yg30ToBlAM7SJTGADc7oSjEMpa0WND
UYKl0zVUoxa0EOp0K9kn0R8VDI7vBZnWTgAXTNot67bvjcSJKh0VAQMYUew3QqcFYdGO2RHRNy2jf4+C
yoWNL0hDU0jjMdi1jmRvnDHDdRg3hicP4xNsjFnn/2vgzQWE2I88TwJ1vDRUkoDfb/UBNoJRAgBwZBZV
m37ucihNi+9ACAvX3oCInUwB6CMMQlEaYYlw4EwDkNWB2RskjAIUgQm6qI2YKlTusa0PAz0JD0PzPg+3
ihx/9jnwzAhO4Ah1FNitAnZZxiYquANHCHQbWh9A7X5QKcMe64K/7oe9URHTBeu72bmDYEOSWBikjF8F
DU8hT8wf8xq241Dey4nVZxhAlyCEdBfvgBAlIXdPCJaVoixe0O14l2ffkElxpSzdI6SqfgBBQwigegiD
BU1btzHAC9VCKt/eO6BZ0O0GchAERghochAWsGcfGBZ0gQWROQft4bIKQr9UUJrBVYX63/01PMK7+gNk
JCAL9XQepkBSCxeoHtlM8OCLGwqqBfFJOfRyBVsAZOUhRUQPD5ySw4Nc3VNRFZs+3UyJsmgICuIQnUds
97ZsCTsXGAFSgFbaZCCAp+F1sEa3Y6WrIXbcjmkIblbAk6Df683fXNQGBnoV3UeDKG6K9PExwDBNNwU1
zkQrT+cHBSpI1L7I1HzVolwAq60RvdsWqlOIgcQqp+isgf901O8+RQ9VBM3yi1ZwbaIaBNK5dihVvCBi
qZsDCIpu1RiLQxJzOMaBA3X4vVvvs2CjIqrFKVMwImgnvz/vK3rY9mSLFlfNXNGZlqA9E5B9Q0goTNQf
IwVJA21bMkTQ4mhpGE/enU2izYN6ST452nfLLQXgKioVCCyqxpJ9HVvdgGVFH8dGCADSEX4srE8Pcjhp
vvAUwXc21zk2cix3JXakIOj0EDxCKBMRHTnjQSg0n0zCC0jRgP/zL0+F7D8ZIB6LRhQ5RxQ5wIAGe+83
kE8GYlVbOwJZTFUDBOgXMcDvFamID6E2TUSAeL0ByAXL/PV9BI/YpNXqhMtFuYcBSrlNj6CAs12cq6oA
SUoXoHe/OlrB+p8VEK2irPruS49q1nY6NHgYcjQFIHIT6yzubpOCTxJ3IQUgdhvikb2mghhfOfJyndUx
3puLaBAoieks2WhrqEFYBCADdapron3LqKyM+YUJx4JMFESNx61dOJrxi1LLiwg/5gCK2YXAH9VHNlOn
6hNBw58K6SCYBPAWz6IVAa3e0lJFPACOA2xEtKCNasCFgpt4LHsG4EzaY7xRj028INO5ICvKLqgMQdnv
soCeDS39++euNyAERQkYCEJDlYQ6ECh/IjNChaOViYmApiaE04DmnwEoCAO/UQrQ+B1FGDoSTKizwgLR
Akmb6CBXcaDVEJ3w/ccBCndFicWZZKsYrElVysgwSluwQNHw4lUSYKoWROEIRIlRDDDYEClbdlUY+aGq
ZJD394wV0H91okQ5QBB1nLbdVcuiIidKv9ouIb+tTY2HNywxuiLfSdtcuUPiDHTSC+W5DHTI6AzN2JuB
KFd0CMV0QsKF7ASOarq8WH8LFe8ouEyJaN4YA4sKDk+YtcClVHW4L8zagG5AVLCA69qFwQGLL+vMD7d9
i4jROcZ2Dwc4ZERtDHYgMcBHKQABkgAmdARHF58msFBVXlEO7UwRmFKFoabsReqYUOh6DFcB1SFBT1Ph
UyecjfsLb9irzPP0BkVdbAp1i1UA9RsW1Y0JTAgPyiOkSxZXPwiL+s6aC0hAEDdIa+ZmURRHD0jSXVjU
SH6QTwIh6MwRFEsc011QK0TxV2bCbpCAZJlPRQMEWmzCVQF3IR3fqiEADlYFVaj2QAm5gvxupY+gBTYZ
x+izWuAt4oPgf3VJCcVzB6QAmirgQT57NzsVQ4iGPIP7P2IsUHBhbbzLRdrUc28DFX5QASU1MbsqijBx
A79bgIhltExXsYmwA/t/7ROQj2RKJpBCXCeSK/QpkIPlQDYw7/jm7cDAgWMPlsJMCeiE0unCNori6LBA
R4GAYgO/6gbUKn5TdGp+KMlRhrDr0v57RludrGxfEDGM72qsLFuJwF/CCVQ0gyNpX8sgKkQDA73sLhkF
jYe1kk8BqdUP7NATT7xbD7cgxigIb8/1mlxQvPEMq1yhltCuvP8QX3qLftsPs1R3SRkICrGMQOioz7av
3A4MsJwTsEYb+V3I/woOsrycQsoXAHxiPq0cfz+2zbYV93cqFzlsdj2B/7Ft7NkBH2GxNDgMHBlHn6LW
bVaCBYwO6LAo9hWSbFAHIk2EG41139gTKiyQsTkVDuwBBWT7SLHcMATYQaAcfdWwjYeN/Td2BDAUP7DU
g/8G6kQLwsH+P7JMxwMusSBXrHm2AmYgfwchUDZQkGwCvEZOAdiND8FudutSH/8OUHYJy8gMbAISrJAv
2hBO6ymfIGMxfk0Acu/zr5IA1SMi2YnAKisCZs+WT6G+AVVBdRkOzRMFqXeBchZmUwg0cNjGugNA9wG0
ZAgDRmMJQ1ytIiEQ3ufe8DQOMulTL3LYhWgRKf8SMwSYvQgTwJNfxzsbCEv7eR8EDhYEwQaix3dQSng2
xjKuXKyLbSWGD8UrA1vXKjABgXQEccZH17OQgDqmkOAhAEtxEl98MhCm3AVgDEhYV3AB0VCi7SiqSAXE
iV8OqiF6cBimFJBNEHMR7rNbiZqqA9zHixKQFHMYGBCC7Tau8a8tLAgJ4cHaDx8AEbfMADgbxpB3Ek5I
YJEXATcICM+GCQ6vPv8YWDAKySsFBIzDTwgfkWAwCmsf9r2ys8F2s7Yzu4AvBH+2e2gkmS4IIHRUwoTf
0CEXN+BzU0kBwZkKSE/guFVLCGdoe8ZJSbIyR/kCEgUiwdMTq7ByYmq3Nl2IGTZTO+uoUeZKcNjYQFG+
kfdCL2ZAb4MHAIIBwVV1DoSrGmVwdngWoMuicwxt+ExVcYBwP0oBtAB9olURrIKRAHGMC2x/GEC3TAO1
Ce9f/iQQAQhobGQIAQBUxn6R4JNKAancQSi1q1Zjr4ICCk5g1EHVItfS8wUjBHQMHB3m0UkNGJ40gcQN
NmAQlxAbMCFwBIYQf+sx/wUi2+/4G162bAhVdB2Dxdj4EggUB8Xla6IUwO0Qdnaf7gT5Rby5ohUGVhxF
oxCFFhQm1NExCcHTYdxbtXrsvwFycxiLBO6D+BEP7HeXLlCfC0cKxB91qaLphSjuEXWjB3DYDaoJIAWQ
dZVqUfEqauqlWlC8Pyh3jP+mDC2KDFiJW3SwrQDACFG2vLq5SAWjCBV+DKJBxyjes+ZwsGAPJj6+6AsG
w8YuVAuLhAlQEfHoBUGvMOwaIkFZf2jHs5wQvGNGi0ez3DHACysgSJ2nNuv4e8AitKyDHAMKuf0p9h4w
6Q0n63BFhcAMK4KAIE5DbzBDOikAJjuKHHJYeCEYEBN1CMmvMgnDwQ6bMFMcMSBTSw6yCd+nOOeyGUVo
TjSsoGFliCocvYtgQ3G3VhsYhHgdIgiGoBZHFCMA4jQtBIgxCLn41AI8BXEByHnHhkV8ITaEHKhQUUyL
xQZpmpYTKCAHD546B9pTWKs8PdrsjUk+XUGDftV0mqDHsE1yATuC7SQoXYMSuYoPuCO59kUBTyCCWcQk
gMMABumDEouqeCIYFDyOBRzGzihjKRKIcgSAIkGsjAmgIB2LhLLOSRSTBoTK6UBLkaqKuUFr8CB4iCF8
DA0UwwbFD0UJIqJsv8HMuPYbVEAj288AuMx+NgoE5JQrim5HdTk84q26EIKUwd8si5S1BUmg45CcOwBA
i7/5FyeuqNp7gf3/+SpXBwVFgtBEQLUQXQRw4QEwbEIaZgBBeFUqdsGuq4B1t90u8gUDf3f/Fh8RDMa4
NXe/qclMomFLz/0Yeh8Q7Eldt0G7vIQmMMIIpLxH/xENLILBHpBf9RAANh1GEOYYSCUoMFaPu1fx2RsI
XBv/OcIPgxK1A4CGAU/xWjkRFyASrKlgSQgBNcg0Tmfgz4gqq9FJAwwkdFZBpOH/WCFR9BkgTCRA3+Ao
2IiXx6ZQBHogyrs/+/DRAnCtp0/GksDYJcTHIgzEmygJ3Aox7YINIOvEpieBK4cDdRWiIAMpAI5BZg9E
D4ENBQzROW+BAf6qYmfJjRztJ9UtNt92QRxNs1BFoNvwB9h8GAQs/3W8dAW22UmTWll54l+RO/jttwNm
R3Q8dpIGbnQHPQc3daBQkOxjdHWZSItwZQUkmm0Cf99WjehDBFr471W6nYhgvS53jjFGMBioEfkPo+Y4
Qj0IR8G5LFgQsYpiUIzL4DfpLGaQkYhPRzjpxw+PQ7QYj//Qq4C+ZCQ0n9RhkTDbJJrFHbESIGhvjxVb
BbtIN9dVU1YwJB4k1kCLziqgs0w/YIBOgQUoMQuiB9+HMCOgJ8PDt4hmQPGW+hK8YUwSmxbwAMU4AIl2
Doq/KMDcAmHt6kGuEb9cP33GSIjYdoN9EDBIHPIaLEi+ZBoSA0bLSM8SxBAiesAYG/ALb71co2VXUdjU
IUC6SEziE9/P0C4G/yK/1Yy+i7D4dAwdwCxHvzwD8TvGdr+cCFiNcAEPwbyZGFhVX6TgiPYK9T9oUODo
zrhGNN2RT2FXjzZceMNMkEcgQgswBHf/dAejAJxOSpFeX3hP4AkVg33EvGxGDiKYCRkOjeARbEAIlFMw
7BH4joWwUHSCfQQgvhNo/AHxNNYc9rzK71zbtRzf3RGew4M4FcDwViyFyWLCjVCirwrihT7Ijj2o7hE5
EmSyqwpG+K//tKRM24SCAjGnEthBA0CLScn2SVoU8QjXKdqwgI/+HGXVg7U1iC7NDB2lGYKFAfaR3LNu
FmEHGBLmU21RL2Gx+gZ7FjMqUphhomhLYDdAb7tsk3AZD6Ertoj7u6WUzaIYXN7/9FkBvYMzi1xO2EVQ
IKKfZ3AAGtmooOUwWUCETK/wXpPVXjQKRldfrxFsePQIZKR2LTBUv8wGVb9ZwwvBfK9Ts6JoFg/FCqK7
Pby8kGpLaMnCCY4Kp+wTCmIO90QkeIVdkyD2iQY6X7kLU0HKIkaLlakZNje6aB0MTFX3VPqC7UzuAmlI
7CG7/at7skdC32UbX7y8yUGYHWRILOmlBwEBR7MxJpwZi7MBaw9IBCFMSBgpOgShqv5AJCr6VHjxUsJG
iB9HKV+EYD8ELIgSiUYQI6KRLLp/HZGNiggZwYoCUcRivJkE56qI8ICSGHROfWBPmIwLABhACAcIDDLI
EBggaXgMYiEqSFc1QT4iEEAQiJ/Yka2kMPi6j3xZnwgtpExfi1UMkNSIVdtpDgGQjuyJ+hDmIjDacA/3
pa7zZueSMWU8vLygZKQXsL/6x0QTRYX2LBvDVMFsvTo25bXN/uI2/iFSX3AI6SgDAEwBehVSQL+4O1Yw
icDHjYvoQXpWOFNEwvj4pYrRNi5Jgk6UKHa/SCvD105FO/dFwMhQorBycQDqs7peUQe5APtb8jpUNIae
eAqA0TGqKzHSpgQqLuTwAPg76IQIBoubEENwK8ywH0d3IMIA0YLR67IOuiBiTynvDu4JMDLwA5TDweWw
gJ6D/MNkfjXDfDggg9GFToP+sCuCUYQzEIg3l5ErCl6v0RCBBwWKVRUQCCB/fAoCd1XZjQQYdlxGBwF2
wNyawpPRzASnX5fCQjMapOZPvpdQQghj2PYYnauBa0wgN58owejDqk5qwN5Ey7GIPaNFzL3g17rBRp7R
bDvK+ADwMlwVsKjcf18Jv2Asjv9ieAGeHGNC0LD90Y2sZtSdQaNWhnbvI0F0ox+d4UYQJgUjBKW5XL1g
1CFDGZJFuaoUtR2fOkm12r5ZfhgVwfg8FtRUGsYix3Y9owKCUFMFCwaJfhh2Kest/8Nt7X5PmTD4cwwo
dwYFIHfQpaJSVzo52p8MfnTvWMLI1DQ7Q+gPi/bisYIROUPwLgkVB/vkeFcIRQdmyMtn6xi/uyNnRNN2
Ei7odww0dgYE9FQAOdw8CQCegMdBxQHGJSITEcAqBA3h4QWu4A7uBu0ImrCcYAWBQxCdEHWHOBMYcDPG
Yaa7VTtwaDsyOKz6DYQ6IFMQkS0IBJHupQ9g1aZCxnJwYdZ2PtBf9VWIOJsX6zDAqmUF35+oWhUNmwaI
BLOuHJfjrjZFIY1TwnMYiaKbpM4GjQdQZCDIrIoEULfDjBYBPHVLhcoYY3wQADBdtE3BpiY1fN5T6yMt
FN1YR013VffAhGxggCTLeAGCAIfRSXJJQyOIDvkIcFjXwCYVBO95aAbDmKntbIqFgjbXl4VAmYjYExTJ
EztsoaEjgDw5xpJDGgjiSJBCuQgGEhUy/7LZrAYibMfyEFFNnaCv4ugIXKJoDi04SGfxDFgaMyhByOxX
0CjI+vl5eBADaJg1vnW7CA2Y5my8XjkoAXQHiWFXcgHRKBCw4AMic0CMLCqOEOwYFN8gAcUhBozOx7bI
0Ql4qoptsyBxhHXONCZ8DIiCRBVHJhO1xW4C+logwK3ZyasnfzQ3FRQBo4rlVJmIGPCvENFANFyLUIuE
ASEYMy0BKIx2AcVZidowVrxJRF4PxDiWWTqnPMRP+Ma84IA9gRZAABXFMBZxSdRBX0Q3lbAnfHY2Acn/
0JsAHdLwC3L/MKJAW9VdDS90e7w4AB9BM9EcG58RsVJDJEnYCoBCEelm5XX8AcANFy0CR2wkIGICk1De
xQgFr6iH1fZoH6OKWqOGjXwtAfytKhc/xS0AL02J7MBgI1W+wiFDDYNdw26Ol8cgAiYkCROSUpLiIBQA
LNkwAU0Y8UJfOAEmQDLIIIMPEFAYyCCDDFggYKAnDDIoaPqrzBQPBYERu3ykml2IdjpIjYHEoTOo6Kwc
x+sDcEINvASRooMzItoDZbSMKOp4e49ieXrBKkME9ZIHNmzZq8wOV0++Q1gXsFUvUbwntokBMiTAl24I
/x10ByyNcv9IizU3YNggdDLEWciZqLEHT6rNf7wox4SPRLEmAMhMA4Sdb3JQQSjM2O+AOVoA7QAeCO70
FnGq86BJKfEWXbOPYyqAPgAIiREnUCUCCJaqoOCI56yviwpDlSnnL47B73QBxv1qSTnVzZHge1TlPlaQ
kZPiu4G1ozH2lyBTakmNQX7/dshgEwDSwKyMIvzsgH0R0HOLtPB6gCRF9M1/Vr6PQQhyMOdIWUg12cmi
CtBaQVrIgUwYrzXCNglBit5JehGwGukerRxILxyRWbP0dM/8NWiPSMkaOOmsgFxQjYlgYUFqV8OY+KBI
p4WoA5u4oDfREHh7UHRxTJqGdAhtmpUcZOKlF2mNVQGWBBwv1kRBgoKOtQNuiBOUmFwkWKc+EpIdrRwH
RmSLjM82RUTeOAi1zEUr6wERUH2gIlMUJlU9o05MAELPsIZbIExH6N3ZPS7RpA/OpkSLjdB1uFgVXRKB
FNjYHDXsPgwYdEMudD6EDYc0lEIWfzFjCNGRTmDN644r69kVI4CHcsu7WV1kcEjm7xKHtOuS1dVUuy/G
RMm3RIRpkc967IDsJlssypqJ66ZJYpKGlHTgWD494RbMA4wPOcp0y+FTrE0AQAhFlrVgx2BJKdXP7hkI
hEEIMHG3AicaHajg+NtnXBfhkG/CAzB5KJQrYKpHqSvJiAO72Hj1GxOfIyIGYR/EO7hPDznRy9kWK6ec
V8YT2gw2zvbTNBCQKen9AADU2ICHsJvHPc2mw88rY3VAjL8blEFzdo9QvChRDUzC+CPMxLdAlDDuWThD
EeOHxD7ddi8BAMMHG2Ml4si+a8yDIiJGAIzkrF0RPy2LvFT/Qv0mHIO8uQ7YjSeHUZHoW0MlgEAJgJ5Q
/0gA3CwSFQPad+KJFgZJLggiZs+YBRO3gyzVUzZkMmK6cwAeAYMreNLcDy3gAj778TnINtLtGtNuPKBw
Df3j0pSBEvd+NyoWf4dY/+IyPAL32B/GI7y11RI8Aw3YPATPbWgN49Oc+RcL0Ny3adgkCLzPMEgB0ngI
lDAe2dVCIs6oQ6XgStmGEywrVL8FCEl3YTusTkCGIm0qSYu0UQEHxAnDAcEadayq3MN3SPf2EkTjyAxY
NiDmzT38MCgJTqgzM0yaRK2pIFfRXu5KfVIUMKpsQZrfwWLHNrj/ZG0pyHr3krVIABYVeYC12ed4d4n8
eHdRqk68313eiwALRfYCOBZgBL+iiShcJK+94g+BcIPtAXXzRkWYLIo+H4TLt8IMSr86xYsx0rMAIGCN
ZQ7k+2SSidYx0pb397gRReocvBZcAfDh8AxxWtesHxjAIAxh0iIfQQ8hCE2G/yAbWFpUyxgJ3oqA3cKI
/4+u0T/sUsEwC0zuARpOzKAFSCoJTPUaxR+dVcs0EPoySJQkCPtmH4sZt3migDgACDAI7ohMwesQh0kg
hEEf7tgDbkgre/ZszF2wZR9IicUMCXCAR4I6iTjA3CnYb6pNDBK/QEDHTIk/SMzprnwkUEiJxbusCOcI
BS3psKhoNoqAJD4HRQtSxqvxUrREtygyfCgBPiIgRVO4UKTBLqRhjDxMRqmsIR08Abh8dqGCCWn+PgEQ
wqQeB4kjMq+ECLBhLoO82T0UY0Aci2ziMPFFiHgX3tzqBQwLRiInbScoHiH73MeLKCIRwx/ENoEO/xEG
FAGw7Bn+pSw5RDEAgo2hOCdRu1iN0jxY7zFYUIYCq0UpVmOcHzgWWHdpdhnwxFbwzPgLMOCSAwABCHuq
YkLRywVEgM/lBWgcafVxg+DYBVZgNlBF1IBhqvUE20cfMGBMaATb9UGpHvcXKVhyl9VlwAe7R7OZmNWl
jomUuzWDYEJfo8cMwxAwAgQOvNBHUZ96/es3X1OFA7pVelRV+RJNNQaeVGn2OmAfsGjI2D1Ii0MFh62h
XMiO27ABnG+u6aOxQxhIi2rsDDLzujA1USCMxQBVC6y6wsNhwFTmSJ982nhEgAsrH2HCBILk4qIgCBFg
mi6lVCNRkYdlMIZN2WHbIFkoKg3GggkQHkV0y3B0VgG1/fAbhKpoTEl/IAn6fQ/oaFkJcCzFQ6ArwoGx
DM+43TDojJMYzXWUWfDuBJxmw/xeX/sRziqg62AaH5+ACBEs17NBTfhhccONXtJcJEgU1l2NRbI4AjjL
HnNdcRLLYvcEwh3Ue3D/2cPiaU6dR9Qj+AYpik0gXUKFsPgWPrFInwOAhqY1gVnwByeEModFKCBaESYQ
FvR7IcHmRcvj/wcr6AF3JglyHIrcWNB3KvpHAw0CAw1kfJkhKA4Gn7gBNAJIQQn/CxXDAk8yTw0vOFXB
upLaRXQAqCLrElADyLdzKd1BdMHEgFMAHOsUbFAnEU8cUy0L+gpR9ho4VBQdEDTCV0ziRfSVTT0mBO0g
KLTwdMsUA4OKqU/sSfEA/ecl/9UhDGBChFa/FbyDHYnQsoHs33QwCiLNYImEuBgIFXlPiAgED8YClw6q
TgfbL4JgGFX9jRVOGAEAVTiDug/xcDbQ/TAKA/EIQBUKSBFCTkkIFA0sn4Tim0HRTN+L4IKohpEg6FTx
lhRUSCEwUB0AnpjkAIhjBSyMvPSNrIoiVEVSnTCCmizKIP1RlKQYSD6COIxm8ZJYxEhCRA+4A/V7BAwf
sUg5xnPf3xBiSBHvzgk1SEHF8C5BBjuEXfgPwAETFsEAAZYQUUOKgAPoFKSYFKvrQGIGh2WJo9cECBZw
32FayMZJAFcixeP2ojgGMPZcJBQhRdffQRChYATTOSzsQTeFWIYqTYolwEdwVQpbDdYgARB4ioG5N7S0
gREGYYx4jIgxgmLsBHEpxvAUwoSCbjLz8FYgsS92sO+IEQNei4wHUTBiQ0U4ibTsBsS22QcPMDZAOepF
bmj9tKMCBoMnaGDVJgw22A+gJ6g9FFt4pKx0WJAelBL9VZhAW0ymg8MBkCQAiCKsijaj2G3rCQ8XPbLd
Eo8KdesUdakUschD4QFWWEV4QvXf+YrPggYSPJwkAEO3IT1gNJUYTQ/aviIAsap4l+WS0QErmt9hKMoQ
FYw45YIARAtQyRsjBukHOEDYRSpQfaBiK4FVCBusCwKoHCgkWAdgsEEGYGg0ELQncs92VVATqUEThHYd
EfoUBxxIyYBIRBcnSBHCBbEwAq3roFTkO2mkQNSdcOyWkIuECFD/zkw744lhO8ACBUAHUfBAEPe0d0Mo
gs5a/OI2i2wxYlLC5w5IhrEgEBUdoFuStqJOLwIye02AnsHR22QLItUP2gvcRVtBIXUDwRX1hf6DsQBc
EH3gQSWjD4CnnBbcoCJYckuLrAG3KGaXSzHtirOKnscDTHfneXZTPZgPjXBIQjushIoBHHLZ7iL1SkIk
d3OEhn1nbsa3hpJMfNZDRBWcz8HjBc6CYEXuTIiS4kYQCSQx9iPqwzJi54A24bUcOA0hFXLtgGEcAqfv
zaBhDy7oU3IT8VjBEL3nnCRARBWilMX6RImCSqAHBqkbQl2TcKI4GWSQwQ94QIBDClgHSAEZ+rDPCkji
a4QkmA8pYX1S6oQkoALqkIJUNYfWDtKBNKnnmOHczYpS5NCqFeCMCIL81zia0ASz/msDWx9V1yr/GET8
WADtUAChERo5CqiF7ZDiQywAIDTgZBgjCUlFu0vyiw5jRMMN6aXvIGaHJSaUNniwhk0dLgDGdKfgpX+B
pA9mkEWJLN6GRN4E4LARihjvv0ldF0ET2RXbYeFqNoOAacteWixiLbaEZoLsrGeceevxum/uGquiH8C6
32EQ7WBWDcsGk8MYLYtdmSAAJvYMa9K7Ld29i4x7+jlgNWW13vbfyzXJQy6cRsXezQqKYfmWEISCk8K+
iFqqAS8ZWEwTqCEA4LJlmHUtmK2hGI5oD1sBxiodYDsScCRxNlipeAeACBmBe7YlIGgIGNwTRLQI+ngI
NPapoKgAAiZATp6zE4oLSBBQWxA6eRhYUAlgBioWinWETgXoNkL0dQnrRO/RKRFICSN15BIwAR0CXxZ0
oqgX7dFBCh7fzS56HN9RHJb1XD6DwSDrwALYzWobjxfirwJiAcFvL6IfAB5rQfSJ1kSOAfGrpYnLtMVN
jcBViUQE9aOR+NUCsup4fNLxhRUvKx7eRTGjRQihwYMCqURkVOD5XJdUxks3kWSIANSqAYgWqq6IpMTh
+COQsgDHbvgbijqoG7/3zIt9uFsAsQhiguvKrwYCOgF3xOxkXVDHxSfrrj8zYy4WHxMfq0Q4AZwFQYif
wQRgAMDsWomIAPBTEMRHIYHUCVvDz0hoCES1/gEzVV8VfAHmoBL9AFpwl48EHRnRXSCCJeavZuhNot4A
Ku3jOHQgQQCgwZ8KgijeEQWjiHL/iHIF/JeWOcd15k6NZD0JElFEqtrPXPUUTeYHRNeYKOAvTuN+NeAK
iFtAUXQs0DFDYEs5ZXQdFohqBI9eC5VmJYrPX/DhYKvbW4hTXvDHSWT16m9V9Uw7LCRyqlq9l21RYfCj
dCil2DAAyLknp0s0IEafTDsRTABu5XNHJJUiBLEd+vyERe/SAq0BhSQkWIGlil2nTSlQJLHgxiKqxVSH
JAIS0BSMGPIT4gaKF4s0JDELEA24+juL7gH2UXUb0kgB2x7rvWN8qYDfzLXw9P+3U1StogvpnTBjqNIB
KD7BKFTHWooZDXDo60F1PwhGAkGMMcAR9FsDKFYgTDWFFttV1KDyVb2YBk9awu7T8lGFiAbrGX9PohT1
6bMQ5+xuhO1Z9/aMD7gnjksWUIO7HBH3rITaxB4C1en5uvm99zyHPdjb1rVSN9wxwCykG9gEAN+QISCF
sC+2CHgghxlmCWgAvJWWQRawH0S1izhgfqGHmwWhOYRdp69Uhwt8J4uNDnXMgcQCAwGKGuhSuysa7EQA
ACe5ynTZiS7aIkARo37Ag0ARu1nrN9cFDoF7uVmbTxUsK4q6w4rpfibPoAHgLjG1ZJbsNSDjMCaKCEjV
bizoA986EdUBiHDwcHqp4o1V6FaXXLuJIpKefwXcj0uHEhTtTR49FYyNYNmJ2lnI6EPYiFLA9kVfiQ3o
6oRPcFd2f29cguW2dygDbzBnPUc40MFWdVJH10/PV3Yj2huSX1hMGJpvaANjbA2i+DB4e4nFyKLqt4AA
HcCqJkQPoNmXFHtVMcAR74e4ACb4yDWKSA1JXZGgPSrJCy+cNCfdRhAK0BjYIM1Jc9LgKOgw8JOdNCc4
+EBvVbFYRUuVh3SE4S14d3iDxxAMpF+4Zl9sJthgTBoPhQZBQeA+jxWaMjUUDYFFVFv5Au1dpBXydo4h
b0+/eR7IkRfxF8QXCpAJkAsm1EKOjJwCM3QEAdCtUXLWjW8CVReKfhHG5XZmDw+JKhLVlsB3xKpYYx3D
kC9WJiAMdC0mbsvoxQGCj+DMNW1D1BBLQOl1VQiMDjbGn5DRdW5lNK+QCaJjKofQ/3gK1xVgoKZS76pv
BcSMUCtd2LqkGwrGfxxGIInQcxHEiBCf7iCI3aqR3+um/90H3AbV/iKVC+3MUvliRcQPB2MEsn0EXakA
/g9dJEN2SdcwD70yJEMyp5F7QzIkQ2VQOyRDMiQmERmSCzn8FufSIRmSIb2okiEZkpN/axmSIRlXQy8h
GZIhGwjJkF3I9RVTH8AMyZANrA+YhJAMyZBwXIyBDMlIVD4O1/RjETvulENlmzue0YGKsfAvV0jBXAeA
p+wHBhlkkFhgaHChipNBeJfPJQDAO5dnD9hgL+yXkA9XEDcoByCDDDIgGDg50ivIMLz3nBU8R44cqRMa
LnwTtwGD5IXeid1LCEgfD++kVJ0wUgSkFUunRwYZZJsPB1BYYBlkkEFocHgLoU04hw8HDxvshWwPkEcQ
NygHZJBBBiAYOOQkBBkwD4wU5HkycpkSKmwSe2FHIC/OiFU1cAUtgvhBFUsAuyvwtlcQFFGEDcC5B8Fq
Et2/yn+D+n9/K+kcrO+0bLsKRtPiBdPrgKLbb1vZdSRMCSbBB6OqxHblKn40Z7sEUWxdR5iD4T9mOtN9
+UZ1y5k0ym21Gig4wQlg2hUHoCPP0yYtmBHhqBZY2THAu0gH4NjXBIw5h0y0EQOJbskKTOuxr+BCgRbR
Qdg8DLf74UvWTIse/vN8iY8NzIhQhQkgcEVFjYIEXC26CqJ8WBZBfbY//IPicID6IBLyrHY2CkDzrCf0
5bMIUPG8MHUrTWD0EUANqg0eCJgoqlNPz26Nih+E0nTpeyoQdOOsqSqGNbGo0ibf7R0NH+f1QCy/egrh
MgLfEAU9YABE3wXhho1AI41T0hh3VMUg3IjgO8crAROMPYSCDznTrggRQaM1mwvsN4IfbTB83vl/mfPW
CEdYCIQK9usq560AsDDU4eTXBUGZ5YXu5/J1LeCAqmRdeUE0Y6HIxRRUNg8ZimhVgcTh2YEXcf11wl2d
fBLws0ZAJJOdAFEdkzhV8SMIGoa/fwJGZXUHgoCFICTf8mRk7PGFUYJp1Q8ZECw59io/fr8It08EQc8U
FpAPSWMqekJAD/PejDFyWysT/EsBTPNFDougLrx5LyfRqDMUzSfAK1GliDai0Ndgt7vRw9PnDWOhCfgu
eNj6omYUdUB0DY8dFtu+7dBMDmuPAiKAZFuwv4Dk5HnmB8+UEV0FMval5Cb/hC+ylp0MNnT/DikvRs4O
2WE+vzEVHFRATk6jpIyOqNpP6px/Dl/wram/gD1GpiH6D/IFPKYhF4qGRTc7PcToiMdIpuWR+8YsENWV
KSABm4joYORK8wlvieUAaIJBTfxJ1Qc8UrF4uHVaSf2r2Coi4/ZjPfSjYN7eQBBbadFgR/qK7IRZ9TQl
QWAQMlRvfHB1BBqgPPvH9jyw9FxB+4rDmmqpgiXHp4PqAuDGjzoa7onZAZpwwpTrhE/+EXEoYJjHqaAH
PQMf0xVdLEksR54s312Ag1TXcub215BoWRD8N1DryQ+EPGE32+u5DzDrqcKWEvI465mfiQ9gQbBhII31
DP9yYLGiBQ8Q14IQE4SkEr/IgU2iPg+IBxYBSFNPcCRDMmQPaGADAgIyWOeMYx2jgl3uDdP7C1ckgyNw
jCfJzgudEIwAGI4vfPQyDuomdBs0gdNIgCPM9Q/bSuAZXCo7QEAW/+Aixsoo331ijBEhaHciUaBRUBPS
UBq+YQuTAe1dGcAla9XDRuRsMD+Jcqo9rIYAQ75fL1RwAA70qYgTHbbtzmkot29vD+H7mN9uYDwBZ1sl
dMnYMnBoJm8ZWJAgzHKY6KRHCg7rtZ89tKKPh+SFPKqieA+JoskW5CF/oj9yciRDMmhSRwmAhkw97yGA
CgukIrtfE3F0OrCAvT0kQ7ottHsIBJKLCE1/2yRjZEBn76igUxGtgApV0O43B/7GhWdeAkheBIhBGESA
YseRiA9x+9xW/A7wIcRCp2+LZgR/JI51xggwcDyt+fR2aDxA7vPYYwmUPFAHxDww+2ypjhw5xrF/ryQM
mwm8JCQ+JCSDiBIJf4N/RwCeB00B3DwQdaUu/cIb8QRNzID7/8AhdCSJ2CNKyYXDbJeDQLfbK0EI/XkQ
mvjwbASKZNcJp8oLgBk7IOftCK0OA3aSnrX5FIfZfi93BpAnJ73eI6lOTkZOOmmNroaDREon/V+r2KBQ
D3ABxevk4nYstjj4A/jESW4OHUH0zjgo16PToS0uxeZNX9PvN/gnQbJgsQn0NzKqxiIUBVMH3RuZ2NFB
cjbvdcSbDcEBiydGCjXxB6vowCL/m5DhDPcwRgACOMQPD1gDRewEDt9jD7FhD1vHNUTItISIhbNNzUXO
eccOATEb+ichdk00ol3vwKDT4Ivhdv/FmEkJxCt42bNozAEiAoQgfyUcFezEbSfrz6ggYZ/o/WQMoHqt
SSDC99FNABVTjUcI2kGNgXTGMf0cBKNGMHjLeLAPOWrMeBT47E3uUjUa8HyUD4kfwpMfjX+ER/l/wXxL
RB2wODQJX6UGiF3CWCchS0SBQuQzfCj7i1UMAqYlckEDD1gOo60to0EyH1tvMmC00AYr30jcLxmM2jfz
pvoUM8BmVRWs+jUxqnLV0FVcEEdh7x2V/DPFdb7pMXOxILyHphd0pSZ9CBFPaC3P0HR0vhLV7lkoUP9E
mkF56NIRpU1jWgnDldqIbQsjotNL2N1aZljWIPas9nxBs6ovzfswM1VozG3DCzpCB/HK7Nd7WL4HUgAc
EFZMBe+whJYwIFhWJxUMID843v7BWBe3zgx5CH7PDa8oFxVfZ0E6EBD7u7T+XGaDfhgAGhU8KqhNg1Bj
/xsTsOsWgflQ5XRkGHSKhd8AeEE5Xhh2Wr7LClUQBPvY0Z0rAAkO0YsK2hbKBCL4SlcDPdsNADZ6KBl3
OQsANBSCl5/x9hYRG2mWUfJ0tEup4q0bIQiyfahBVCC6XrgOd6ZO7XQr9CeCqrUn/IsYFQbFoGj1xBA9
NiugBr8aB90B7DHAF4tyhDblSkG5M0hSi47tADoKUlCs+Cx2Ee0J/f3IF6FNsNEV9N4YSgjpEOAfgB2/
Y13fAwY9T9m66Ccjuz8zAmMkHv8ewCmDgIY8579gFVEiIsXYw/YCAF4Meo/XDT+yfBo2+DlCj/7/7H8h
4QhtCo0x2495QCRsMwSP/1i6gmohEKsdIeHIEXBPAr8HjyCck7NvHjCZj4HuGgZsUy+JmSGB1G6sGtRk
KDew0H7QbTtfULSKFVhFBUnmNrH1BlVz4z1VM8uIbrfbMgJqCANiEDhaGBLwuR9yiRUrJUBhrIGFRMUS
IS/B2F88kXfJFVIctCsXB8L7dYs4KTfpE+D+IKCfPeGNazeAyFCeVcH4tkUboAU6weZm9wJ4AejFdTtC
i1XInkQ9qvPzicEYKsDtZrKQ1qoNr/pU9E24cVi4dL97ey0QDYqNhgHKSANNwA1s7CTBznMA0AfpdqcI
FTlyqhtbBnPY/VFtKv/GQhgDGf9WdduDcwgaDBu2MDsCxEKiQigGaLrtQN4ZMAMxMz2airr3Mh3HyGir
iBrAGwQheuyuk40EDxBhizm5eosC2wk8dfOD5/0djbmoqhA0SHm9a4ekBVQYgBJS+XQKkOGAchQhIqMU
LVEnQVZTxK0Z+AIEw7wNEUkCum0Wg4dBI05sJgtoFQELjx6wI4AWv+PN0+18xAJvX+t1Lcrcd8GC2W8Y
WzQ5yFcFWzBYqBE0LMiP0BH4j7N1tOwB/Z3/ABGPMBbvGkMg/wDCCIuSlUR/cUccGOqFMQUBThoOSN9+
BC4MORYu2R8TAjIxwB+aSHeLiu9iKJ4F4FEBoogng0EJ3MvJeUWzLwlySTnCKyuD71z/K0r/RYnI4xYd
lOLJeNZl40mGW4luYR3gF0wcbFqxLcSELAvwCnBKFokINb7MuL5YEh4kzGS+JA8fX4QLA5kplH5cWwhO
2A4Bs8NbykYd4abGBVd0W5AATxihjjD+W1IZ//2ACL9KW0mB/P4J4ou/C/ICBoVEiGIyAEFN24VaenpN
KfCdQstCJKwDQEvFZniwSGOaBkJBU+rB3GGNUeNsvuNocwtQKuPgAuubFTeqIHUmssS4Foxt+9pkjj/a
7uOwVDfcJjbM2nLk88h8c7X/AGb9dxib3Co56fzTkwSZVgdbUeWVlkyid3drxXKwYepC3Dh3EXKaHlR9
0ktjDJQnhQF9uxiMdxe/ddg6p90PUkBFiEoY6+EvMG9bAGziUBbRWtAp8YVGFG0UGwMwPLxF1HIaA4D5
DEAJFrcLAf7JSVSPTIWmm77s/+E+Geui4wHrnPFjDRRtBZb/ct30ZOTIkf6I/IkXC8wAiWQc/0J5cjLy
KPxFVsj7YOyh5AQN6BYtEUKHNM8mOgIxTZp9RNGOvUIC6HC2mfqw4CCpCFIhBTEOyEe2z0AH7ghQq4D5
MPZsRr+ZwXH/3Kv7mUsCfDbMay77APaZ3AVBCMrJ6yDHEhdiJ0NY/3rb9KClkaWA49to2aTrglr4Tenb
blJ4cjLyqP08Pb/6sWO0SkspgOPRYtvpxgasBsv/kGPpDmRsgQjjcF/jGBk58tz6/RVfdzk5O0qrr0Jw
mSIZOTm6HHS1sBBE8wxhEOpbAPzcBtxNZ4T2eQOA2l3adAlbSiCmBZWTkWeG12Pc/DUXSc+TVrj5aTBj
FLBjD+8E9UWLC0WIxShLCAyaNAwuAOvITEndIoPrusOfcXR5vnUFY8jletMCOdN1aE4ckBas6fN/x2z2
EMbGSk1jCGWMb75Hjhw5//t2+ZcU+ficHSU8XWVJQoKInJycM0S28QiNMmkPjUYE0UA8JE5IRIs2yPaV
giLTSvkKwESxge6F5G1Qe3QRNBRQtwfIDFeiA0JvIFzoP0hMicj3uEWLAKNwid4UDZArlVvKBWHoR9P+
6FnWuh2PMsF1xPRNGG+ginMuChzFSeKaFQgeRXyEWOwDrhKef/DcKB1c3VK4Glz3NLCOIqK7zxyAfTFt
RahJqogLzQs5TaBcBxDfnYtFuElhBwkVYiGiGGcKbnPNEEc4B3UDLxCo4seJR1QJ45+K7xliDPP/FcaO
trtFVwVNmGbv/BsM3UpQbVmYmRNVkLVvIuC2nhk8/3RFzIsZoJqcJZ+YvT0DFHQwOJB0IhfrBvLCGUTI
JiNUB+u6iiiaoHwKfHRHcIg/lZw9347gjDZ8qfQ9r56fC40cdIMZBcCIptVWBb2xBic0MgE8AW/B2sVS
FBWfPA7fePsM4xgbBBh17spgCHfsFtiC+Ew7YBBzr1jrBjLqPgrH219/uxqjH8H052wBoChg9I9GNbH+
AAEDBrCJlkFcF7kuISdnLXJTzSYiOtALXS+fgg0FjNJwkVNBVaMckYR57bChAdF9sGgfdaCCVgHQdqgb
/Fl1AVRlyBc55XYuQbgoCgSIeKCFICKlZ3THLxE5rhqLdciLBo6qfu5GKpskMyk2d9L1VAC4AoX4lloJ
Ec8B84UCBDiYJZnQNwXAlsevl8BBIMeAS2wsV4nhSaLrj2oBDYGPqUgVz7aaXHPrj09YaAUIFrHHuDzc
DcPV6rh1vhVno6pNAepPGN9VMaEWDFwAMBJb9fhBDldRL247DYm5cyhTLzX4KmMUuZTx17ahdFAIRxh7
RInKiB98CLQCENOSDxhDbJFHtAIRLAgCtORYGz4g/Youaxqh97WsOHIY9TkQghTCik3/9AB/WAtcQGSs
fiJA1Ya6DT9nxKaA2GVopY1wB4UKIi6JqGSVA6oULyNA1ew58yiGfvFRl+r/ifqs0+LF0qkOqAoXXNrR
mCEkRC7tadkF7C16BExjeQ9Ei1mBEgmko5q5zEVcY2ea04YLHcAqpZptmHsR3CrRkOuShdPnRACNTGJ8
VnzE1nMqePs4xjSI3LBtRVbATooOwBmpvFrFSAJH6P9pVBL2WglxhK3/81rODo4jZw+2j5T/KSJdICAn
J5O03mSIBbsM9McNb0kBgMcHp2bmGx1wNKBRqLp8Eu4DDQpz4mMECpWJos89kAH4TblWAhf/qyclQBA/
Lik53xgMtFruo9veOcfvuGAMQuIABYkKiOpXYANOgHgmcRGSdBfbIFrIHWRMKePiKygGGi5MBPrAroCJ
eBYMgs/fKarGDcFv68mOfBsfYwwEgYsLqliydy8PYA+3KA8AI0QqEVAxCdiAorvlUfgYgsgF3Fgidkss
Yf4pLiwSHFPLwynPovnpG8sIlz6pDrsJ+KbC/qLD3iIoSDnTVTI2tVcNfLESdr/pADqCxTBzrjkPN5gr
6G/4Ja0oAIuMJqVTFww3wKUWpdRH2KoqN2fkW/SlqEgWa/8RWnKE8eTPDG5ORs4Owy6Md39RQEBOoDkZ
OXPPKTJ0VTUNATl2vpiQZgJi9fAkn/87Z1syeovzBwwZOxocg3Ygjcd/XaBo5oMZpthND4IePBpuCCfx
1wcHBWPYKQ+b5BVjEIPg3dp2FwwiYN1Fi02YJ272CBxFEEUxwCZIxOwWUHJIGS4U6+BrQS9I6ekuQgyj
nsYPYCefQBWgA9dT8CwVhjcLjb2w7YRIErsN/T7IjagNi3WKjaAKuUS0CCgR9w0xAsJRTatRCUr1AhM8
TFuFFQU2SjFI6mBboKlVpSOW3ggfAVULOB6gaVc3MuJoL3fIwUlgQRhqaYY88DZQVAMNl8h14Mi/fy+V
PzyA2CBqPMAHIsc8QCDYe+yCiHlEiIWLeKBiLWbrDgYcVBtQFXEXZbYkNvd2BIoW0RIr1J2pGBrURInA
Z64KYL//QMqBRASK909T4jGo4BJ3JAItu0tVGCCG1cSuFnAY68c81C4BqN1/MiYpQm/WFUQtAro2lmDJ
yV9MVi/V99VDYIywxAIp/ALDIgRTUwSM8YxYv9FkYwoUnNVjVg277u8JSGHwgXA1Ne5cUAL3hGeVmPwt
8Ys1gjoVEHgSgV10ORNVZe+oRrohWEiqC+8sASAEKeCBh3hUHaT6cBiJ8BYCIVCDVC8yHWUAFoPZGexE
ey+V4SKAl4DsD69CW8LJthPClpWQ1ZpEkIsJTL2ZbGegf9p9FWZHt70ZChkDRetFDx/eCuyGv0IFi6xO
rwQkTBUlwEb5gFU85kNNBTdj8FJQhYQkL4gQwggv5MCAsesvNi8lgC/3gpE2ko8vzjnM0RZGifEzMHog
8pEzxoPmjxMTYMsoQX8xEcihkIkrzgI5FHKRKqdAjkIuoUR2FMKJJQ3/DX8o8HoEvyjrNCBWVMLWBRsF
hnEQ2J3HnYCJggNCEnZAReDo4Z2JELBKUQbnCTnmyAOZkDFgwfrACtKQFklAksWCNQ9uJqM3AyoxiFOi
N3NR+IF7inVAlMptE4GxQ1glU8CqX4ZYDbKeURXA1/xQKCGXHyRTkIHRFiCPKI/ZUUgXmY98f3yTgFCu
gDUYWxh8kPK/he9jqZgJQ3/G8I/ZCIMh8sN/KmcAGoqDWyAcjEtgCA2+XsVDF4wwhcJHqmrhrEr4B+g2
JINg/Qf+TIc5AcJQkH8ovAqRHAopsh9GVgijgH8moqIuGVHveeHYq1LRS5dzf9lPCPBMCcpGLHxJOfdX
6WJxgEaMfcGmskMQv3ctQF6A7SsjLm8jLqhORYcxqdPAcJijAG/WGWwwgiXwKoffJwUKHNSuOFGRhOD/
idCVk4AloBHt3OxIuCAEjxW9j0sEKz28cCxXdSOgQtI8cASAIyqBH5noJgoQ7LqLUARYgSSa/1u6H3EI
5BEmLyw/oZAXgR8n8l5goZDE7ydsRiCHQCsG3P02go8EKB+sCQl1bdiFhCDSw2UtjxXsqk7DkAK4GN4R
TAbPAi3HQvgDG6p4Ag3CEiB1BBGuqOhG7ayIv7qQx4SCIAF8iQubI14R8hskQEEwWIJ1guMRs5INgQ8N
/4eBxAiDxg+fJPUISuGbQxi4t5awSAKt4sdEUs2RWJjyH6OIT7qMT4t9CInw2AVbkE+UEboiJCKPfQRZ
LWU8UAc7PDB25bqI1l1pc9Dk1VINoU7/4hCeAY95Yv0A1xPxNYAkg3EzTK1cllW7QQ43Jy3A/4xb1ah0
y4nBPyGMbAyvx8M/qKAF6y3AF1mjIpdQhz3BO42k3VnUAg4gFTI2CAuHhEm7QbwxKEGQCiof1hb2lEdJ
Cfp/K39sGEQOLbtFfxUohBXbaCVBruBwzZ9gbYGs33fC3wGD+IDyFXPIsbOzwttjYAQNRYsHNRBOD7cG
CbykOEJWtRrjB4vgJYxVAVf7tbtA9aCnnjwQ/qQRqv0gQE0BgPESfhx5GAt/R1aQ8MOAQdIPHSzAAo7S
1J5QotI2AQ6BAvDqPegSUSwsYAJIgQBKwynXElV/j/2LnAW4D4wFsAeJXAJml1FHmgKnSFtiGCWMrm8E
hrWoQ2YZo2GhEKE5ZqE2wGHwYAb3FS0PUEWn2ecl5ewODN5vJP+J8KnHLHjZJRkyaKeqx4uAG29tY2As
zq/nJ7TFAmIf8U7TlJrFgv/lm3AQBLIbx2AEw4iWBF0v7NHARhjsh61UzmCAcLBXYGNQECQUAkFOce8e
Bu8OoagvJi6iZpCPtIXAEM4fKcAwGAkfkQJQBJsfsLMJDxjbNBq1kUiLtQ+yp6JYW/G1L2JR8MDpjdDd
ZSOs8B26NCcyWmHBotd3vyQWcsAfMQRP0U0lLCwyJi8LECJFby9hsEhoLC9FkNB2aAcDQAgsbBd5X+08
HSFasA9XRtIz2ztmrwMhhUC/31DSIoM7/3OqpIHQMQ93VZwS0l6F3GT4MnVDAzWQx0AgtEo6BrJgKBUa
kVqMbzVgGF53uw8iXuZKdRiqx0YgWiTAsQVJZihlITyEfC8wTE0JyE+AsEh4MKz/T8hQyFQChZBXIFME
L3whLZIp1BJFBwxIly/0HTIgfV/QD8rGEhkwJL/0l1QOOAwShnuQ5kh0/05oN+VBNCRm0PpvyYAvGM9A
Hq/zpHnYgf9JKUKU3ecwgAFIU1/YwYlZkb6nMjsbhhGSggP1xwQw6CIO7JQBU0P2hAl96hVmYgeZAEsl
XgN2RA8hCScmik0WIM0RCUvmRWKsPog//n4kvz/RLWsN74I1QN0ASSHjIMwKNioC0DfABkhco9/HIRcI
J5/nJm8nVChYhQuLTQE8obwbiTRQAlfCCbAIcDrgOCbhd0cBoVFMIfUi5C6EkFABVDCBqoEdQAA8C8Jo
eKwUPD314itJf0d2I6y98kfMSxXkrAqENEQOrNqUG4w/Gh3YPbfkSL1w1RqR8CnJychJYlN3RqueXMhn
OPnXOOxCzi4cKT0OvXqFVPM95hk4HteHYUGsV92nKEAkgYhmNMCoLTK2IC0VhhE+BZBKwIE7UgnhV3uV
mMO4hwiBAOUv4kgnjCHTM6olMelsNohwd7Uss0EoCdD7SF4PhJZ1ZYjk/hnfkCOpYWV65oYtzB0zGM/k
3Qt2gCwPhdxzFdhG36yAvp1LwATQ7ECALRiFWYXLEOpiB0iLLV6AqIk+qBpO8d9L8FIBJHtIIQCQSwiA
uLH4BQEkG+bXG2aqwtd9jBAYGUqUHpwqJZPFSgzPlSAnA8m1tZU6wktIow3hLy/XhuANiIP/dZqvDYwc
gexb5NfFYro48C6BkFsAJ4dzctKV4ytnuJlGYIHAOocy5ExCqYKp9nYIwsCYaiI0LETBciQoKQPhoGhC
nBrdZQyFgDAM4wcrCDLYk94qtw+McKwXIoYF9EZDStPIsV4WQNjQQ9nrwKJFTspGTROkedKNM5aH2kBg
52QIYptnQJpnRy4zr9lHKZAjh/pFk9t38l0GEjFAuTqo5tkQ2D90hTOO2FSZIZBGUWJYRUcLz/QTcoSN
/8+iRuondSCEZ13o2W7zRAChL1JnxT7qgoQAkA99E8SPj0FXw1ZJjXkICEWcVbrUzIEAHsH1edABiCXi
TTPJB32LQYV6BoEYEgCUCnCPAIHBIAk2gvgYUO1EiUW8Pla8deLYx0XIpFIISQNiQ1UjbPdBUWZBt6i6
QVCY3mIr6p8SSkSJvF5fbonoirVVRkVqAe6ttuEwVW0rRRgt6Fj3UnQQU0yhUi5aWVWwkKJhsAK2gB+2
D8L8AhpRhFU1ZBcKXTRq355ABxNjBBYBL4C6FUcAHgpK41uigHwTdw8IY88Rlv9DvwLgnc4YgKORDcIq
4FsvEglBB4jMP+RkQsZXBDkaQ1b0ZKHrpv+JFTSQgslhCreCqLBOSI2NFQCGgptVbIiYTCp1qCdQCz+y
RZhMqZCgdYi3A4ghVYHEJFgZgaGSr6KABaIyyLeCjr/7AjS8Jl1mRYBQeFtQfSDdiNBWgzCYbNhYjVPF
F2RFXFzgBQDbZY4SrZ80qptbxHgGW9hFqW8tolAn+AneiEUUsRmCj8AccKbi0wh1AXM45CrwBUcFwuOA
SdHpSxALVA4BqtVk4N8COpVDgH2PDFBmb3hBG7M4bEiLPgyiuhWvjwHAH8eeUJwCQVo5NFacQQnFJxRb
OZRBXFd1QvE5ZEFdOTyEIx1h0EFoQ856usu3IFgSdNvm6ZVCeEA/NSrLygYb6FKvD78uNp8ns4KGHWMO
Xy3sEmYOX7cfEvFrRIyXPioHoAOqtWt+usgGiEQ8HFftimiBaC0mUE7VB+wKJZCJ40WoaKkiOOGzIABc
cQnYNy0SwQ/7PVRIOd9TN0mJ8V6hOPIL+tVADs0DD+sIL7nKAMrlezb8awIY2WYun4gaoMhzVsD/2Ntn
RJNtJ/uXX4m4AR0E3tzT5pMC3ALVjPAuCGgRuv/jnNPwUcWMHYD40LORghMHMaOkzBjI2WV1FaM2LhQx
Cv+EDUGCTE8ohTbNyQD82/1sSIuRRahpPWB2Er6NogUrRaA3TopCNSN3Wk7BWAFXNVi/rUbDNea2ya6y
xWg0GoWY6OTIETmjBtgDwjBuxIis0DwMltbTBkGn3Tf4SasjB0vHaT/6yyKN5NgBTcnHbuQNWD07/y8q
zCgdenKAnC8+CcrLlYwdsC7tyC8OVW6E74O9xwCkL85C7C0W18CuSIvTrg24KCB2Jv7k7g5ITz17D0B0
jwUUTOiCSwkwbRBOLkKmT6wOZEmA/g1d3AAAB10KAF4yAnemqwiCa28KELyx2dhDbBANtcp8ky5HqwFs
dk3cg9dS4aJob5BIHAuILu3W/gmciTKdEQE9stgIF2O12j21Gx9+ScQpW4Y1zkiLGIYcsWntzshSUalo
eYoCdhLAGO/DFggIszcLAHjt0y1HspBtADn/0zdcaTAAOn54qMGVCkIXwE4unwSoYUg/RzLCefC0FA1F
wD/ggDaAqIzMymG3QEV33MrAOmxnS4WyIwSXzhAolExgNwJ1wmEFujiNMdmPIA7LsG4RaXWkOuuNSQrB
+ik90oGpoJZPNHauggv/0+5MUTfIJlSTAPmcAeyG0CsxThBJ1wBVI69JSukssxajsOZHrXbAHtG+MFEM
6+QGECkOLG1BlLFvUt2kRInJfMMzNU8xWAXXyJ/HwGcfAbf5wk0Jwm4Iz4aDxTpsz1cVu6yCF+LAxYoV
gVcX0ffdworlcnpyGjlrQ/q5Ec5GPMgXCTLhih3szRc6nA28sRXQVkpdEFgiAtaxrYLPyxFFxHCG7BHm
YymMr5LLnLpi3IWq2WRs3F7HOmB1rDpr88ZWgcQsgCXHa4Lfyhi2i5BcEzvUCXeyhxUwCTpoHTxVQWwR
sHiIsP//1H71ET9CRGXs2BIAALHwIUlRaz/cHaeOG41UvEOagP1ssUHwiK2incAPcCx+W9T/9qXAeYUx
iLNnG4UQDbitZwNL0WQ0Hw4RGO1dAwB8VuzM5hsLAt5REWh1GcaDhgSAauIBuR9I3QAbBL1wrI21QFAV
mYqAmM86ALFj+cl0dcJZBdx4FiLpQQiKDhbF4dACM9Svoytqo8RYPMeDiF0LFo0JHD9phCLXCOIUP8cK
xD6Jg7jpq76DwCcnJ2cNaMiQ0Ozs2RdrhfWD2BpADQm74OTwSP6D7HjBAavqPvpf/9DYBr4CrRWUQ5Uo
37ZVkbDmLk4ZPgSEw71GJjlBTG0IG6dZzCANP/VAFQ5VyyTmHum2M6wtDAz2WV4P5OshR64bhLd7NTAq
AYbfAwjUVjWMHwHCI4iWSEF2mHCjaZUPwkhPEDMFYRBAG2gRIktTWDRiuUgJT6a9EDQ5IgJGuBCzuGiT
wnkhxLiPQPlacMKxF4vwL7v4n9g6CoeRWhJbWiiCsGtDDUoAjHMhCAcoVyMC+FXhMDgt1InAt1sqTAQt
AcKdWFrhBkbB7kAeOkBzT1JBMApLAI/BBgj3+zbeFNUAUISMggAa4EQdM6MdexgNVeHeoI0FklgQDQEt
dZWJR0m1jVB2G1WiKQ5TEIh4EhHuKcZAUIQRUI0e2xhEzaj/28E64p/UHor4x9doKwAp+gSiE24IAQFH
uOA7gpIxzRbIjSoIAb2KKgKgWhF8SD5cEWC1gcuHVXdFMeNuKKBrC8u17CgDERGIh2YX8YHhgBBf0+A7
sMQOCn9SdR0TwTqQ7CWLflgwfYqOtQFj0zXJDMJgQEdG/7/aAP1UKwR4N7+9A1oVJxf44FrbL554nbj8
BceuTCtZhT5UtHsPYHPUT7TW6t0mABwd9QZJx8T/UQDDALdbUCtyA+yk6gV8YKMDvZGASeYOTi60oUk4
kUwW31EVzdAJSZDdRImAlq8ebaCoAfQTKAM/TlgV9Tn+L01PwAo2EJGDxm8JBV0dS5Y/7ncgtvpx/aFC
ykPyKNlbQt8oSDn3TSgRQSHb+KGDWjK/L/80RvBBBRzZ0nMCWEc4SAQl00/m2GW5oAbsQu+UFjAYNXZS
ZtVP+vcxebLnS1z2l0w5/kBbWCxX9R0qu4RvRnNQENjBllTx+zY3RI1pkB9MrkEVw07KcS6rV81MKRmv
xwBnEcwnG3DLimIQT0NXLA+51i5v5gnRh+27IkDWQY1NAnARrraoytFMM+QN2slK1Berg+lOSe8YhQu6
AaOLTKpScChFpcCZiyi6x4mppUO94HajcUD4qQCSwBroCEAygJUXG5aGKALIlDYb8OtuFTgAhfjWSxyX
DnaIKkM9nTxXRLUtGzE/fWV/gzk8EggO02j4ErglVzJgeFpANmE3y0QQA5aVshhgA9mXG5POIsQZyjUy
RwySITA3jki2kTwcARIJXMJOdvcQu/cYxiK2Q3YLuUAI3kiZKDiyyUzBQsNYKWsCNgs2KidCIngj2Soh
g25gR+iCiSf32lcl2msk7EiLAEEOGCP7LkDhCf5A8EyJFMm6L1kyIInBidvW6kEV8gZZgtVBgYcX0H/s
JWzA68Cjc68UhIUFHcfFyICMjC7u7ZCWCkqzyPiHeY6kmWjq7eXPUVEDx2z4qQQYLr9MHmYVrAXCLy2X
tqBggWcPLw+pz7H+9s0DAwFEKAWkCd2LDkYFBy5l2xIin0nYFiaKXtmzEg+3JQ++ZQcWCx8mthKwhPAg
DfYj40HA0rqA9f40sv1gMZ1LJA4EVRXRYkBTCI2gkm3dEW2HFpCRsS7VPCVKjWEg4kI4gT7Qv7Abg3VS
2wHyiFJA6+vb3Dt2K2jrO0Jg68wRC9kFd5u5uTDr0yDrzRfHBVjrwTc3NzdQ67tI67Uo668I66lsLzc3
EOujGOudEuuYBJK4u7sPtOuPE3DriQV464NhkEO6Hz1KBgggKEMOOeRYUEgOOeSQQAgQGCZ1sEECB4KA
LhiRw8YccAh4T4qqMGEOUSvsStCDAAxJ3ssHQgcVMA8tUmYD4zlFzBcoInYR1DajxQXPg/1qVTEMVa+C
UoMtDUpcE4PpYCK+aLNlkJI+AcpNAShcB4+NZenZ9fbqGEQgiM/ntpYUA/aX5fXcEiQM55rmExNvCgIL
+hF3ONKDdx5iys7OkYzZIG0DYer1cWiK58juO4nYB5T5aiz3tzgWx4B7Mv61Ho/RA48WQwchIs5UwbDH
ghkIIAx2KKXkDpKFO+SwsRpwCCAoNYkKiCUIV7sMOKErdLit03ogv4Q81NBETA875JCxCAgQWF/kkMMO
UAhIQGHBBjsYLBIHsiAyFuRMDwh4WZCDnST2TA97k5MFOUuCV0uCcthhYxBYK1AISEqAiBxALywKftH8
iwHRqIsgfgJOfHZKOiU2RVCCpnpBCKJ6hCBL0VtdeHAVHPCGHmxnst0Epx+J0RnoEJwRxEiLh8MAAjZK
H/cThlQQx/cEEAbGqhgr/yp3zOrhyBF/C8mMzpNmi4R6EDU1zbMnpK4AclqJ+B1JVHR3T0xCrcwAXcOA
2H2LRjitThSnyZAM2UYwDyAoDMmQDAgQGCQo2IUGDm/2fUEYhuoTQC9wP5YqYUN4D/8pgAPSERfetBjl
skUPYwwfzp1OWSEbsoPfRmhPYA+SIRmSWFBIWUQDGUD/8BbCPL3A7FCQCKGiBR1jztgZ4T4shIkTprWI
GUCngDANTCUgOphhRlP5Eryxgp0ojSG1iGJQDfo0d1sStHqxLIuFK4INgLM6VFG9hgJ+v1uF/x1e8knx
dkSC8ghoiYVQx+xYEdiFcAqPmpPmbIV4CiBQGDikOWlOMBAoQE6ak+ZAGEggUOikOWkoeFhwc9KcmegK
aEhghSPNSWBYMAZIOTarDoAAwhVnGAC4I7QOJYUIBkZUArdo8gYqRS2qhe4Pj+DTYGuT0KILRJgdyNQj
0N0V3MeFgCMAveyOgkxRbC8moBoVgae1n8VgQESOUvxBg1MhnCH4R1L0FBkcYscq4PYTTbweamApmihT
4vq1k0Z4ULGf7x2Q6DYE1CAgxBAoITdYbCEni6W79yQ5C9Y9yhV4wg1wOTk5ORA4GFA5OTk5IEAoEDk5
OTkwiDgYOTk5OUAgSCg5OTk5UDBYYDk5OTlgSGhoOTk5OXBYeIDEcIPwi7WbgBSlQop4F8SBxNgTC0h4
AtC/5JBlvEMYwj9tIUwVNe046MxRdFlRkYTvSNe4bj+kb2AD9oKzMSpmH0PJUHJwWAgylAwlYDAlQ8lQ
KCBQMpQMGGgMJUPJEFBAwMtggFtekIsUMNiAdcdbhz/h4EouSEl9NQJcFG7Rac52Z3tOKI1wCgh4k+ak
OShAIFA5aU6aMBBAGEiak+akIFAoWDCkOWlOYGBoSHqYk+ZwaHgssIF+qrdjrbS1AeiDiL4gS7cbT74i
VYT/37Uu2CXPu3YIKO8cZ92yk3ggwre1wnaSZ92SQLe1wnZQ3ZJn3be1wnZgrLVnXbBnwnZ4txFYnlUt
4XOHvFIanmBawqxz0p61dghhlvCkG561djBhuiU86Z61dkhhnrXZYQlPdlhhCJ5y0i3hdnBWnrWNKWQS
Aj1YuOQAkDBgaBMgD0v1PUhQTJFMIShYLBkQltFoTCFXID1IIBCWXIRQ0VMhLBlgPSgIAWkWMdYgAlIw
CLzoGAvhECdQU/kFhCUMUOcnkgYhICUnMNlMwkKYeD3ccEKBNIVoGmVBLhBIeJ6RcEJ4RjA5hRAuhMAi
gRcMLuTAEp4gUFQIBECr5EIObJ4oQAtEBiNKngm5kAMIeANbUAbpnktIJ6QQFoVwC54hPC0qtRjKAisA
O4U4npZhMYVMeFgSQACDFUCDBMGCFJ5nVcEn2FXtDRpDmqX0p3o+PaejOMw1eqMAgmCURVMP0LEu/74t
c7j0zAH0UgG/uqsAPCdnk5M2HlSFSEHLKIZfC37VRtC//nQF97uADuhVR490TxAXMFlEqhjFu4BIwJeJ
zPB1dscCtkYIt8h7CFRP3AyqJiB8EYYBAxLAzwMliINAff9QDtgRRL+DbIPwauvSbquoB9dVcE1BVF9X
1F9mF4sOxkUuqB3p66UrO8NuE1hIiQeLX66Hn4BUuLFjTVgIkl8G3KByTZFXGeaLbzaoShB+3YtZlmVZ
i4uLi4sFgPtmi2c4X8PD2EaAqkthuUziUBk+qSIQIPOrnEcUuRa2YSGqXhB0gzzC1oVSALdsjQSPtxGF
cES4+H0JiEruKvsldwldIMBUWO7cIAuiHQGQ6+Pr3BxFBd8urkrYwaDgaQUvPWD3A4gIBesadRYjFeAA
KPoFK2L32UmzNQ9E8A20OcwC/o7vtQaJnTJI/8aKRv+TAOBfLAY8L3Xy6+2sT+gA4AKz/GTo2mATiGEE
BAqEKnoD5Hh1HZgARyo6OSZ1C6LiYUOO2ADwbz4eRPAy6GXRE7SDKE8IvucIFhAFBZ8BFKSIzKq3CCbt
dsoPBQDTcQGPAfRUlCD4MYCR9kTYBiCGZ9utqYnwHUge/8MfrCgy/AN15McFzU6d7vjCw2dbe+hmnv1h
HS8WV1Bv7907HVAsBnMI/72r6sZ2COvvH0GEY8Zi1LBBhDHCXMMJUD0AIPzSAICJ4mGQDgCiULVr7v1V
BIWfRgFaVc6FGDPXB/3RMLIzUSEWFAwWDRU0FTum6N57xl9VPFQkCKj/4GbdCBCxvj2n/SmdAOyoomx4
Kex1BcVXJULr91BNQgOPRvXo0RPFWT/gQe8AOJ4Bn3UR5y4U3hSfPXUHSkbu6wZUhyjGzNKv0ttIUgwi
PJvoHwB4wgavekvLef8AHN8NTWJIIRKhgURDaCjZCJaOKJgAnrMFhGMLl0EXuA2NQe8gkl2aY3g4uEGK
6hPYBb/YYY892AggPgi4Dhn0vwl9WCDq7L9/CbXX0R0EOQAGwfEBZXBQV5JiEkVNdrpyYFrWsd4x/4FB
ErEducBuFHcqBnbUIWgU3OsoxpsSPEF1V+jD8lOHUIWBBgFjVJaguFX6dRBPyR4C+u6sQQA9BHUgYFB8
DigTqBCEABhCQvh4+yMYGG5j00U1agBF/9vPfg7+vwKyopCFwBn4Wll4Fw+64xN2jBfVcxF0jrhI56qK
BiIpDI0bVUhPDwDwCKKKjaB3v/iNEwBBDyNUrWNS9fffiTjio0kXg3QNwrlMg/IicEBVAI83iw0FRxFQ
UOTLHwf46lqA2ht0xKfBB0wcQTwodIpVgAmgyERBU7Q9SRHBXAi6tM90mYsRywZ1u40SBdhkFQoCdQB4
K6gVL8GZvRFRgS370kSI5go3NCtBEE0ap42KaKob/9keALTh2evCcc2MG6KHpiIXTCpmiSIeoTtcJAhv
KlgBJKIGFF+iUgNHEEj/wILiAzjrEkicUZ0EQefnRJqWTpJP06NwAiAIVVfMAOJC74kZfNhBAckxNQNo
CNqCA0URU2ZfFfUqV8EFaKgAA7ZMIMFCxS6YZlwOQAEFdxSjTGPoxbd/dVFNaIsFvUU/T408Boo/4hjm
ZizPQYcH7Bv7pZaNXwR0Jn+5FLq+u/AK4N6I+ZW6KcB2gTgX1t9LTG1A1e8Lt3zGEABGZ/E9dqlmNuw5
xVjrQYtsqaLPKaFniMWuwISgXRdlbGUb2IAQcwBO0wJAbO7r0BNUBMEGba3TlhQ6Yp5BC1uEYpyh3z3/
ozqA6Ix3tsEp7gUCXPvOdAf88mhTkud2iXTuE2WV5NlSMMcAHDcdiVDdAdQXfAP8CwfDEvEQJy4cZC8K
X9htAD2QQbxcHth76LrwBccjPwm9BR8EkSqAlMUA4hO+UxDUxFlVtfXEoVCCoCPoKF8YUxBtn1Xl/gPI
bwjH20IIIAcKDC8BzbvdbhVzCgfwDSQAFUcEERjrIbwmQbnKg76BZ8gIWDBgiOjf2oB+XS5hNdYNxBiE
kYWki0t21g6DbE9PcyFTEKzgG9JPb6AlFxX/nf6F/SWecsAiIQWxMiEA7+2S8eGLayVnAQINZkCMAQIA
n888jLEBYU8ozmjnnDIiER/PaSzIA3mB7UJo/DAGOwFqwMwAznJATnJpu2pPaDzRRsYAQM89yEdyhM+g
DfG0GJ3heXwBfyzy75GBvDIeaGXPubS0RUYbPc8f0Y4ZUBWqKeiYqpoVbqh2oQIiGVVKEBApiAk9iVEY
huB4ELBj4tXJAbaQ4WjReMPa1aONkgdoHyHVJCtqAQyv2DcnY9fCwhXZLyEA6+Ibxm4radgBDBAI1EqC
b0lBZSrG/NIoRZeicIX15/44BlBskTx3O0VBRKE2DAFxVBwG/9Q9hDUhACO9BCtqCBn/cIwvBN8jRQio
VGy8CF5nBdPIKvQuAaZJNkUADyrCxZAUbY6ClzBlqycBweADADY1Cz+mY8cu/QYJFADYAcMpwz+AuNHQ
CIMwiocDJQXjj2SNcwRHHysNK4CpHyelGFE8deMuqcUWMwTnaAPGZNuCEOyBzFhqjGjs7jcwBZo0Cytv
HjZhHz2JNCFe/lsFb4UhYMcqddv8sVKFs63cUFVEQfOxnGwR3EkL9hZCKhcQcGi39LcXhAlhNCH7wPiX
nHXfXW/aQACL6DJGA0JDBhgZf4QiQbg07iMFMWA7FItoIKoJoAxnSdAWRcE4Wf4K2iRHVBwLoCgUhseO
0EZRrQ1IgFQGbrQCdo4xwv1mRPFNWw9CxYlEFFT0jAVNPK5rLCQ5sH+mi3QkGD8GW+wBAeRDP/1yhqK6
iQxJyjfKIZvBHzjRsFSGhIYailLiLPvCWNsMKsk5hV9XBBBrJ4lUI4hZkT+DYxSgFCs8PphiISMYLEVB
1UdHApcVuZsD+h6MUDkY1RzorK9Dw4cFUrtRKwhVHCw/mFTgFoIFR8RxR24BAc0Bc4NyErB0pIWeuArT
4IMJYTIOr/djXvOL/5P8GGEy9BsLPTI2BgU/YhYwbyFFeEdqI+kWPj0PBsO+gQq2RCQQSIvXHQDwbgjH
GBK2/SjSNwTpiWQICEmbGOzQgEezTlQpAIbINIBm1pAVwf/AfMmYsB9shA8fD7zGwJ4WyGYxDWoy1A2q
WgwsJB8oWIDAsBjgZDt1rBCB51gG5mzY92kpXXh1K7k4looCYqW/UcDPWiH/w0i43+8EVbBiZsoqAkX8
LwJwzDRWBLFaJWnPXQMEQ3gcANhVFd2CqO8qIeKPqhk9Bx5IIy5c+OAbEHFc4rzbqUw7bgU13CCJXHdj
bCxbBQwFoMFfJCQaVet8LggxTqpaAqV2dC0QsWRRQ+LAMO6vbTiJAsat4dBbSTYrIH6Fi1hPbfhdoOpM
TEA567Fyp4DBCDF/lfQ3tFEGbRU3IRtQCxg3DBgvKPhVA9vgx4ADoAEfPlwQJHPfwAVbGBYmMYEnEBjh
IAVJuSKa5eEIBHWTw4numAoziOCNJVMqqGMBtu2XWDocARotEIFoGKkgCbMK96wdG6QI//UgiWg4Kyo+
dnB8psAVUKyqZ4roIW1XOQ10M5sA0bOTArZjb8WkG/B0ui/nKF1VUwMskt0/6DNrYBg0Ue4QjUQ9eCHq
VAUAdNbodWx28Jm8MrkKu2eNiNkkFaESixVcUMCxoxhF+DOI3CSfmZMojApLCiA5STAtYIhQxHURBwlc
BbEla6kbwEa4ALKT+BCBAI4lKcNqu6BYPDDQaXyJBNCF27EUEo1QnDtUDHYucAEmBbeuPDNcHItNTiny
koPKlruaWIJxV08U2ksIDaYIdm1q3ARKcbih+IEy2YP5J79zmotA7ALg4Ns5wQ6xz24VtlMIcdZIK10C
HwmJ8IEBmpuBm3hijXUaDTGrn9QOXw5MOUwkGJUlYKRiUToye2xUGIpn0kGiThU1z3n0QEXbIxYHGAME
s/q3cQgg4lhRz1ETde49ImNK6HJhUCLI297DQ197Pek85T8RWR2yGh6pdYukYhO+yVPziWiHxWa0HXuu
Af+FynAK2E1zVNULhiNsIM+D+Qt0ohmXgriEAg90chUhChw8hKoPRAJvDhRAq+Qn4sIEgvim0+AYLE2o
KGbkC3qKcYsYRibN1XgNKYI72TsmIe8tpC5QdyYhzlCRwWIbOQwRsOEe2TpI+CWDXYvjsoiYqfhI2If9
iBGJwYRMJByGAtwY3MPEJUm9Bib5YSoN4bElqgKnMM4WKOF1DbXAYjcCYjHbBhPD65Rxch9agf5ZNoSf
mPFy0+lXs7k/AEwYtqPQq1zUqMM7RHvsXIPBwRdIY/Z4k3jHAAxqaQRsQoCPHnOI7hjGCr5hfOokIQAH
I6sd7Sasj4U9+HTWcNjqBhGpf/DuxohdCSK/J2rcmG5AM18Ug+acdrdLELjGqBsB9Bx50BBDiAiPEYiQ
Bc+n4AHywXfMeFaJ/QbA9yMfOcLrdnQFcNjAXnDj4MOR66qopoRJb+K3AJ4id1RP8EH2xwG7pjaKoz5v
H39JgbYjBbT9Y5d3jAzFauwTeEmCTDnufYTCQZWqzl8IujG2xc9C6LM9NqDgA6NpI002oAEqZmiTYOHf
CB8Rdz8H9nB4I7sgWwxWATx2Rc9ID6EZUYzcd9wZIvWKSeG52CIgB1EOfR3Y9EJDOd4rs3MwgG4QQ3vw
+wsiaEX116OI2EIQ8E8JFahiNDKzSEVtUBpMANeo1V8ATo0kMVaP7xbshuo53rR23ExkYQmiJHAkFZJF
tAVE7uyGVNQjv41T8O+HBYGa5tejhkhGiNFhuxCeZSzakiL673x/LCFhSaqPcy7BA5HgF7d+GUgJPBUV
2n58Edg1W4RN+H8yhEjGSRFG5LrQgwFQdHf+B7gYIlQTxXcfSIeIXBETXXQvirrHNbi6UgMAY40SemxH
W+JYsUXA9LnSuAmIn/2mDwUsZAxawwjXYj8eQffBFnQNMHVhsKhg4+sah/583eEF+8Z2FhuRg+f/rb60
UFv2bInVicvYIEgGQfdfIjorDTyGArEpTGNBcb6LF4uGPLtA9QuKY9VMY9NMuAmOW8BFMGXPhQQvRVBj
Etqfg/sgrNtRFHL32GP0ayJg31uvW13psVOUrigZggoXd3RLWKtgIp2Z62NdKyAKn1aZRwxmEQFWpwOI
FmF83ZVLREUDBRhgFUUPZ1B05HxY0QGXy0CWIKsoEsIusrgZPnsIMSEKuYk08lDVRz24C2o0ERAT9rwI
Lxg60ZHIkzYx/wHkAHu7el6kVRk80YMGOf7ScPBUGSY6vdiYetJJVKoQI3oZWxKdJOJj84SHhwgVJPwJ
KAoiwXozzoJjVUMiMv1VAPBED6QwWHELqGP2AnyZPgF4QgW9+I1P/5AFzTeiEj0OpERjyaojV1XQgMi5
LdTvsBCDPWUwId82CLAlWZDo+y1IuI8D/M65B2uxhdPOxwWBKxEC2P1a9oOLBRB1pBUQ5AZjkTA6LkFP
HBrdBnVm56IgB4ustS/JIrQLG3MI6mHQRe5WxIOICqUEBfGrCNHrfAEQAa4h8F0pR0HQAg50i3/Rd5Ea
BOsHMdLlSWP9iNeWRealfLEvCNjodX0akJg9u1DPPTKCok+WsVDBV1dRP747R+1iBUtKSEnhhwlO0QhO
O1QVm1RBQeyEgDpSLKRISnuaOoyFt+L264RV/ThYAuKzIKaNR+D94LLdHHYNB/8/d8d6nnQMaUaLuv9a
C6eIeJbCeYEPSJfqfxD/MHcNI+sR9t0WtsFHCJ4QNYC4g2GIKmQgHKgAIhRihCMFZV0iuSZZ2Yy3aOJ7
ibQkfQcdYtWl/8fHX7+4VJnaQnw+axB5BPw2dAhkP4HET8OQo6liTXYPay3/arliRYV5jf2tga0S2fcx
dIZj+uswvgG6KEhCRKjqCvqMP+oFif7stey4JFdQM2JMagquAg4otQCX4IOBXFN+BWQsIwHAgQulMe0j
9u4jvAA9HiOzfWyJxRuQESEAGaGIQR6EEQkbxcZJtYBkbj9JjIzoYgRlhwsPfAM+eLoLQSZDH0ModArr
2IIEFzhFAAgjcr83BANbcOu8S33pi3VB8ZZQh0hk+xwmO9ZKB0eJxUYf/1TBRwHwSNhGRSM8Dg5dTKga
gGJdcyC0O4Efxq8pxvNTBNC6L1Ao6AY7oQIuOAcoFQQsit2sdTAIRnR+34JSV10C6gMuieggij6JoqOE
wEhOFQ2J0LRBwI+C6nQ31CmiZnapBIM0UVAppEJFnADgrJxtMahoYAe8QXAYUN/gqiTVGX4IV9QRBEFp
nTCPLlgBdJKYKWBIUX2Gw6yqHeMBpdPXg3rhBI0eKAMgJNsqqEB3LyYMLMEClXPiF1kdHVYBhf+814lv
G3ZMvA/X0THlVoO7kKcFp4o+5XgWYlqCuhHZLf+FRaI2FVEpT+vqSLOCgxNxSZWJS3ChAWMoVCzrvmiw
CqDqh0jgUlU1/4YB7VcE6QWd685anP5Dk0VRuKf1v/joEsTT2+pJdfWKYAyiY/aMCwTk3KeLgUswG+Tk
9s/GenIQ9UjcfzBFrcRjAhEGsEoMtCJyA+85GjyAJSP1X1frXQkJH5BJICEAF13LAATEtw9aS4jVfRgw
COmp50dyFAjiTBjgQw4gmuCD7gm4qceIJgKCgM1WnQAQQJIiNluCoNW2L7s3wVMBQG9xA0JtCusMuXgK
6pB+StUC7Cj7zYI6J4smL8Ba1F8oD7errAAUfk2gmsq2viVISraKSGUtm0oLQcAboQfDi0onr9Yi30cB
DioQEyuqOvYX3QDbP8MQg8C7AwQdHJsY2ygDUBQ4y+kAgI6v7A9D//RSQd3X8YPbFuvsAAcuclBRCwq+
FQCpvBGD6jDov32hZHcmPcwADHcUa/D2gcYF2Pp/fDnyfwdrwAoB0DhEvpg22tH/wczrzA0HRBV1dFQl
ddH6oLHUiPrDF4EWF9vT7xR1dTnRfXEbQFr2vIIRqnjTKcu6Jv0Yg88C/4H7AG3coImNKozTSkkAoH0q
IKDnFwcixb6aGC6E/Jmg6veC3IHrEOvglMGqgIAWxTWCYkmWKRDlGhaYRI5c47Y6HR/brM8GGlwU5IBY
7LeMYKOfvdnA26Tb0A09EHS5bd3bXXTuQaiAEdcF/JolzHUEweDrMfQKF+94QBGF5A+64AvcGADEciGU
0x4VgaGgAyDTRq8lKNfF+yfsEvCHmuwQah//KnRE78hZXmmShJVbAtcIMjPppDpBG7zwg+dbD0XYAnvb
cmcdTJkZjgYi/xiUgILvRHpFI0ZFHVEjvlwYlogiYvl8p6J+LbD+TYLzWSkKMeJJY9VbJ4Tciw073g9D
Pzcq5m7DQj/wAAo/exDhqPwmyO499GFN247camjJx4L4/3/DgdjAWFrZ7tnJ2+l6AnQE/yJo5RaFRYPy
UHyiIaphiIdngI/gDwjZBd+cgwllqFzXsNlEE7734SMs/A4ddza4D4sFqCZ/UVBhKdgaB9jJ676w8LH1
PoA4LXU9yoTY4t7C1vC31m0HA+sE3MLe6kwwC4t3gKKmmSuKEi+wb0zdDMH4U7QogQupmG2tqq87cAMQ
04HMsJDpDnMDIPoJrWHbdgwLxj96RsoKaD1gwVDEcP6GW4iqCAyXcjU5cQsQX9gTQdQgwfofgAjfgIjb
g+K0wiuvQY1XD37Q3W4G/tlZXmaAXup7gKgqBZQ3hNduF7ruXOzZbAXbXGwH3jawdF5EiDRjI9pkAwoM
Bl74d9SGb0IBiArYynUdPA+awYt2gwJphMmOd203uXh/BUV83UICxiEuwvd3sRx758LrsHX53dgBSDZe
WIDoDLqGf9n1TCnCURUXH2PLdUKpLZXnbn6dyqia2rsuQRI1jVwrAiP0yvatCugdfVfDTSnTuBpCEv4c
K0aNPCv++xFwnIr9C8wmjATGKetDMzCioslLAAH4thhMJA05e1UpFgGgpc7CzD9Ye4DiidoHRLI94wDQ
bGa4mE0mmQI5TBhbr6Dvqf7YiQhaePoL2A1zimzQHCgGVRGlSkMJOgrzPBW0OoinjWtU18n2SREKEaMr
X8pKHBAMxcLffB4RC0EcwuoEYisAOEE2/I0dHTjF7d9H3umnKscg/NvqetJ10KCLYH7JZSrhbMi7AMqa
OwBoG9xjfk/zHc4OovqtAn78D07OI7SmgPr9dxiLF23vVkRVgQJTXVTRAnfR84lX3uMWbYPYYIlFde0M
JYK2BdqDMk0Jfu6liuA36e538CnOfO+aKoKthInajUMduX0r8IAJLNYDRI1YAa+tKjoNbp3cb7uwEJWJ
H4kceL8kGKljUV332XLqbrQCWDzP6Q5w/w6I+O1ITL6o0/5lbxAEhTGJ6h+LOubKAEDaDCUNXwKA78aJ
cvxLTOSAqMUh/uLNRXsoFdNQVbzYuihQYrcHKDaApgJNIuP+ZlQBbBhE1dXauFGoPFSCwf6JOVHDJd56
D0/y57IBtIggyrkSnMKsKmqCvxH1cySeEIBCD7ajuK9qFFVbtd/7Rw6WIqCI7wh+yrmo0EH/0sha1ZW2
N3KVwEGHwOAOZ7YtLFV+McfbE8GrgOsg4iHRtiuDbgBbAJhjK/oCXoAoPP4PHNEPjSCKW913isR6QAJA
4xdEDAaZ9/FKrS5EbIyGWlUaBfCalL5+8RpU/N7Ra/YKc4s5sABsCxUxutLi003Q0FErQYjGJYoOl6qz
rBmoyIH+QL70X6rQOc1zDvZB/AHD2y35l0u4jQ6vBmrVByrRRPf7C0k5w3IPdRdC2ehEdbYl3rb3EB27
JcfYCbXJ2qhk/qkS9pda16wI7vrBBTbf37/whbfpJ3oGdTg5608BrTGBOf/JBAsXbnZ2H6rpBAwERCL+
CJ/NdgvHRfz2BiBsbEL/LtlbBQQ4qspluICidkp1mTYQYWfQi5Zr4lKjR+jUh8N+axTtDU74/HwuqUTW
9Ft7zynD7RDvAv/L9sIIMLbBCG4/bXYVi1QibAiiGjHJZKIe4RBWdWnB6+9tXaKrH2OvY8nHIA1smbpW
ZnWZGitCuFIBhmPLwfvL7WibWuMc21QG7Eg5LPupKd5R2usviivBY9hI2aKiBZslyJwKE1DQY5sKos0o
dRcq3LqeVU6N08KwAXoVJkr0ZZOwT/xGbBG6aX8pwjnTjoY7Zu6lb0hMGAGOiKVMdWxh4dAeuAuCyMTA
JKK2qOpDWkXWwNCbvE/I62YZPKrQYNPBe3uJ3kSBRsEMYn52U+F+t+Mpwoh/CJvGADDr7UEoQdugBC9t
iAMoReHWXwIDwCuY2hEMuznSE0D/bW2wzy4AOcNvRQHZFeiDcEpgksEpyYnBwAiBWevABF4EGip/NMFB
PNyGg39MZriNhAkKKAGTfh/Y2PN7SBNsH+1MEndL8UZQFMhhjUcJbNxiUQ3fSTmzDRDsQkDsdhnetxYI
aAiyDO1HCBC3boHGeoNpMAtXCYYOIg7v/gQNMUbhY47rroXb/ix0Bo8RN0I1s5Hde7oBHuLdul7cTR5A
KH48d7gQ2wgUCXTP6HYrIm5DTrb7CQL7wxbcYuPTZWPSg+sJaEyogD+7jVMJRT0uPkgYe0CsBtvoxR7n
7OaQ8HTVAkW3D4MbfbDobGTOQCYK9+X7YQmuOeXBC/l2T5twEYB5ycYBIdiD3iS0/36UoCE86IXbbQDY
EICXnTWykPMo71MXCyZnCR6JzhuvaQYdGTm2AtDtuu6JYCm8w9SN8RIRJH7D6fkSAD8XFQdiqiM1YiFX
xjAaIAAXFUN3sY0a0ABjfRCiKhcUPQUDK9iHHZ4EVYhgETPAhIIyPfYb1ABwF44KiZ0K6gUNPkEDRkFQ
eA0pilf0tRgyGFFylYMUsKILAeABvftJFJgSTIs7QQHcQThR8UjaApehJ9+EAypAIyA8JXQc/WdUAWpw
6+WAeAElRW0SVXUT2wocFhlwaCXkWKfOFRpNUVsYNHfiAFGzxWJhokKUoAhDiPDkCrxM9jFsxT4ZqimP
UkUHvtuOl0p9xuswQYx3GWsCKk6q6iR1E5UUBwswrIq8/8SovVVsy/8NNr6JKBurYHsRY0RDCNh/L3Br
6XX5H8SA+ipfkRPrALcqghV9c/AN+NitZTvT4jkJ1evOcaKR7e9IAUgvMIP5cj857gMWgU53x4SXQNyi
Ru0BBjGzL7wNCx/9weIE9rwXAIVWCEdQLxaB2I6BFSZGmB3+B12CioR0LeIBnzHgiw+7ylcQ0NFJtAsR
7Va2Sq5ibtvhTghUOqpjsUEB//F5IIHNRUH33+sVDqoWZi0+ocLbjdinx1iYEvvEyf9n6p0ZfguNLvWS
Aa3/5tG2XfLoAjIZA+gsuSKSALnOTu4WsuWW20xjjEuQH/tFTJC0z01jzXQyN6wqjhYYBIqCLVlR1E0K
A6BCkIrsu5pq1WDQPRObG5PGhsXS79pBwxwqeheAjT0EjjvYC9An3RCD6lo5D4eJEEGrgGV6W4Ie/Uy+
tWvSOgAFu9hpQYwB+sQFWmqUwEb1B3daJFqi6o7ClTHdVYONRRu4IHhq6QWciO8OCS5bpu3GSyxCiTSz
weP0A6cpikMQaO7PIBcwOXrrMkRVLWL9VlMzauEyeLvzUESAASChIGLbdXYwwIETukzBgqify1DrC2Bo
6HgY54XJ6UCpwwcAG7SnqcBx+HYBWgNQHN9FF8OJ6CVfFMAOgffFsUXx27Zozxm/xjfwlqaWAdAB34sm
4F4hoGoYWIpdsBWbjAvPSgtGFIwKTpOkCGB2IOl7InZYG9kQgw+U78I9onpjxNMSaPQA6rUQkvlq2G8m
7LdCyIPNCCjaPSNuj0yNtM01TX+D4W8BhmgX0Ctxx4jLAkxAWyXOBCjRf4sFChw+QYge6+S0D+6mqBKN
HQvHFJRi5paK5gYIEwwEpwBq1gSxYe1AFz4BhxOogPtUsmzfiMJcRIECXBNT2QV7K49cFuvnSV2tiuD2
Xg2zNNXBTLBbvBvlwg+MFqBKAVzwJUeU+0b32LsBX1hWBE7uD7rlC9O96WISVFlyJ4noCk9DN8cCqUOK
RN1M0FkA8GzrCn0vipucqAo2SLSPImiDYR/5RJkK4J5pixM1DD2AGzUKdEb2wpsTFcEozwWq1JmrCCBK
ALtRosKoZSuE0iUiCAH1lrcQYPhCIbwuyUwp8PhAQGtBaYq3ew/7P5at24HlTJiWiawC29hZuc6sOogh
vzth3xIMQLwqN8WmLloIgrY4NoCoXYzAzajrGboWEUNpTExNcwtQ1KCwwhqYd0DxoL4Btw9J8UtA7GFC
oDzpXwb2BBV0IXn4AOMInGxjrMGY/YgsoAaGtXqye3xBIMj1HNNrAiUhoDgrY2CxNSI19/FoQ7FN+pgm
izPmCUgETlV94oPD07n2w5XgVwaI2ZhM7ULhDkAMJhnRICfh68F8gOL/BQSLBEsG4iegCkOuielEwK3S
j3eDcrg2WFph91VyGSEEEsA8iFOIYUsv6w7b6QweJhqO9XoXAEt3DSJ7QZaPf+lMjQzB6M0p2IUKhchU
tIcZMVARiiMKQdHAET4KE0GiNEA2FwgapbYUWb4gA/gYFoY9WCLxoGob0xj7UGsRgjJUphUuDPmCkZc1
ML2A4D2OUB+78YPR277II+LsPCRMieqMHLIhnkkgACCHWLOGNNw2A9gwg7sif5KZx2CgkaAgLUl3MNCA
P2FCizSA525F4AGA/M8meonoLcPAIBIKddnFXJCqa0sXwIU2uxN07Dpk7nTrHWOQiLJdSxvM/7lgP54t
gf16d+Ot19gb0YapB6ZFMfbfKNsxIzcxdzHdQFWBQ37AfsSWokC93+pedMndqLAwWno6AdbqPVTVT3IC
KFAwgaBOL5vigkhYBX8gQy2Lw6WBgHjxWssAYAIEEEO+CoAnfNagTFzUhIi63PQBQa6SGU2Eh4gcNBzH
SzoqTnDzpYdG+WqpZ+x7ju7vmkBthapYxZKBRhQLBXCBCQAAaCsMnWa9wAU2cQRDHH9G4N8FAHJAwSQw
UA7gg31ghuGpii2IV1goQKpipFAgbRtSFdstWFQzIEhsVGYcDw0Vpqo6WfltQNFmdZM0DxK8j5oLX9j0
qA8iMNU8u0ljQdDcVUhBSTiJBBsgZ3MAbwXF+wxuxrovv1a1b1FF2gtEw0bBdAgJAcRg7MC4EdVAqO9w
LKqGt36Ln4GKCFAvWxOGC1Abi2/D7wVo1AoZvrZeATW96KWAO/xXum0KWgErHGsIyAO+1qpViazoByIV
AckmTToltFlBLGLGmIBagtdVODgEluhFBbOKiG0gAILJ2oX22gLCUMZu0auoExipdcXBo45qx1eNkGoM
LhVuuTpIRFE9ujMwMd7++GsD6OD6MP9PpLkIKsjZCqgwqoBDlgaFDwCIxdA31gEEpBBQ1RFtvQIAN0G2
pMAYL1Zbo7tJCIJlQQ+wEKm+pdWnADs+C6hWJhfvSdHiSxXhCkSv30wBDVQUtpve3e+LCt4Cdhx4DwD/
zU6PLdCiOYjlMuXrwGo6JdUx25VmkHScdInLCg6Q3ccHvCC+RDb2dR/rXx0jCkGaRpzMIIATVe0shKtX
4yJlEuIMgQguHPPDRzc4tlFh8S50esrWSbeINti4AQBNoqT6B2hRDcV2ajUzWVoE27okwB+AAA9vESUW
iyFPDUlJuVTFswapAOsbhULxgmcyhkwUUDfY99AmG4UIJwCxO6VVd92xnGgQULI6r+pVFaUK8QuoK6JK
f8+/tYMKNx/owQGLaksQXum236EC3De1KjQoYA0cfTjBdSnVWEdFVLO/Esh1FvZRHezWMtc3McDvKchQ
cPgJV41UF/8wcCiWDJ99kJAQcaGiI/45zlgACkrml+1QvQlBJGAqwQhPwlNEnlxMNinGDkEBEFNvbBCo
dx7pCNcDGd5FNZvwB1f2wwd1qDCEhea/Ym94oVQj4Q5oz0m6whQBSVb8quAChVZMMdF92IiOsCFUymsp
+hvRhq0LBQlK0HX/2FfFEAqJdL/Cgy2Kzos6c5thhNsU8zHPncqAzPfFQru11wkPCfo4M9cLBfBcr5vs
EkXdsWM3wwEPdATB8QkFnRBOQNWEIUTRAQ9XCN0bfxY4wnUchD8G6yAwHGGLqh9sG9B06inQ70hJUSWP
nQEEA8dMtR9GQV3SxzM52HLUwBUEMebEqGID2XUwOOWiKhgdz/VAAGPN7sXkLBEJm0Uhf/+RCxYAmRyw
kL1AkR3/AESPxwKPML96gD8OelGhKWJ76wWAOAlni6ighJfQRAoQXEi+mVyI0DBMApGOhfL2MIlozUd3
EBqOwBUSB012oAEjqBPvwvBjwq61dffexuuY46RlVV+HXb6W6tEwXE+N5MGNvwmI4ZXARYTBdD7VIGYE
8XQh6zjfCKL2lo7GHxSiDl/3HR8eQRmUht3bAyw+TI1GCk4B7AGjaLTQX/kzCDYiDog68xaIQegc/ZCc
z8KWqKGh8IWZ2F/CiC8BiD9TifWiOgyh3q8hAhSYjqWaeFNHx/mdk/jZCHIU97XiJ6DhdAyklDEjCJ4L
dfS2cLvQBHHieQWkGXX7QOAA6gWEGXgoXl+Z0WAp+oUql94W//3zpH0EpapgR9kNLKtFMpU4wAiCd3dl
fnd47XBAiDfat6pW4TFrdmNmiS3tVnWBThf9hHZVDHUjCLoDC/k8dkmal+5GDAdIDfEedjsPurfv6wMX
EeEE6RY+diQSH/m+pukDJy83GcEEyUhsr+fR2X3RDxMqzu7e+BEE0XUL2avnLpXYf8Ozp4PiX3Cg39VE
RyrRzuvfiwWnCRBNcBByok6/gBMAvADYD7EXljz4QTMUtY2Csuwa7w0YSNCNiiUtJQ85ndGlb0tg/86J
fd9TOPBEMaBLBMEHmUCDIrVeu+8sAEstAeIiUNCghshUgFzetcCLEywHRkwFzbZHLEmQ4GUAWqLSbbtF
sQdbQbZ1wej0674b0XkzuCHwXT1+dCMI0BQCgghu0P0EMMMWtnnpxolB6QcE7YXJ7dC7KFB+Q/BTuGXt
Hdz4Q9P/vBhNBAqLFzk7aig16FDzkKU3w++WoHVdfE2FfvDIu9Pf3tgFEsm91rwFkznDdRqmIhxBeFlh
t2+wznnpz+AM6+A5e9NYwQhvg89ki0cMFe1ooqpd+W/R+7gVoPbj7LjwCRlr4IOYvQf/QwjWEbr92GER
mdYFCotTDPfCX6cl4hjMySRXog4AR/WV6+daikaDFLAV9AwQ+lERtxZk3YsGVbwQwYu/1EoQefYF1FJX
AiXAmNRWCCJH/L6Qs7ODxKfDpSaPQbiEjTBW8o1CNGNGUGQzSVSZahoePwACR+yJ0NslakLQkwW6AtaG
7lgsZA6J6CATfoQl4tjdWL2HB/t13NyBVAKV/3bxQnEoDMz2Bg/nakYFbET/LKAVVCC4vnwUG0TkDDQl
8doAPww7QTgCp7GeoM1Rb9+BeghUKRZiIWqTdhhpEEdx6KRa87r60UEPDcbLGv5FLoA4EDpEAUQUCuc0
U2PQn81TTY1nIFyjkuAKolF/9v+gb6RLGEQCnG8LQAFV3UPydQYSKAI2HtS1KLB7vlgt0RNvpDmeFDNs
B/AhMa3zXSy/Hwr4Ahyw17osAXUMIKDYBOQSrMJVbBnwAaKPYkRfxbH2gTgRxyoZvJ3NZaJhAEHLWlRH
RW9a98T7m82qjYpyxTVb11Cia4teCn2KAQgkXBDwKImsrdQc3fZ/DG/wh/H4EKkAoItFpt8dbhbCKBwR
XKYcs52J0iNddbjlNWugQpnoqhPGKSRuRREvbyAsqa5Cwz45LcOLgRRLRRROE4EpCmJoUCbdIESuCCMo
PVBhC+pHSVQ4hCiIASPbKyLDbBBOT1qo1F7D7D7CwQRcMYlajTOKC4JDDjBuE+ueEGuoIxSWjqoiPKFL
/bXFReHsRXynj52OVAFBdQTIwKaim31tb7F6FPxYCnB9i4D0ShS4AuhU600Ck11h6Tt6MVCtk6oI5th1
e7BI0b6D8CoQvgMP6KroDut8Sx194wTdQbRE6NssSx8GRoxfF3URxzYBAW4qfUSJ6G7AJwDDVUyIton9
iFanNuqJ9O816glBKmMJi1UCbxwiaoPJvgHqNbVIPeR0LwGK13JlqExFmWAB6DbY7XoYDokJ63ZEkahq
zD04EN8bcRLrzC4ayUJBBiqInKrgaRsPAE4IhKV3MJBIiWrRDM0CDFU01kMgWJu8uQFVCIXoVQVDa1gS
wIQU9KRGu3aYA4WkZrXHBwwXCrYIiv5IdhUK3FQQpB91Dte8oNu/IIAJxjGtN8OI9/BlEE6LgIi+/xAE
EVoJbgAc2YZiGWy2uIit7h1RwPMxFR78IAsgTgiIkD/KxAkfoxPJ9yAAAdjA/f1FeYsVlxGNDfAGLgCU
grViPPEuwes2RR0qnhH2BXVBNRT9IYkcHLCxVVS4C+saTec5FHO7KHiYPXgcGBkc0BOWWuO4KaAWQdEJ
UTQ1WJrEvudukO4Ii3oZMkXQBGMUW8Co5yndNOA7FlBtzYilBBHyxUsBMIw5xHWso+pWg7jAAUyqWjC2
dz0FBiPYCnoAGk6CmDMFgCBnMIlQiwoSFVxzBAIXZkCKYsOF7TH2j6o/sA52vMsvVwQI6xwILSNgJzni
wYGFaGUnCdgfoArLr6wp6w88p0i8Tcv59sQI2ZEAIgnbq6UwCwU4tEFsi/fQLID4NYuom3FDIEktTw42
VEeNeyZng0EDyMTOBtfqGwoodRnoUsf32kRduEXABESddOksiHYN4CENI0kta68rtAYRbnOTICJa1b91
ZUGA4QR1N0HaiwpeKh5yB+7TLRLVuniJCcYLgb1QpAf7F/APBUs3Nhb86yjHQxQC3+3pVVWiDagRA9mi
TeJCNrgjqxOQIZoICgyMqZmimnx1MqG7VdQBvblOdd4rEVVoETggi7EIoPoyBubYGi1X/LgQAueNoOYC
DeD9IYxVt+dggeVz32auDRbudVvDPz97xDaIaIbiYtrM/4RH6NiLEv0UXDtKOHHB6cJrX/tNgc5GDqAK
3CexNjH1Z75ahKjpZpKfqUIgaAxxmIhB2nHhU61XBChkTFK9hu0Gflg4Ew92JX5LtG4Nckp8wQgvVxT7
DsDuAHkUF8dHPi1A5sRDVbCtTYkDIxUoscl19mUPgelPuID55dGt1//B1xOe/ZoXKdc90biDTT0cqWoQ
Rq2L4ArYyLXXZwTQDgluRcKPiJbKuCV1HqoO3BHfgAnk8o24kLjIRW0q+7gR++ENYlufcv3fxyCBywHg
QNXGO4A0AhEU2iBFEF4KHb/d0bOB4a0J2bRKeGG4hqZCHNsMVgDsZuCG5gx1RRKR6zjwETQoYD9kgy0K
aMkVzks2Dh+jBDf31oHmrK4HkmNgO6wPBUB8H1dqHzWtB+u91agEsQq2r7Cc4Y1ou09KIANyJnIgdHNg
MQe1cfgMHUdTIxQ4dAyHX7iYJX0M0luZBU84dxFDArYTEASIKMPpY6m1yUxF0IsQp4iAS1TeifaKGLdP
pAKuwR9/BLZEJ/CAhTXqVfx+uK2B5pg7dTjBr20UbhRcTs+sEYvqDzdHABMKiUfAr1WJtvhricuD464R
RQDwIY4bgeMORdiCBaJchQJFAHBgAmV5vB+8BtGF0fZTixMNClwFxmNM+FQBh4HFEmzdBXWiBs1w+Ouh
26ABWChAdELEEpNaYepNHraht+FjqYDrHvjYXbshInC8x3Xg64aJCIYwYX2UjBRte4jL6yGHJaPgjRW6
FZUbaugNYYJbjWrkIlbul0nB6x90Nx6hkXgNzQ9r8FPxsj1QBYzAWQGQ9EIqBTHAQxAAA4Pb4GEkqitK
C7j8EDgCwdR0r6VWBJ5+FBawLuxvOqwTL0ASF4sTXDSIWIBSIxTrCmKzHvcPGSwIF1iCeEAZgeJ7sZWk
3/oFdeH4BAQZ4AHYGzNEhekmk8PaGiAVgAAEPZ30g7Grixfef5B/AaX6tHk9rnQW6hrDtYJjbMzJw4IP
R0fRw0SWYE+FgTUgwYC/WPgCVGqNcf91wfaGraixgTcI1niAsmCqOoFo6WAICLenwIBpaIyOhFIwXwrH
8BFiNeIxvg2D/wMiWYNOGvWZxe+4lW62QjtAiHpIMcBYIsiBLJBc+rUSu9heMtuJMoXVA8QxwCSYsSHS
gNvCRP9JAfUFqYBcQLIcOmBVnQq54evgua67UHkzBdIXwx/KBy63o1JfwA2/Cup0GBj9L4sFufcgTgwL
BixkTtLDLNUgAESvoQoCxAg38PEIEJsorr8D8gJEgzhaWej1r+gxiIoPRPh6aoHhu149/wFVGdJ7cqIV
/YJh/8LkEK3qpt8PJfC4EK2oQOSZ6pG4QOd0Ffz7dRN+qAaEeUPS47hPaFnRDGzVEKq3tvQmYYA7L6pU
PFDEjhKIOIxC3328F8CTI/CkSKpFPYMIlrgnG5WBijBpBQgcqiBQ5FOC3UMB3Ikr0WoBcQhYyve2YTEo
9t3C5ccqDmWRGiYtY8o0rZBJFHE/NahjQP6+nCt4Ub/Q6kqWxwUV+CATe0IElfVwPYcRE9Qitrjawi6C
+7TbXDYQOVtrWxhMg7AoYrEoGoMSBnpFJYL2SNSEiJu3CFVTvjr2Qwv026mLHdwGLcVd+OIRvoQHIF73
QSHDFTdFFwYpVitFKFwioFf5I4PFC7U1EIL4En1XVVs4A6gQ1G2G0lDdMFGumkLdSqPYIgNVjH7YhUch
WrAgehREFREp17sGEy9dqqgU8k8orgUX3ATRqmo6CgJPEN+UXoswg/6S2UGARlSuqG8LcHqBn0q9/1LZ
8aolCmh84i9AxQu1DTWB/lECjgi6A3UiuAxLWxDAxdJ2KIGqFQS8/mC3MEEhFu/zz0N6CWILXcmCIOud
nXprquYHKwWl22vJsHW1C0VhIBpKQSvZ3u5h9ApC7Q2mChGv3YQXODCeBbj2jBWhZw0iOpMji7exY5/2
DYQqFYUUyFEFYwkoDWMlck3Yy3fWuWjIRC9bNmQGL3BdAX9YTwiigMeObTxIMj1hBoQQ94UCb6ReOmCm
da4bKaI9ysY9HhOOBqf6dh5BuiKrhWCyqH9B0DH/uAnGeEUM9rN5BxgLcBTbhkpMjb9zbQE2mgrvEM2E
XGCpipKkOe4umaKDd2wLYoA/whZQ4IER9zcH0VLE66d26p7QAWu2l8OwsB21hIGgY5tYuOdzujzF6PEb
EGz5kMYHL+2JDVyJqG3wkCdgoqZiyBZM3xG3DVUiBAJ5QYi7XWhEANaJ8sjNzABRNBB0dEtH0CwEAR0B
9+YDFfx1HWHxNbkbxgQHewMgImebjUH/IPjdUlBGwSONBJIBwCn0bYMinDAtQog0B8gZ6FJ/3fP/bAd6
t4LFATA4tlDVONaJ91vKTQ1VnQKgexkBB1/rX/Lbk/YdUQwBYO9fKxoLOGhZtxoa4RJViTU6uP2iglWC
K947xRclRlG4VV4bCIJDdMiB5hViG2YdpzUGM/1LtYpGUlwyDRgE39vt8xC+ABAw0xnHILjU0ZvT5h45
1gbBY0SVD0PeQeLAIDiJ3iO4FLfI3TMFq0BYXQAnA6BJ4Z8F+ShaAnAaazIX6GAEuI1lgGmB+AAoBacB
b+ufqaqDKQkt0wGJCGJQqVVXagKdJUHHEStBW4LKSZDHK4u5GFQtK+HeRcFjm742YjQKSEVvt4thRolV
yjUeF2REwF9Xt01mhwvYkapxMcAXDA8XDAeQVUpy992aIRjhd6zokznHU7kErfs2E1FFM0f27EGblNvb
hWCHDQHxRtFkIE+NfDewo4dhMh25tFwYalWFujQh65tzRxTRgpJlCCJBRTb6rqi6AS4DePB+dCkC3IlT
X7d78I+igFFnu/tuJ4D3bFJmkDWNLyA+U4CQPc7l6IUh2wsIhQJKVEHDChU4igJ15d8MggWJ+D9B2Ccs
gGBPMwgxCAO5sMAXFhOWoqXouJGDCJvoHBdcC8FenuhmaPQUETSMFT9VihsByAnw1CWiUAt2yV95UhBQ
tsMe+qJcgVdiAxkhUJmsxdaoIJRLTUQBbFBB7g+IXlFHqlOuoooDVaZ8K2poeyTBReGhMLgFvxEd3dkw
HNgN5m8HK2rgtxX73YMrANsz+nhZXussROskNvlRwda/PLfRdBrd2GYUgIBumygh3mYNBYkXPlHA5iJ7
LLxbw4o6IYJN7FJ/9K8VAsIZWouLj4zhClAwa1AlWBAf0BRLv1SvoVjrurkpIqyXBwL4YhfEeoHDQLYa
HFqlvKfTK1MwBNQJmFKIXbS1qCgBnHULABFDIihFotkv7LriHnMsN5RiIYAI1MTmnuiDwf7Flvatz7cA
Bbq4thGIyS/fIOipywkCo+u/wxQsQlBdksUmeBuNhwfBcyZhUGwlqEqVJvQBajp/eFqHDICGOANtY38j
ASuLeKCl160XXwCavfCm4jAg4EG+FIcoDAWEqZkJdMAoCkTlSZeqkTBjh2QtAdR1cSpuVXt4przuUIAh
lnK9CcdfXT5Y3QNTYMdeJmKJrkNKUydSQALAjeAngwtT/QJV3GKLEB5MCAjrisK7QJ9VCHMriGhFLXvg
0MYCLfyhzYZFI0Gx2+1FCMe7dnooogOJokxZi28QwQHZhQnQiXWBV0HUcqgIlYNvVTfIIIkH07tBUAvG
R/tHEHOU7qQ4R+5HpUcJKOFKzbHRJ6mSVQ9VUxft1oxKUfoUHgkbTjp0GZzaAVtdXIZEQIu5P0CkDpGE
Y/8LCkITle5f0C5E1OlFc2OBea0RxYsJuedUxLOKuBC9rjUFFB4xov8M7LpjFW6+9TWLDnXZQCE6Qd2L
yhQZaFIniEVQwap/pqgp+iR5E44FK6iYRVA0uh1AcGqluG5geQSOADaQeWNMmcpQQyWKYRTEDhO/yh/f
aBGjSmBqJl5fdaoxKagik9BBahZ7sckhLLPWAQB/KAR0EkoNBGL3D+B9ulpFwusVFnUQUM9e3X8k7mwW
RMKaAExSmsNMDkAVAZi4VUGJAA1eowBOGgr5QQTvAynX9MVIxd7KJInuixyVnaAFcEQ3d8MYEIHBUigk
Z5wAaV6+hl++hnMRBowwV8GCGHUABJioWHDwqz0DwwUrYPfRDrieYKRuisKebDXeansrgGdv7Aarv2wJ
d1SEG9hJ7BVf0QfgeEZNCllgYqeCKHX/4lqnDppUEA87/QcUFMaaJDUpwIS7UFTbRHROxmnH6psIcCPg
PfK45N63Go6AB6sldSgCXDjYhe0fdR1CuGAWqaC7DWnm6AMLmIwsZi2Q9gVFDwAgUy/p65AQER/4NCFS
wdpiY+z4pHURtsEMh9EXd4FqK/FR5ATQKe+IS8V1YwTNuE2LHAACWODsTYXbIkXqS0hRbV0o2kkpIAtD
S1K5FGlZL04Tqgh9Nu8YRd8tUzbrGvf4Ai0CD0DBwNQbAX0l3MLSOUsgpwIYnH4BVEPF3cYDageJZ5sn
ahAfdeDSwL8Bb0ZV+QmpXMAYiHrADxH8fUCSRQLk6yKKohv7F/sEKPwJBbxfEPE33Vj4NXh3oQQfaAMQ
GgZ0XXbTvV0ABPvwqW90Wgj8AXFAOi7qddFyRMHbipTC6MLUXRW1jfhQMcDaYoBBz0kDTgX9oAG//t8o
WIAgy4UMAHaRfxPAbl8XXAmb0Q+4BFEEQVd0hU3gfMNaoKOAGBKoTgA7oIDmuOsc0IqAFX8jCAhaUJcB
mTpswA+GEsJtiYIGc/oPCcdLEPSj9nPcXr4GBL70BS58o8Zzz2Zgfwajx0GLN/iqGQHNMQwHFLw2FwGk
0hQ6ECeqyCQoWtgBl21BtjwoiiW2he7b5/BGE9hhCB/H9kYC27dGQBUbRgRmJRdmAtEWQEoaHfh4DooH
wU08QG0PMbYDrhkMAHuwSS9uizQGcfiw0cGi6ExHOMDBbIhEuSJGwMMhxOocBX/fw8+3IQAftfqgB4mw
fQmgCAzZGy2A3wQfyEWbwsMRKBHPLlm4AYXDIEmVqmgg9x3E3OAWVID5Bk6Ag0+8RBTxRwG4RIhcNOCx
DySNjgDuxzLdjSCydggy1y/7bducwS8MLOCIConBPOE/ur9F4ohCArQagIhKAetTPQBksE1F7Xc2aBLv
d+Rl8AO4BInxTeE/NWD0Id9PAQ0GAusPDNZiQsFUugXEAsERGjRHUyv4FIEgKeK6CwkESSBuJyougWAS
EkUAu4dd3w5QWxAYgmav5wiewCXJDkLDK4P9Uh2Yqj1p5yAAET0NRTTYBd0LWyfLCHhxhCBOK1VVquLV
JeOB+7p+MVaXcoHsw4VhgeuN2A/2Cxt35Ewp3Bc4haSA4sTJw/WPLGSXAAQHAAEAHJKTJxIAJP/+bsgO
mweAAMAzZENyYAOAAWdhk0M2CgA/AAewkAzJ/yIAIEN28gIAIQcPJEMyyA4cD4GcPCwAAwAg/f+/wGFB
KSB3aGVuIHNsaWNpbmcgYAECAf///4Q3YWxyZWFkeSBib3Jyb3dlZGNvbm5lY3Tb1t62aQYgGHNldDsL
dB5u1v3/AgQgZm91bmRQZXJtaXNzH0Qa8P/222kvQWRkck4cQXZhaWxhYmxle3TpBtsuiLpzA2sHxQMC
WLMdrLUHKHoDERgHNc1yO0yAA5B/ocg813Vd1w/VB98DIgsvA5ELJ7cFaKSJ7YYDFYc8dgTYsocLAw4T
7tntENWXA7+WB4yZe3VN53YDfJi3A8EsD8zbdU3XB94D1R8PgAeqrQO5bJpmxN74Eq5zv8JeyWYQCcR2
wA+SQ9j2rr4DsSsJxJLNtrs7BwLQAyO21DbbIbtcF2/RA7i21NvOvUos0s8HW9UDnk2ebZbX3EbYB2TZ
mzx5kAOc1ubVRzmyVfbQ2DcDkqzrOrcH2nMHFAMTQyRH3dmuG9aHyAP31g9wA98NWNd1DwgHWAM2RwLd
YF3XMyUH+x/tv0cDgbBm2zU1GxTpA0oHB7bsYF8D6gca6hMDbTOAHTITArT1A4KcbZrZ+xD2B05NnjzI
A3v5QfUe2Sr7C5j1NwNJ+myRvUD79Q8XBV5lD/v1P8QqYoAFa7rHA8/KBwPYkA12zQfEF9IrAwtkA9VH
A1RkIbDqJwPWDVlz2NsT3gPhD003YAPkC+cD0VTthW2WOrWhOAulPgOa7jPLhj9tC7QHtD/ZfaZr0QPK
C+0DDEDuM81yj0KvowvQA7ZbLpvqmUOcRNwH+EcDzrao3aQHgkXuRQuvbFfiQQFG/jYf10YLpOu65k4J
Bw8DDgvSNNuuGWEXB5NPAzQ/uq4724RUD38DlguqA/Usu65poCsTNwPnULYE2LKDJFELA7buEHaEE+9W
11cDEWmapmkiM0RVYaZpmqZvfYuZp5umaZq1w9Hf6+9qmqZZLghrITpTbGmapmmFnrfQ5NM0y6b9Fmws
Qlgm/jdNboQvcnVzdGMvYjhj7/1v//8wMDQwN2E0YzU2YTNiZGExEjYwNWM2ZmMxNsUW7b8ANTU0NDcv
c3IsP2Kbi9aiGhELSAVt9t9M/G9kLnJzZvMuIHRvIGxvY2sHe4tti2ggV2RmOyBwF4XbtnZhcw0vLWpu
GFv8Fq0xEl5ncmFtLpVJbV8Xs2YRRnUjcCt0hn1rsUZsZERjdXIsHG3tFi29lHVnCD9g1m3hwjuXc2A9
UFpvB7YdcI50SGYkbSA8bdvb/2h0dHBzOi8vZ2kadWIuNm2ydMPaFq1fO51rt0jdvsdulnMvNXM+Lt1i
ZS9jtt8P3dFdIB5DPD0gAFplLk5ba61dZVNEKGhdeCDdCr37dTEyOGkDY2hhcjNVbXXgW6EPGHI8Qqcg
LT4gB1CmAGfJm9sgqu0vB25kAYS622VrXWRLA2n/DQkdYQ8g1wEMkQyRNwIDhoANhAQvwWPhR/9hbnNj
YXBhYzdvdkNmHSgUBmN3QmEUgDD80N5+YXdfF2/vv72dRfay6ztiBHRyZToKb2pkI6sXt9D4sMMHFR8o
YnldX9gOtrdPiGV4DXKqIkJveAt/1Pg8QW55PiX/ICdOr0XqaFhTAXJv00YrbBQ+71T2m0/kj7KR1Qgf
j22ESDgAR0sgVthMnwA8OjpUBG0cnrMbhY3ZOli/YyANpIW2pD6BFk1lgnxvx0ZocJNgYBUPdlZqaip0
HW90eWkX/QqFpZxln6QrYXQwuY6AMMRtEE7W5KrQsqUCkHMwI9vchcVmaWF0ZDCauzVmV/+dIGgeMuxl
X8Auai6cZ2U4c5Wc4W59D4gibL1C4XR5YsZ8jwbGXhcrUGadZKxjLlaFW8Kr4Wd1jI9NONbec6vIISFg
CudGVpi3wLd81XVlijVbfv2hbbvRlYJb8FBvjGVnOy8r1kZ6eeU1LTH19hdoQgUyOTlkYjkJODIzsDH2
lzswLjQuMS5zIXIyVNkkDQEAAMlEMlUCA3AF7AwEPeBTg6NQ3roZvmI7h4UIja12cm6eHNgGBkUcaRgw
OGAzUzV0Nj/WvWEY7V5IMTAAfoMd/DEwMjAzoTUwlTcwODA5f4N/2xAxADIxMzE0MTWhMTcxODE5LPxt
ayIQMgAzMjQyNTKzN22tFQqdtzQiEDNrrf2/ADQzNTM2MzczODM5RjQiEL7BBm00ANc22DQ4NDm01lrb
WDVINiQSAK219hvvNzU4NTlqWEY0a99EayIQBDc2ODY5fGq2tdZaWEY0IhA3AGuttfY4NzmOfGpYRjS6
RttaIhA4AC+iOUi4rut+OVo5NjkSP4EhzEboMje8WIySJ9ojEpgFKzQ5ZxEPLUUwmRoucgEOLxK2HTMt
DFsuAF1ngr2CNdJl/zxBCRMcVMlZ0tI24b6kB3mMafjYd2stJJImICl6YEyK/yAfZm10BA8VGxkDEheM
BxmX3A4WSwYTYGV/gQMH3QgMHRwYGhv/d4BxBcAQBAsACQAUAA2bsBMZug8SDh8esAf2IUlGZh0Pij4e
B/aBnUtTDWcjQg49YNtkYwUjD3UCLR8fxYF9gk48DmNOWmzC4GANgTYKL9jZT9gnABMACIdDAHIAiQ4y
4n93BwN9BRg/ADeHCUBkI5miZkSJkerf/YAADAAwAFwHGXdxAGBHNUTD/TsIQDkRZSxRXn9QFvq+MwNV
NSo6BDj7f4sXhIhfK5tdT12EgCpoFDsAF1+xBRQJlFfhs8Ncxw9ZBiZuG/jxt8s+bUocLCQCfABSAHsG
//9/I3dIBH4odidsKQAiWw5hDVZwYgSFIHj9d38H9HoeeQFUADMfhnNYAE1FbwtqKW7YvgoybEwA+IqX
ioo+57uQYiIND0AHcpBBBra/+AMJ4aR48AePB3kJKU5uAB4AOMA9ezbYgH8PgAbA/3mA/+yzYYNQgEgo
ASCAD9ghPBujBvx/7wZ5bQEpXoAJ2jV++1k0iAeiMkD+DyDnsOzABjDaXOJgh/0EGQCEXHDABx6KF8Lg
I/AM9DD5bBfQLlTBPQceIIAWkUcGwP4h/rPmhv0GYEQIaEl0Z8/eHQLt///528mA+Afg254x2LwPPyHk
PDsD5xPCIz3SEMCfnzrA++/TIULADsA/WCuOsg4KGPjn/wOEYR9eAMD//9GDZxdC3xcBXYAHQKPvNISj
ck7VDB8jGIM9+A8XGDE1F9wkHMMB/B9hF8AfXjh7pB9rgO8ffx8RhjkCdxC+kfUCJjCCfma0ME4Ytx/8
bQMAKHWz3w128M+coDb3//0hEAOZGYzGjHgLRBPAONjHBvIHhwEEDhgQCKSzwc6fECAUwfCalhDeH/If
3+D//qG65z7h7NkgL8gzFrBpgPc/Z0EYJKFA/8iAEwbh7NNAAhdQOVjRDXZ27P1m/kj4eRfA4P6EF9KD
B/9/ACaAMJm7wU54A4Bu04dXkGp/5RCD9Owf+J8O+aWVp8IgnESEsFC0R2F8aAhA/nm/EdtB/wY7ncFP
0ASgwwf4I3ywGdoH//u+IfH8JjVYsACgL/9hwJ6xPUMq+1EA/wDMYIBFjeL4//9vEgMFBQYGAwcGCAgJ
EQocCxkMFA0SDg0PBNwgqF/NEhITCRZSGAL///9LBBoHHAIdAR8WIAMrBCwCLQsuATADMQIyAaeq////
AqkCqgSrCPoC+wX9BP4D/wmteHmLjaIwV2/0f6EnkBwd3Q4PS0z7/H8/XF3x7f//X7XihI2OkZKpsbq7
xcbJyt7k5akEERIprVvgb6c3Ojs9SUqajhy0Hd1it/bGys7PHBsNDh0cRUa3v/22HV60hJGbnckaDREp
RUlXDo2RW1u2u6ksxcnfK/ARExKAv93+/4GEsry+v9XX8PGDhYukpgrFxzDa20iYvf///9vNxghJTk9X
WV5fiY6Psba3v8HGx9cRFhdbXPb30QL4C4+ADW1x3t9+7dt/azO2X31+rq+7vPocHh9GRzT/he3/WFpc
Xn5/tcXU1dxY9TaPdHWWly9fJu3/327Xp69Hx8/X35pAl5gwjx/Awc7/LtuXAOhaWwdPJy/u70w3f6kW
/D0/QkWQkcDQyMnQ0djZ/7f+rucCIF8igt8EgoAbBAYRgawOgKs1WPiX/h4VgOADGQgeLwQ0BAcDAZIH
C/+XWJBQ6wdVCAIEHAoJAwilA7T9/0eYDAQFAwsGAQ4VBToDESUFQvu3uD5XB2wVDVAEQwMtN1HCf6v/
Bg8MOgQdJV8NBGolgMgFgrC/7Re+/QaC/QNZJAsXCRThDGoGCgYStRvtbw8rBUYKLARQBTELB2p7t7ER
C9usGh9BTARJdP7tGyDLAzwHOAgmgv8RGAgvEbf/298UIBAhD4CMuZcZCxWIlAUvBTt7DhilL0H0CYCw
MK7WGgwF9v8X/m8CtgUkDJvGCtIwEPADNwmBXBSAuAiAC21to8d9BFtNRhUGv73d/nQLHgNaBFk3gxja
FglIHYoGq6QMv7C1/xcEMaEEgdomB0dFpRhtEHgoKpVob7cGjICNAr4DG44R/39Ht/gB4wKuAgoFCwIQ
AREEEgUTERQCLzRAAcsZKAUdCPH///8kAWoDawK8AtEC1AzVCdYC1wLaAeAF4QLoAu4g4QvfuCj5BqwM
Jzs+po+enp9kvtELfwk2PT5W85gEFBjqVle9NZGMjTcm4BKHIp5+bzQa7X0tXAQ0GxyordDChanCCTfR
qN9E/v8v/GZpj5JvX+daYpqbJyhVnaCho6SnqK26vMSN//8XSwwVHTo/RVGmp8zNoAcZGiIlPj/2Pv5L
/QQgIyUmKEU6SEpMUFNVVllg3P7/jfBma3N4fX+KpKqvsMDQDHJEy8wXGgpvOl4ie+mIZZ8vLoGFf+GA
gh2kDxwEJAkeBY9ERFz4334qgKoGJA4EKAg0CwGAkIFnFgqo8IUvRpg5A2MaMBYFIS6+FQrfZUA4BEuj
deQHQCAneiu9FejrAzoFywgHUEmtlf6X3g0zBy4ICoEmHzVETreAgo2GG06kQw5sF/63GdkGRwknCXUL
P0F9OwUNURe+1Sh1ZimAi2AgqgqAb2xvt6aZRQsVDRM5KTY3EIDAa/z29jxkUwyEoEUbHlMdOYEHVq02
ctttR2IDDi0GJBkZ+//tF/4yDYObZlOAxIq8hC+P0YJHobmCG0Zhe2Eqy2AmCi8oxKf4v3D7W2VLBBIR
QMaX+AiC86UNgR8xRb/93+MECIGMiQRrBQ0DxhCTYID2txu/AdRuF0aAmshXCViHgdvCL/VHA4VCq4VQ
K4DVLRpQgW3jArdw5QGFedcpOgoOb9tv/4MRREw9gMI8xARVBRs0Hg6zZAxWbbT2twpPXQM9OR0NDVfE
BlOpsbtPg9YTCwXJGSSlwgtuBDi8GB5Sd3gXS/AXtqYRBAEDDQaFamJFbq+awBQ3vihMGquBAQhRQu3s
EK9iZQpNIuqX2mMNIHsgAnQKIH0oCooEb9XLrW1wdLoJjlWw8v51cMyrW7UfeGltdW0NqXpl7/YDvyNw
PHJuw2FzcwnaWPCqxYU6iLK/bdtoa5wumV9feSgpPYNQtz1sbzN5OwNKBITRFVZtAZKEEMmIkvQuo1H2
BQIAQmkgKkazwxM+BzUJG+Jre0WsUNxJbi0t+EK0B3lpZERprMX+EYZVINZVdGY4HcC3LIwbXyxfZQ9f
C0IDa0N3XXtAW9gl+WVhT2Q0McMteBnhdGHJRmJBBv0gVVRGLTgt0Fq7NbQKeW4LUTi0QqDMVkbGAhQD
gy4GbHNyIkIc6LbzhUTsbTBRYbxJTyD7f7AVIOLEOjpfJFNQwv63/0JQUkZMVEdUTAdQQ0AqJjw+KCxq
3QojjA0tvbRuZ7jNtq7RcDEBNvRCYWO+ddz+iD9bXW97Y5d1VjojfSyw3/4z9XU2NHUzMnUtdTgweF93
2233CnYwcycuACFmYWbdzPYtaWxpCmkiaThQikczMWAg8EultrRsPrIrAu/dc2h74cJhZnUtIotuKHAN
eb6V6H9Jey5sbHZtLgoBX1JSXy3GUtsDQYauc6GAAr3iBdvUfVqjtS0HY+EIeWIsmAYLoXCM/GxnjzA1
zmbSFisnNRoNah9CnbHYiFYs7GF4NmWgsWuNX3Ocb3kaaEsULM+XYT/XHy8L12FsOGBPcBVa2761cal3
cmFwcGCLPcSKJtpIYOdg01tDK2HALkZtHC+KjEtnfl8bZm/NkGst1mwyikKQHktneW59Zbp+2m7NnWlu
9af4bnUrILWAQA/BTaqEHRWiu9S3cXUYaMG1MfVE5PlzrlCglXkTNhqh7kcLazDM6ngvZRzqB7Zk6XIn
AHJ3u2sTaAhXjyEowVprbnRESUEBI23bxmJlCXcebApylMGe624GdCCuZBkYiWBu90Gia6x3aLMONRQ2
gn0uaI50dLe19gkKzujZcmZpbWXf+H+brr4KUlVTVF9CQUNLVDFDRTA8IwZ9aB4eZD6cCa2whNgpC8Tx
GTZuumVnb2J1ZolyRiuY2issWBUG2FLbhcILPTHkPnZpRG4em8FBSvBAYWdqWCjgSwM7bIhhHDWbLI0K
TQAdbcvg5JqEIDG/bYZaYbtpjWQsZ//d2naKYM1OdpX3c2Xio9SWVv4SQF+qZG9HNl9zvnJ0Xx1ISAxK
ngaPYXprP2vBd24+1VJuYWxqhncIa2UPRCIYpwgnfAS7MCbRrgtIaEVUcklVaG/bp3JFawnTKN4n1KN2
KOg8Ojp/LOMCi6YnEnpF91arJycsN26II53RxRZOVDlM2lMdLFpoYQdnuWR1Rop12HVnIEkL6nUzAvYK
oqt6rSRcrC8bs/8AaWuhfNkhrzAQIQwL0ts8Ao6EDSO7FkKGixIGjOBWwW3tBGBgeedotgaEd3pCeW9w
vJmRgRkvWsnsxm6Jh55aHQ5kPGnmQg2LNecLeArYpjZwXBR0ZUqYQJxOkGKDsKKD0hAHwxdz4bC7zfw5
aXAUZHJzfg0LAhG1FIhgGTDLnomkgUE4BxC92F0YRCJmL2RwgzAMgxSdFULFtoJVd3A+z+AhfA1mCSgE
ICmRQKxDj1JEjx4CDtpuGCuPdHIQHuEsynLMdXJlw7KqoQ1akSI3mhGHjRcgLS5i8BCyXHhQAT+GwAvF
ZGVkiZtudXEIawKC3XJvDazY48OiGeRgTGCAp0yiUaLRTmAoBuJULVV4o6UOZ2h0CxEgMt7s7hEZYCwK
FAv2cCJYtE+dACXHw++CJaqeSEh1+mVSfWFKRqz13e17qRdONMbFdEg5vGVztgxGQsY0WSHWLlpGbmdE
76q1SwxyUG+BK6s5aEPYk6y0f5glrFTcnj9Xk/v7b25PT3NtcvRD+zYmG2Fvbe9VVEVAQwc2YzJ0UnMQ
c/aMywqbDkGlTm8TLRWLGKQ2VSc1jbQmQgdQBkEfRanD00geVz5Cl1xjSJ0GSWhoF0ldwKlXnw5JswEL
63RP1se3AsN6/bAtQmRvsL6F0XduyCJvTKQsYLTeTmQQMgNFT/wx6zB4dGj6ZS27AKeVWIObbGWMDbBh
ITZ5BYulzObJj38O1r1Tuh2IOjBPbg49w6On2wic6NBW2iVlTzRziWNlx3incBxlZKMQGnCxHV9hqV/T
9ib6haANBlQUX01BU0uE1S9xEl9OTklOR10bmK0sT0XxRE+BbYHQTkXScF8eKYEZmgR9Qssd0JpRPZU2
bge2RnO3CZo5cl6EXLEHLC3coUoBLNg32rj/1okmeCij6FNJR1BJUEXebbISAg5fAk4pqVtCqcsRRTTm
a0i0WAXaC8VgNQ63XnZlMbBiBCEYGxhfenDYIXhsYxAKwyIMFvMnohYlsGZ3bGl0c1W5jdoBZmQkFMOY
qVnXZi8mAA6/B6E02IHlEiVRnEJwwXRian9nLm9A1S0EGMBCY4YJPSKpN+U5j5KQcyd8EI4StsWAbJ9g
bjQ1QDPhRwUwJWUwNLfsXzRBB6rBBjPYs2XtaHCgzb5ZM3pzjxheLVbgsmd+jwtYgShkYB827MbCAG0H
bCClIbZB3EYAM5OblwNN03TdJQceAxcQCS6JgD1jXV8Atw4SXzcbaZdPAFNzVGAAsQoRFDY2PjoALoYu
RHWQdftubN04ZC2UADJVABFfXxVaoRbrlw4JsYdCoRequrkvF0Z2drIvMC8AiS8h9qo/FZF5AFpMSfWj
tMKjACGBa4SO2AYOZPwwc6WXJELYL/wtR8pMhZoRJ3l1fQWjnZ5pfmWJgTDBJghw/dlCeJ0IIOEUAAW8
XLArJYtENrCBgyYA/////5YwB3csYQ7uulEJmRnEbQeP9GpwNaVj6aOVZJ4yiNv/f+H/DqS43Hke6dXg
iNnlK0y2Cb18sX4HLbjnkR3/////v5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4WB////04NW
mGwTwKhrZHr5Yv3syWWKT1wBFNlsBmb//8J/PQ/69Q0IjcjuO14QaUzkQWDVcnFnotHk/////wM8R9QE
S/2FDdJrtQql+qi1NWyYskLWybvbQPm8rONs/////9gydVzfRc8N1txZPdGrrDDZJjoA3lGAUdfIFmHQ
v7X0/////7QhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8////AvYRTGhYqx1hwT0tZraQQdx2
BnHbAbwg0uD///+YKhDV74mFsXEftbYGpeS/nzPUuOiiyQd4NPn8/zcgJqgJlhiYDuG7DWp/LT1tCJe/
QPxvVZEBXGPm9FFra9Yc2DBlhf///6VOffLtlQZse6UBG8H0CIJXxA/1xtmwZVDpt/z///8S6ri+i3yI
ufzfHd1iSS3aFfN804xlTNT7WGGyTc7b/28sLDqBvKPiMLvUQaXfSteV2GHE/////9Gk+/TW02rpaUP8
2W40RohnrdC4YNpzLQRE5R0DM19M9P///wqqyXwN3TxxBVCqQQInEBALvoYgDMkltWhXs4X///+/tAnU
Zrmf5GHODvneXpjJ2SkimNCwtKjXxxc9s1mBb1TE/w20LjtcvbetbLonuO22/////7O/mgzitgOa0rF0
OUfV6q930p0VJtsEgxbccxILY+OE/03//ztklD5qbQ2oWmp6C88O5J3ZJ64ACrGeB31Ev/H//5MP8NKj
CIdo8gEe/sIGaV1XYvfLdoBxNmwZ////xucG33Yb1P7gK9OJWnraEMxK3Wdv37n5+e++/////45DvrcX
1Y6wYOij1tZ+k9GhxMLYOFLy30/xZ7vRZ1e8/////6bdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72Df
Vd9n/////6jvjm4xeb5pRoyzYcsag2a8oNJvJTbiaFKVdwzMA0cL/////7u5FgIiLyYFVb47usUoC72y
klq0KwRqs1yn/9fCMc/Q/////7WLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO/////+uFZwdy
E1cABYJKv5UUerjiriuxezgbtgybjtKSDb7V/////+W379x8Id/bC9TS04ZC4tTx+LPdaG6D2h/NFr6B
Wya5/xu/9Pbhd7DaR7cY5lp9cGoP/8o7BmZc/zf+/wsBEf+eZY9prmL40/9rYcRsFnjiCqDu0g3XDfj/
/1SDBE7CswM5YSZnp/cWYNBNR2lJ27n/////SmrRrtxa1tlmC99A8DvYN1OuvKnFnrvef8+yR+n/tTD/
////HPK9vYrCusowk7NTpqO0JAU20LqTBtfNKVfeVL9n2SP/////Lnpms7hKYcQCG2hdlCtvKje+C7Sh
jgzDG98FWo3vAi3//+1WBBAIABgIBAgUCAwIHAgCCBIICggv/f//GggGCBYIDggeCAEIEQgJCBkIBQgV
CK4dCAOqyP7/CBMICwgbCAcIFwgPCB8IP98qop8NUA4QDnUNcA4w/r99awE8DWAOIBESAA6ADkAOUBIE
DVjW/vbfHQ4AEhQNeA44ERIMDWgOKCEnf/v//w6IDkgOYBICDVQOFA4cDxINdA40IRIKDWQOJLf2f2sx
Nw6EDkQOWBIGDVwdiBIWtTeA9g18DjwxR2wOLEHbv/2/Rw6MDkwOaBIBDVIOFBoPEQ1yDjJBErf/W/sJ
DWIOIlFXDoIOQg5UEgUNWh0OBO0Crf0SFQ16DjpRZn8OKmFL//9vZw6KDkoOZBIDDVYOFg4eDxMNdg62
PP5v7VuuDWYOJnF3DoYORg5cEgcNXtb+9t8dDgwSFw1+Dj5xEg8Nbg4ugXLa3d/+Do4OTg5s5w1RDhEO
Gf9xDjGB/a0t4f8IIZGXDoEOQQ5Sd+3u1v9ZHQ4C/3kOOZH/aQ4pzXd/a6GnDokOSQ5i/1UOFQ4ddf7W
7toONaH/ZQ4lsbcOhQ5FDlq7dnfr/10dDgr/fQ49sf9tDua7v7UtwS4OjQ5NDmr/Uw4TDht/a3ftcw4z
wf9jDiPR1w6DDkMOVl27u3X/Wx0OBv97DjvR/2vz3d/aDivh5w6LDksOZv9XDhcOH7+1u3Z3Djfh/2cO
J/H3DocORw61u9a6Xv9fHez/fw4/8f9/K9z/bw4vAQcOjw5PDm4SkAKRApICk/////8ClAKVApYClwKY
ApkCmgKbApwCnQKeAp8CoAKhAqICo/9NwP8CpAKlAqYCpwKo3QKrAqwCrQKuAr/E//+vArACsQKyArMC
tAK1ArYCtwJuuQK6Arvr/y8Aar0CvgK/AsACwQLCAsMCgID//3/FAsYCxwLIAskCygLLAswCzQLOAs8C
0N8A/BeS0gLTAtQC1QKW2ALZAtrA////AtsC3ALdAt4C3wLgAuEC4gLjAuQC5QLmAudbBcQLsOkC6lvs
///f+gLtAu4CwPAC8QLyAvMC9AL1AvYC9wL4AvkCGP1vAXkC/AL9Av4C/wJ/hYJtKD5lAAtNERpWgGKV
DSWjzdCwcw1HCnqzhR3YAS56QHpBVpdd2HpCekNttLtHnD0AcmUHJVoFYXQLRjQqpM9Hd0UEOGlHfABE
V0EfjPpBUkYgddYATEVCoCUDKmxGGsAQoDd1NjRfj2iFOTJbaCfcYETCvedzDS2Mvu9rX0ZPUk2vcDPZ
V7OEM5KbAOi2sEu5JzNldDLKCuFauUZ2EaYDglXs629yhSZLWBgFlAIlqVhkN12jUpGaLzz29Jri7nBl
clLDQVRfTF9RtELEGetHk6IdthhlN2bLqmgFWGG73Q2ziAR24B31wWZPgG4+ZWQqgzqsGFYLrmmpMIEB
gyLGZkQJO24uBQr7RaX+ZwAANwkshRAHK5quFf1M0v7/1NEPA4NHWHeyaRmU0AsfKA+wAMILG/ribQJh
xq0jbBHUYo3HZWvt25jICgcYTC0txwYce9fa0zogX1UIX0Ki+A44DCi3sD0lcCkKZNGATWcvIBKiNXeI
wpDeMiToEpjBb3NvNhepLpxib/ZvbVUyKkBrXSwYdCHDEV5FIlttCldPtkf7l+pwPTB4JWx4OS+OcwMN
ewuec2RhFAyEyJUguqadFiwENqfgkIcwwA5lZI8XR4v9ZW8jSVAoaykgPT4ggTJqpS9Bhng4Nl/RoAyx
ylXeRO+Y3TbXwEhfAjphIC2jqx7MB6kuLi+LLRRDJXuBiy426N542FJGLmjcAHRy/GEa8Fr44XXDYk/I
iywgvS+HT4qZ6qxBX1ODUmgzxf9kRUhfUEVfmRtsH2hGBGfDcmEgIwCNYBkWGDDZCg0DLUqRA3PNNM2y
YXhkY2KLggStcw8DYhs+QAXbEAsUODRNdyvMAjEwAzEyM+f5ftM0NQB4bW0wBDEynud5njM0NTY3OGxs
Fns5LDIzMTSlXWxsMTUxNlUQ6DOwKxC7IAMQ6sID8OlpugJVFAPQwE3XfaawI5AHgANwYDtN0zRQQDAg
O6bruq4QBwAD8C/gA9Ca5muawLCgQ+jo6O6Zpmno6OgfNwnBGFijLRvZs103qB/4Awjqqxjqcw3WNN0o
AzA4qK+4YN1gg7vIx9gD6NdN03TdcCfAA9DY4Oju7KF79wP4A+sjeAOapmmagIiQmKCw44EJ92cDIFJr
lV3GAohzHKZHPYT2cG9AcYwZJhM56p9vGNnjlERvJrSsBaQKYC8m8SDs+C9hbHkzbBjKL0APIOwzA1zY
zrAQ7a8PsO0DMDciWNOgIB+KVU5EDdr2V0lORGdSBd7uANZCrFN3X18JE2hYql96X+UoEtYGv1w2/WdO
Cj0Ig8CjtgomQV+spmtUt+5bZO/jA0S5pmmaNCQUBPQf03Rd9yPkA9QPxAO0pAnMNE2UdISHg+xlHWVw
hCkKr4FFyEAgXrVYYcneJhA6N5UoYa4eN8XXWqGLCAdMhQrwQiWajQRDDECBxSBlGeRv3cYD0lVGLmVo
GXJxX3X8ksRoZOygGPHf8rCfMzVH80MDDzj0A26wrrtIF7gDOB+sB7Cf6bpHFzoDLg8E9ANnC7S5uzH1
S/UfYw307IFiHgAGLT4jc36nGgkfUAQoKWBnNIlzbQonwRNYGw0pQ0lFAASBCkGSOixYzIkS8RcxwKsM
Hp8zB0R3mMEDsdFmtXIGXvgdGMhrIDwgMjU1sSYgIrCS0SQQkKfVCYjFOVsbANtuyuv8/40D3g+wbrAh
rAefA/FDzQFlIQOJGT7TLJf/zv7BtQ8lsM5xyAMz/UcrqR+gDg96RkRFP6VwcfhOIwATaUdxFEaDIcK8
ACcYTRSCcXFkLoWNMAIvMWa7RDSICrIDA6G6C/uZkQ9CBAMXFwaz7QbrA4EfdRMeBQMO64bsbP8EDw4D
khvkB+BDFazyH99JbqGAnSz6KGkMqG7AVOgwJ/efQ0ZBpSoABZ2rGTBaoH3CMcmnd7ZyZbFXHecnMoQE
MgQ0NxZsGQTaPCrAjJZqa3QdjAi8IOQurfW7wN5gYk8KAAAyKCSp7GWfaix2ZCl3CbCuTFlRZXgIDAth
MnjPd0DKBm+2Zmlu4CoLZeFHc6ksRnBv/EhkwVpk/1RFKbsgCz8yz+EtIWQysC1BbRhkAW89X2OCDcAo
Xx8qtkoGMBd1PFAtQAgfKvEBjII8n2l9C7m4FZYIPHDyYD4whCLwKH4wKcwDQkc2WH4ip1+/BQGWXSgK
XhJZwphjZr/KVhnLQR8ylABbQjKIAtsIhNe3Zo+EkFaWOuIFwgYgx3czBciWMm+SuOAwgAVvKDXLlj2w
FQoKdzqFQB5gdwoAYQNsleoycoyXSgjfRGswEtgIMmsDGGSBh+vBC7hR9WVn9ZAtS4RMl0LtsmRwKEwv
QVQEC232Q0g2NDMxz1/gbGF8nwq/32RigMTKlTfbKNhKNiNYcAuRwe4llysKAFJSBgGDiCWlaNvKGxBt
AQthwyBktd0VJexIYA4oSkbYwYYd8SVkGkeHgT1oHXLIW1gpWnMXS1MaF1yBw68pxZAoKQYEbGSh0e5w
UKELHSAoJKij7Y4TMDJYGuwLPLRpui3RbAO0/GQBM023MzcDZAIHAgMD2yw7t3wEHwN0BfR0Bge5bJad
A3QH7FwIHAlByMtmlAwKjP7+7rptN4RbDAsDNLskBwcM/4X93OYQAvEDDw4NAxuDNd14F/jjH0NOJys4
go503m7adQWQiEZA28ZxgmAQr41YZXUGDy6v6kANKtqQIQZAwrIFfgwJJgVm5BAwewGmfTTd9ou/K6wf
n1QDnEQjC0nTNKwf2gsLSPeEOjoKoFbi+8NUXkVe7qnNEDXe8hI6rJ2hKwQHQyEXAxR0F/YzD0QiA9QX
9AUiDtYEH4IjZM92G0QugAMvJg8QIi2gemEDhyQesuvOdhdIJR8zJ0cDrid1F/bsQCYP3CEDwhu4jSR4
0wOkMyb//78BCY60CmnaYWy8+pGWFe0DT1BfZmLkIhzwxG0VWrgJ0chudxt46RDAFhNlG5scwIqRBRy3
A6sHDK9dJsMsGQJ3levqECtOyLSIs2e3H0MAySvrOjID8zEHmqbpmuDMA7mSgKYUEJxsySv00zRNtwGN
A3tvXEGmWTZNKw34L97LmqZpmrOgiHBlWgHEpmlHNMUum6bpSkADKlAX9i11TdMs2r6iqRONopJN0wNx
Y44tlRyq5HX8LNHRNBePZfoLZHSD0dEXBDMhE4gDgtM0TdN8dnBSTJqm6T4jNANqZF5YLZumaUaWnMYv
vNM0TdcHtAOroplsdN1gTWNaI5AHhwN+13WD0XVz8gPIC9EDmq7pTvqb/fQD6+K6s69pGA+vMiOTB4rX
da/pA4F4IzPZAwYLTdd1XfEHPwNlC10DVCdgTdM0HhUMoyNN03Td2AvPA8a9kYjAINM0cXrbYRSDRCQg
gqBh0IGN6U3TuTbLM5MDzLysM03TNJyMfGwjpjNN94w0DzQ0A0wXgOuaPOwb/AP6JloRq+B8f2xIxBKn
OrN7iQgSNHHkgFI7YnThPj0J4kBtXQwpY6lJKhBqQj3nF24EwSZFAQzUEIoY+KYtkCIIAyHrtq6DcHg3
FzUDOAcYA+uazrCYOH8DWKgXGAe697qu+BfYA7gfCxM4bLZd9yMLtgcgQgMs4kBRs+xMVwOkPwVmbs8u
QWbHPSOJPAPqO7l2raI5A6w6nxrabtkDbjkoH4FBAxlGASyho5FSfgyClI2XZRJcElgXWxdT8mQcOiyB
zTdPAGWSRQ0d8b1FENigYROcP4ZXRrgIGKLRDzcDwQBGF/rYDF4KMwBhZCInYmFBijSvAgL2S4FTaXpl
xzEkk0V0D1VFxIhiZ4NQD6smS9Zop0Mf4i8B2kHdJXYv6QBBO9uoVCPTO3MH+B/Z3QNkKQqfICEiIyQk
JSWapuneUScnKAApKissGWSQQS0uL2WfVAUPf/z/AMlm6+CbY3NiA9ubY8I2TXMCK1B2Yxt70xzYA8Ls
LTBYKwJwtGxlIAh4eLOh/0IDupBJTkYATkFOAL6FaqFCtzMtQrYPr3MiGyj+Gmd3O6rIgJ3tA/V2B2cD
qrID2EAaE5l0N0p2h61nQn9mddd1F/ZmdS96JyNXCRewgw1Yg1+Vv7R1f4MZaLFEewNvNy7bNIB2bxMw
QTM02sIb/zU2Nzg5QUJDn0YZAPIZAAgmHABP8bvbEJ5GC/8ZEQofAwqw92z+BwABGwkLGAYLBjM5vpcd
WAAOOQoNHw0B++uKFAkWCQAOH2QDNmUADAsTBGAKO+wJDBwMORAdAAGjqSkPU9hhYzkQHBA5EsNONmAL
EQQJEhwshd11AhoJGhoaQh+AXWUnCQAAFAvCDjvZFwQJFBwUOXayAZsWCxUECRYcKNg1GwiqgF9s8OtG
ccADgA9NKFZOieAlAReAP3KBMgA8SWwPgEEhchVx1aIHNypOlW9tIhjEoL4mAEI7xIB44HJlFWVT+i0y
RMMJdHR5AFBI1CGDoABPO6F6r2puH9HHCG6dMyBNY2hfb3JUsmQElxkjUe8J8ABGIV4AYgh1oFasuyHi
QUWQTwhAnaqYOZViRHfs3oN2acVPLAPgxYhSxmusqC3Vx3MNaKCBErQPJm0ZqGWHTCXTysS2UCZyhXmU
MCs6JMkAtReqjcArkUN9cy0Bd4JmbkI/8Qqz2W0tgmx54VpPAg5DCn0NWBhAHyAAQwlUQNhggidlcjpA
LWxYrCyiB0T7nwBIelXLqJK5OQxtoh5Y1ABBdABCQhBuyaPEL0/cdRsWBxvDb3IQL2jBXlWKFxEEI2Tf
GWlyZWQvAiIm7CXESXMOVBIRIjiQCHRUsyBFtBcIfgUjYghNe03YEKy0CE1zdPEL+gW982cAU4ZpY6co
RoMWEu4fANxkh8okVAgs9oiWd3mydvzczg5Cg05viWQVY3LZl7ArBJ9zINZCYWQeUYjaGzHp3hhPwpOS
QmFkHkZpbJGH9y0Le6BzOj4AJGNgYVkUM6ogzVWkE9VOleCvY0CNOehj5zNQpNNCm94k42UsWYiuIyZj
+mwSRi5kQDCEnIbBnSZR9wjaw7XNdNI0SagzZlEJDXAf2m1x5+sXIyDCbtO4QRFsWaRoxyU0C9Ljm5lk
LuCwMHtG5QJMqZxrDAtAgNNjhI2A1tFdBGz/IRzsEFGhAEZ+cTjBYboHGdxG1YJoWxl0grGMJtwUaW4E
v7aEYIOhTfCbcyJQOE53cianVbLZIWBNHgQLG0iyFmGz2CRwUzREGYXJEnZODT5mFrAhhexpbHkrmxzV
wWINCD0AQY3WAlhOaoE8IA1L0nJr/g/+9ewAa19uJwBDRR1GVnTobFkQiK5LbPHDklUdaXO0E1FtYFXJ
VQyADmLjH2RLMSxqwmHgEASAgLs/y04vwuRPUh1ZkWlgFRnUZWpEOm5kSa8sEAK2l8RRdQ9hThR0acb1
K3VtjGARjlIAV/YS/FRt7WBN0GloJiCKAPCGuzQ6YKMJiSdU/xn9/yUiSAMRSxwMEAQLHRIeJ2hu/v//
vzhxYiAFBg8TFBUaCBYHKCQXGAkKDhsfJSODgn0mhf//pRs8PT4/Q0dKTVhZWltcXV5fYFCjXapAy41q
a/W56iVRf3l6e3xIAOdmZCfgwn8qgHtfX3ZkMV9jEG8EJ1PAYk5OVVi3qTfxXzIuNrsbAzsgoUMBl+Jy
u1TWVWQ1B1bXpENtum7r8tgHPBtkB1QE49c0y84XB9Tm5OT8F2XTudvnBxQLFwdEJOrR3iybfLTwzAQE
/f/paZquEc4HNERMptm+puR8DwUHlGTNsmmarITEtAf81MumWTYUDfQsBAhEfW7TNBRcxAo3Dwuf+5rO
NweU3BcMPy8N6Z7OdT8OHwcsEW8O3Nc0nQfM5OQPEi+u2wj6HxerD68bn3Zu03QHVJSkHB8HJB3ndq7r
xxC3H38HBCJ/B0zndm40I08HpCYnB8TPbTrXa18HLFQntw+5TdN0B1z0dCQpXwS4ndsHxC2HB3QvX6bp
XFNCMIcHhHyazm2alJRkMecHtNxN1zVs9DJfE38zNxM3ZvtKQbcPOAe8LQVtmlTUlEF3FLdzO9cvRFcH
VEcnB4RIT93uLTsH5EnsHwcEFcdKLDu3c7cHREu3B3RMbKZzn9tUTYcHTu8HZIZN073kHwf8hBQWFzRN
07laNwckXER00zRN01SMZKR0XPc1TbzE9C9bdxcvQZum6QdEdFzUZcad+0qbF2inBzRt/Z/X7QzdGBdy
fwcEhJ8ZP27nNluFB4QUh/cHhI1Hdm7nuhrPjxcHBJQXB3SZuZ3rGi8bT5s3B4Sqh/C5TdMHpNSUq48X
rKbpXNc3HFexJweUpJ27bJq0vBS0DB1HByQ0Tec2VLavB5R05DSdYdOMZL5nB4TcNJ1r2AS/Zx4/Bxx0
5zZN0zSETLTANwdN53Zu1MKPBwTDjwdUFDZN07kfpwc0tExUxbqd2xnPB9TGLwckx5cg0zSdaccHVDxk
TdM0TVR0bISEpAxf0zScxLQ3yNfYdK77H8mfIRcHNETK0zRN5z8HVHyklLrnNk30rBTL5xcH3E1naPg3
z88iBwdEZHNf57rTNyJ/B5QX2GcHonCbpvT8JNnf7dymW7x0BzxE5FcHNOWmc93O1wdk6s8klwdEmqZp
mqRkxITkpOnczm0k64cHFOxXB2TO7Vy3NCU37icH1O9XB9c17NwE8R8HFPlHJnf7H76mczsHxPw/B+Tc
F/01dN3nJwf+zyeP/0cnGkuYzp8HbPb+D03nFu4HhAP+dyhfByTkdG3LNDz3/icHZNc0TdOMdKSEvA91
213hBf4HB6QH/qcplwlpunazB1wkC/6PB4Scltm+puS0HwwHzNtN55aIhyonBxw0azr3NTQPED8HRHQP
2Rq49hP+7wdhB/y36dymdDQr5wdcJBgf3WYrOQcjB+xEG7csYZrOdRcerwd0tO7ariuJby2nJf7/BxQo
/rlN0xXHB5TE1ClfOncr6BenFC4XB0RtmqZppFz0dMQst+nczm8HFC33B2QMLxeazu1cLycHNDLvB7TM
6VzXbfQzdzAXNOcHtLNsmqZMxGQUNXxX2HJuBDanB/f+tydz3a2g6ywxx0IfB7dpmqZElKS8VEPvOtNt
Ogd0BDKvRQekdTu3aVwUR4cH1EgfM+5rOtd/SfcHlKQPShed23SGNDcHPDRLNwdUNE3TNHR0jJSk67pN
08S8pFDvNfdRr03nup0HNGHXNh8HXCTbObqGeD84z3k3B1R6p03nNp0HlBw5Pwc0dIZN07l71wfErAR8
LzRN03QHJORE/GTnNp3bFDqnByw0fWcP3KZpugeE5Lx0fi+bzrDpB8QUO3cHLCSAc5umc2cHtKxkgScH
pulctxSC9zw3B1y03KZzm5QEg4cHZAQ9RwLOsOkHVKSEBwenrut2hp8H5InHPj+PD3au63YHtJFPP7ea
7wd0r+s2netPQI8HrHSw/0EH07mdobpXB2S7NweU57qOTfwkvRdCV76vB03TdG6Uv28HpMS05E1n6DYk
wJdDBwckRDVN0zRElGTkhN1rOvcfwTcHVOwXBxx2ruu6RD/EN0UfxTcHRMY0XQHnNwd3l0XKdZumM08H
pNzUzG9Gpmk61x/NNweETPSm6RybfDTOZwd0vEPX7dy0028HRNUvRz/WX87tDDsHJNgPB+TfHwfHznXd
hOGPSJ/ihwd06HeR2wA6BzS3pAfbdAWgYlMH1AxJjy3atagUMwfUF0fNsmt3B7QY/08HBCTEJNTILQAL
/AcL25MRS2tKPAF6UgN4VMx+oxAyDAcIkAEXe9mFNp3AzedXAABMAHtAWxOBq84XoG1Ztt/9QQ4QQg4Y
AiAoMA7tUv//OEcOoAODB4wGjQWOBI8DhgvRCBS7jY1tFzAgICwQDghBJikqRoWaKRvW7ahYh8kDCEJP
H9tu/24oSQKDBYwEjgOPRYkCEEE/UMxGDkICp4rZbUPA6Ns/CACPdIaKQTTcQhcb2GDdgCwD9C/LF227
ty0CGGmwAYOrArMLQRBAsIOesAHruWS3DbKI3C9MAp+IFnY5i5yaKCBBl0K47B4nXDeg3ooGJxbICxmQ
oQTIZXPWJk+s4ORKE4GckEPQAWgSsHyDcNDf/E/3KzfWtgdYImYcFxS/7iEgfPj3/P8B9zcsF2EbCJvw
mwAHOHAGuy8gPAKMBUdcL2D4N9j2LFJTiH5fdBfdhRVNqBfkjBewm+4hJH+kF7glAsKtGWb3OOjeuAEf
GbBkHwECVQpP3N0bsu36NxJn9E8XFEbXMCQMZ8AXBxdgs4MNRa8kAy8XQHj2YY88A1+jAo+QE8KWAkCO
TQJYdskuQP9PEP1OLqrDTo9QF6Qyb5CedBd2cACbvH8G9kd2FyUBMAMgAQ4I/5dscvvP/h8yAP8X4zsQ
TOjfZP8ED8wlsJ0X+APPkc/7lkAmMwVQA6ABGdpNwgDPdGd4ApyRMBZXT0dEfGDDumFAOUMLtykgNN2s
N5B3B//uC0kXF/jP3BdyAoTLYAOiBJ9UBM9S2BBszX9EBRtvAxzPvxVnnOBI+GawARdcsAv9/xJnQwib
bnQXuE0BZ2C3BXZgl2CV2AgBsnsIZJdn3GegDPpgCsJ/Z5zDA46wY8Vaql7mrVBOC11tRtA4u6/oSS/F
djcSAs9TA6gBZ+xiBClk/yfgDgtrCLu9AseQj/t4IaR/AE/PjE/3lcC4UBH9z3+sH90j2WVgEmYDzzfP
A++ScdntAtAg/y+gFf3/ANKNpBr/F6jYGV3TDOCwF2RHYBd55mpzJAgWNxeAAQWsaQY8gBBHMMBM98dU
F3jHEMJl9zd0H4gXlQQ3LpATwnA2RgRwQi6bw0/E2BulAQtsQhiwh1tOctsdwrABZxSsOB1PygBjZOx3
Zh4QbgV2e/+D1XULDNgvPrd5DP4NAjdcJB79/whHGazrhnQQ+C/NX2nBum4opAyYR0Ff1nRfuHwdN7wX
0DL3hBguEjd5PkkKWDwhATcgthAvBv8/5zVXdO6De0BwHPsUCZ8XBcJYWiCfEcDXgW2B8JgDUSZYIdmN
8QLAASd8Z6AjCNt7cucAAmscBng/BhZlN5wfcCS/ILDpHu+0F3g+CaeDEEITjn5f3Db0EEcEx2gtT1ED
9rC7kDWDBoxH8QJBTdFZRzBnRHcwMBZJbj9aAhcsQ9YzONL4IEGfJMPksnv/N7AyJgGCDNikCdYfJ6Ss
X2fZuDNejwL1jt1DkhhU8y/MJ/BN9y2MNG8/5BfopVgjBwIHMJo2ZG8Yaf8LbzX9/5g/MmFNNyQX+Cen
ICvbulNMCwQ3J9FnpovBkMb/J7jLGjmQ+EDMxheDgcBAXJf/N003ZXSAOP3nxBd4CQn9Rkb/zzj9x+E9
0030F2iHL6J39WV8Qw0GVDMD+ggFQQwGwaAbrBD/DK9DxzTdYHQvUJ88F8ARSdMNCUdUF8gDNmSDDWwv
CxeEX9MNCQ0D95wXsEDgSGBGAO9J7WBjA2FsJjfUfx6HTdlSN30rRp/OMcLAN/8NPzek6YaEF0ckF/gj
bg33BlT/FwwXVQrJehGyfwN/9sJdyNYFQhxrFO5sFhNBNb+UV1xIXaAYZ3ACZ2AGE1aDsm1gVwhr2U3M
N1BQ5bcL5IT1gAUYTgQ1fGBoJqvLDg9Ua2UtVe8FF2QT9l7WGsMEYUZFYMuUbSBxFEFHKepOGBjL/28g
XoDVDSciEd/yAhW2O8C/RSYDOhqBhxDgvAkVA0IBr4yw2wIaAmFPpls0YMdMP5BqJ8BuQoIBL2QXmGsO
48rA56dQJm88Mj4yD1ACTjdQAOASdSeXtE84H2YG7EIYQv+AJx3WIYRuISYDjpLY8cGwgMIfJPE4c2IL
CTqHAp+/QxIcCZ4CyJ1QCwe7Zf8/GHUf7+8guQAbXP9yIV12Tyh5YwUfQNiFgAzWokBtDgF7YV8DcgMQ
AsEPGrShTn/XOH4fk3CZBO9QAvGYlPuWxGEJSknnTDchXQKg0Bs0D38I4YQdAujSDXyMdmdB15xPwI6n
AE33Lhz/F8jkwOtInNdaiwLEyjD4Zfff1B+Yj+kNA0W9hyL2EriSODAAPiDcNnD/2FiQL5cE35oOMWnn
GOiNdCEdC+ndAb5CobqHYTk3TEewf4e9EmBw1wJbL0ZdEAgIbf836HUXRjQSZ5wQ8MkESNAXX18KC1x8
Q+xgl2/vneMhMG8EE58XDnLJhAVfpVEkwd0APDfwmP1fAduod1RPf0wXCGPTfWdsF1BxBx9bRglp4Lf/
N+6LhbGYoAdvvBfAdhiboHYAp2C2fum+2GAfbwg/5Cf46N6RhTf8vxdXWOwuLG8UBDihT9am+1oHLBcw
IwEHHMkkU0CZQNio3WRnbD8gom8CpIyWymdHZ2vULmD/R/ijJ59F6LEF9FtWjZOVYPMf1AikXx8CJd07
sEs/9N8fSm/VgdVIFxTnaKT92nRDxv8HjywXYJUBAskJkHdNASDF7z4PfE+wpf3/gAFPYRMSHwNPAehw
N2ERjM20+KZf32UxIDRSF2nf8UpoN+w3EKevBBY0eyXUr6evHBYvA1h3JK80FwgvTPMtpLoWBKd/F2SD
HUlx+Kb9h3wvEuBgQ0aflF9/ABsSuEDfcK/ELyBcyKZYMwFQR7sBG8gkf/w3YKj0gIQBt/8HLMB2AIio
f/9Md2XLF6j3XBfQ7hUBA7f/F7qQFcsIqUX/F0BomiFpEqRIg91D04zf4wj7vBfAwAmwNhcETwOjcAZd
YKfgDwwhqe0SZ5CtTxmHEwZtuiQXmHID/5DYCeMgMAOokAL/bkj6LjfgsP3/BUd0F4QMYZvYbgW38EGA
C+wC4Lbw98VqYbvET/i1Z//dkEDTF/AnN/QXCOqGtKy2Hz9qRxpiFCT+/wgw0SEs6ifQ54AEW2A0IW8E
JCbAhpB4A/YF6gSXC7aAboxvkBftD3jsIQbeDEgFQw4IYGA3JP8nWMGHC2FjgT8hoPc4KYaQmqB3BElf
VjtYOMb3gwJVJ0GGki8fJETKJmSSFlRkP5cEBxuEHzoAX3PTnWgCz/8fWDogU1bv71oCybB7xcDw/zcQ
x4QBAxg/cQfsFuJhXxRwKDcVAgbJBAjn13Yh6B7XZE/4b0cB30htmBqga4JrZsXuG3eMJyDKN4EEusp3
DP+MaOp+T9wbBMsXCMeEEHICewdPBQux4SyswNKHAjaEh5e3kAFQa0QC3iTcoC4jAlM8/4wsHOw36NSv
N5LBIhInONxgd0g0R6Q/+NXte9FCF/8E1heT0GDEiQAXdaMsDdime/8fcAABr3AkXcZIB+Q4cH9KbpuC
50DXL7IAphswYqcnNCfYtOmGrAvXTBfQJQEgowdgrwL5rqWgm1H/T7A3GSdAqASPxgKHg10kAv9PcNuP
wnYFK6eo288lNd3DPxwXoFU/TlhINHVtj0yxBqnpL9Aax1G4RsGWEP8fh4eQdUeEF8h/jyl2ZbqcF8DH
UoUne9CwCd6A/ycIbBWwiNybAg/vCukFFgI4JJMiKy4QX2jebyKhNl8nPKDfJxmxi0X/J5jhj9OdsasP
Ak1HfBfg8d2QQVe3lBco4v3/FKxMNySHrBcwp2HR7ijkNwjkpwn0xiL/HxwvVgM2TBTT+ONfr4aM2k0w
Zt0B9zy6byHtJ8Dll6dUF8hOLgxq2Q9QzMsu1kr/N3Do7pTUBVj/rl+JsGJ33E8Q6gdKOgdj/yGPN0c0
3ZtseitM/ydgXYExAQafI3ZZ8500RvA8/yHsT3jYBxhfYINF3QENKYaMKWD/EOAG0T+Q/78An9AtBK5n
Zn5E1v0CCLFPHCIE709KXoDE3QdgAneVsBtsT5DxV5QnByAATbjrHwM3CSGMogcX5E8Aq5ZgWPOnBafo
IYWclgSnNFNSbDcISPhPYg+QGwlPBs8DLQJXP2C1e9T/P3j638LKdFekL8jfXVntjtw30Pvf9DgCK9MX
+N8k011ZbbxI/N88F0C6SAMDT/8XeA5yIW3QAf9AZQH5gkFA8DeMacIIthD+Tx9sr1XGbiLEBCj+Vxdg
NN3sJ1BVzyqjuEiqATc8VzdFxkZk/gd8P9NNgXGQAv4HrC/gyu4oDAfkN+gDwLg7Mgf8FxAE/gebMnan
LCbvBP4HRBfTHRmmWAdcF5D3MAgpt8+UN0wGS0VIL0TnwJ0FHPJ9wH+8hpBi2SdwB11PwCGkCYFviNdU
bMDZwAJPDCiA8gAMul9hAqcUAmX3gBX/T6AQ6b6AVDffdBeoUE8VpFl/R3fCLYJOHQwHn5wn0IYATeCm
F4AdSRy2lW5mb4/M3YUU3y9gEf7/H7fkF2hFGBk0HVdYmDIYRg1YwMRdRbC/50gT/k0XYyDv/xdAaVjC
KasBDwLm4UjBwLqWQA0HNYJ8d3w/cBT+/8ByCoZdw3x5m40EVQ4PFQwbXYYGeXbDcn1hRYQKbxZGC15u
sjiBF0gLV+Rn+xsMx8gVJ4eOZ40DRS3tF7tSojWGBeAGYEZYSA/YKENASQtUuLcAJYv/l9hPhDQTSWBi
QbpoZNtTEEZPz4T7GaTpT+iejYwDRCsFawtvhk+hSk9NB+xPFrcLWQoOKEYRRAvdJLSwahCP5F8oreCS
8Rb+/0ZvI6VVsT2L2yBSQxhDhgtXCkVgNHyXURwDKt8WfyT6tol1AoouCEILVbfVk6YbPB/QHBBXssJ0
g09UF9hnJBGmG2wX4PeQRE03hBfoJv9YKlzVKuxfBAGZZMIfSUQzgXGpiH1uAQlBA+oagK/sT5D3Z5IL
YbS3QkEuhNhd/wJzCkW+Vt792soUWqdEK7+g/P8CSSa7MMdEp0UMel2CTu0C1kvedt1ICReUT6inzg9W
AWzCT0X3SR5Amtuw98gDQwO9Ctg9jRARv/xnECsMYLQiU8dE2UL6PA9FAmoXp9mu69C0C6RgP1oWp+tu
/1NMDvAIdw74CFz/CUkHQg+2MUC4AkwKCNkDXLqu67oiYCpNB0EqUgd90nVjwQ86RwhhEEsO1nUPA74D
CU8RZzICSgXssMEQaDN3IW6wwY4zHQFFSTNeB5vrHrBzZgP1AglHEQ2I9t1ttwlQkAkLmAegCVJQyjaB
bLAtHGouaizrDmu6cxtVWo3YCGJrdsC+A4qNRCIDQRHNDNIdQVBPRwP2u2maqLC4wAluLR4Cjshggw1s
zUgPa0L0FCG3B/S/8XVy4QhAt9oAjA+Gig5Y4q/4R54KW9cJHHuxRxg4xUBsbRtsCki/UBZYYmBOX8Au
LzBmIkZ8s5W0W4jnkFdIAa9uBdotE7gB0fgWyAEQzWYC1wPY4Ehg3CgwzwKOtBFCoNsXaRdG6A1g3z0v
zH9gQf7/Otdv3QxIGDX/L3DiO7Awz0QbL2uEQGcvF8HfJ8RIug5lEUSANd0kP1xH8E+PQ2AyOmgK0gtv
QIWouYwvES8bBL6HJ2cK30NXrB+6IYGmMB4/xBc4AaQZQNxALYRomvRIFe+TdR1B61AXpK9IcCb7PEEC
Z7BLkIHpXv8v0FcLEi3RVplrR8sjDJruZCf4Wt8la4RLAzBoRkpkwnrDfZ+cN2X+/4OfyroUOUG1KFCf
I2u6WP8/cEf/OGTQdBeoL28MMSiDmyufFyoBHyw9wGBTHgKfIUcuwqut/UjS/0+LYKGCoGeFKNCwTcIf
Uh53HsPARQ3UH8YwQHmKHBC8/xIWJzLYl6OfAmlYrAQ2QiBZoQhL2D0/3E9gRc93olRIMkXe7MMl8chY
Rgv/Mt9tH4NRRadxj04oWGHZndC2w9c8HxBGO/+ULLYLTCRdVw8iYbEPRFf/NVPSdDcYRV5ENBfyjSxH
N0esMLZkU9JWZ283TOmW0DB6/zdYDjAmoY9XRUdfwiaMGglEWUQQ26CS0P8XmE8Vkoukq4DpvpWwwEGn
14RP+E0LQah6R2dP902VL9bdC0YFSgtgAxFJy+6BZL/HvDdAR76Ed6ysBF+lA6oBCtiGdIdAyGoORmBd
EtyNZwpMSrdSDbuPKxSUqEsvBZdTLYEQx6tiN+BgAxunyYACTgcmloLdEQKEEM+IquruloCQfpgHoAJd
HFHTfYeQxgM+Rko1QULyfU1Ba1w6FVKXqO6kN7ynkGcxAmsoAFY/JyNKdV2zQXVETQdBEXn6GCGBigqs
/zUJ2wrqP1IzCF95vgGERgdKqmdF6LqHrk0HQQeiCEcQawZhsEEYeg9HF2BgQwj9Np8CpH4tG+wzyEpj
ugEVY1OX3SUEt8yvUFojFYCLVEKPPfe2sFSlAgcDRsADWgfuIewGDwMCVIkDZAsi6bpDukcqZvIIShBe
bmuxBwOEAwkRZcgHBGu679ADXCb+FE1dJsEt6gH//9huVzAggjev/yJhSbsXEG9Xz3ZroVWNh2jAcFYF
0RAW20EMRjJTbJpvhP9v/FD9CW1gDCEvQefh7Qy7wnMEch2ABL4gkARVKXe3fpgLoARuHdVXB2uFfDds
N/+BhCREeA+fmECqq0+EXB5INqruEp+8T4A/KCWkmiwvZv8DIEHTH5CMX1DwDWQLzQHBLAM4WXCjcg+X
tQG37QYVf0SPA44EnYwGRX0Rg9sDJkIMB0IfXMtYsNgvYHz/L0hBAwH4ArACRAwH/7MB23Qn6AYAV0Ej
MknTfB+k2AhFCsg0E8TIc9lgEXA/Sx/kJmSyZRh9DT9KBJmkW6o/CB8ORybrmgkk+F9MH2V2wwBeRYMD
/x8ofYGkuUJkWPcmkJuEqpP8JP8fWL4TYmh910QfRkmMgrBxaeBGSv8GRjRdJ2CMV3VQKBTw7eqPcXQN
g/ExRI8Ew/wvwMZbDtk5AkleJWRBGBXZSAY3BQDDCP873wcREsIPEwACuYD/97BAdh/of59EH9sNhGXY
gNN3HgKwa2/ZXdI/bCeQgTY4IJcQpEMPn2ooKLtvd5wvoIQidjAetlm3Wca5A9t0J/8fwCMCd7tQixaI
hdoCt+eQvosx/yfIhv7/Ql/O/dyWn3shRwQ8/x9bNDqQWEMoRWWW3ZB+REwL/ycwh2tIMyYwX3iQ1w0w
0w1cL3C/hpDuEf8fkCw1YE/3/x+wBW9N0OQ7629udXFKF8hl90fML8CMgQECN9nshNcTUAY3BIDNVVgB
Fzc8cN0hB/KP/v9MSFE4X3to2QnSaDi3dDf1sVC0iJBbB09y/u7AgnBw0i/DxszNzs94ELVWiIUQIPH/
AoebTWLDQsxCzULOQs9BxgYA3YRfzFfw98uGLNmej1ZDh5QAdg/3/C9gmcf0DTsl9wKZKVckgUsAWzgI
rxkGx8bcZAHnTljgSYTL7jAnVC/4n7IhF18SugNHL/O5L4Q7EFg2iMHF30IvRDKYbE64rjBsEuxe/y8o
wp8vz84YaUZvb4FLBgJTm+4bGJBn7DfA0AismyxgZ5dEZ0SXQRMNJxw/H8tfA0masIA3L5WyhOU7Rf8v
ztlP7lTDrtHA/yclDAj8GM/+/0ELd0mnp4oFiUYe/y0hGXYvONp/5+8JOwK/ZCVTC7FCC+647GIE/zcg
3DUPJQI6kq9JpR9BsGNp8wLB/0D7FqBM3++cQFEviNEY604ndHFpAAAAJviABAAA/7gYAADEBgAAAgAA
AH5BcpAAAwBg9EIAIIOcfeD+B+z6Bhnk5Aj/EyAtFmSQQTxLAEFO2Efg6kEHgOz25MmT8HDv8OqQ6y+w
YAcLB7BgVw/BBhlsgAdwoE+PHezZ8D8nMO0/kGMHUANAO9hgIxCPCAcgMxe1g5099M43SBfnCgN0g5zd
AgAC0BcMCQMFyAY525zmFwGoD04OcnIO0AI95wMjW9hBjekvZ+zCXths0B9Q0T9TDyNbCIcA6Xdfnh1s
sGcvFw/qAseb0oUdws4XBkeY0mcQ/pLw3epCBwDQxkJXPLKRkAeHUDjBzl4gh5AwF7AHBhtssL53Gx/Z
DxjBLuwwr+yX8R8GGWSwag+hHQWHJezB48B5QHcHQLODTMgzQFD600cgHWywUCdR+0rVByEbbLAXig8S
557xsGEA/yAvl3zWQQa7EHeCDyI7e1iQZO9yCsOkF2ywQQYWug8NNxlskCF44hcLQnhhB1XjR7Pup2Bn
h+zMZ1MI90c3SIMx2A4XFKcE5xxlIWMPV1dgzQDWBRdoDrfhYYMN7Q8mb9FCx8oWwgkT11d/XkgHOWrn
6q8Z1waw7sInUOAkF0QGOftge/jdFxo4BmEA6wMPFzkbagDSFzI/Hyh/1pEt7EXxlx+oh8g4jFCHGO/C
Pnt2cFQXwFoHkFtAL7DBhmQI0B/gB5AjY3KwXG9+gHUXdrzj9xAUFRcyyBAyPj/6IOsOC1+dAxGnF9mL
7HPHMHUf8GwQDiWgeDd5f/bsYCEXUIUHIuW/eGgYdkcnmCl/hcEGu0CXkBegB7AJe5CwwPJAH9APBAYb
bPAHaWdGpwiBgzUTwIVvBhtsdjtBJzdRFyjBBmOw30hHUxdkDQincVsXAdfuyIIwQDc3dAPgIIO9HIcX
T9wDIM2RTZsXVDE7smAMbRsXcucYXBgHtO4ng9+ePUIgh/BRFzfosNnBzjdDFx4D/zeDXCCPEFJuE0EY
1mAXJEc3IBkJ6eDcQO8vNntkwQ+/cwTvFzOANEcqETAcZLAvk3oXLafuOxJYWFcP4K8WhMEGHg8y/xeE
DCFHNDaPkggyOAcU7DyBFxaXewE3sOlnz14gL8AoN8ApB10WjAuJ7ucrDxeDDCFHMDIrkj3IIDJN6UJP
YTFYJEcPFddnL5AOIO5nsBWn0Dk5yGAH8BAWMLChLAYAN1BfYAcZbKAH8ADvFy+wXtjwNyDyXxDznQ0y
WEfz9Adwgw02hC+QF6AHsAKZrCCP8gV7hMA/EPU3QuIggwegANLHUod19mXrDw9H6z+wI4lFF9EPvsA4
bE53+09ABEGOLGHP/wRBtycw4ezZwT+w/gcf6l9Yt4ONjCEwry8wITTYYF+TN0r3aQawprchF44UL7Jf
CC/m6v8R69KzF0aPiwPTR+unI4xgFwIDd+lC4tnQ1Re965/v32qQwQbxFyMKCByyQWvXLzzsFwY7klq/
Kw8RQzakQfuj12yA1Quj7Q937V+Dwc5ewHcXtS8Zn7AGsAEJF3AXJzIeZAgCAADXkCqkgzRYlyvvLkFX
gYnsiYAqQa8wH2RfZAeQLyfAL0GXg73ITlA0H8AwrzYLDC6wQYc3nzN4gcGGA4eUA+/KIMjZM+8XH5c8
spExD1eRA4whoyePGe8nAuPIghzZL5cXzOoF9qsEL7kEb4cNqyEnzwdQHlkshDdH/4A5FwkvEu9wO4dw
HEousjkfYMBAGS+snmLwnwUB09gwCtl4Fx+Pg1xgU0lP5+9sEi+k8C/0ARsXCINJjy4CX49wsAnxYFOn
ByBVBhsslAcf4Afw9gI7yi9Yx4QCo4PEI2yXgF2XXsEusmcHQF9ngB/AYEFqcEcHMmyBACe/E8+XkYWM
jiV/ZzopBuMAa2dtF/FkQbgQP4yHFyDNEHKo6QmrANIM9R6/GBcCD+bxzzFPB+nIKP8oqzDywoIXQj9F
8reDwIV0F/PXWZfABxvCYCcltzPl8jDihAWH8/KXwhJGnPzyPwAxK549kJ0nfrQ3s8HoWX9jqg+xB3jy
5MnQnlaiZHuwY84G4STHdJfoBzcF4dnBPxarB0CgF3vYYIM/QB8QX3VBf2cHOztxD/UX+30HyGdnxJNm
IXonZAeQBhvsjAEnNE9Qx3yDcLDBD6DfQn5HtAaLFxJPoHcnpUagJ88H0n1geTd7Jyfswa+AdEEXHLGH
BgvGs68HdrPnF5t5crDB97YHFGSlpHYQBjueF9AX0HnPUNiDDbLHd0IAAEggFHYCL+8YJB7ZACAb/5s2
eWFPH8CTB+CQAMIRxhEFn7wHgw12EcYvsAdgCDYVwqJjB/8AgNmDQnlAwJ8AAAAAAABAAv8AAAAAAQAA
pLQBAFBS6K8CAABVU1FSSAH+VkiJ/kiJ1zHbMclIg83/6FAAAAAB23QC88OLHkiD7vwR24oW88NIjQQv
g/kFihB2IUiD/fx3G4PpBIsQSIPABIPpBIkXSI1/BHPvg8EEihB0EEj/wIgXg+kBihBIjX8BdfDzw/xB
W0GA+AIPhYcAAADrCEj/xogXSP/HihYB23UKix5Ig+78EduKFnLmjUEBQf/TEcAB23UKix5Ig+78EduK
FnPrg+gDchfB4AgPttIJ0Ej/xoPw/w+EPAAAAEhj6I1BAUH/0xHJQf/TEcl1GInBg8ACQf/TEckB23UI
ix5Ig+78Edtz7UiB/QDz//8Rwegw////64NXXllIifBIKchaSCnXWYk5W13DaB4AAABa6MMAAABQUk9U
X0VYRUN8UFJPVF9XUklURSBmYWlsZWQuCgAKACRJbmZvOiBUaGlzIGZpbGUgaXMgcGFja2VkIHdpdGgg
dGhlIFVQWCBleGVjdXRhYmxlIHBhY2tlciBodHRwOi8vdXB4LnNmLm5ldCAkCgAkSWQ6IFVQWCAzLjk2
IENvcHlyaWdodCAoQykgMTk5Ni0yMDIwIHRoZSBVUFggVGVhbS4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4g
JAoAkGoOWlde6wFeagJfagFYDwVqf19qPFgPBV8p9moCWA8FhcB43FBIjbcPAAAArYPg/kGJxlZbrZJI
AdqtQZWtSQH1SI2N9f///0SLOUwp+UUp919IKcpSUEkpzVdRTSnJQYPI/2oiQVpSXmoDWin/aglYDwVJ
AcZIiUQkEEiXRItEJAhqEkFaTInuaglYDwVIi1QkGFlRSAHCSCnISYnESAHoUEglAPD//1BIKcJSSIne
rVBIieFKjRQjSYnVrVCtQZBIifde/9VZXl9dagVaagpYDwVB/+Vd6Dz///8vcHJvYy9zZWxmL2V4ZQAA
AQAADwgAAGwGAAACSQ0A////5ehKAIP5SXVEU1dIjUw3/V5WW+svSDnOczJWXv/7//+sPIByCjyPdwaA
fv4PdAYs6DwBd+QbFlatKNB1//+//99fD8gp+AHYqxIDrOvfW8NYQVZBV1BIieZIgez+7f/bABBZVF9q
ClnzSKVIgz4ABXX4SYn+SKu2dLPLDPwKDPb/Av7fbv/1TSn8uv8PN1dejHvtallYDwWFwHkF22//3w5q
D1iR/UmNff+wAKoadA7/86Q77/9v2/YDxwcgAD04Pgzn+EyJ+Ugp4YnIMW/bW/74g/AIg+AIx28mCDh3
+Ej/7f/vwekDiY1nCPxLjQwmi0P8IwFIAcFBWV5f9+3WvlivCHe54lAz6OisBQv7/z92gcQIEkQkIFtF
KclBidhqAkFaagFavtq27t32agDbCZ+J32oDBl+iC/7bt9/9/2b4sAlAyg+2wBJIPQDw//9yBJqm+9+B
yP/DsDzrArAMAwMCC6HhpmkKAQDrzoZRR7bdv30XTItHt41K/3MKv38S6MVA/9u/td8/+f90EUFTi//J
Sf/AiAYHxtvbd9vr6bpX4hdYw0FVcdVBVATMfnhrt1Ws/VMD5oPsKFoPhOZ1/97gRC8kELoMCYnv6JZR
i/Z/YbvSEIsUFFt1FYH+VVBYIXURLxvsu+59ADC1JusEhfZ1gEQue2H7vznGd/KJwkg7E3frCkg4CHNs
Seu27nZUJH2LfaxMCERQGBKa+7ptwv/VUsZeSF8c7f+t3S51uLchGYTJD5XCMcBNheQHX9he+MCFwnQd
Xf4AAl93JTkzdQ9tt21rI04aBMk1ewhE1HNvzdZAFN5FRYwNifK3Ajbb133G6Nv+ulRbAx1T0Ej9j/DW
bhgD6RQlxChbXUFcQV3Dhe2/oxVL0XQ2QPbHAXUwLQ+6WXM3/PBMOcF0EkkBD5SH34Y1utvGCDMHAk8I
MsngcHQXvh7HEOvQT1e4+QCRv+HS4M1b/VVTUmhMA28gZmsdt+2DfxB9idIwuQQAPKq7DdtCaonrQBA8
TBcgD7+Nvf23VzgPRMh2hCSgIe47zf8x2zHbCr/w/4PBIt8A/8p4IZuYFiHudvttRso56EgPQgMDRkU5
wwq2x8K32CzGOOvbHuU84uvw33baCcMRBuMQ9sEQdAXG1njbDusTse11Duxex16j8Y3CEFdvRchFMaRr
Fpr7tjHSIN7odP0+HJ8Ebn+2lSWjHNH+SSnuZiN/OLYZbjHWboSig3F8vjP8jfYAdCIXAQZ1G0mLVWES
t6H0ezC+A74B8g136WEp2ssuPCFAhVY0SUkSuj9llyR1QjRJA1cg6HM4SYN9nB0PGgVQXxM23v88JwRL
i0UQQYtNBMFt377rTSC0GEBiUXNL8IPhB7rEQvtb97FYJSjy5cHhAtNsHyRsH9uHGoNkCQeQUCvgtve3
bRjq4+wrCLky8zAI/PHs9hudKeizdQeuPLES+7Z9dEoYphBcwVPng8oCINvurjC8GOg0/JM5xO0ldQ1t
kgEZLuBIOCi7zf09VFDCQOh8KQlsYvfdIy11Z5H2uwKySAiJDnbj1un8fzwEdPOqX4Tc27E955jf+1q4
vP8Bqm28d+Mj7Ui6CQMO0IVtO7Z7lMFVKANNpTsUx97wDc0KSo0cMPnY99gl/fgDw/gtwnc5hRhcMQx0
LQW9WIfu/7kiPbqPsHCb+8n9WOha+684w3Q3kIXHEQ63rQOsWgwSuqCRLcJjbxvf6F4m23QTqBGS4G7g
2jH2Zf7onu46BmtzGzfoNShOdDATrcI/9jb4AehJAcRMO50vL5Z77idMKQY1nRqi8Qi/CKBByPprdb3/
uHt7y6not0c40MU4OQwPjF6ptZP0x0swTe156sn022RoEPBBXkFfsqoCS91Cxc75VaxNCKOZtj/VTI1t
QFMgw7k/H2LfeJvEGAQ+jbwkgOPYNnfYhiDG25g4KcK72xb4NTCABBR8voPADBC20rb7EOicnUFTVeFY
Y9i7W/faJ/GONyh16NDtvgngdmxjTcIZ96bofhIcbjVoUygpfTh08EkbDnjzjwA/A3Vy8EK7tM0/Hn0Q
TlHo8Pl36fvtPKV4F7oABEbus+jrFEF3CG9IPQ9VvRFJ6DbDr+1KQVBDAsDsV3dzDUSU1ElzVRe+IHAN
brCG97XFjDiGLDQ031cMVkUJ2wncC4JxMkgt4EoAAECERyABAAD/AIADAAAOAAAAAgAAAAChKpIAAAAA
AAAAgAT/SAQAAFgBAAACAAAA7f///0dDQzogKEdOVSkgNi40LjAAAC5zaHN0cnRhYgnfXPP2aW5pdAV0
ZXhmDAVyb2Rhlv1/axoHZWhfZnJhbWVfaGRyDbfXfuYrHnRic3MFCzFlbLE2e3M1DGdvdBEFHEOAte1j
b20wbhMAC2AP1nQDAQYPkAFAByEbsrMPAy8BD8EGGbIRP6CgKGTIJuzmwwIvED8XAmywh4bFQgcCf4Md
FmwdE2WgP6DILuwgq2UvID9ZsIdkJUwrQwd5ZMgu7CQKLwQ/M1mbPORwcDUHP2zILuwwQC8IPz1/WLAH
GwNYIHljBz8s2EU2AL9EUz+SQQY5YFCIubDDhkp/AD9gkFwkB+AUV2DP2uRAjgcRuAH/RsgOWwdcP3iR
PWuzPwcR2AF/ZwcbdmL/D+CRP9iwi2ywkf8bP2d/jMNGQmc/EX+AdGAhBwNXCGUMNuk/cL8AAAAAAAAk
AP8AAAAAVVBYIQAAAAAAAFVQWCENFgIKUZaAW7NVvdFIBAAAWAEAACCWAwBJDQBZ9AAAAA==
";
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | from itertools import accumulate
n = int(input())
lst = [int(x) for x in input().split()]
acm = list(accumulate(lst))
ret1 = 0
tmp = 0
for i, x in enumerate(acm):
y = abs(x) + 1
if i % 2 == 0:
if x + tmp <= 0:
ret1 += (x + tmp) * -1 + 1
tmp += y
elif i % 2 == 1:
if x + tmp >= 0:
ret1 += (x + tmp) + 1
tmp -= y
ret2 = 0
tmp = 0
for i, x in enumerate(acm):
y = abs(x) + 1
if i % 2 == 0:
if x + tmp >= 0:
ret2 += (x + tmp) + 1
tmp -= y
elif i % 2 == 1:
if x + tmp <= 0:
ret2 += (x + tmp) * -1 + 1
tmp += y
print(min(ret1, ret2))
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n;
cin >> n;
int a[10010];
for (int i = 0; i < n; ++i) cin >> a[i];
long long int res = 0;
bool plus = false;
long long int sum = a[0];
if (a[0] > 0)
plus = true;
else if (a[0] < 0)
plus = false;
int j = 1;
while (sum == 0) {
if (a[j] > 0) {
++res;
sum = (j % 2 == 0) ? 1 : -1;
plus = (j % 2 == 0) ? true : false;
} else if (a[j] < 0) {
++res;
sum = (j % 2 == 0) ? -1 : 1;
plus = (j % 2 == 0) ? false : true;
}
++j;
if (j == n) {
cout << 1 + 2 * (n - 1) << endl;
return 0;
}
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int sum = 0, res = 0, prevsum = 0;
for (int i = 0; i < n; ++i) {
sum += a[i];
if (sum < 0 && prevsum >= 0 || sum > 0 && prevsum <= 0) {
prevsum += a[i];
continue;
} else if (sum > 0) {
int t = -(prevsum + 1);
res += abs(t) - abs(a[i]);
sum = -1;
prevsum = -1;
} else if (sum < 0) {
int t = (-1 * prevsum + 1);
res += abs(t - (a[i]));
sum = -1;
prevsum = -1;
}
}
cout << res;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include<bits/stdc++.h>
using namespace std;
#define int int64_t
main(){
int n;
cin>>n;
vector<int> a(n);
for(auto&x:a)cin>>x;
int n_actions0=0; // when even elements are positive.
{
int sum=0;
for(int i=0;i<a.size();++i){
bool want_positive=i%2==0;
sum+=a[i];
bool is_positive=sum>0;
if(is_positive==want_positive)continue;
n_actions0+=abs(sum)+1;
sum=sum>0?-1:1;
}
}
int n_actions1=0; // when odd elements are positive.
{
int sum=0;
for(int i=0;i<a.size();++i){
bool want_positive=i%2!=0;
sum+=a[i];
bool is_positive=sum>0;
if(is_positive==want_positive)continue;
n_actions1+=abs(sum)+1;
sum=sum>0?-1:1;
}
}
cout<<min(n_actions0,n_actions1)<<endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
long long calc(int n, long long* a, bool isPositive) {
long long nCount = 0, sum = 0;
for (int i = 0; i < n; i++) {
if (isPositive) {
if ((a[i] + sum) < 0) {
sum += a[i];
} else {
nCount += abs(a[i] + sum) + 1;
sum = -1;
}
isPositive = !isPositive;
} else {
if ((a[i] + sum) > 0) {
sum += a[i];
} else {
nCount += abs(a[i] + sum) + 1;
sum = 1;
}
isPositive = !isPositive;
}
}
return nCount;
}
int main() {
int n;
long long a[100005];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
bool isPositive;
int nCount[2];
isPositive = true;
nCount[0] = calc(n, a, isPositive);
isPositive = false;
nCount[1] = calc(n, a, isPositive);
cout << min(nCount[0], nCount[1]) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
a = list(map(int, input().split()))
L = [0 for _ in range(n)]
L[0] = a[0]
for i in range(1, n):
L[i] = L[i-1] + a[i]
delay = 0
all_over = 0
anti_delay = 0
anti_all_over = 0
if a[0] != 0:
antiL = L[:]
sign = (a[0] > 0) - (a[0] < 0)
for i in range(1, n):
L[i] += delay
if L[i] <= 0 and sign == -1:
delay += 1 - L[i]
all_over += 1 - L[i]
L[i] = 1
elif L[i] >= 0 and sign == 1:
delay -= L[i] + 1
all_over += L[i] + 1
L[i] = -1
sign *= -1
if antiL[0] < 0:
sign = 1
anti_delay = 1 - antiL[0]
anti_all_over = 1 - antiL[0]
else:
sign = -1
anti_delay = antiL[0] + 1
anti_all_over = antiL[0] + 1
for i in range(1, n):
antiL[i] += anti_delay
if antiL[i] <= 0 and sign == -1:
anti_delay += 1 - antiL[i]
anti_all_over += 1 - antiL[i]
antiL[i] = 1
elif antiL[i] >= 0 and sign == 1:
anti_delay -= antiL[i] + 1
anti_all_over += antiL[i] + 1
antiL[i] = -1
sign *= -1
print(min(anti_all_over, all_over))
else:
posL = L[:]
negL = L[:]
pos_delay, neg_delay = 1, -1
pos_all_over, neg_all_over = 1, 1
sign = 1
for i in range(1, n):
posL[i] += pos_delay
if posL[i] <= 0 and sign == -1:
pos_delay += 1 - posL[i]
pos_all_over += 1 - posL[i]
posL[i] = 1
elif posL[i] >= 0 and sign == 1:
pos_delay -= posL[i] + 1
pos_all_over += posL[i] + 1
posL[i] = -1
sign *= -1
sign = -1
for i in range(1, n):
negL[i] += neg_delay
if negL[i] <= 0 and sign == -1:
neg_delay += 1 - negL[i]
neg_all_over += 1 - negL[i]
negL[i] = 1
elif negL[i] >= 0 and sign == 1:
neg_delay -= negL[i] + 1
neg_all_over += negL[i] + 1
negL[i] = -1
sign *= -1
print(min(pos_all_over, neg_all_over)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
const long long MAX_N = 10001;
long long a[MAX_N];
long long n;
long long choose(int sign) {
long long sum, count;
sum = count = 0;
for (long long i = 1; i <= n; ++i, sign *= -1) {
sum += a[i];
if (sum * sign <= 0) {
count += 1 - sum * sign;
sum = sign;
}
}
return count;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
long long res = std::min(choose(1), choose(-1));
printf("%lld\n", res);
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | def op(pos, n, a):
if pos:
S = 1 if a[0] == 0 else a[0]
else:
S = -1 if a[0] == 0 else a[0]
count = 1 if S == 0 else 0
for i in a[1:]:
if S * (S + i) > 0:
count += abs(S + i) + 1
S = -1 if S > 0 else 1
elif S + i == 0:
count += 1
S = -1 if S > 0 else 1
else:
S += i
return count
def main():
n = int(input())
a = list(map(int, input().split()))
c1 = op(0, n, a)
c2 = op(1, n, a)
print(min(c1, c2))
if __name__ == "__main__":
main() |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
long long sum = 0;
long long changes = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sum = a[0];
if (sum == 0) {
changes = 1;
sum = 1;
}
for (int i = 1; i < n; i++) {
if (sum > 0) {
sum += a[i];
if (sum >= 0) {
changes += abs(sum) + 1;
sum = -1;
}
} else {
sum += a[i];
if (sum <= 0) {
changes += abs(sum) + 1;
sum = 1;
}
}
}
cout << changes << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner((System.in));
int N = sc.nextInt();
int[] n = new int[N + 1];
// 入力値を設定
for (int i = 0; i < N; i++) {
n[i] = sc.nextInt();
}
int s = n[0];
int m = 0;
for (int i = 1; i <= N; i++) {
while (Math.signum(s) != Math.pow(-1, i % 2)) {
if (Math.pow(-1, i % 2) > 0) {
s++;
} else {
s--;
}
m++;
}
s += n[i];
}
s = n[0];
int p = 0;
for (int i = 1; i <= N; i++) {
while (Math.signum(s) != Math.pow(-1, (i + 1) % 2)) {
if (Math.pow(-1, (i + 1) % 2) > 0) {
s++;
} else {
s--;
}
p++;
}
s += n[i];
}
if (m > p) {
System.out.print(p);
} else {
System.out.print(m);
}
sc.close();
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int( input())
A = list( map( int, input().split()))
ansp = 0
sums = A[0]
if sums == 0:
ansp += 1
sums += 1
for i in range(1,n):
sums += A[i]
if i%2 == 1:
if sums < 0:
pass
else:
ansp += abs(-1-sums)
sums = -1
else:
if sums > 0:
pass
else:
ansp += 1 - sums
sums = 1
sums = A[0]
ansm = 0
if sums == 0:
ansm += 1
sums -= 1
for i in range(1,n):
sums += A[i]
if i%2 == 0:
if sums < 0:
pass
else:
ansm += abs(-1-sums)
sums = -1
else:
if sums > 0:
pass
else:
ansm += 1 - sums
sums = 1
print( min(ansp, ansm)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
constexpr long long INFL = 1LL << 60;
constexpr int INF = 1 << 30;
using namespace std;
using ll = long long;
using P = tuple<int, int>;
using iarr = valarray<int>;
int main() {
int N;
cin >> N;
int a[100000];
for (int i = 0; i < N; ++i) cin >> a[i];
ll partial_sum = 0;
ll cnt = 0;
int index = 0;
for (int i = 0; i < N; ++i) {
if (a[i] != 0) {
if (i == 0) {
partial_sum = a[i];
index = i + 1;
break;
} else {
if (i == N - 1) {
if (abs(a[i]) == 1) {
cout << 1 + 2 * (i - 1) + 1 << endl;
return 0;
} else {
cout << 1 + 2 * (i - 1) << endl;
return 0;
}
} else {
cnt += 1 + 2 * (i - 1) + abs(a[i]);
index = i + 1;
if (a[i] > 0) {
if (a[i] == 1) {
cnt++;
partial_sum = 1;
} else {
partial_sum = a[i] - 1;
}
} else {
if (a[i] == -1) {
cnt++;
partial_sum = -1;
} else {
partial_sum = a[i] + 1;
}
}
break;
}
}
}
}
if (index == 0) {
cout << 1 + 2 * (N - 1) << endl;
return 0;
}
for (int i = index; i < N; ++i) {
if (partial_sum > 0) {
if (a[i] + partial_sum > 0) {
cnt += abs(-(partial_sum + 1) - a[i]);
a[i] = -(partial_sum + 1);
partial_sum = -1;
} else if (a[i] + partial_sum == 0) {
cnt += 1;
a[i] = -1;
partial_sum = -1;
} else {
partial_sum += a[i];
}
} else {
if (a[i] + partial_sum < 0) {
cnt += abs(-(partial_sum - 1) - a[i]);
a[i] = -(partial_sum - 1);
partial_sum = 1;
} else if (a[i] + partial_sum == 0) {
cnt += 1;
a[i] = 1;
partial_sum = 1;
} else {
partial_sum += a[i];
}
}
}
cout << cnt << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int sum(int i, vector<int> &a) {
if (i == 0) return a[0];
return a[i] + sum(i - 1, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int c = 0;
if (a[0] == 0) {
if (a[1] < 0)
a[0] = 1;
else
a[0] = -1;
c++;
}
for (int i = 0; i < n - 1; i++) {
if (sum(i, a) >= 0) {
if (sum(i + 1, a) >= 0) {
c += abs(-1 - sum(i, a) - a[i + 1]);
a[i + 1] = -1 - sum(i, a);
}
}
if (sum(i, a) < 0) {
if (sum(i + 1, a) <= 0) {
c += abs(1 - sum(i, a) - a[i + 1]);
a[i + 1] = 1 - sum(i, a);
}
}
}
cout << c << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int ans_1 = 0;
int ans_2 = 0;
b.at(0) = a.at(0);
if (b.at(0) <= 0) {
ans_1 += 1 - b.at(0);
b.at(0) = 1;
}
for (int i = 1; i < n; i++) {
b.at(i) = b.at(i - 1) + a.at(i);
if ((i % 2) == 1) {
if (b.at(i) >= 0) {
ans_1 += 1 + b.at(i);
b.at(i) = -1;
}
} else {
if (b.at(i) <= 0) {
ans_1 += 1 - b.at(i);
b.at(i) = 1;
}
}
}
b.at(0) = a.at(0);
if (b.at(0) >= 0) {
ans_2 += 1 + b.at(0);
b.at(0) = -1;
}
for (int i = 1; i < n; i++) {
b.at(i) = b.at(i - 1) + a.at(i);
if ((i % 2) == 1) {
if (b.at(i) <= 0) {
ans_2 += 1 - b.at(i);
b.at(i) = 1;
}
} else {
if (b.at(i) >= 0) {
ans_2 += 1 + b.at(i);
b.at(i) = -1;
}
}
}
cout << min(ans_1, ans_2) << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n;
cin >> n;
vector<long long> a;
for (int i = 0; i < n; i++) {
long long temp;
cin >> temp;
a.push_back(temp);
}
long long cnt = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (i % 2) {
if (sum <= 0) {
cnt += abs(sum) + 1;
sum = 1;
}
} else {
if (sum >= 0) {
cnt += abs(sum) + 1;
sum = -1;
}
}
}
cout << cnt << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | import numpy as np
N = int(input())
S = list(map(int, input().split()))
mod_count = 0
pre_fugou = 1 ## 前の符号がなんであったか 1ならplus 0ならマイナス
for i in range(N):
if i==0 and S[i]==0:
S[i] += 1
mod_count += 1
pre_fugou = 1
elif i==0 and S[i]>0:
pre_fugou = 1
elif i==0 and S[i]<0:
pre_fugou = 0
else:
if pre_fugou == 1:
while True:
if sum(S[:i+1]) > -1:
S[i] -= 1
mod_count += 1
pre_fugou = 0
else:
pre_fugou = 0
break
elif pre_fugou == 0:
while True:
if sum(S[:i+1]) < 1:
S[i] += 1
mod_count += 1
pre_fugou = 1
else:
pre_fugou = 1
break
print(mod_count) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int inf = 1e9 + 1000;
long long infi = 1e18 + 100;
long long n;
long long a[100005];
int main() {
cin >> n;
for (int i = 0; i <= (int)(n - 1); i++) cin >> a[i];
long long sum;
long long ans = 0;
for (int i = 0; i <= (int)(n - 1); i++) {
long long p = sum;
sum += a[i];
if (p < 0 && sum < 0) {
ans += (1 - sum);
sum = 1;
} else if (p > 0 && sum > 0) {
ans += (sum + 1);
sum = -1;
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for(int i =0; i<n; i++) {
a[i] = sc.nextInt();
}
int num1 = 0;
int tmp1 = 0;
//+-+-
for(int i=0; i<n; i++) {
tmp1 += a[i];
if(i % 2 == 0) {
if(tmp1 <= 0) {
num1 += Math.abs(tmp1) + 1;
tmp1 += Math.abs(tmp1) + 1;
}
} else {
if(tmp1 >= 0) {
num1 += Math.abs(tmp1) + 1;
tmp1 -= Math.abs(tmp1) + 1;
}
}
}
int num2 = 0;
int tmp2 = 0;
//-+-+
for(int i=0; i<n; i++) {
tmp2 += a[i];
if(i % 2 != 0) {
if(tmp2 <= 0) {
num2 += Math.abs(tmp2) + 1;
tmp2 += Math.abs(tmp2) + 1;
}
} else {
if(tmp2 >= 0) {
num2 += Math.abs(tmp2) + 1;
tmp2 -= Math.abs(tmp2) + 1;
}
}
}
System.out.println(Math.min(num1,num2));
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<long long> a(n + 1);
vector<long long> tot(n + 1, 0);
for (int i = 1; i <= (int)(n); i++) {
cin >> a.at(i);
}
long long count = 0;
for (int i = 1; i <= (int)(n); i++) {
if (i == 1) {
tot.at(1) += a.at(1);
continue;
}
if (tot.at(i - 1) > 0) {
long long sum = tot.at(i - 1) + a.at(i);
if (sum >= 0) {
tot.at(i) = -1;
count += sum + 1;
} else
tot.at(i) = sum;
}
if (tot.at(i - 1) < 0) {
long long sum = tot.at(i - 1) + a.at(i);
if (sum <= 0) {
tot.at(i) = 1;
count += (1 - sum);
} else
tot.at(i) = sum;
}
}
cout << count << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include<bits/stdc++.h>
#define int long long
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int a[100009],n;
int d1(){
int sum=0,ans=0;
for(int i=0;i<n;i++){
if(i%2==0){
if(sum+a[i]>=0)ans+=sum-a[i]+1,sum=-1;
else sum+=a[i];
}
else{
if(sum+a[i]<=0)ans+=sum-a[i]-1,sum=1;
else sum+=a[i];
}
}
}
int d2(){
int sum=0,ans=0;
for(int i=0;i<n;i++){
if(i%2==1){
if(sum+a[i]>=0)ans+=sum-a[i]+1,sum=-1;
else sum+=a[i];
}
else{
if(sum+a[i]<=0)ans+=sum-a[i]-1,sum=1;
else sum+=a[i];
}
}
}
main(){
cin>>n;
r(i,n)cin>>a[i];
cout<<min(d1(),d2())<<endl;
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | n = gets.to_i
a = gets.chomp.split.map(&:to_i)
sum1 = 0
sum2 = 0
ans = 0
for i in 0..n-2
sum1 += a[i]
if sum1 == 0
if a[i+1] > 1
a[i] -= 1
sum1 -= 1
ans += 1
else
a[i] += 1
sum1 += 1
ans += 1
end
end
sum2 = sum1 + a[i+1]
if sum2 * sum1 >= 0
if sum1 < 0
if sum1 <= sum2
a[i+1] += 1 - sum2
ans += 1 - sum2
else
a[i] += -sum1 + 1
ans += -sum1 + 1
sum1 = 1
end
else
if sum1 >= sum2
a[i+1] -= sum2 + 1
ans += sum2 + 1
else
a[i] -= 1 + sum1
ans += 1 + sum1
sum1 = -1
end
end
end
end
puts ans |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x = 0, a[100001], ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; a[i] == 0; ++i) {
ans = 2 * (i + 1);
x = i + 1;
}
long long sum1 = a[x], sum2 = a[x];
for (int i = x + 1; i < n; i++) {
sum2 += a[i];
if (sum2 >= 0 && sum1 > 0) {
ans += abs(sum2) + 1;
a[i] = a[i] - abs(sum2) - 1;
sum2 = sum2 - abs(sum2) - 1;
}
if (sum2 <= 0 && sum1 < 0) {
ans += abs(sum2) + 1;
a[i] = a[i] + abs(sum2) + 1;
sum2 = sum2 + abs(sum2) + 1;
}
sum1 = sum2;
}
cout << ans << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
long long a[100000];
int n;
void solve() {
long long ans = 0;
long long sum0 = a[0];
long long sum1;
for (int i = 1; i < n; i++) {
sum1 = sum0 + a[i];
if (sum1 * sum0 < 0) {
} else if (sum1 * sum0 > 0) {
ans += abs(sum1) + 1;
sum1 = -1 * sum0 / abs(sum0);
} else {
ans++;
sum1 = -1 * sum0 / abs(sum0);
}
cout << sum1 << endl;
sum0 = sum1;
}
cout << ans << endl;
return;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
solve();
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, t = 0, sum = 0, count = 0, count2 = 0;
cin >> n;
int a[n];
cin >> a[0];
if (a[0] > 0) {
t = 1;
} else if (a[0] < 0) {
t = -1;
}
sum += a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
sum += a[i];
if (t == -1) {
while (sum <= 0) {
sum++;
count++;
}
t = 1;
} else if (t == 1) {
while (sum >= 0) {
sum--;
count++;
}
t = -1;
}
}
sum = 0;
if (a[0] > 0) {
t = -1;
} else {
t = 1;
}
for (int i = 0; i < n; i++) {
sum += a[i];
if (t == -1) {
while (sum <= 0) {
sum++;
count2++;
}
t = 1;
} else if (t == 1) {
while (sum >= 0) {
sum--;
count2++;
}
t = -1;
}
}
cout << min(count, count2) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long cnt1 = 0, cnt2 = 0;
long long sumv = a[0];
for (int i = 1; i < n; i++) {
if (i % 2 == 0 && sumv < 0)
sumv = 1;
else if (i % 2 == 1 && sumv > 0)
sumv = -1;
sumv += a[i];
cnt1 += abs(sumv) + 1;
}
sumv = a[0];
for (int i = 1; i < n; i++) {
if (i % 2 == 0 && sumv > 0)
sumv = -1;
else if (i % 2 == 1 && sumv < 0)
sumv = 1;
sumv += a[i];
cnt2 += abs(sumv) + 1;
}
cout << min(cnt1, cnt2) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <iostream>
#include <algorithm>
#include <cmath>
#include <limits>
#include <vector>
#include <cstdio>
#include <bits/stdc++.h>
#include <set>
#include <map>
#include <stdio.h>
#include <stack>
#include <queue>
#include <deque>
#include <numeric>
using namespace std;
using ll = long long;
map <int ,int> mpa,mpb;
typedef pair<ll, ll> P;
priority_queue<P, vector<P>, greater<P>> pque;
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
int N;
cin >> N;
int a[N+2];
for(int i=1;i<=N;i++){
cin >> a[i];
}
cnt1=0,cnt2=0;
sum=0;
for(int i=1,s=1;i<=N;i++,s*=-1){
sum+=a[i];
if(sum*s<=0) cnt1+=abs(sum-s),sum=s;
}
sum=0;
for(int i=1,s=-1;i<=N;i++,s*=-1){
sum+=a[i];
if(sum*s<=0) cnt2+=abs(sum-s),sum=s;
}
cout << min(cnt1,cnt2) << endl;
return 0;
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long int sum = arr[0];
long int ans = 0;
if (sum == 0) {
if (arr[1] >= 0) {
ans++;
sum = -1;
} else {
ans++;
sum = 1;
}
}
for (int i = 1; i < n; i++) {
if (sum < 0) {
sum = sum + arr[i];
if (sum > 0)
continue;
else {
ans += abs(sum) + 1;
sum = 1;
}
} else {
sum += arr[i];
if (sum < 0)
continue;
else {
ans += sum + 1;
sum = -1;
}
}
}
cout << ans;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
inline signed wait() { return 0; }
inline void dout(const char *arg, ...) {}
template <typename T>
inline void SWAP(T &a, T &b) {
T t = a;
a = b;
b = t;
}
inline void CSWAP(char *&a, char *&b) {
char *t = a;
a = b;
b = t;
}
void CombSort(int N, int *ar, int order_ascending = 1) {
if (N <= 1) return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<int>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag) break;
if (h == 9 || h == 10) h = 11;
if (h > 1) h = int(h / 1.3);
}
}
void CombSort(int N, long long int *ar, int order_ascending = 1) {
if (N <= 1) return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<long long int>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag) break;
if (h == 9 || h == 10) h = 11;
if (h > 1) h = int(h / 1.3);
}
}
int EuclideanAlgorithm(int N, int *ar) {
for (int n = 0; n < N - 1; ++n) {
while (true) {
if (ar[n] % ar[n + 1] == 0 || ar[n + 1] % ar[n] == 0) {
ar[n + 1] = ar[n] < ar[n + 1] ? ar[n] : ar[n + 1];
break;
}
if (ar[n] > ar[n + 1]) {
ar[n] %= ar[n + 1];
} else {
ar[n + 1] %= ar[n];
}
}
}
return ar[N - 1];
}
template <typename T>
void CombSort(int N, T *ar, int order_ascending = 1) {
if (N <= 1) return;
int i, flag;
int h = int(N / 1.3);
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if (order_ascending && ar[i].SortValue > ar[i + h].SortValue ||
!order_ascending && ar[i].SortValue < ar[i + h].SortValue) {
swap<T>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h > 1) {
h = int(h / 1.3);
if (h == 9 || h == 10) h = 11;
} else {
if (!flag) break;
}
}
}
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
void Replace(char *c, int len, char before, char after) {
for (int i = 0; i < len; ++i) {
if (c[i] == before) c[i] = after;
}
}
void Replace(char *c, char before, char after) {
int len = strlen(c);
Replace(c, len, before, after);
}
class csNode {
public:
csNode() {}
};
class csStack {
public:
csStack() { num = 0; }
void alloc(int size) { param = new int[size]; }
void sort(int order = 1) {
if (num > 1) CombSort(num, param, order);
}
int num;
int *param;
void push(int p) { param[num++] = p; }
};
class csPosition {
public:
csPosition() { x = y = 0; }
int x, y;
};
template <typename T>
class csPos {
public:
csPos() { x = y = 0; }
T x, y;
};
char s[200010], s2[1000];
signed main() {
long long int n;
scanf("%lld", &n);
long long int cnt = 0;
long long int i;
long long int a, b, sum = 0;
scanf("%lld", &b);
sum = b;
long long int flag;
b < 0 ? flag = -1 : flag = 1;
for (i = 1; i < n; ++i) {
scanf("%lld", &a);
sum += a;
if (flag == -1 && sum < 0) {
cnt += 1 - sum;
sum = 1;
}
if (flag == 1 && sum > 0) {
cnt += sum + 1;
sum = -1;
}
if (sum == 0) {
cnt++;
if (flag == 1) {
sum = -1;
} else {
sum = 1;
}
}
flag *= -1;
}
cout << cnt << endl;
;
return wait();
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)(n); i++) {
cin >> a.at(i);
}
int64_t count = 0;
int64_t wa = a.at(0);
for (int i = 1; i < n; i++) {
if (a.at(0) > 0) {
if (i % 2 == 1) {
if (wa + a.at(i) < 0) {
wa += a.at(i);
} else {
count += (wa + a.at(i) + 1);
wa = -1;
}
} else {
if (wa + a.at(i) > 0) {
wa += a.at(i);
} else {
count += (-wa - a.at(i) + 1);
wa = 1;
}
}
}
if (a.at(0) < 0) {
if (i % 2 == 1) {
if (wa + a.at(i) > 0) {
wa += a.at(i);
} else {
count += (-wa - a.at(i) + 1);
wa = 1;
}
} else {
if (wa + a.at(i) < 0) {
wa += a.at(i);
} else {
count += (wa + a.at(i) + 1);
wa = -1;
}
}
}
}
cout << count << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | N = int(input())
nums = list(map(int, input().split()))
ans = 10**10+1
for start in [-1, 1]:
before = start
cnt = 0
sum_n = 0
for num in nums:
sum_n += num
if before*sum_n >= 0:
if before < 0:
cnt += abs(1-sum_n)
sum_n = 1
else:
cnt += abs(-1-sum_n)
sum_n = -1
before = sum_n
ans = min(ans, cnt)
print(ans)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
StringTokenizer str = new StringTokenizer(br.readLine(), " ");
int[] A = new int[n];
for(int i = 0; i < n ; i++) {
A[i] = Integer.parseInt(str.nextToken());
}
int c1 = func(A,1,n);
int c2 = func(A,-1,n);
if(c1 > c2) System.out.println(c2);
else System.out.println(c1);
} catch (IOException e) {
System.out.println("error");
}
}
static int func(int[] A,int flg,int n){
int sum = 0;
int c = 0;
for(int i = 0; i < n; i++){
sum += A[i];
if(flg == 1){ //次は負
if(sum >= 0){
c += (sum + 1);
sum = -1;
}
flg = -1;
}
else{ //次は正
if(sum <= 0){
c += 1+ (-sum);
sum = 1;
}
flg = 1;
}
}
return c;
}
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | use std::cmp::min;
fn main() {
let (r, w) = (std::io::stdin(), std::io::stdout());
let mut sc = IO::new(r.lock(), w.lock());
let n: usize = sc.read();
let mut a: Vec<i64> = sc.vec(n);
let a0 = a[0];
let ans1 = solve(&a);
a[0] = 1;
let ans2 = solve(&a) + (a0 - 1).abs();
a[0] = -1;
let ans3 = solve(&a) + (a0 + 1).abs();
let ans = min(ans1, min(ans2, ans3));
println!("{}", ans);
}
fn solve(a: &Vec<i64>) -> i64 {
let mut ans = 0;
let mut sum = a[0];
for i in 1..a.len() {
if sum > 0 {
let require = -sum - 1;
if a[i] > require {
ans += a[i] - require;
sum += require;
assert_eq!(sum, -1);
} else {
sum += a[i];
}
} else {
let require = -sum + 1;
if a[i] < require {
ans += require - a[i];
sum += require;
assert_eq!(sum, 1);
} else {
sum += a[i];
}
}
}
ans
}
pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);
impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
pub fn new(r: R, w: W) -> IO<R, W> {
IO(r, std::io::BufWriter::new(w))
}
pub fn write<S: std::ops::Deref<Target = str>>(&mut self, s: S) {
use std::io::Write;
self.1.write(s.as_bytes()).unwrap();
}
pub fn read<T: std::str::FromStr>(&mut self) -> T {
use std::io::Read;
let buf = self
.0
.by_ref()
.bytes()
.map(|b| b.unwrap())
.skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
.take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
.collect::<Vec<_>>();
unsafe { std::str::from_utf8_unchecked(&buf) }
.parse()
.ok()
.expect("Parse error.")
}
pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
(0..n).map(|_| self.read()).collect()
}
pub fn chars(&mut self) -> Vec<char> {
self.read::<String>().chars().collect()
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 61;
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < (int)(n); i++) cin >> v[i];
long long wa;
long long ans = 0;
wa = v[0];
if (v[0] == 0) {
if (v[1] > 0)
wa = -1;
else
wa = 1;
ans++;
}
for (int i = 1; i < n; i++) {
long long nxwa;
nxwa = wa + v[i];
if (nxwa * wa < 0) {
wa = nxwa;
continue;
} else {
if (wa < 0) {
ans += ((0 - nxwa) + 1);
wa = 1;
} else {
ans += (nxwa + 1);
wa = -1;
}
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | N=int(input())
A=[int(i) for i in input().split()]
S1,S2=[],[]
if A[0]>0:
S1.append(A[0])
S2.append(-1)
a1,a2=0,A[0]+1
elif A[0]==0:
S1.append(1)
S2.append(-1)
a1,a2=1,1
else:
S1.append(1)
S2.append(A[0])
a1,a2=-A[0]+1,0
for i in range(1,N):
if S1[i-1]>0:
if S1[i-1]+A[i]<0:
S1.append(S1[i-1]+A[i])
elif S1[i-1]+A[i]>=0:
S1.append(-1)
a1+=S1[i-1]+A[i]+1
elif S1[i-1]<0:
if S1[i-1]+A[i]>0:
S1.append(S1[i-1]+A[i])
elif S1[i-1]+A[i]<=0:
S1.append(-1)
a1+=-S1[i-1]-A[i]+1
if S2[i-1]>0:
if S2[i-1]+A[i]<0:
S2.append(S2[i-1]+A[i])
elif S2[i-1]+A[i]>=0:
S2.append(-1)
a2+=S2[i-1]+A[i]+1
elif S2[i-1]<0:
if S2[i-1]+A[i]>0:
S2.append(S2[i-1]+A[i])
elif S2[i-1]+A[i]<=0:
S2.append(-1)
a2+=-S2[i-1]-A[i]+1
print(min(a1,a2)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python2 | # -*- coding:utf-8 -*-
n = int(raw_input())
numlist = (raw_input()).split(' ')
sumlist = [int(numlist[0])]
count = 0
for i in range(1, n):
sumlist.append(sumlist[i-1] + int(numlist[i]))
while (True):
if (sumlist[i-1] > 0 and sumlist[i] > 0): #i-1,i番目までのsumがともに正
#numlist[i] = int(numlist[i]) - 1
count += sumlist[i] + 1
sumlist[i] = -1
elif (sumlist[i-1] < 0 and sumlist[i] < 0): #i-1,i番目までのsumがともに負
#numlist[i] = int(numlist[i]) + 1
count += (-1)*sumlist[i] + 1
sumlist[i] = 1
elif (sumlist[i] == 0): #i番目までのsum=0
if (sumlist[i-1] > 0):
#numlist[i] = int(numlist[i]) - 1
sumlist[i] -= 1
if (sumlist[i-1] < 0):
#numlist[i] = int(numlist[i]) + 1
sumlist[i] += 1
count += 1
else:
break
print count
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int mod = 1e9 + 7;
long long a[N];
int n;
int slove(long long f) {
long long sum = 0, ans = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
if (sum * f <= 0) {
ans += abs(f - sum);
sum = f;
}
f = -f;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long ans = min(slove(1), slove(-1));
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #define MOD 1000000007
#if 1
//------------------------------------------------------------
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct Entry { static void Run() { T().Run(); } };
struct MyMain;
#if defined(TEST)
#include "test.hpp"
extern istream& mis;
extern ostream& mos;
#else
istream& mis = cin;
ostream& mos = cout;
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(16);
Entry<MyMain>::Run();
return 0;
}
#endif
//------------------------------------------------------------
using ll = long long;
#define int ll
#define FOR(i, s, e) for (ll i = ll(s); i < ll(e); ++i)
#define RFOR(i, s, e) for (ll i = ll(e) - 1; i >= ll(s); --i)
#define REP(i, n) for (ll i = 0, i##_size = ll(n); i < i##_size; ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define INF INT64_MAX
//------------------------------------------------------------
template <class T>
struct arr : public vector<T> {
arr() {}
arr(initializer_list<T> il) : vector<T>(il) {}
explicit arr(ll n, T v = T()) : vector<T>(n, v) {}
T& operator()(int i) { return (*this)[i]; }
T const& operator()(int i) const { return (*this)[i]; }
void init(ll n, T v = T()) {
this->clear();
this->resize(n, v);
}
ll sz() const { return (ll)this->size(); }
void pb(T v) { this->push_back(v); }
void sort() { std::sort(this->begin(), this->end()); }
void sort(function<bool(T, T)> p) { std::sort(this->begin(), this->end(), p); }
void rsort() { std::sort(this->begin(), this->end(), greater<T>()); }
void reverse() { std::reverse(this->begin(), this->end()); }
void unique_erase() { this->erase(std::unique(this->begin(), this->end()), this->end()); }
bool next_permutation() { return std::next_permutation(this->begin(), this->end()); }
// これ以下はソート済み前提
int lower_bound(T const& v, function<bool(T, T)> p) { return std::lower_bound(this->begin(), this->end(), v, p) - this->begin(); }
int lower_bound(T const& v) { return std::lower_bound(this->begin(), this->end(), v) - this->begin(); }
int upper_bound(T const& v, function<bool(T, T)> p) { return std::upper_bound(this->begin(), this->end(), v, p) - this->begin(); }
int upper_bound(T const& v) { return std::upper_bound(this->begin(), this->end(), v) - this->begin(); }
int find_nearest(T const& v) {
int i = this->lower_bound(v);
if (i >= sz()) {
--i;
}
else if ((*this)[i] != v) {
int p = i - 1;
if (p >= 0) {
int id = abs((*this)[i] - v);
int pd = abs((*this)[p] - v);
if (pd < id) {
i = p;
}
}
}
return i;
}
// 見つからなければ-1
int find(T const& v) {
int i = this->lower_bound(v);
if (i >= sz()) {
return -1;
}
if ((*this)[i] != v) {
return -1;
}
return i;
}
};
using ints = arr<ll>;
template <class T>
struct que : public queue<T> {
ll sz() const { return (ll)this->size(); }
T popfront() {
T v = this->front();
this->pop();
return v;
}
};
template <class A, class B>
struct pr {
union {
A a;
A key;
A first;
A x;
};
union {
B b;
B value;
B second;
B y;
};
pr() : a(A()), b(B()) {};
pr(A a_, B b_) : a(a_), b(b_) {}
pr(pr const& r) : a(r.a), b(r.b) {};
pr(pair<A, B> const& r) : a(r.first), b(r.second) {};
bool operator == (pr const& r) const { return a == r.a && b == r.b; }
bool operator != (pr const& r) const { return !((*this) == r); }
bool operator < (pr const& r) const {
if (a == r.a) {
return b < r.b;
}
return a < r.a;
}
pr operator + (pr v) const { return pr(x, y) += v; }
pr operator - (pr v) const { return pr(x, y) -= v; }
pr& operator += (pr v) {
x += v.x;
y += v.y;
return *this;
}
pr& operator -= (pr v) {
x -= v.x;
y -= v.y;
return *this;
}
void flip() { swap(x, y); }
friend istream& operator>>(istream& is, pr& p) {
is >> p.a >> p.b;
return is;
}
friend ostream& operator<<(ostream& os, pr const& p) {
os << p.a << " " << p.b;
return os;
}
};
using pint = pr<ll, ll>;
using pints = arr<pint>;
template <class A, class B, class C>
struct tr {
union {
A a;
A first;
A x;
};
union {
B b;
B second;
B y;
};
union {
C c;
C third;
C z;
};
tr() : a(A()), b(B()), c(C()) {};
tr(A a_, B b_, C c_) : a(a_), b(b_), c(c_) {}
tr(tr const& r) : a(r.a), b(r.b), c(r.c) {};
bool operator == (tr const& r) const { return a == r.a && b == r.b && c == r.c; }
bool operator != (tr const& r) const { return !((*this) == r); }
bool operator < (tr const& r) const {
if (a == r.a) {
if (b == r.b) {
return c < r.c;
}
return b < r.b;
}
return a < r.a;
}
tr operator + (tr v) const { return tr(x, y, z) += v; }
tr operator - (tr v) const { return tr(x, y, z) -= v; }
tr& operator += (tr v) {
x += v.x;
y += v.y;
z += v.z;
return *this;
}
tr& operator -= (tr v) {
x -= v.x;
y -= v.y;
z -= v.z;
return *this;
}
friend istream& operator>>(istream& is, tr& p) {
is >> p.a >> p.b >> p.c;
return is;
}
friend ostream& operator<<(ostream& os, tr const& p) {
os << p.a << " " << p.b << " " << p.c;
return os;
}
};
using tint = tr<ll, ll, ll>;
using tints = arr<tint>;
template <class K, class V>
struct dic : public map<K, V> {
bool get(K const& k, V* v) {
auto it = this->find(k);
if (it != this->end()) {
*v = it->second;
return true;
}
return false;
}
};
template <class T>
struct arr2 {
vector<vector<T>> m_vec;
int m_width;
int m_height;
arr2() : m_width(0), m_height(0) {}
arr2(int w, int h, T const& value = T()) : m_width(w), m_height(h) {
m_vec.resize(h, vector<T>(w, value));
}
arr2(arr2 const& r) {
m_vec = r.m_vec;
m_width = r.m_width;
m_height = r.m_height;
}
arr2(arr2&& r) {
m_vec = move(r.m_vec);
m_width = r.m_width;
m_height = r.m_height;
}
arr2& operator=(arr2 const& r) {
m_vec = r.m_vec;
m_width = r.m_width;
m_height = r.m_height;
return *this;
}
arr2& operator=(arr2&& r) {
m_vec = move(r.m_vec);
m_width = r.m_width;
m_height = r.m_height;
return *this;
}
bool operator ==(arr2 const& r) const {
return m_vec = r.m_vec;
}
bool operator <(arr2 const& r) const {
if (m_width != r.m_width) {
return m_width < r.m_width;
}
if (m_height != r.m_height) {
return m_height < r.m_height;
}
REP(y, m_height) {
REP(x, m_width) {
if ((*this)(x, y) != r(x, y)) {
return (*this)(x, y) < r(x, y);
}
}
}
return false;
}
pint size() const { return pint(m_width, m_height); }
int width() const { return m_width; }
int height() const { return m_height; }
void init(int w, int h, T const& value = T()) {
m_vec.clear();
m_vec.resize(h, vector<T>(w, value));
m_width = w;
m_height = h;
}
void init(pint size, T const& value = T()) {
init(size.x, size.y, value);
}
T& operator()(int x, int y) { return m_vec[y][x]; }
T const& operator()(int x, int y) const { return m_vec[y][x]; }
T& operator()(pint p) { return m_vec[p.y][p.x]; }
T const& operator()(pint p) const { return m_vec[p.y][p.x]; }
T& operator[](pint p) { return m_vec[p.y][p.x]; }
T const& operator[](pint p) const { return m_vec[p.y][p.x]; }
bool isIn(int x, int y) const {
return
x >= 0 && x < m_width &&
y >= 0 && y < m_height;
}
bool isIn(pint p) const { return isIn(p.x, p.y); }
bool isOut(int x, int y) const {
return
x < 0 || x >= m_width ||
y < 0 || y >= m_height;
}
bool isOut(pint p) const { return isOut(p.x, p.y); }
struct iterator {
private:
arr2<T>* owner;
public:
pint pt;
iterator(arr2<T>* owner_, pint pt_) : owner(owner_), pt(pt_) {}
bool operator ==(iterator const& r) const {
return pt == r.pt;
}
bool operator !=(iterator const& r) const {
return !((*this) == r);
}
void operator++() {
++pt.x;
if (pt.x >= owner->width()) {
++pt.y;
pt.x = 0;
}
}
T& operator*() {
return (*owner)(pt);
}
};
iterator begin() {
return iterator(this, pint(0, 0));
}
iterator end() {
return iterator(this, pint(0, height()));
}
void disp(ostream& os) {
REP(y, m_height) {
REP(x, m_width) {
os << setw(2) << (*this)(x, y) << " ";
}
os << endl;
}
os << endl;
}
};
const pints around4 = { pint(-1, 0), pint(0, -1), pint(1, 0), pint(0, 1) };
//------------------------------------------------------------
template <class T> void chmin(T& a, T b) { if (b < a) { a = b; } }
template <class T> void chmax(T& a, T b) { if (b > a) { a = b; } }
constexpr int gcd(int a, int b) {
if (a < 0) { a = -a; }
if (b < 0) { b = -b; }
if (a == 0) { return b; }
if (b == 0) { return a; }
while (int c = a % b) {
a = b;
b = c;
}
return b;
}
constexpr int lcm(int a, int b) {
return a / gcd(a, b) * b;
}
//------------------------------------------------------------
template <int M>
struct modint {
int raw;
modint() { raw = 0; }
modint(int v) {
if (v < 0) {
raw = (v % M) + M;
}
else if (v >= M) {
raw = v % M;
}
else {
raw = v;
}
}
modint operator + (modint v) const { return modint(raw) += v; }
modint operator - (modint v) const { return modint(raw) -= v; }
modint operator * (modint v) const { return modint(raw) *= v; }
modint& operator += (modint v) {
raw += v.raw;
if (raw >= M) { raw -= M; }
return *this;
}
modint& operator -= (modint v) {
raw -= v.raw;
if (raw < 0) { raw += M; }
return *this;
}
modint& operator *= (modint v) {
raw = (raw * v.raw) % M;
return *this;
}
modint pow(int n) const {
return modint::pow(raw, n);
}
static modint pow(int a, int n) {
if (n < 0) {
// not support
abort();
}
int r = 1;
while (n) {
if (n & 1) {
r = (r * a) % M;
}
a = (a * a) % M;
n >>= 1;
}
return modint(r);
}
modint inv() const {
int a = raw;
int b = M;
int u = 1;
int v = 0;
while (b) {
int t = a / b;
a -= t * b;
u -= t * v;
swap(a, b);
swap(u, v);
}
u %= M;
if (u < 0) {
u += M;
}
return u;
}
friend istream& operator>>(istream& is, modint& m) {
int v;
is >> v;
m = modint(v);
return is;
}
friend ostream& operator<<(ostream& os, modint const& m) {
return os << m.raw;
}
};
using mint = modint<MOD>;
using mints = arr<mint>;
//------------------------------------------------------------
struct OutputStream {
template <class T>
friend OutputStream& operator<<(OutputStream& s, T const& v) {
mos << v << '\n';
return s;
}
} out;
struct PrintStream {
stringstream ss;
template <class T>
friend PrintStream& operator<<(PrintStream& s, T&& v) {
s.ss << v << ' ';
return s;
}
PrintStream& operator <<(PrintStream& (*manip)(PrintStream&)) {
return (*manip)(*this);
}
} prn;
PrintStream& endl(PrintStream& s) {
string str = s.ss.str();
s.ss = stringstream();
if (str.empty() == false) {
str.pop_back();
}
mos << str << '\n';
return s;
}
//------------------------------------------------------------
template <class T>
void input(T& value) {
mis >> value;
}
void input(int& value, int add) {
mis >> value;
value += add;
}
template <class A, class B>
void input(pr<A, B>& value) {
mis >> value.a >> value.b;
}
template <class A, class B>
void input(pr<A, B>& value, int addA, int addB) {
mis >> value.a >> value.b;
value.a += addA;
value.b += addB;
}
template <class A, class B, class C>
void input(tr<A, B, C>& value) {
mis >> value.a >> value.b >> value.c;
}
template <class A, class B, class C>
void input(tr<A, B, C>& value, int addA, int addB, int addC) {
mis >> value.a >> value.b >> value.c;
value.a += addA;
value.b += addB;
value.c += addC;
}
template <class T, class... ARGS>
void input(arr<T>& value, int N, ARGS&&... args) {
value.init(N);
REP(i, N) {
input(value[i], forward<ARGS>(args)...);
}
}
template <class T, class... ARGS>
void input(arr2<T>& value, int H, int W, ARGS&&... args) {
value.init(W, H);
REP(y, H) {
REP(x, W) {
input(value(x, y), forward<ARGS>(args)...);
}
}
}
template <class K, class V, class... ARGS>
void input(dic<K, V>& value, int N, ARGS&&... args) {
REP(i, N) {
pair<K, V> pr;
input(pr.first);
input(pr.second, forward<ARGS>(args)...);
value.insert(pr);
}
}
template <class T>
struct inputHolder {
T value;
template <class... ARGS> inputHolder(ARGS&&... args) {
input(value, forward<ARGS>(args)...);
}
operator T() { return value; }
};
template<class T, class Tuple, size_t... Index>
T MakeFromTupleImpl(Tuple&& t, index_sequence<Index...>) {
return T(get<Index>(forward<Tuple>(t))...);
}
template <class T, class Tuple>
T MakeFromTuple(Tuple&& t) {
return MakeFromTupleImpl<T>(forward<Tuple>(t), make_index_sequence<tuple_size<remove_reference_t<Tuple>>::value>{});
}
template <class... ARGS>
struct inputWithParam {
tuple<ARGS...> param;
inputWithParam() {}
explicit inputWithParam(tuple<ARGS...>&& param_) : param(param_) { }
operator int() { return MakeFromTuple<inputHolder<int>>(param); }
operator double() { return MakeFromTuple<inputHolder<double>>(param); }
operator string() { return MakeFromTuple<inputHolder<string>>(param); }
operator char() { return MakeFromTuple<inputHolder<char>>(param); }
template <class A, class B> operator pr<A, B>() { return MakeFromTuple<inputHolder<pr<A, B>>>(param); }
template <class A, class B, class C> operator tr<A, B, C>() { return MakeFromTuple<inputHolder<tr<A, B, C>>>(param); }
template <class T> operator arr<T>() { return MakeFromTuple<inputHolder<arr<T>>>(param); }
template <class A, class B> operator dic<A, B>() { return MakeFromTuple<inputHolder<dic<A, B>>>(param); }
template <class T> operator arr2<T>() { return MakeFromTuple<inputHolder<arr2<T>>>(param); }
};
struct inputObject {
operator int() { return inputWithParam<>(); }
operator double() { return inputWithParam<>(); }
operator string() { return inputWithParam<>(); }
operator char() { return inputWithParam<>(); }
template <class A, class B> operator pr<A, B>() { return inputWithParam<>(); }
template <class A, class B, class C> operator tr<A, B, C>() { return inputWithParam<>(); }
template <class... ARGS> inputWithParam<ARGS...> operator()(ARGS&&... args) {
inputWithParam<ARGS...> withParam(forward_as_tuple(args...));
return withParam;
}
} in;
//------------------------------------------------------------
#endif
struct MyMain {
int N = in;
ints A = in(N);
void Run() {
int ans = 0;
int s = A[0];
if (s == 0) {
if (A[1] > 0) {
s = -1;
}
else {
s = 1;
}
ans++;
}
FOR(i, 1, N) {
int a = A[i];
if (s < 0) {
int na = max(a, -s+1);
int sub = na - a;
ans += abs(sub);
s += na;
}
else {
int na = min(a, -s - 1);
int sub = na - a;
ans += abs(sub);
s += na;
}
}
out << ans;
}
};
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] nums = new long[n];
for(int i = 0; i < n; i++) {
nums[i] = sc.nextLong();
}
long[] prefixSum = new long[n];
long minCost = 0;
if(nums[0] == 0) {
nums[0] = 1;
minCost = 1 + count(nums);
nums[0] = -1;
minCost = Math.min(minCost, 1 + count(nums));
} else {
minCost = count(nums);
}
System.out.println(minCost);
}
private static long count(long[] nums) {
long cnt = 0;
long prev = nums[0];
long cur = 0;
for(int i = 1; i < nums.length; i++) {
cur = nums[i] + prev;
if(cur * prev < 0) {
prev = cur;
continue;
}
if(prev > 0) {
cnt += cur + 1;
prev = -1;
} else {
cnt += 1 - cur;
prev = 1;
}
}
return cnt;
}
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[200010] = {};
for (long long i = (0); i < (n); i++) cin >> a[i];
bool flag = true;
for (long long i = (0); i < (n - 1); i++) {
a[i + 1] += a[i];
if (a[i + 1] * a[i] >= 0) flag = false;
}
if (flag) {
cout << 0 << endl;
return 0;
}
long long tasu = 0, aa = 0, cnt = 0;
for (long long i = (0); i < (n); i++) {
aa = 0;
if (i % 2 == 0) {
if (a[i] + tasu < 0)
continue;
else if (a[i] + tasu > 0) {
aa = abs(a[i]) + 1;
} else {
aa = 1;
}
cnt += aa;
tasu -= aa;
} else {
if (a[i] + tasu > 0)
continue;
else if (a[i] + tasu < 0) {
aa = abs(a[i]) + 1;
} else {
aa = 1;
}
cnt += aa;
tasu += aa;
}
}
long long cnt2 = 0;
tasu = 0;
for (long long i = (0); i < (n); i++) {
aa = 0;
if (i % 2 != 0) {
if (a[i] + tasu < 0)
continue;
else if (a[i] + tasu > 0) {
aa = abs(a[i]) + 1;
} else {
aa = 1;
}
cnt2 += aa;
tasu -= aa;
} else {
if (a[i] + tasu > 0)
continue;
else if (a[i] + tasu < 0) {
aa = abs(a[i]) + 1;
} else {
aa = 1;
}
cnt2 += aa;
tasu += aa;
}
}
cout << min(cnt, cnt2) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
int32_t sgn(int32_t val) { return (val > 0) - (val < 0); }
int main() {
uint32_t n = 0;
std::cin >> n;
uint32_t op = 0;
int32_t sum = 0;
std::cin >> sum;
for (size_t i = 1; i < n; i++) {
int32_t a_i = 0;
std::cin >> a_i;
if (sgn(sum) * sgn(sum + a_i) != -1) {
int32_t diff = -sgn(sum) - (sum + a_i);
a_i += diff;
op += std::abs(diff);
}
sum += a_i;
}
std::cout << op << std::endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int nums[n];
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
int current = nums[0];
int res = 0;
bool current_positive, val_positive = false;
if (current >= 0)
current_positive = true;
else
current_positive = false;
for (int i = 1; i < n; i++) {
int val = nums[i];
if (val >= 0)
val_positive = true;
else
val_positive = false;
if (current_positive) {
if (val_positive) {
res += ((current + val) + 1);
current = -1;
} else {
if ((current + val) >= 0) {
current += val;
res += (current + 1);
current = -1;
} else {
current += val;
}
}
current_positive = false;
} else {
if (val_positive) {
if ((current + val) <= 0) {
current += val;
res += (abs(current) + 1);
current = 1;
} else {
current += val;
}
} else {
res += ((current + val) + 1);
current = 1;
}
current_positive = true;
}
}
cout << res << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | N = int(input())
a = list(map(int,input().split()))
odd = 0
even = 0
temp = 0
for i in range(N):
temp += a[i]
if i % 2 == 0:
# 奇数番目が正
while temp < 1:
temp += 1
odd += 1
else:
while temp > -1:
temp -= 1
odd += 1
temp = 0
for i in range(N):
temp += a[i]
if i % 2 == 0:
# 奇数番目が負
while temp > -1:
temp -= 1
even += 1
else:
while temp < 1:
temp += 1
even += 1
print(min(odd,even)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a) {
cin >> x;
}
int sum = 0;
int count1 = 0;
int count2 = 0;
for (int i = 0; i < n; i++) {
int i_sum;
i_sum = a.at(i) + sum;
if (i_sum >= 0 && i % 2 == 1) {
sum = -1;
count1 += (i_sum + 1);
} else if (i_sum <= 0 && i % 2 == 0) {
sum = 1;
count1 += (-1) * (i_sum - 1);
} else {
sum = i_sum;
}
}
sum = 0;
for (int i = 0; i < n; i++) {
int i_sum;
i_sum = a.at(i) + sum;
if (i_sum >= 0 && i % 2 == 0) {
sum = -1;
count2 += (i_sum + 1);
} else if (i_sum <= 0 && i % 2 == 1) {
sum = 1;
count2 += (-1) * (i_sum - 1);
} else {
sum = i_sum;
}
}
int count;
count = min(count1, count2);
cout << count << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | l = int(input())
n = [int(i) for i in input().split()]
ans = []
ans.append(n[0])
count = 0
for i in range(1, l):
while(True):
if (n[i-1] < 0 and n[i] <= 0) or (n[i-1] > 0 and n[i] >= 0) or (sum(n[j] for j in range(0, i)) == 0) or (sum(n[j] for j in range(0, i)) * sum(n[j] for j in range(0, i+1)) >= 0):
if n[i-1] < 0:
count += 1
n[i] += 1
else:
count += 1
n[i] -= 1
else:
ans.append(n[i])
break
print(count) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int sum = 0;
int ans = 0;
for (int i = 0; i < n;) {
if (sum < 0 && sum + a[i] < 0) {
int change = 0;
change += 1 - sum - a[i];
a[i] += change;
ans += change;
}
if (sum > 0 && sum + a[i] > 0) {
int change = 0;
change += -1 - sum - a[i];
a[i] -= change;
ans += change;
}
while ((i < n && sum <= 0 && sum + a[i] > 0) ||
(i < n && sum >= 0 && sum + a[i] < 0)) {
sum += a[i];
i++;
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
long long inf = (1LL << 62);
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> v;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
vector<long long> v2;
for (long long i = 0; i < n; i++) {
if (i == 0) {
v2.push_back(v[i]);
continue;
}
long long a = v2[i - 1] + v[i];
if ((a <= 0 && v2[i - 1] < 0) || (a >= 0 && v2[i - 1] >= 0)) {
if (v[i - 1] < 0) {
ans += abs(a) + 1;
v2.push_back(1);
} else {
ans += abs(a) + 1;
v2.push_back(-1);
}
} else {
v2.push_back(a);
}
}
cout << ans;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using unsi = unsigned;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using db = double;
using plex = complex<double>;
using vs = vector<string>;
template <class T>
inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct aaa {
aaa() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const db EPS = 1e-9;
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
signed main() {
int n;
cin >> n;
int odd{};
int ans{};
int even{};
vector<int> a(n);
for (auto i = 0; i != n; ++i) {
cin >> a.at(i);
}
if (a[0] < 0) {
for (auto i = 0; odd < n; ++i) {
odd = 2 * i + 1;
while (a[odd] <= 0 && odd < n) {
++a[odd];
++ans;
}
}
for (auto i = 1; even < n; ++i) {
even = 2 * i;
while (a[even] >= 0 && even < n) {
--a[even];
++ans;
}
}
} else if (a[0] >= 0) {
if (a[0] == 0) {
++a[0];
++ans;
}
for (auto i = 0; odd < n; ++i) {
odd = 2 * i + 1;
while (a[odd] >= 0 && odd < n) {
--a[odd];
++ans;
}
}
for (auto i = 1; even < n; ++i) {
even = 2 * i;
while (a[even] <= 0 && even < n) {
++a[even];
++ans;
}
}
}
cout << ans;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | import algorithm, tables, sets, lists, intsets, critbits, sequtils, strutils, math, future
var
N:int = stdin.readLine.parseInt
A = stdin.readLine.split.map(parseInt)
ans:int = 0
now:int = A[0]
proc dist(a, b:int):int =
if a > b:
return abs(a - b)
else:
return abs(b - a)
for i in 1..<N:
if now < 0:
if now + A[i] <= 0:
var v = -now + 1
ans += dist(now, A[i])
A[i] = v
now += A[i]
elif now > 0:
if now + A[i] >= 0:
var v = -now - 1
ans += dist(now, A[i])
A[i] = v
now += A[i]
echo ans |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
int dx[] = {0, 1, -1, 0, 1, -1, 1, -1};
int dy[] = {1, 0, 0, -1, 1, -1, -1, 1};
int main() {
int n;
cin >> n;
vector<int> v(n + 1, 0), w(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> v[i];
int ans = 0;
for (int i = 1; i <= n; i++) {
w[i] = w[i - 1] + v[i];
if (w[i - 1] > 0 && w[i] > 0) {
ans += v[i] + 1;
v[i] = v[i] - (v[i] + 1);
w[i] = w[i - 1] + v[i];
} else if (w[i - 1] < 0 && w[i] < 0) {
ans += abs(v[i]) + 1;
v[i] = v[i] + abs(v[i]) + 1;
w[i] = w[i - 1] + v[i];
} else if (w[i] == 0 && w[i - 1] < 0) {
ans++;
v[i]++;
w[i]++;
} else if (w[i] == 0 && w[i - 1] > 0) {
ans++;
v[i]--;
w[i]--;
}
}
int sum = accumulate(v.begin(), v.end(), 0);
if (sum == 0) ans++;
cout << ans << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | import algorithm, tables, sets, lists, intsets, critbits, sequtils, strutils, math, future
var
N:int = stdin.readLine.parseInt
A = stdin.readLine.split.map(parseInt)
proc dist(a, b:int):int =
if a > b:
return abs(a - b)
else:
return abs(b - a)
proc solve(L:seq[int]):int =
var
ans:int = 0
A = L
now = A[0]
for i in 1..<N:
if now < 0:
if now + A[i] <= 0:
var v = -now + 1
ans += dist(v, A[i])
A[i] = v
now += A[i]
elif now > 0:
if now + A[i] >= 0:
var v = -now - 1
ans += dist(v, A[i])
A[i] = v
now += A[i]
# echo A
return ans
var a1 = solve(A)
var tmp:int
if A[0] > 0:
tmp = A[0] + 1
A[0] = -1
else:
tmp = abs(A[0]) + 1
A[0] = 1
var a2 = solve(A) + tmp
echo min(a1, a2) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
a = list(map(int, input().split()))
#具体的な操作を考える必要はなくて，ただ部分和をひたすら考えていけばいい
answer1 = 0
answer2 = 0
sum1 = a[0]
sum2 = a[0]
# pmpm...
for i in range(1,n):
sum1 += a[i]
if i % 2 == 1:
if sum1 >= 0:
answer1 += sum1 - (-1)
sum1 = -1
if i % 2 == 0:
if sum1 <= 0:
answer1 += 1 - sum1
sum1 = 1
# mpmp...
for i in range(1,n):
sum2 += a[i]
if i % 2 == 0:
if sum2 >= 0:
answer2 += sum2 - (-1)
sum2 = -1
if i % 2 == 1:
if sum2 <= 0:
answer2 += 1 - sum2
sum2 = 1
print(min(answer1, answer2)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
long long int count = 0;
long long int sum = 0;
bool p = false;
bool plus = true;
for (int i = 0; i < (n); i++) {
sum += a[i];
if (!p && a[i] == 0) {
count++;
} else if (!p && a[i] > 0) {
plus = true;
p = true;
} else if (!p && a[i] < 0) {
plus = false;
p = true;
} else if (!plus && sum >= 0) {
count += sum - (-1);
sum = -1;
} else if (plus && sum <= 0) {
count += 1 - sum;
sum = 1;
}
plus = !plus;
}
cout << count << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
list_a = list(map(int,input().split()))
i = 0
k = 0
count = 0
if list_a[0] == 0:
while list_a[i] == 0:
if i == n:
ans = 2*n -1
break
k = i
i += 1
else:
if list_a[k+1] > 0:
count += abs(list_a[0] - (-1) ** (k+1))
list_a[0] = (-1) ** (k+1)
else:
count += abs(list_a[0] - (-1) ** k)
list_a[0] = (-1) ** k
ans = list_a[0]
if list_a[0] > 0:
for i in range(1,n):
ans += list_a[i]
if ans / ((-1) ** i) <= 0:
count += abs(ans - (-1) ** i)
ans = (-1) ** i
else:
for i in range(1,n):
ans += list_a[i]
if ans / ((-1) ** (i+1)) <= 0:
count += abs(ans - (-1) ** (i+1))
ans = (-1) ** (i+1)
print(count)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
int main(int argc, char const* argv[]) {
uint64_t n;
std::cin >> n;
int64_t sum, current;
std::cin >> current;
sum = current;
bool is_sum_negative = sum < 0;
uint64_t result = 0;
for (int i = 1; i < n; ++i) {
std::cin >> current;
sum += current;
auto tmp = std::abs(sum) + 1;
if (is_sum_negative) {
if (sum <= 0) {
sum += tmp;
result += tmp;
assert(sum == 1);
}
} else {
if (sum >= 0) {
sum -= tmp;
result += tmp;
assert(sum == -1);
}
}
is_sum_negative = !is_sum_negative;
}
std::cout << result << std::endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define int long long
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
int a[n];
rep(i, n) cin >> a[i];
int ans1 = 0, ans2 = 0;
int sum1 = 0, sum2 = 0;
rep(i, n) {
sum1 += a[i];
sum2 += a[i];
if (i % 2 == 0) {
ans1 += max(0, -sum1 + 1);
ans2 += max(0, sum2+ 1);
sum1 += max(0, -sum1 + 1);
sum2 -= max(0, sum2 + 1);
}
else {
ans1 += max(0, sum1 + 1);
ans2 += max(0, -sum2 + 1);
sum1 -= max(0, sum1 + 1);
sum2 += max(0, -sum2 + 1);
}
//cout << sum1 << " " << sum2 << endl;
}
cout << min(ans1, ans2) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | N = int(input())
a = list(map(int, input().split()))
ans = 1000000000000000
tmp_ans = 0
cum_sum = a[0]
for i in range(1, N):
#print(i, tmp_ans)
prev_cum_sum = cum_sum
cum_sum += a[i]
if cum_sum * prev_cum_sum >= 0:
tmp_ans += abs(cum_sum) + 1
if prev_cum_sum > 0:
cum_sum = -1
else:
cum_sum = 1
print(tmp_ans) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count1 = 0;
int count2 = 0;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
long long sum = a[0];
if (a[0] >= 0) {
for (int i = 1; i < n; i++) {
sum += a[i];
if (i % 2 == 1) {
while (sum >= 0) {
sum--;
count1++;
}
} else {
while (sum <= 0) {
sum++;
count1++;
}
}
}
} else {
for (int i = 1; i < n; i++) {
sum += a[i];
if (i % 2 == 0) {
while (sum >= 0) {
sum--;
count1++;
}
} else {
while (sum <= 0) {
sum++;
count1++;
}
}
}
}
if (a[0] >= 0) {
while (a[0] >= 0) {
a[0]--;
count2++;
}
} else {
while (a[0] <= 0) {
a[0]++;
count2++;
}
}
if (a[0] >= 0) {
for (int i = 1; i < n; i++) {
sum += a[i];
if (i % 2 == 1) {
while (sum >= 0) {
sum--;
count2++;
}
} else {
while (sum <= 0) {
sum++;
count2++;
}
}
}
} else {
for (int i = 1; i < n; i++) {
sum += a[i];
if (i % 2 == 0) {
while (sum >= 0) {
sum--;
count2++;
}
} else {
while (sum <= 0) {
sum++;
count2++;
}
}
}
}
if (count1 >= count2)
cout << count2 << endl;
else
cout << count1 << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | # -*- coding: utf-8 -*-
"""
Created on Sat Sep 8 15:51:53 2018
@author: maezawa
"""
def f(n, a0, cnt, sa, sign):
a = a0[:]
if sign == -1:
cnt += abs(a[0])+1
a[0] = -a[0]/abs(a[0])
for i in range(n-1):
sa += a[i]
na = -sa//abs(sa)*(abs(sa)+1)
if abs(a[i+1]) > abs(na) and a[i+1]*na > 0:
continue
else:
cnt += abs(na-a[i+1])
a[i+1] = na
return cnt
n = int(input())
a = list(map(int, input().split()))
sa = 0
cnt = 0
cnt0 = f(n, a, 0, 0, -1)
cnt1 = f(n, a, 0, 0, 1)
cnt = min([cnt0,cnt1])
print(cnt)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
long long ans = INF;
long long sum = 0;
long long count = 0;
for (int i = 0; i < (n); i++) {
sum += a[i];
if (i % 2 == 0) {
if (sum < 1) {
count += (1 - sum);
sum = 1;
}
} else {
if (sum > -1) {
count += (sum - (-1));
sum = -1;
}
}
}
ans = min(ans, count);
sum = 0;
count = 0;
for (int i = 0; i < (n); i++) {
sum += a[i];
if (i % 2 != 0) {
if (sum < 1) {
count += (1 - sum);
sum = 1;
}
} else {
if (sum > -1) {
count += (sum - (-1));
sum = -1;
}
}
}
ans = min(ans, count);
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int64_t n;
int64_t i;
int64_t sum;
bool default_flag;
bool plus_flag, minus_flag;
int64_t ope_count;
cin >> n;
vector<int64_t> a(n);
for (i = 0; i < n; i++) {
cin >> a.at(i);
}
sum = 0;
ope_count = 0;
default_flag = true;
plus_flag = false;
minus_flag = false;
for (i = 0; i < n; i++) {
sum += a.at(i);
if (default_flag == true) {
default_flag = false;
if (a.at(i + 1) >= 0) {
while (sum >= 0) {
ope_count++;
sum--;
}
minus_flag = true;
} else if (a.at(i + 1) < 0) {
while (sum <= 0) {
ope_count++;
sum++;
}
plus_flag = true;
}
} else if (plus_flag == true) {
while (sum >= 0) {
ope_count++;
sum--;
}
plus_flag = false;
minus_flag = true;
} else if (minus_flag == true) {
while (sum <= 0) {
ope_count++;
sum++;
}
plus_flag = true;
minus_flag = false;
}
}
cout << ope_count << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
def read_h(typ=int):
return list(map(typ, input().split()))
def read_v(n, m=1, typ=int):
return [read_h() if m > 1 else typ(input()) for _ in range(n)]
def calc_num_op(cumul, a):
tmp_cumul = cumul + a
# print('current cumul:', cumul)
# print('current a:', a)
# print('bare cumul:', tmp_cumul)
# print('goodiness:', tmp_cumul != 0 and cumul // abs(cumul) != tmp_cumul // abs(tmp_cumul))
if (cumul <= 0 and tmp_cumul <= 0):
return abs(-cumul - a + 1), 1
if (cumul >= 0 and tmp_cumul >= 0):
return abs(-cumul - a - 1), -1
return 0, tmp_cumul
def solve(arr, sign):
num_op = 0
cumul = arr[0]
print('current cumul:', cumul)
if cumul == 0:
num_op += 1
cumul += 1 if sign == '+' else -1
# print('modified cumul:', cumul)
for a in arr[1:]:
delta, cumul = calc_num_op(cumul, a)
# print('delta:', delta)
# print('modified cumul:', cumul)
num_op += delta
return num_op
def main():
_ = read_h()
arr = read_h()
op_plus = solve(arr, '+')
# print('op plus:', op_plus)
op_minus = solve(arr, '-')
# print('op minus:', op_minus)
print(min(op_plus, op_minus))
if __name__ == '__main__':
main()
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | import copy
n = int(input())
a = [int(i) for i in input().split()]
b=a.copy()
s0p = a[0]
s0n = b[0]
countp = 0
countn = 0
if a.count(0)==n:
print(2*n+1)
exit()
if s0p<=0:
while s0p<=0:
s0p+=1
countp+=1
if s0n>=0:
while s0n>=0:
s0n-=1
countn+=1
for i in range(1,n):
s1 = s0p+a[i]
if s0p*s1>=0:
if s1>0:
a[i]-=(abs(s1)+1)
countp+=(abs(s1)+1)
elif s1<0:
a[i]+=(abs(s1)+1)
countp+=(abs(s1)+1)
elif s1==0:
if s0p>0:
a[i]-=1
countp+=1
elif s0p<0:
a[i]+=1
countp+=1
s0p += a[i]
for i in range(1,n):
s1 = s0n+b[i]
if s0n*s1>=0:
if s1>0:
b[i]-=(abs(s1)+1)
countn+=(abs(s1)+1)
elif s1<0:
b[i]+=(abs(s1)+1)
countn+=(abs(s1)+1)
elif s1==0:
if s0n>0:
b[i]-=1
countn+=1
elif s0n<0:
b[i]+=1
countn+=1
s0n += b[i]
print(countp if countp<=countn else(countn))
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int sum = a[0], count = 0;
for (int i = 1; i < n; i++) {
if (sum > 0) {
while (sum + a[i] >= 0) {
a[i]--;
count++;
}
} else {
while (sum + a[i] <= 0) {
a[i]++;
count++;
}
}
sum += a[i];
}
cout << count << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int a[100010];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int tmp = -1;
int flagg = 0;
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
tmp = i;
flagg = 1;
break;
}
}
if (!flagg) {
printf("%d\n", (n - 1) * 2 + 1);
continue;
}
if (tmp != 0 && a[tmp] > 0) {
if (tmp % 2)
a[0] = -1;
else
a[0] = 1;
sum++;
} else if (tmp != 0 && a[tmp] < 0) {
if (tmp % 2)
a[0] = 1;
else
a[0] = -1;
sum++;
}
long long oo = a[0], flag;
if (a[0] > 0)
flag = 1;
else if (a[0] < 0)
flag = -1;
for (int i = 1; i < n; i++) {
oo += a[i];
if (flag == 1) {
if (oo >= 0) {
sum += oo + 1;
oo = -1;
}
flag = -1;
} else if (flag == -1) {
if (oo <= 0) {
sum += 0 - oo + 1;
oo = 1;
}
flag = 1;
}
}
printf("%lld\n", sum);
}
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const double pi = acos(-1.0);
int main(void) {
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < (n); ++i) cin >> a[i];
long long ans = 0, sum = 0;
for (int i = 0; i < (n); ++i) {
sum += a[i];
if (i % 2 == 0) {
if (sum <= 0) {
ans += abs(1 - sum);
sum = 1;
} else {
if (sum >= 0) {
ans += sum + 1;
sum = -1;
}
}
}
}
long long tmp = 0;
sum = 0;
for (int i = 0; i < (n); ++i) {
sum += a[i];
if (i % 2 == 1) {
if (sum <= 0) {
tmp += abs(1 - sum);
sum = 1;
} else {
if (sum >= 0) {
tmp += sum + 1;
sum = -1;
}
}
}
}
ans = min(ans, tmp);
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | UNKNOWN | p :: Int -> Int -> [Int] -> Int
p n x (y:[])
| x + y >= 0 = n+x+y+1
| otherwise = n
p n x (y:ys)
| x + y >= 0 = m (n+x+y+1) (-1) ys
| otherwise = m n (x+y) ys
m :: Int -> Int -> [Int] -> Int
m n x (y:[])
| x + y <= 0 = n-(x+y)+1
| otherwise = n
m n x (y:ys)
| x + y <= 0 = p (n-(x+y)+1) 1 ys
| otherwise = p n (x+y) ys
solve :: [Int] -> Int
solve (x:xs)
| x > 0 = p 0 x xs
| x < 0 = m 0 x xs
| x == 0 = min (p 1 (x+1) xs) (m 1 (x-1) xs)
main = getContents >>= print . solve . map read . words . last . lines |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
int i;
long int a[n], su, cnt, cnt2, cnt3, cnt4;
cnt = 0;
cnt2 = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
su = 0;
for (i = 0; i < n; i++) {
su += a[i];
if (a[0] >= 0) {
if (i % 2 == 0) {
if (su <= 0) {
cnt += 1 - su;
su = 1;
}
} else {
if (su >= 0) {
cnt += su + 1;
su = -1;
}
}
} else {
if (i % 2 == 0) {
if (su >= 0) {
cnt += su + 1;
su = -1;
}
} else {
if (su <= 0) {
cnt += 1 - su;
su = 1;
}
}
}
}
su = 0;
for (i = 0; i < n; i++) {
su += a[i];
if (a[0] > 0) {
if (i % 2 == 0) {
if (su <= 0) {
cnt2 += 1 - su;
su = 1;
}
} else {
if (su >= 0) {
cnt2 += su + 1;
su = -1;
}
}
} else {
if (i % 2 == 0) {
if (su >= 0) {
cnt2 += su + 1;
su = -1;
}
} else {
if (su <= 0) {
cnt2 += 1 - su;
su = 1;
}
}
}
}
su = 0;
for (i = 0; i < n; i++) {
su += a[i];
if (a[0] <= 0) {
if (i % 2 == 0) {
if (su <= 0) {
cnt3 += 1 - su;
su = 1;
}
} else {
if (su >= 0) {
cnt3 += su + 1;
su = -1;
}
}
} else {
if (i % 2 == 0) {
if (su >= 0) {
cnt3 += su + 1;
su = -1;
}
} else {
if (su <= 0) {
cnt3 += 1 - su;
su = 1;
}
}
}
}
su = 0;
for (i = 0; i < n; i++) {
su += a[i];
if (a[0] < 0) {
if (i % 2 == 0) {
if (su <= 0) {
cnt4 += 1 - su;
su = 1;
}
} else {
if (su >= 0) {
cnt4 += su + 1;
su = -1;
}
}
} else {
if (i % 2 == 0) {
if (su >= 0) {
cnt4 += su + 1;
su = -1;
}
} else {
if (su <= 0) {
cnt4 += 1 - su;
su = 1;
}
}
}
}
cout << min(min(cnt, cnt2), min(cnt3, cnt4)) << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
A = list(map(int, input().split()))
prev = A[0]
cnt = 0
for i in range(1, n):
#print("prev", prev)
if prev > 0:
if prev + A[i] > 0:
cnt += abs(prev + A[i]) + 1
prev = -1
elif prev + A[i] == 0:
cnt += 1
prev = -1
else:
prev += A[i]
elif prev < 0:
if prev + A[i] < 0:
cnt += abs(prev + A[i]) + 1
prev = 1
elif prev + A[i] == 0:
cnt += 1
prev = 1
else:
prev += A[i]
#print("iter, cur#, adjust, sum til cur#", i, A[i], cnt, prev)
print(cnt) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <iostream>
#include <cassert>
#include <queue>
#define INF 922337203685477580
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
ll a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll op = 0LL;
ll sum = 0LL;
sum = a[i];
for (int i = 1; i < n; i++) {
ll a;
cin >> a;
if (!(sum * (sum + a) < 0)) {
ll tmp_a = sum < 0 ? abs(sum) + 1 : -1 *(abs(sum) + 1);
op += abs(tmp_a - a);
sum = sum + tmp_a;
} else {
sum += a;
}
}
ll op_m = op;
if (a[0] > 0) {
sum = -1;
op = a[0] + 1;
} else {
sum = 1;
op = -1 * a[0] + 1;
}
for (int i = 1; i < n; i++) {
ll a;
cin >> a;
if (!(sum * (sum + a) < 0)) {
ll tmp_a = sum < 0 ? abs(sum) + 1 : -1 *(abs(sum) + 1);
op += abs(tmp_a - a);
sum = sum + tmp_a;
} else {
sum += a;
}
}
op = min(op, op_m);
cout << op << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | n = int(input())
A = list(map(int, input().split()))
cnt = 0
sum_a = 0
for i, a in enumerate(A):
sum_a += a
if i % 2 == 0 and sum_a <= 0:
sum_a += abs(sum_a) + 1
cnt += abs(sum_a) + 1
elif i % 2 == 1 and sum_a >= 0:
sum_a -= abs(sum_a) + 1
cnt += abs(sum_a) + 1
if A[0] < 0:
cnt -= abs(A[0]) + 1
print(cnt)
else:
print(cnt)
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a[100001], ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; a[i] == 0; ++i) {
ans = 2 * (i + 1) - 1;
x = i + 1;
}
int sum1 = a[x], sum2 = a[x];
for (int i = x + 1; i < n; i++) {
sum2 += a[i];
if (sum2 >= 0 && sum1 > 0) {
ans += abs(sum2) + 1;
a[i] = a[i] - abs(sum2) - 1;
sum2 = sum2 - abs(sum2) - 1;
}
if (sum2 <= 0 && sum1 < 0) {
ans += abs(sum2) + 1;
a[i] = a[i] + abs(sum2) + 1;
sum2 = sum2 + abs(sum2) + 1;
}
sum1 = sum2;
cout << i << " " << ans << endl;
}
cout << ans << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
string flag;
vector<int> a;
int str;
long long str_sum = 0, str_nsum = 0;
int num;
vector<int> co;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> num;
for (int i = 0; i < num; i++) {
cin >> str;
a.push_back(str);
}
if (a[0] > 0) {
flag = "up";
} else if (a[0] < 0) {
flag = "down";
} else {
if (a[1] >= 0) {
flag = "down";
co.push_back(1);
a[0] = -1;
} else {
flag = "up";
co.push_back(1);
a[0] = 1;
}
}
str_sum = a[0];
for (int i = 1; i < num; i++) {
str_sum += a[i];
if (flag == "up" && str_sum >= 0) {
for (int j = 0; j < str_sum + 1; j++) {
co.push_back(1);
}
str_sum -= str_sum + 1;
} else if (flag == "down" && str_sum <= 0) {
for (int j = 0; j < 0 - str_sum + 1; j++) {
co.push_back(1);
}
str_sum += 0 - str_sum + 1;
}
if (str_sum > 0) {
flag = "up";
} else if (str_sum < 0) {
flag = "down";
}
}
cout << co.size() << "\n";
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int f(vector<int> a, int sign) {
int ans = 0;
if (sign > 0 && a.at(0) <= 0) {
ans += -a.at(0) + 1;
a.at(0) += -a.at(0) + 1;
} else if (sign < 0 && a.at(0) >= 0) {
ans += a.at(0) + 1;
a.at(0) -= a.at(0) + 1;
}
int sum = a.at(0);
for (int i = 1; i < a.size(); i++) {
if (sum > 0) {
if (a.at(i) + sum >= 0) {
ans += a.at(i) + sum + 1;
a.at(i) -= a.at(i) + sum + 1;
}
} else if (sum < 0) {
if (a.at(i) + sum <= 0) {
ans += -(a.at(i) + sum - 1);
a.at(i) += -(a.at(i) + sum - 1);
}
}
sum += a.at(i);
}
return ans;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
cout << min(f(a, 1), f(a, -1));
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.util.Scanner;
class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int N=sc.nextInt();
long[] k=new long[N];
for(int i=0; i<N; i++) {
k[i]=sc.nextLong();
}
for(int i=1; i<N; i++) {
k[i]=k[i-1]+k[i];
}
long counter=0;
if(k[0]>0) {
counter=1;
}
else {
counter=-1;
}
long[] tasu=new long[N];
long kaz=0;
for(int i=0; i<N; i++) {
tasu[i]=0;
}
for(int i=0; i<N; i++) {
long tmp=counter*(k[i]+tasu[i]);
if(tmp>0) {
//条件を満たすのでOK
}
else if(tmp<0){
if((k[i]+tasu[i])>0) {
long tt=(k[i]+tasu[i])+1;
kaz+=tt;
tasu[i]-=tt;
}
else if((k[i]+tasu[i])<0) {
long tt=((k[i]+tasu[i])-1)*-1;
kaz+=tt;
tasu[i]+=tt;
}
}
else if(tmp==0) {
if(counter==-1) {
tasu[i]--;
}
else if(counter==1) {
tasu[i]++;
}
kaz++;
}
if(i!=N-1) {
tasu[i+1]=tasu[i];
}
counter*=-1;
}
long m_kaz=0;
if(k[0]>0) {
counter=-1;
}
else {
counter=1;
}
for(int i=0; i<N; i++) {
long tmp=counter*(k[i]+tasu[i]);
if(tmp>0) {
//条件を満たすのでOK
}
else if(tmp<0){
if((k[i]+tasu[i])>0) {
long tt=(k[i]+tasu[i])+1;
m_kaz+=tt;
tasu[i]-=tt;
}
else if((k[i]+tasu[i])<0) {
long tt=((k[i]+tasu[i])-1)*-1;
m_kaz+=tt;
tasu[i]+=tt;
}
}
else if(tmp==0) {
if(counter==-1) {
tasu[i]--;
}
else if(counter==1) {
tasu[i]++;
}
m_kaz++;
}
if(i!=N-1) {
tasu[i+1]=tasu[i];
}
counter*=-1;
}
System.out.println(Math.min(kaz,m_kaz));
}
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | java | import java.io.*;
import java.util.*;
class Main{
void solve(){
int N = ni();
long[] a = new long[N];
long[] s = new long[N + 1];
for(int i = 0; i < N; i++){
a[i] = ni();
}
for(int i = 1; i <= N ; i++){
s[i] = s[i - 1] + a[i - 1];
}
long pattern1 = 0;
long control = 0;
for(int i = 1; i <= N; i++){
if(i % 2 == 1){ // 正
if(s[i] + control <= 0){
pattern1 += Math.abs(s[i] + control) + 1;
control = Math.abs(s[i] + control) + 1;
}
} else { // 負
if(s[i] + control >= 0){
pattern1 += Math.abs(s[i] + control) + 1;
control = -1 * (Math.abs(s[i] + control) + 1);
}
}
}
long pattern2 = 0;
control = 0;
for(int i = 1; i <= N; i++){
if(i % 2 == 0){ // 正
if(s[i] + control <= 0){
pattern2 += Math.abs(s[i] + control) + 1;
control = Math.abs(s[i] + control) + 1;
}
} else { // 負
if(s[i] + control >= 0){
pattern2 += Math.abs(s[i] + control) + 1;
control = -1 * (Math.abs(s[i] + control) + 1);
}
}
}
out.println(min(pattern1, pattern2));
out.flush();
}
public static void main(String[] args){
Main m = new Main();
m.solve();
}
Main(){
this.scan = new FastScanner();
this.out = new PrintWriter(System.out);
}
private FastScanner scan;
private PrintWriter out;
private final int MOD = 1_000_000_007;
private final int INF = 2_147_483_647;
private final long LINF = 9223372036854775807L;
private long[] fac;
private long[] finv;
private long[] inv;
// Scanner
int ni(){ return scan.nextInt();}
int[] ni(int n){int[] a = new int[n]; for(int i = 0; i < n; i++){a[i] = ni();} return a;}
int[][] ni(int y, int x){int[][] a = new int[y][x];
for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = ni();}} return a;}
long nl(){return scan.nextLong();}
long[] nl(int n){long[] a = new long[n]; for(int i = 0; i < n; i++){a[i] = nl();} return a;}
long[][] nl(int y, int x){long[][] a = new long[y][x];
for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = nl();}} return a;}
String ns(){return scan.next();}
String[] ns(int n){String[] a = new String[n]; for(int i = 0; i < n; i++){a[i] = ns();} return a;}
String[][] ns(int y, int x){String[][] a = new String[y][x];
for(int i = 0; i < y; i++){for(int j = 0; j < x; j++){a[i][j] = ns();}} return a;}
// Mathematics
int max(int a, int b){return Math.max(a, b);}
long max(long a, long b){return Math.max(a, b);}
double max(double a, double b){return Math.max(a, b);}
int max(int[] a){int max = a[0]; for(int value:a){max = max(max,value);} return max;}
long max(long[] a){long max = a[0]; for(long value:a){max = max(max,value);} return max;}
double max(double[] a){double max = a[0]; for(double value:a){max = max(max,value);} return max;}
int min(int a, int b){return Math.min(a, b);}
long min(long a, long b){return Math.min(a, b);}
double min(double a, double b){return Math.min(a, b);}
int min(int[] a){int min = a[0]; for(int value:a){min = min(min,value);} return min;}
long min(long[] a){long min = a[0]; for(long value:a){min = min(min,value);} return min;}
double min(double[] a){double min = a[0]; for(double value:a){min = min(min,value);} return min;}
long sum(int[] a){long sum = 0; for(int value:a){sum += value;} return sum;}
long sum(long[] a){long sum = 0; for(long value:a){sum += value;} return sum;}
double sum(double[] a){double sum = 0; for(double value:a){sum += value;} return sum;}
long mod(long n) { n %= MOD; return n + (n < 0 ? MOD : 0); }
int gcd(int a, int b){return b == 0 ? a : gcd(b, a % b);}
long gcd(long a, long b){return b == 0 ? a : gcd(b, a % b);}
int lcm(int a, int b){return a / gcd(a, b) * b;}
long lcm(long a, long b){return a / gcd(a, b) * b;}
long fact(int n){ if(n == 0){ return 1; } long a = n; for(long i = n - 1; i >= 2; i--){ a = a % MOD * i; } return a; }
long fact(long n){ if(n == 0){ return 1; } long a = n; for(long i = n - 1; i >= 2; i--){ a = a % MOD * i; } return a; }
// nPr(int)
long npr(int n, int r){
long a = 1;
for(int i = n; i > n - r; i--){
a *= i;
}
return a;
}
// nPr(long)
long npr(long n, long r){
long a = 1;
for(long i = n; i > n - r; i--){
a *= i;
}
return a;
}
// 素数判定(int)
boolean checkPrime(int n){
for(int i = 2; i * i <= n; i++){
if(n % i == 0){
return false;
}
}
return true;
}
// 素数判定(long)
boolean checkPrime(long n){
for(long i = 2; i * i <= n; i++){
if(n % i == 0){
return false;
}
}
return true;
}
// エラトステネスの篩
long[] erathos(int n){
boolean[] flag = new boolean[n + 1];
TreeSet<Integer> nums = new TreeSet<>();
for(int i = 2; i <= n; i++){
if(flag[i]) continue;
nums.add(i);
for(int j = i * 2; j <= n; j += i){
flag[j] = true;
}
}
long[] primes = new long[nums.size()];
int index = 0;
for(int num : nums){
primes[index] = num;
index++;
}
return primes;
}
// mod pにおける累乗 a^n
long modpow(long a, long n, long p){
long res = 1;
while(n > 0){
if((n & 1) == 1){
res = res * a % p;
}
a = a * a % p;
n = n >> 1;
}
return res;
}
// mod pにおけるaの逆元a^-1
long modinv(long a, long p){
return modpow(a, p - 2, p);
}
// fac,finv,invの初期化
void comInit(int max){
fac = new long[max];
finv = new long[max];
inv = new long[max];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < max; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数nCr
long com(int n, int r){
if(n < r || (n < 0 || r < 0)){
return 0;
}
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
// 二項係数nCr（nが10^9など巨大なとき用）
long ncr(long n, long k){
long a = 1;
long b = 1;
for(int i = 1; i <= k; i++){
a = a * (n + 1 - i) % MOD;
b = b * i % MOD;
}
return modinv(b, MOD) * a % MOD;
}
// 二次元上の二点間の距離
double distance(double x1, double y1, double x2, double y2){
double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
return dist;
}
// 三次元上の二点間の距離
double distance(double x1, double y1, double z1, double x2, double y2, double z2){
double dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
return dist;
}
// Array
void sort(int[] a){ Arrays.sort(a);}
void sort(long[] a){ Arrays.sort(a);}
void sort(double[] a){ Arrays.sort(a);}
void sort(String[] a){ Arrays.sort(a);}
int[] reverse(int[] a){
int[] reversed = new int[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
long[] reverse(long[] a){
long[] reversed = new long[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
double[] reverse(double[] a){
double[] reversed = new double[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
char[] reverse(char[] a){
char[] reversed = new char[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
String[] reverse(String[] a){
String[] reversed = new String[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
boolean[] reverse(boolean[] a){
boolean[] reversed = new boolean[a.length];
for(int i = 0; i < a.length; i++){
reversed[a.length - i - 1] = a[i];
}
return reversed;
}
void fill(int[] array, int x) { Arrays.fill(array, x); }
void fill(long[] array, long x) { Arrays.fill(array, x); }
void fill(double[] array, double x) { Arrays.fill(array, x); }
void fill(boolean[] array, boolean x) { Arrays.fill(array, x); }
void fill(int[][] array, int x) { for(int a[] : array) { fill(a, x); } }
void fill(long[][] array, long x) { for(long a[] : array) { fill(a, x); } }
void fill(double[][] array, double x) { for(double a[] : array) { fill(a, x); } }
void fill(boolean[][] array, boolean x) { for(boolean a[] : array) { fill(a, x); } }
void fill(int[][][] array, int x) { for(int[][] ary : array) { for(int[] a : ary){ fill(a, x); } } }
void fill(long[][][] array, long x) { for(long[][] ary : array) { for(long[] a : ary){ fill(a, x); } } }
// Algorithm
// 深さ優先探索
/* void dfs(Node[] nodes, int v, boolean[] seen){
seen[v] = true;
for(Edge edge : nodes[v].edges){
if(seen[edge.to]) continue;
dfs(nodes, edge.to, seen);
}
} */
// 幅優先探索
long[] bfs(Node[] nodes, int start){
Queue<Integer> queue = new ArrayDeque<>();
queue.add(start);
long[] dist = new long[nodes.length];
fill(dist, -1);
dist[start] = 0;
while(!queue.isEmpty()){
int now = queue.poll();
for(Edge edge : nodes[now].edges){
if(dist[edge.to] != -1) continue;
dist[edge.to] = dist[now] + 1;
queue.add(edge.to);
}
}
return dist;
}
// ダイクストラ法
long[] dijkstra(Node[] nodes, int start){
Queue<Edge> queue = new PriorityQueue<>();
long[] dist = new long[nodes.length];
fill(dist, LINF / 2);
dist[start] = 0;
queue.add(new Edge(start, start, dist[start]));
while(!queue.isEmpty()){
Edge now = queue.poll();
if(dist[now.to] < now.cost) continue;
for(Edge edge : nodes[now.to].edges){
if(dist[edge.to] > dist[edge.from] + edge.cost){
dist[edge.to] = dist[edge.from] + edge.cost;
queue.add(new Edge(edge.from, edge.to, dist[edge.to]));
nodes[edge.to].past = edge.from;
}
}
}
return dist;
}
// ソート済みint型配列でkey以上の値の最小indexを返す
int lowerBound(int[] a, int key){
int ng = -1;
int ok = a.length;
while(Math.abs(ok - ng) > 1){
int mid = (ok + ng) / 2;
if(a[mid] >= key){
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
// ソート済みlong型配列でkey以上の値の最小indexを返す
int lowerBound(long[] a, long key){
int ng = -1;
int ok = a.length;
while(Math.abs(ok - ng) > 1){
int mid = (ok + ng) / 2;
if(a[mid] >= key){
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
// 文字列sとtの最長共通部分列の長さを返す
int lcs(String s , String t){
int[][] dp = new int[s.length() + 1][t.length() + 1];
for(int i = 0; i < s.length(); i++){
for(int j = 0; j < t.length(); j++){
if(s.charAt(i) == t.charAt(j)){
dp[i + 1][j + 1] = max(dp[i][j] + 1, dp[i + 1][j + 1]);
}
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i + 1][j]);
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j + 1]);
}
}
return dp[s.length()][t.length()];
}
}
// ノード
class Node{
int id; // ノード番号
int past; // 直前の頂点
List<Edge> edges; // 辺のリスト
Node(int id, int past){
this.id = id;
this.past = past;
this.edges = new ArrayList<>();
}
void addEdge(Edge edge){
edges.add(edge);
}
public boolean equals(Object obj){
if(obj instanceof Node){
Node node = (Node)obj;
return this.id == node.id;
}
return false;
}
public int hashCode(){
return id;
}
public String toString(){
return "[id:" + id + " past: " + past + "]";
}
}
// 辺の情報を持つクラス
class Edge implements Comparable<Edge>{
int from; // どの頂点から
int to; // どの頂点へ
long cost; // 辺の重み
Edge(int from, int to, long cost){
this.from = from;
this.to = to;
this.cost = cost;
}
public int compareTo(Edge edge){
return Long.compare(this.cost, edge.cost);
}
public String toString(){
return "[" + from + " to " + to + " cost:" + cost + "]";
}
}
// 辺の重み比較のComparator
class EdgeComparator implements Comparator<Edge>{
@Override
public int compare(Edge e1, Edge e2){
long cost1 = e1.cost;
long cost2 = e2.cost;
if(cost1 < cost2){
return -1;
} else if(cost1 > cost2){
return 1;
} else {
return 0;
}
}
}
// Union-Find
class UnionFind{
int[] par;
int[] size;
UnionFind(int N){
par = new int[N];
size = new int[N];
for(int i = 0; i < N; i++){
par[i] = i;
size[i] = 1;
}
}
void init(int N){
for(int i = 0; i < N; i++){
par[i] = i;
size[i] = 1;
}
}
int root(int x){
if(par[x] == x){
return x;
} else {
return par[x] = root(par[x]);
}
}
boolean same(int x, int y){
return root(x) == root(y);
}
void unite(int x, int y){
x = root(x);
y = root(y);
if(x == y) return;
if(size[x] < size[y]){
int tmp = x;
x = y;
y = tmp;
}
size[x] += size[y];
par[y] = x;
}
int size(int x){
return size[root(x)];
}
}
// 順列を管理する
class Permutation {
private int number;
private int listSize;
private int searched;
private int nextIndex;
private int[][] permList;
Permutation(int num) {
this.number = num;
this.listSize = this.fact(this.number);
this.searched = 0;
this.nextIndex = 0;
this.permList = new int[this.listSize][this.number];
this.create(0, new int[this.number], new boolean[this.number]);
}
int[] nextPerm() {
return permList[this.nextIndex++];
}
boolean isNext() {
if(this.nextIndex < this.listSize) {
return true;
} else {
this.nextIndex = 0;
return false;
}
}
int fact(int n){
return n == 0 ? 1 : n * fact(n-1);
}
void create(int num, int[] list, boolean[] flag) {
if(num == this.number) {
copyArray(list, permList[this.searched]);
this.searched++;
}
for(int i = 0; i < this.number; i++){
if(flag[i]) continue;
list[num] = i;
flag[i] = true;
this.create(num+1, list, flag);
flag[i] = false;
}
}
void copyArray(int[] from, int[] to) {
for(int i=0; i<from.length; i++) to[i] = from[i];
}
void printNum(int[] nums) {
for(int n : nums) System.out.print(n);
System.out.println();
}
}
// 一点更新区間取得Segment Tree
/* class SegTree{
int[] dat;
int size;
SegTree(int N){
this.dat = new int[N * 4];
this.size = N;
}
// [a, b]の最小値を返す
// l,rにはノードkに対応する区間を与える
int query(int a, int b, int k, int l, int r){
if(r < a || b < l) return Integer.MAX_VALUE;
if(a <= l && r <= b) return dat[k];
int vl = query(a, b, k << 1, l, (l + r) / 2);
int vr = query(a, b, (k << 1) + 1, (l + r) / 2 + 1, r);
return Math.min(vl, vr);
}
// インデックスiの値をxに更新
void update(int i, int x){
i += this.size - 1;
dat[i] = x;
while(i > 0){
i = i >> 1; // 1ビットぶん右シフト
dat[i] = Math.min(dat[i << 1], dat[(i << 1) + 1]);
}
}
public String toString(){
StringBuilder sb = new StringBuilder("[");
for(int i = size; i < 2 * size; i++){
sb.append(dat[i]).append(",");
}
sb.delete(sb.length() - 1, sb.length());
String output = sb.append("]").toString();
return output;
}
} */
// Range Sum Queryを実現するBinary Indexed Tree
class BIT{
int[] tree;
BIT(int N){
this.tree = new int[N + 1];
}
int sum(int i){
int sum = 0;
while(i > 0){
sum += this.tree[i];
i -= i & -i;
}
return sum;
}
void add(int i, int x){
while(i <= tree.length){
this.tree[i] += x;
i += i & -i;
}
}
public String toString(){
StringBuilder sb = new StringBuilder("[");
for(int i = 0; i < tree.length; i++){
sb.append(tree[i] + ",");
}
sb.append("]");
String output = sb.toString();
return output;
}
}
// 標準のScannerより高速に標準入力する
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
} |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n], s[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) {
s[0] = a[0];
} else {
s[i] = s[i - 1] + a[i];
}
}
long long cng = 0;
long long ans = 0;
if (a[0] == 0) {
if (0 < a[1]) {
cng--;
} else {
cng++;
}
ans++;
}
for (int i = 1; i < n; i++) {
if (((s[i] + cng < 0) && (0 < s[i - 1] + cng)) ||
((s[i] + cng > 0) && (0 > s[i - 1] + cng))) {
continue;
}
assert(s[i - 1] + cng != 0);
if (s[i] + cng >= 0) {
ans += s[i] + cng + 1;
cng -= s[i] + cng + 1;
} else {
ans += -(s[i] + cng) + 1;
cng += -(s[i] + cng) + 1;
}
}
cout << ans << endl;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, count, sum, x, bsum, s;
vector<int> a;
cin >> n;
a.resize(n);
cin >> a[0];
for (i = 1; i < n; i++) {
cin >> a[i];
}
count = 0;
sum = 0;
for (int i = 0; i < n - 1; i++) {
bsum = sum;
sum += a[i];
if (sum * (sum + a[i + 1]) >= 0) {
x = abs(sum + a[i + 1]) + 1;
s = abs(sum);
if (a[i] * a[i + 1] < 0) {
if (s - 1 > x) {
a[i] = a[i] > 0 ? a[i] - x : a[i] + x;
sum = bsum + a[i];
} else {
a[i] = a[i] > 0 ? a[i] - (s - 1) : a[i] + (s - 1);
sum = bsum + a[i];
s = x - (s - 1);
a[i + 1] = a[i + 1] > 0 ? a[i + 1] + s : a[i + 1] - s;
}
} else {
if (a[i + 1] == 0) {
if (sum < 0)
a[i + 1] = s + 1;
else
a[i + 1] = -s - 1;
} else {
a[i + 1] = a[i + 1] > 0 ? -s - 1 : s + 1;
}
}
count += x;
}
}
cout << count;
return 0;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | def count_loop(n, old_state, count, a_list, flag):
print(count)
for i in range(1, int(n)):
num_state = old_state + int(a_list[i])
if flag == 1:
if num_state >= 0:
count += num_state + 1
old_state = -1
elif num_state < 0:
old_state = num_state
flag = -1
elif flag == -1:
if num_state <= 0:
count += abs(num_state) + 1
old_state = 1
elif num_state > 0:
old_state = num_state
flag = 1
print(count)
return count
if __name__ == "__main__":
n = input()
a = input()
a_list = a.split(" ")
old_state = int(a_list[0])
count = 0
if old_state == 0:
c1 = count_loop(n,1,1,a_list,1)
c2 = count_loop(n,-1,1,a_list,-1)
else:
c1 = count_loop(n,old_state,count,a_list,1)
print()
c2 = count_loop(n,old_state,count,a_list,-1)
print(min(c1,c2))
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | python3 | def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
n = ii()
A = iil()
cum = 0
ope = 0
# first plus case
for i,item in enumerate(A):
cum += item
if i%2 == 0 and cum <= 0:
ope += abs(cum)+1
cum = 1
elif i%2 == 1 and cum >= 0:
ope += cum+1
cum = -1
# print(cum)
tmp = ope
cum = 0
ope = 0
# first minus case
for i,item in enumerate(A):
cum += item
if i%2 == 1 and cum <= 0:
ope += abs(cum)+1
cum = 1
elif i%2 == 0 and cum >= 0:
ope += cum+1
cum = -1
print(tmp,ope)
print(min(tmp,ope)) |
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int tmp1 = 0, tmp2 = 0;
int ans1 = 0, ans2 = 0;
for (int i = 0; i < n; ++i) {
tmp1 += a[i];
tmp2 += a[i];
if (i % 2 == 0) {
if (tmp1 <= 0) {
ans1 += 1 - tmp1;
tmp1 = 1;
}
if (tmp2 >= 0) {
ans2 += 1 + tmp2;
tmp2 = -1;
}
} else {
if (tmp1 >= 0) {
ans1 += 1 + tmp1;
tmp1 = -1;
}
if (tmp2 <= 0) {
ans2 += 1 - tmp2;
tmp2 = 1;
}
}
}
cout << min(ans1, ans2) << endl;
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
void sum(int *N, int *S, int n);
int main() {
int *N, *S;
int count_eve = 0, count_odd = 0, n;
int j = 0, k = 0;
cin >> n;
N = new int[n];
S = new int[n];
for (int i = 0; i < n; i++) {
cin >> N[i];
}
sum(N, S, n);
int del1 = 0, del2 = 0;
while (j != n) {
if (j % 2 == 0 && S[j] + del1 <= 0) {
count_eve += abs(S[j] + del1) + 1;
del1 += abs(S[j] + del1) + 1;
} else if (j % 2 == 1 && S[j] + del1 >= 0) {
count_eve += abs(S[j] + del1) + 1;
del1 += -abs(S[j] + del1) - 1;
}
j++;
}
sum(N, S, n);
while (k != n) {
if (k % 2 == 0 && S[k] + del2 >= 0) {
count_odd += abs(S[k] + del2) + 1;
del2 += -abs(S[k] + del2) - 1;
} else if (k % 2 == 1 && S[k] + del2 <= 0) {
count_odd += abs(S[k] + del2) + 1;
del2 += abs(S[k] + del2) + 1;
}
k++;
}
cout << min(count_eve, count_odd) << endl;
delete[] N;
delete[] S;
return 0;
}
void sum(int *N, int *S, int n) {
S[0] = N[0];
for (int i = 1; i < n; i++) S[i] = S[i - 1] + N[i];
}
|
p03739 AtCoder Beginner Contest 059 - Sequence | You are given an integer sequence of length N. The i-th term in the sequence is a_i. In one operation, you can select a term and either increment or decrement it by one.
At least how many operations are necessary to satisfy the following conditions?
* For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.
* For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.
Constraints
* 2 ≤ n ≤ 10^5
* |a_i| ≤ 10^9
* Each a_i is an integer.
Input
Input is given from Standard Input in the following format:
n
a_1 a_2 ... a_n
Output
Print the minimum necessary count of operations.
Examples
Input
4
1 -3 1 0
Output
4
Input
5
3 -6 4 -5 7
Output
0
Input
6
-1 4 3 2 -5 4
Output
8 | {
"input": [
"5\n3 -6 4 -5 7",
"4\n1 -3 1 0",
"6\n-1 4 3 2 -5 4"
],
"output": [
"0",
"4",
"8"
]
} | {
"input": [],
"output": []
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
int main() {
size_t N;
std::cin >> N;
std::vector<int64_t> A(N);
for (size_t n = 0; n < N; ++n) {
std::cin >> A[n];
}
int64_t a[2] = {0, 0};
for (size_t i = 0; i < 2; ++i) {
int64_t c = 0;
if (i == 0) {
a[i] = 0;
c = A[0];
} else {
a[i] = abs(A[0]) + 1;
c = (A[0] < 0) ? 1 : -1;
}
for (size_t n = 1; n < N; ++n) {
if ((c < 0) != (c + A[n] <= 0)) {
a[i] += abs(c + A[n]) + 1;
c = (c < 0) ? 1 : -1;
} else {
c += A[n];
}
}
}
std::cout << std::min(a[0], a[1]) << std::endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.