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 | cpp | #include <bits/stdc++.h>
using ll = long long;
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);
ll ans = 0, sum = 0;
bool f = false;
for (int i = 0; i < (int)(n); i++) {
int now = a.at(i);
if (f == false) {
if (now == 0) {
if (i + 1 < n) {
if (a.at(i + 1) != 0) f = true;
if (a.at(i + 1) > 0)
sum--;
else if (a.at(i + 1) < 0)
sum++;
}
ans++;
continue;
} else {
f = true;
if (i == 0) {
sum += now;
continue;
}
}
}
if ((sum < 0 && sum + now > 0) || (sum > 0 && sum + now < 0)) {
sum += now;
} else {
ll add = abs(sum + now) + 1;
if (sum < 0)
sum = 1;
else
sum = -1;
ans += add;
}
}
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.Arrays;
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[] sum = new int[n];
sum[0] = a[0];
for(int i = 0 ; i < n - 1 ; i++) sum[i + 1] = sum[i] + a[i + 1];
long ans = 0;
System.out.println(Arrays.toString(sum));
for(int i = 1 ; i < n ; i++) {
if(sum[i - 1] > 0 && sum[i] > 0) {
ans += sum[i] + 1;
int temp = sum[i] + 1;
for(int j = i ; j < n ; j++) sum[j] -= temp;
System.out.println(Arrays.toString(sum));
// ans += Math.abs(sum[i] + 1);
// for(int j = i + 1 ; j < n ; j++) sum[j] -= sum[i] + 1;
} else if(sum[i - 1] < 0 && sum[i] < 0) {
ans += 1 - sum[i];
int temp = 1 - sum[i];
for(int j = i ; j < n ; j++) sum[j] += temp;
System.out.println(Arrays.toString(sum));
// ans += Math.abs(sum[i]);
// for(int j = i + 1 ; j < n ; j++) sum[j] += Math.abs(sum[i]);
} else if(sum[i] == 0) {
ans += 1;
if(sum[i - 1] > 0) {
for(int j = i ; j < n ; j++) sum[j] -= 1;
} else {
for(int j = i ; j < n ; j++) sum[j] += 1;
}
System.out.println(Arrays.toString(sum));
}
}
System.out.println(ans);
}
}
// [1, -2, 1, 1]
// [1, -2, 1, -1]
// 1 1
// 1 -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 | cpp | #include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 1e9 + 7;
signed main() {
int N;
cin >> N;
vector<int> a(N), A;
for (int i = 0, i_len = (N); i < i_len; ++i) cin >> a[i];
int ans = INT_MAX;
int sig[2] = {1, -1};
for (int j = 0, j_len = (2); j < j_len; ++j) {
A = a;
int sum = 0;
int count = 0;
for (int i = 0, i_len = (N); i < i_len; ++i) {
sum += A[i];
if (i % 2 == 0 && sig[j] * sum <= 0) {
A[i] -= sum - sig[j] * 1;
count += abs(sum - sig[j] * 1);
sum = sig[j] * 1;
}
if (i % 2 == 1 && sig[j] * sum >= 0) {
A[i] -= sum + sig[j] * 1;
count += abs(sum + sig[j] * 1);
sum = -1 * sig[j];
}
}
ans = min(ans, count);
}
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;
using ll = long long;
ll ts = 1000000007;
ll sum, sum2, ans, i;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> a(n);
for (ll i = 0; i < n; i++) cin >> a[i];
bool can = false;
ll ans = 0, sum = a[0], nextSum = a[0];
while (!can) {
sum = a[0];
nextSum = a[0];
for (int i = 1; i < n; i++) {
nextSum += a[i];
if (sum < 0 && nextSum < 0 || sum > 0 && nextSum > 0 || nextSum == 0) {
ll N;
if (nextSum >= 0) N = nextSum + 1;
if (nextSum < 0) N = nextSum - 1;
ans += abs(N);
for (int j = 0; j < abs(N); j++) {
if (a[0] >= 0 && i % 2 == 1 || a[0] <= 0 && i % 2 == 0)
a[i]--;
else
a[i]++;
}
break;
} else {
sum = nextSum;
if (i == n - 1) can = true;
}
}
}
cout << ans << "\n";
}
|
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()]
def f(A, op, acc = 0, cnt = 0):
for i in range(n):
acc += A[i]
if i % 2 == 0 and acc * op > 0:
cnt += op * acc + 1
acc = - op
if i % 2 == 1 and acc * op < 0:
cnt += - op * acc + 1
acc = op
if acc == 0:
cnt += 1
return cnt
print(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 | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
long long b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = 0;
}
b[0] = a[0];
for (int i = 1; i < n; i++) {
b[i] = b[i - 1] + a[i];
}
long long cnt1 = 0;
long long cnt2 = 0;
for (int i = 0; i < n; i += 2) {
if (b[i] <= 0) {
cnt1 += 1 - b[i];
}
}
for (int i = 1; i < n; i += 2) {
if (0 <= b[i]) {
cnt1 += 1 + b[i];
}
}
for (int i = 0; i < n; i += 2) {
if (0 <= b[i]) {
cnt2 += 1 + b[i];
}
}
for (int i = 1; i < n; i += 2) {
if (b[i] <= 0) {
cnt2 += 1 - b[i];
}
}
long long ans = min(cnt1, cnt2);
cout << ans;
cout << 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 | using System;
using System.Linq;
namespace ABC059
{
class C
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int[] a = Console.ReadLine().Split().Select(int.Parse).ToArray();
Console.WriteLine(Math.Min(CalcA(a, true), CalcA(a, false)));
}
static long CalcA(int[] a, bool isP)
{
var result = 0;
var sum = 0;
for (int i = 0; i < a.Length; i++)
{
sum += a[i];
if (isP)
{
if (sum <= 0) { result += 1 - sum; sum = 1; }
}
else
{
if (0 <= sum) { result += 1 + sum; sum = -1; }
}
isP = isP ? false : true;
}
return result;
}
}
}
|
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:
/*
use proconio::*;
#[fastout]
fn main() {
input! {
n: usize,
a: [i64; n]
}
let mut ans1 = 0;
{
let mut sum = 0;
for i in 0..n {
sum += a[i];
if i % 2 == 0 {
let dif = if sum > 0 { 0 } else { 1 - sum };
if sum <= 0 {
sum = 1
}
ans1 += dif;
} else {
let dif = if sum < 0 { 0 } else { sum + 1 };
if sum > 0 {
sum = -1
}
ans1 += dif;
}
}
}
let mut ans2 = 0;
{
let mut sum = 0;
for i in 0..n {
sum += a[i];
if i % 2 == 1 {
let dif = if sum > 0 { 0 } else { 1 - sum };
if sum <= 0 {
sum = 1
}
ans2 += dif;
} else {
let dif = if sum < 0 { 0 } else { sum + 1 };
if sum > 0 {
sum = -1
}
ans2 += dif;
}
}
}
println!("{}", std::cmp::min(ans1, ans2));
}
*/
fn main() {
let exe = "/tmp/binA4A6465F";
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 = "
f0VMRgIBAQAAAAAAAAAAAAIAPgABAAAAYPxBAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAOAADAEAA
AAAAAAEAAAAFAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAYAQCAAAAAABgBAIAAAAAAAAAIAAAAAAA
AQAAAAYAAABADQAAAAAAAEBtZAAAAAAAQG1kAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAABR5XRk
BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAFSu6o5VUFgh
CAgNFgAAAABYVQQAWFUEAJABAACXAAAAAgAAAPv7If9/RUxGAgEBAAIAPgANIARADxvybRYFANhRBAAT
gR27ezgABgUOAA0rBQAALiFP2EAHKDYEWRas+2IFNwYDwBcHsM9OyGSYGi2ANgA3YYGsmwcDBDcA/X1L
2Ig1AFDldGQx7OwDkCdkiw8HQ7wJAALbHZatUTcGAADCgp28EABSb6cYQsI+QBkAB4EAAAAAAAAkAP+Y
NAQAMvMBAAJJFAD//wfyUFjDAEFXQVYxwEFVQVRJg8z/VVNJt7f//4n+TInPTo0sAkiD7EhIiTQkA0wk
CBPhTJv7b3cHKPKuDlQkGEiLlCSAPRP3/o+8bQ/IDYwkiEQkIEj30EqNHCD/29vfQRwrTY17ARNcJBAE
/ugUAbV8SIXAWvs193R+TItABCqJxzpg77l21wtYSQHFBypZS9q2fWsbD4nR86QEwRJ0gLa1bfsJzgLv
F9kKEbR+tvtuO0iNOTxFQsYEGABhcyxDbhvs2YQ+i4yg+h/upm//t+9BicSCvNXESESJ4FtdQVxBA15B
X4UjtIfDAU1DAon8AYbNvW0v9QLvvi89D9UFf/vetggGzjsDYRy+CXNYAUgp6+szt/Z3CC3u0AMAMdtA
Cg3jR7WxrfDpRU0+2nTnNT/H/rZDDDRBWUFaeVYmP61BuAcPNnNjm+cvLClfQVi9bZHfeS0oNR4Z6RgR
awDu9rDNJ4TYUVleKbr/AGvvAvYPSMJaybuNFfq3ODbwv7tt+wLxiIHs2GiLTxBEK08LdxG+xIsHvshb
RwNBNiR71s72tzAL5jHS/1MoKsRNRTyyudtMpta+RAafFRDbDr+b+zUiDblwAUDlUxjbfQ3fFAVkMyRs
GPTfVD9OB+2+2z0+GQQiiiQYiXwkDAwjUfuzu/YEUigGgwiLFHZwSDHtjrPd7Z1d0/u//y7k8OEColy0
d2+3VwOLN40FlYB/iw3RSmrwrr0tXckXPWcNgz0h3maQFi60vyNTUIA/AnMq2AhbBsP37cLm++d3s4s+
AkYI/xAFvneFtxt4CAC6E/8VY0uwe0X67sMv/yVSEGYuDx+ED+u27b0aB4B/LAg4G95yZClmxm54PCWg
bQF1HAuoIIZmzP3fxkAIAS0ntrkYcov9b0hID27BZGYPfwQyL8cELTNdbFopjG2j4eOxv1V+e1Os+NPP
reAeHQBOokarf0oFF751vBgPex19+AEPhCAOOeOybA1y8A0DjwUxJL/Yzb0Pc78IPTN7SSwmD3ft+DZs
RRhauEZPx/9VHGNAvi8Hxr8ABChSql01NV16xw+3khRmwmSbEOlLBdMHYKhhC4kEJPtbem67Aw9XLCka
BLvHBA3Y2G8wwr9odgRNtrbThb9sww8oBeF+tg8RyanF3bby2zUoOihME0AIEUjx3jazQosdQwPHQzhK
vfDhvd97QLicRcDzRENIZuXburYaWA8oYCdaoWR8M1v7Q17GQ2ATlIsNYYlLZM5deG0kfGVnFTyHCHOV
zti+AZUWzH8L8I7bbEoZCElIR4T2dCkhOSCcQY48PkiyuQ33iQWbTBJybAYfzj+8jTDbg0YcnCSwsYPD
ED3D3Qiu0B29ACATBCJ9J7sP8EdNDmAtuHxsbjC2ocApxeMNyBx2p9bGBn5pBTL0QuE1NH5I+Z4L9Hpx
+7bbhUIMmRBcFTtZZkjxGduElwsLi2frFrhspSWHhsB0IIl9v/+bj5XAiksIhMlUDmyX4Ldp2dYyiIHo
zIU1HKrYb4HYkLKTmAeF0svY7W/bNRDBAtaAOCt1Di/G/xQVcFs/g8EBMf8gCikUsXH7JE85/nQ01QQ5
FSj9u7a/BdCD/QkPhy0NLthJ9+CyAg+Afmnb0Q3CMInoQMdQAcNzzOljO3TEEmBIlcXvC+49CNsNUHkI
abkXQRqP3wZr4T8PiGPBwXEJFxd+Rr+W00fVxt4+we0DCKwk8DRsR9JbHbwfZCRY4uBN9usnjdtWYFsH
QPLPAThNMHbbdgfFCAPECzneczEmoYuwYbwnpRAdoO3/kkGoDbmKCID5K3QmBGF214ctYQfssoP6ARt1
+7dbU8UB3IPA6onX62eQsQEcOzTa93Xn87mAOr4xLvwuYWY/+jkHHD8sOI/wHxBAC0hryQpAtgM/Dont
Aev7CDwp6XHPSA7PIZe1DQQB11BPx5tMyPYQg8JO+gKeYSH29onSN9Fx0E4wtD0YCiM8i4QDgAoCEBgw
Lh91YYQ0HCJE+hlJ60NBVm4I/JAZaj2HdSPrwDQTJvAEFVdF+f/txBbjCaFB5CbCBFhiuxcadaX8dS6q
DhNQJY7dFgjxK/a9Pw9OOmtsW2wD8F/p+vuKKcbDP4auE0kDNP+J+Tb2t2+XvcV0w41OATNJLA9P8uF7
iWczdcwgScfAar2chpMDNm8kuND9b4VusL5v8APVPII533N4luWwN28kFPiotct2UCvEQgEySZ7t1n62
btAycs3rAmI2yUwSNIwzbgOJjGONa2Bnt4KRJqN8Dpgeu6aOyLjuxikDIFosEOHTWUcQSRgCMN8ggzW4
AC+QMBU4uOnrkQE1Ni7sfDONVCTd9JH+5lqchE0MSkCKOUCA/YV34GOLD8e7D/sEnj3ETtIIQ3UQHHLR
w3fsDyK0f8aYA1UQui/bNqG7VTPsSP8EcCVv7LHvezArYBAgChC/GFqz0yVwrUJCm+U3MtjuuUUwNmJF
ACqCkYYuFggoBZx2MrjBQwgyEBDPSxQRbw+GwRFAWwdjQLW70GnDAoo5PAMPYjwC9i0aJxtZ8dxNHRW4
TTgGQCBDJa+NtAOm20V30jhsPWBUYBAE2qym7CvRwdi3jIN7KAAb3e0oYCLC7Uw8czAVlx37k65mPRAP
A4B7SH0PWWevzbW1UHAvAX1Q/2SxZ/B0Q4C8LHUzP4Vggwx2EMPKyjzF4MN2Br4JKIO8d+mN8C2qDh3A
QUgYpO1m4oHUG3V1DVvORu3kvCSwQdUj+FloNIxwKzQDhSLdBoYgCyTpZUKxD4087Gr/EAZ8bTu3dwoW
YuVBtFgKHe4imNpdows26WKM73Cgba6RCWC9fI+wxHuYbxVpMQZ0zBO7IzBhTDAFuBEYEYSe2wJDbgXq
xJ54IyV4bJhvda3dhyQEZQv9QAwD8pe0I/cBQIh0pGWTA1/HxRLSSVgDe5eCtJwtVy4LaIxFVu/7Nj5w
EXi1CEOcpGcnfQV/dqOIDggrkSnYQg4E745hxjs5AxcwIpDrI9B6XA8L6o6yAYiUFrQ7vAcFa5K1NjdQ
BfYkv5Dcr6otTCRIrH31zQbXUl44J2RXdg8f5mpFTBABKJiGCwwE64mLZGN1hC5Qxj8U1pwfeEV7xgvZ
AL4kJWF8KjWAe4r+5txH/4jtjdVjBz0oflU5aJfMYLvecidDZr7GOuw0lWefy74IEBScomH3bsAGMGR1
S4m/ENbc3m5o67w9rvl8IykrMI4c+3tE/Lg9eHVneTGSMXTdkkMQRRFWFJb7HNAL31YYEB8st0bddBAU
7wYDi4tykbrOIkgOS4fJHrrt/UZIi44HERwUUhiFPOs+v/Z7GJWtO2UiZL8BvwjbEuhi5btTdRENrBkQ
dIhUsA3j7yGqtpHQ7e4GPAtoGn9RaIrw6rZUvesMWM6dHdvNbKFgixURHaFHjnCEXID4lxjYJVkmBALC
ISuAonp1yDC7D5461zO+mvBuTfO4ViiMjnWkYL8NN2A9pVasjlEHE90mRBlkkG8HoJCAnuczEPgEYFBA
+Jt9ejB3wAAAmjC/C6oU2Z5x9mMkCifDDN5zdTDH7Rq3ctjB4OpaAciNdDDSyNn25fM8xgX8QAUBSQfR
7w852jx0EIA92yB0NyEXtqGwwBIJWZDgjQxyB5miOFZLUhASx0ehONF1MDElAib2eT0c4XYWWr8eK1w7
dLAQn7pZJQC66rkis7l40Im4FeYk18EcHIRQFF3LPLhva70fF9ACxoeJYJuDdR3vhSN3IP46AcNckq9I
dGMAb4d4D7FJAWhGbLo9HumJHczJNa2KGRIwup/VX8WWAAEEzAjnbEncw4RucA8QvMLQB+p3aITsYPiA
E1nggyfEgbaAaN2LsAG6aIrB48lgE/ceBow9lwKrHToPKGRNXc9LDxHyTGNIVTgmAzJpmCk+wbVYJY9E
e4M7AKBxWMZYNwNC2mzQuJndAwJ0+BEgFrvbGckJQXsgzOwMQtvGgC3RR5FBfAd6cAkccHMgCnr9PXAY
7GAyBDsI21I2utjQOSgRbdxWixc+JVwdAZV1Z4IT4c4QkfCAX+VsSJPosGc/EmTrIg+JwxK6zSK0XeeD
LosKYoyTI0culEuSQzNcM/Gcu+QIvkbGqJ3sk7j1no49DYJm7jcS63P3kDATShyJmANJOIOxI/CsR0Xu
DBlijWstOeTIJyxALBgnpHnWJQE/0TcmHnDIJCcjHzgQE/KcTFDhJ12sljxnGd8trrvD3r2QUMlrnA8L
EFA1wngHBJojwSERUx9EJ27QAI7s2Il8dmMQJEx3gG4FheGcweEw+CA5TuJBaGU+BY4hiTghMUg/i0AD
JUiJ7yR+3xgbWBJgAomNMBDAdA21OHtGn4gjdeBVHIOJ86n/d9QNzQ6LbjCJ6UD2xQR0HQdAa/S2fsoM
g8kIc3fmQhQq6AcY2G3NomC2AxUER2r9N/pf34nBkEjB6ZcPjVAwjXBXPLvVv70stsJAA9YPQtBBiFB1
g8ADulQgk1RyV3XUu/2KmykMJL/mKc+G/4EJI9bUsHMtKWbNubnBN9eecL4BMUdceVl2iWtXitdoibRy
7CyB8KxhkiRWgCRMLIzU3wOB/wABTfuLBtDBiINiF0SMF14CjZm69nYYHQxRa/YEhqU05uB+5w6Hm3bb
9gXCWn/82yQBuGwnPjjQdFHT7EdKsdZ2DZznItYsDNAhFKunbyv5A3Qrqjgl2pqJ9u4IBGgELygKBstW
+ARgTDtmMBYPg9eMdzD2LZjZNygeKCiUYkvIYIaMmzMGg3c0ci9DEA8omSjtdrDBIigyEUNxEUtwuk1D
6hFTOBpmGFXzELYt0HTWFqHHQQQZHDkgDFkNGGbYNjCJRYBjulgw9g3QB5TYLvBBBrkSFcDQHccGkODw
PkNIVwAkNAyBAQwHICFWPBqGGRpP73NsdwdYLEWJzgLEWsre249vApowaItqexBCKA+pY0/3UAs4EBtC
SFOmY+fsIBcYtos5fIgxNtNBCBQQQK20uKECxdGjZhKAePtCBZYDdXDFCAExwI/2oXuwHSckHgiqGe0I
eu2A7XkgA3E0zx0eisH6VS0BCAEdEGwXrE+fUokDVhQoAPq2XZBg4irsHSVFAw+0Y+BswhrwDDE1jdzN
gvHmCwErJMm7qYK7qmzIrpimFUMrISQbuTvCC890A8ohAevqLsyLeJ1wwQyW1VlNbo30dFMBWojdgUog
5BrXywgvG/KwCs8r6yMhUnI2IAJUDwy20balbEEWbPUBYydMgIx/ieANhBIn4fJzAwLG+qYC2dnum/Pg
aBVAKi147JVc2S2KVByeAB8BZLKZAsYwIX4sowGOsiABTd2MFiRLQwiMUbGOGXDoEDFtFkyI54Ok52ih
jwtT/QQ0G6G2xREoNcedCBxRuWE09u2FFij4uc+5scCbrmAFRlymWIR4VB/9SYfJgKZU24tQSEHh7Cbe
ieEKAg1VAxZYGqOzzgG5KJNIuRj0YAQVFnMDaG9HkG8ayBEc2llyIONlRRMb62aGNoS7QPIdBOlg7vJK
TgRmAsonugmrEDNEP4kwCd+MVhjYE5SEwy9Yx7t1IcUHflG3O0BeNQjqujVQGES6btQgOrABzVh4xRgW
7ihbljjGxwlQQYP87hj8lf+xxlqk5gn5UIQnKRh/b0SJtHIcHheAvORZEiLt7iZTIC95MCe0cOFIIa2Q
cCPIOMJAD24LGRe6AAgcToQDTBDmB7DcA0gYMEeNVA9jBEOqRrASEP9rVgzZURiFjfU5OmBnB9hDC2ie
fBgmbNnIF57sARqjkDK0pLRmhBIGMT+Px9DVrcSLYItHV/huB6GO0x/HgR/4F18IqRs8KdMxXHEnTHuY
gIHQMBFIFIBCM9TktSM0IGf1MUA7Nre1Lhg4RDARQAULQf4wxQH6DH5EbgOwP2GEgKwKMVhFhP9mgHff
YAGaOesPggvvSQHs0LC9N3t1mukYOndYvGHcdAbvV09EJCjRUI1GjsVNw4cd+o7lMV4wHrEwdY+IsYlG
LUcYyHPCCL/YQABGQolEVlBNwR5GbsFDlgxTCWjofZgeU/tnzIqHwG53c0coTzHA5O8NQQPpFfpiAwcd
AmOzQWhzJQpMi4E7MVe0hdh1ZKA5ZIdEuW1LWGDLFu4C4tFnng32PstOswcVm5VsZMO+NmjuX7AP+4PQ
lTGaSY1AAaJPje1CQ/8UNE2NTv8x25xBmAwcREBDr/B5I+tHyx16xtaCURuWwwc7ImHptw94JonPNiwc
g8fQ+wqdHQNj9yIIwyJMDV8xTdzetv9W0DzZdBF0BByMAvrf/ndAfBwBg+c/icqD4mT533YmTDnQdCbt
31ClIHeD5T/B5wYJ7xju/5fn8HIhLwCD4D/rKcHiBusSMe1Pv+ztYSBz3xMMCdeHcizrbupv2wp9VgcX
EiTXCcfMccLWFoQRAJqfK0kfT7xzRDUY7yDkPAYfYEWD/tAhLEiHd/cgMXBBgLO/D48UqjTBw7Bw5LIw
uzjYcJs2IXQhHHQcCdwK9/utewGGKuA7PBzAfRU24JAgjbpdMBtXMl4bJNgtsl3gidlN+3UTd/sWphtQ
aqXt8Ev/6ba9YscMfS8p4LMXHF0BCguGjQVFWP9iCw0fOel0O1opJTjXrPr2o88xtJL4SffiX4WGMnUx
tn17xcYIQnvVAcdfEt8aw4BLA0xFJ15o4d9blMFNKf5JKfSUPsh1FxTtxxaI/sxwS40MPLPJ/r63Jo4N
PTAzOITAJBqLNMsyTwQYDS/BuHsRdVfeJSxIng3H7JBIhRXz7tkLs4Uw7AQmHH0AaBt8S3ixpqGqDRDG
GxEceDLcQYoLEU3bQrCWTfn82TNIT3VN2/faBd4ViUQOf0qVoy5sjA5UPAKI48KNuickH3F0Szt+Aehs
H5ujApQKwJJHJywYbnu7AdUe3XR2Ey4dmTxLs01zHwzR2Q6+KmyM4aRxlsxoxsLbz0Z3ucHgMMeNR5f4
m71Q+998f41Pn7ip/wAzGnIRQjuMvAy/uMkZteadGbHft88PdlPpCzHtSeuxf8g2jUsMc7jrLjHJH5BH
Ngot7ODHCc/YYBMYHt8viPdbw7PtAdCv2B2KDhWICSN8e7a9/Lqu+SgPgxIkfOvRbVEYEt+zC0LjWTBh
jboScnqX1mvDtYndll3rmXYBd/KsmRleAQfNuY5fDCByU80+NbsbsbGEXMp0erdNQeiBwgsu0flfPHU1
t+MWhI0ABjvXRQiG4+nH/8BJyb/pxsFY6vxWL2wCRQBOwWjvXwsmnDwueBM4bvGYsGRUZDi7dAt1jMk6
YQFb/EkqMgw/LNCgVeTSHSnKiRV6AqHFShcFbHkD1sVmEzHnbp4CcsnIgFwCAgBbQmw4xP7qKof/r+67
kAIHTQEZYEVk8FcDY0yFZCQ4yuK5G70NVbgkCgPGQu8Q0VBSlsmtBPru1Aeu8Se+uAgAjoAvvcRdyHRI
x+BJD0cOxGbak8I/M8FqGktBAj87CjGWiw3cD3QfEg0C1VILuKPrdeolBETYg+PB7krAbsvTKAZ4sxBy
WJeABh42YNnvendKkONGhfNdID0BHyvQNtTF783UywPGA/buHHHbxCwIcMBOCXuuBbTiCcq1bTfT793b
dsiT53YNWDIDMf9Xc6iBfIM4UC9i4vfSSAO/bYES2vqQLMLTIJnbtXRbfwGcQO3LgMGdQGHrnPKdzxQc
JRE47K1DRY1tApv+XUv4KQNTvXDrG5ATYmMTywH7ZN/2iF9ga1d2NG+J80n/w2xv/JvaQHQTTTnccg56
BDE6QlwTC2xjQY8Z4LHYFKlLaOAgnjAZaylLwdZcQmxJZVvKYolWuC/ATG9oiS5MFlom7rlzx8LCti3J
TD457/lvNm4wISzfOtF/6277HcG2E4JG0aWHKIUrxN496ao/hhq98ELB+YnYjUjwH893awgbGrY07t8F
BD6NIcskR8LF1dAuQ/DPdspFsDIU/AZk4dQvGv9rc5RS0LZkL59MAgBabDTEK5N4X9lowUBAIP9AFxah
c/AoLC/dW6/dgylYIsbgDqpdSNnsuAFJ4Vw0LInCSA9t91sM0ivWokBTvUXIL/TbAluFdSL6yjVi9yLQ
0T4rORkwx8dgH7YGlugc8KIrTCDt3RbNLhc7P1kuO8HhIVxIX6fI+k03+gFImkCexXoBvXbbgDT6/83n
ajD1ObJDk/L1OVyOk1gGCjlMJW3NNo7EdBJlJUMRHU+KLWuhCwLwOXJmG38catUIdBdfxDPbOGwsxwWD
Tm8og13jxYaFx/AdBQJsHCx+7izK9iCj1gmIhzcoXnx1dGBuo9hBErqr9zsqKhAFXgFZJwzNJ3MLuOCN
LW+h7GEGfFsD3G/BGy3tS1MbUx3cbHMUUkMUWz1igNCrWsGLWDwb61cVmIK+fQJ6BSYcfI1G/9SZw6at
aEo1cPl1J7t6ycT2LcHjod9oNgZyDBasXTCgrC5WHCGB9ju2hkphKkCE7XgPZuSxvf1s7y1z0uvcI8F0
GBt6qdTgdBDC22VHl329cYD9SKjrECDCEZY44T5yULgKK/7kc+Sehc8ZuRkyKFkHvesr3sIg2/2G7bnj
DKScK+26K/klZCTaFl4HHdLfNqSsDbYuTv5ylBjIEWroclm1Gd09aeMTPVNQaxXPAHLWEdIsvbdCAHJy
IKaSORmQz4tSRnpnLdBnAF9MVOhzWGNy1g1SKEBYJJx1zzM7R04NLiQdu9gggzsXSaN0KSAnx3YNKXok
+nEWIO147xJ6m8hYKyq6PAE2Donu9tVOfFUo8uRZtGRVTFWGCiP1fydY8gLaMHDGdS7/0snxEmC7MH4C
yAnQ9kB9TbfoqsEko11wtit14NasoRFd/hOcXQMCbYHYOPA+wK74UYP4xlccFAuNatC3Cy+8GTGNctj+
GnPZwqmZg/pgtthGAh9vFr8diGzt7wsayXfYpUywDbrq3w+AbRqMvYkFAehzqTM9N2rfYNYbJEuB4QD4
Dx5jIxZgAAe5R0TBPWrSS8QHE0AIz3rdYrA5E8ogrmbAgaMHnPQLhpPT/mcobC/V/gBw7L/dHJhnJ3wm
JVQ2LQclNaVLICA04U+iF4Q2A6FJ6a/6plsVBCIWjVGFA7/tlzn/eBiJ/ukkjzBhFLqmIcB2X0dNKAIK
vF1acUjmPzbQif3Bu1Fbmn//RB2dS0Qa/ZPpawgFQWdj5gZECc5QgG/JH4VCH0kZybZ/H1jnHes8MfaN
wEONerfwd7zB5czufHVJ61yEn2wvcxxBc74dDCvrPt2y0BoKNP7l5jEJG7YN6f6B/pnNZq8qJQpAq3Sw
F9vOqINTboX+iXyFmNABK6NBsB2BBuN630AJxTBgobWJxeQY3C5Z0IZA1gsGRgaFCFdxItDBDDMqCPZP
Dmu40nRLcH5+8uTDQqPdtW9Sd1IaYEh9f1IDQGXYYUFLGXkxSEI4JMTtcEADUEhW6x4PwB34DzhzHxhE
FPgQtnQE3rIiSLW6wFw2YdVhVVIwn4pxCMA4zUBiqg/ArfUYjCLXb4KEEfzsdA1AAHwAlvNU+TR2gDzy
+YJsDYUNML4rn4Ldj7SJ3g6VvMrmBI48O0AHE0wskgnMYEEK3hCBAEvWAloQtIco2BZf3G7iAhK0Ym4k
XxDL7YIBSMd+eGjotk1hiz4CRk/mSzRuUSi95yEzDhjDtRDiAa/DP9qWtlh/RFB61wL20MagjycHZ1SL
uGjDEhgYqD32JQ1D5C7FdR3GGal0IWgUFUhmGv4WoAf5xtQhi3MQuWNhAhe+DZIn2zXMtlHgJAEnSHUj
ISBY8XA8JO8I1t3h17nZ23z7dCT+qlAHA4hR4H8oxleIXNBHGAlm3aKJA25/EO1m0AQBIhx7wgipTIlO
3G8rdoUex0H1Mfdct5uwKPEAR8YATUdKsqDvOmNABkAY/+Bmn5FtY+5IZyM5AkEfT8AgxVCrFEQAZduG
Fd7q1gL0hKOGs/1bX8fBjdsHvr2n0XM8Fd9NAfcANKLnDEAJU110+ZBdn6C7b/smSYt9D/h0RESNGf1X
Y0GKJd6LXRDrLfhQbPof6y9CdB0c+xirYh1McjQRi9dbau29Nus7vwtoLHB9f2W2zXEB33oC8i+rMUmt
LSHzGUwyw2BuMgIZB1fQLpuaqS8zBAh1vhkYSB2L0GysT8L/kFBTT7h4z8xitleL4K/GPyEa3T//JVgZ
JG8ZJoNSD1Bnz7hENOBHWUdAyvkBMBQmwHUVCJs/pei7rfhQgTf0ikc5NSx6t+lcaAOTPWUGSbsAPnnb
MuBSUOsf31APBKBtW/XO0S/iHIZdrPU37bMIUotPlm/rrY4Mgk/ti2cwx8xrrSL2wjesHcrrFp+ssKUK
1HW7GQfUGlM3oERDAm8o9zBid3sShNJ4XYnqkjac33xNXXg55XT7jVoLXyNyrJrYHkQj2kvlHuoGbEDt
4/KNUywstG23VyggG30/otD9bUcP497lcjxp4HRATY1Qru2qix9BECLrMb5ohYOHbRHjR3e4Rwwesm2e
2zvgc8Q9OzD4QrHrKTHSOtYSSgiXQTw3v40FFw5LnSPNkdBeYlcZbyDyIHcM707AP27Fo8ugNXyB+qjG
5lb6C8HjDf8vl8HewAJ0tVuKLKTFvtEtLjfJQYKJBEYLOfNIAM3dNsrpDRypDC9guZVoJPoi1QDpCfgX
JlYpOBy7FWVfchcGFCssiUK6he10B22l3hrhFcHrFffsyP/F7VuJ6AFyFQX4BJA4MkOLLNDajcaBvvBi
IfVdoefajUK4G41xemHVIWgGeDW8Keq6Ok8XjnUJZBRzBkJKNDl/gvZu4znVDi7KOct13jGDJL3pDc/r
K3JsvBqAfzi2Ej3cIxawmpEPESkGjtZ6znRwh09chnEGNYrV6zUrMm3AcCsByGvxHDxgEJUVDwNk7iQU
x/qJz/fhAhUSDDmSBLNR7TF4shU97lathv8jHGpZMoqfAfPttsASXylYqm4YmRg4UZ/tObBoEG+ojRZ2
fmQFHT79AizQcvUAxkUgeyeONKAVEjYKOvE/qvZhY1s61oPzlu+HObUvG9jaS1Uu73Vn8Ux1i9vHKfki
O6SLVRkB+rifqBI7ZgFdLDChDeJFABVRO4UGyIDg2nHZLX6B9v4CdFwPpzE8D3VvOoqPFm4Ocpr33ss4
zo2VsmMEvBeOrChWvOkKb9R7DXpWIzoXbqeI2+0QvDjO6z3AYEAQX3RAt+vioOsNOzSQClwOkRNb0HX/
OB8xJTRhC22ggz5DVXUPd0Hl7IHYtgMEZDHf85+IrZH7HJ1F5nQXlqIVaBlYcAv+X3zghyYVEhOIXRij
IGr7TfdEiDeLVIuJRwGJTwQlZxAHjCYCWBC7IfXsbM+YBDw1xTs3FEmCTGfR0IWuLhk1AXNIUbohibEI
SM8ZUJ4PakZwBCSGK5Y9CWoNn+ISUpQjQQ1VyhBJQSXCFZeGte3ZIci5KHR+HMSm7VpjU+zX/F4MekHG
R3ES1DMOuUHahCVBNwREJMo2hoPQQioC0jm9mgpzZMc57qiAZiX9z8A9sC0VKhJhTCyVVUwGa8yKWgJx
2L/t3P/ewIWLf5QACDwDhkU1tqc8QYjColoU0W2FGB/yPN0SEMwSJN+qEIUgO29h7Eot+2e8TKz/FHhy
cVCZhQBAITqgDwZzFr4EkgbaOzcJnzycWcNFYCjl/ne7cynB6AYkHwzAiDbRIfm7FfoDzoAyBboCN2i3
A5FGczYwgA8MsO6vveAwRT0/DIAMBT3YW0g+BroDKBIM8DOQAxtyDEAGgkFIPge6BK94ArWwL1M+mAL1
2lgM0wD3Lr1S7bHBJ41shgRwm6qQxCa/6v/VNgGIbSvtHqs/Y9wQhXReAdlJpznrRwfiwXYtjf04bATm
40ajNEB/i01CMME+AKYz/fI9/DHEMyb92HY1TInvW/GJXFREKiKrZDb86sqV9PiTPlK4P9dbLceMv7Gf
WzwWT+0M3ok/6C0Y/FisrSqZ2ZAjEOt3rJIYAXQ+PJZYTbcoGBd1fr0kJcTTaywbdJj6PJXhqNB+7QyV
ZeCOfYFPLfP3AnE83B7wkaHXEukKP91EP3TV0IEgETDDM4QhiVYs4ABt+g7YNCFeQzUigmzHKNZdmxMh
pYTrOE1cb7COSFnvgup2A/z7KObbojzz6zU06KvfrOqEPb46IbE6XGgyi2VJA2FZUFgAA1pabNT3+gPx
MGyWP8i7HIcEdbKWov8ONEATpuTklYd7ZBxANjuSQzBaUnZYrWIsVwLejGCDHTJGBiwtf3cUBTcC4nI+
R/gjNKxgRVSMWjNCVlNFiNftvQ8Oi+4WHYpFJ7aGhcsEdSu6fbA/Akdnu6wRuUcfP3e9sAtmcyAJs691
CFpI4Ab+RQmJTQzXELABv0mAWFfLLpjkrIUc6z2JYfb+99uEVECuHD+hAC+ABbdPuojbbQYCThADViBv
MHifImcJoTWGdwEkg+rYCDdUfHw0aMNvP3mcFZHVks8QwgkXYMJAL6OJRDJYhZBDU/ePgHbtRlk4SX+L
Hw/61tHKGFqiAIB7WLIb7RTbRBEJWfAJV3ucvc2qUBIMSbz/AH/loE1tq1nB/kXDC7mfLlgp7bhEgpBB
BhrD8OtwHObtQEK2r8lqoZdRX3NAPu4OcAfgRk4PQtXHA44F3X1UC6J0HUeFar+R+yCJwoHiF7TabL/u
tuglIP9S6yoow4s4LgEbVNrIap11ZXbttQDTLwbzZ9R77LbNKAzqE+EgOEgJyEl1cxXdegn8rgnVqQtt
PYtbY+1L/XM2YN3Zt0NYzDz5k6FQ0oReM92DvgzXVFuN92w7yfJN20PUHAYOWFzYtQMQvfk7CiSHdZLx
RMhxxcM6wuIHaPkwcReXPZIg6AlSrdSyYR0sbEQkbSm7Fi5kvsdzIG7Y88UGrRf+ICdHWtTtgPxHEQNP
FLZLUHjkyxYF302MXiDCKezYb8dDUBafFCw8e0A7/UQV+wjuQ9UQ9mPKd0gFUUvFAt9CCEi3DNsroikg
QgCDBvAdDjZuFGgIGhc9lzh22GJZZ6sgIhOAU1gTw8j0Cat/7yR169pndZjroE95WSbc1FGq3lz0LJQc
g/M0FMzWEmIhkB+/dEiAE+v+f+xI4sQBFi/Hp/IM4gxHKOZnXSKRDCBVvYMFNQD7BpAOMmVBfxBhAMA+
kEsIhvMjWBGjLGgCfyIksMx/dJ/vjQpQ/9szQbsnK9mR4AIDECceRqUSgLfg/0m4S1mGONbFbTSjSkwD
ABwNjH9vAr8vlYd86gtpwjiJ8W58a7/1D7fB8wJpwHsUDwgRa/hkd/v2Aky3yUEDBEFmQpoc/Qp3N4DI
SYzD/HT/4PVtb0G7BaJ3r+Vjfi8fwjdsy4RCyMoTyt/JSwMainRvnbcMSj1MUcJr2v3vNAp9GIDCMEKI
FBwT/+tE8krJjjX8f7Xr4jCTNQRQc8bbIPf+To0EKfW54/cjGoLd2Vu3W5LXdkKKF/QxyfRhnfCrw69R
jVvZCFIdTtgLGfKMEMeDUUN1YJh0nD8SCAkPn0i48gPbrwT+dCMQKP/pw68YTYnPj8WtHAQLn8xJJajA
vxDodFJEi0MwRTMxGuKXrQFFhcm6BkHwQOn/QvRE8k0B+UH2wAR0sfwdfKkR1+R0eEkd/0SJ5YPlAyDQ
RDcOA3Nuvu+r9i6160jmvkkHDk8BVUYf+JmiUz91wOeDO2uOPgTRSRqdQjfgUteRMeHVS7a0Adog07FY
S0L02UP21+UahkD7I/pTmTH2WqNEbTdIMyniDC3PmWefaDs1DWkHFQHtAgvBix+dTwMcrLs13W7ZBwLh
A2LjCwETuBS47g8G6RIvbOy3u20JZegDdg9w3dQEc/PZ7d66OFXjA3LkHxLk7QnjGNx23abbYtwI5Ybb
4gP74yVgtwHGBBDcTrHqQgloGZ/9Ac77gxG2agQVXC8hMdKPixqAPwwXgOHAxYB0XspVWybGkc/VdeW6
CNsXa+FJKfHB1Sg4RyLYAOAMT4tTghveWPLXUs92PkwIdXiFFhYaFQgHyiY4vSpa4Y+5XQ9FyGBbrhBv
aLtqBkhjBIFkNT51CEoHRW5KIeEQLRB343wQMFECBmi67WMb4Bk0o8cGMHOKSNh20X2DB8YGAdCSE9g2
hO6nsjr3bd9Glv2n7T39p8evK+iOcEjR7RjR6sRIXwxbwiUK4xqn67boG2Q0/1Ag6+hw6W0TLcD4i2s0
XQhBG0I9+L8cw3irKyEcW7+DxwFDAvxwBeK0Sz/JnIt9t8n/U23qaq2lydjn/ixJ0e/CpZCfFKJhl17r
XBF7NBeZs5OZd3x1QXhr5r4hqUHPSU8Pe9JogL+t01VK7esRM4mwUGhYhIp9iFo45IILoVFBq8OjwEXD
D68wjhWlQ0Xw5XQTHKlww4ecQXUghgZCQ8wZ/5wahbcUpFtOnK8KgxqLY5DfMHiB/AH6//9m7V+QR1gg
f4H5RClApgao5YuWj8H3TAQFKmQDCoraUXAb+kgFsCBOCrNix4ORWVEt/UqEKf5N/U+NDDdJMeRemKOr
2/9E341X/Xhho4MH53gVSPjG/2+APvBBTVhPRc85ynRKlegCbCBfbMcCGgLwFrB++qDiHzx9t9Ru3U0b
RCS2Gok5QRz9C4EDe3tECds88HI77t9n+R1IQQKD4BzrOjHbZQAEawXyQ7mNpaJ91BNR2xO/m4qHOnPF
1dOJ2I11OARDKmKJ1AeJbi/a0wnDG4H7P1EjkwgSEs+PttQgaDIN6vluQTsV+/1JOfnTGSwNBsICiEkn
vIPWwQZiTmHwomGzgoel+Ron+merYm2ETggIEgYdH5SqQAVYDVOC58mTNVs18zT60HQPNDn/3wcC54Gu
Oyf/ehM6Bu//70ImAMLf6i0ZiG36BLP/tiLgy0+g5/8cMoDj/4D7gHYHsw1rxycA8HXkrgtcYKPkKQyL
Rds5LLw6bO2DECoSVJaGQrNG8nMS+Et2jmgCwf6MXlA2BrGEGwtQVz1/25hrbaXKQvGHBEfibVvFFtcP
UowK7QUPrYl4GN03+dAWDP9D9wxDDzRAeJ48FzSvM/7P0HQP279eT9sHAuMQuu6cT14THgbrT2wsZALG
pgFNuCN0fsdPT6z5T/+hzDMITz7JSfGLoIFMeTn6scR/K0/W8EwBwEGLTThrA2uoRWzLzXGTW9uoq7iB
dgyKLIkYdH1a2OEBxesuxXLGwBHNwOg7ckDdtuoMbxhUIANFKOz/ILBMddDnQbYB60pFi2U0G3AGJjAv
0RmYoGMb1C5NF20orUTgZRH/g8PPw3QINM7mzwMD8AVgIZQPjUjdEhs2TDD4A/EiAsNahtxUbqIW1gtb
N//gTx0FkSByFMDBBydUVMgWsTfR1EZV8ycBlXJFQeiqX8S6///yuCNFxtJAKO//BjyNWJf6B79/Gq1Y
/91C++0tBEk9KX3Ydd3rBjD4NkSbTcPKoAAUnLn79iiALxW2UAMGHXhBeGPbYEVkTcjaiPEBQVkE37EA
BIAosEXZdtTYuGvye1Q4CPHfHkYOysXxDQ3WdAh2vaWCtwmNF8B8QcrUBrjuQFgcNjx1XlsI8I1OAV8W
v650l9gxfZSNQr/6SKin7g37wnXj60XQehaiLQLsOk4D6JbCsFXbQ40MB6sRxhMqRsASMwycU13gDLdT
TAH3YBWUmgEs/MQDG9huVxBELFmYwQJ8fNUNthTJIIPm1FAA6HY9IPr4dA78CaCBUmA0HGNBoaCrbkBB
CcvYMWUXaK67+nQHIAocOV/mEu4JdGcf8yJBYXUQextua7dSP+YGvAQMGzlc+0NuYJonKHIevgINSTXW
PAAIED4BR4mzevSD3gB4Y3Q8Jgw14YRIMC5UT5zEN/JJWBwM0RDkIK3hAQxwgUBwBzMEAAC6gLwMgmqU
AQSJCsKM52CB+mAUJgUV5iO4iRokLgWYMDviCUMtuasFYAjyQZggTInG28uAjgJLBkzpSARJfr938Su+
kEtO/gCwBRjlkIHkwIwDA7IDwgeNhCTAQ/Pwg1kMalJyPXyQ5MOylUdoAOzJIJcogIis5JsrGUgOBARI
qIABb88UMWGx3/QOATvauIt+EkYoOUYh67P7EbABq9sYX2LpM0F6964ed0W4d0ASeOy9dIYV/C5ufrwb
rGsabgVAtQW7rr5c9QLkApNrDU4v+0utZA/DQP5cdT64AimOvmQCJEWJ9ZwQiY2l2wPu4P0BbrftdiBX
HNhXTRT3/11MsXS79ItkT8gBn734WfccncDetFXvovcHuANfxC4JbLCAibNyKah5NpCab16cCibCdgch
nOsbeUoumtTAT//f9ovQUPMoe95VsTBabElz2BlKNSBCB8swISC1rRj2yCC7A3TPsg2KAlosLUWBC25b
kwQgvn2wXwpTtJiCztFAgN0Ae6GLF3Kq6foPQ8HGt3hzcecCjwL50+qUD400eGvXSjDqxlfGCg9CqxPY
FWJYhDi+eywEjCF/DAO+dY8Qm4pATW3zSTirJj6xWHw7SYdzDNXkhhlD4iNQ1E8GKREYVUoDAIcYpGEm
DVQqXTVGhFqHqTj+SYN9UWyfCB7eEel7KlF6bA8fYUnMAZ/gRuMwqAZZbQYjxm7EqCAKvMX5gF/JQVos
hDkDAD9hxJNvici/zinGD7cyYhuSxv4T9r/GiJFvBApxBr/5l5xKRtEJOQZHdIUllaw+w1DoHPFUHAfE
8VptKWDWQqCNVuIlWkjiyC9dmMaFBrfhO1Ew2s/5CiASMlLAyvHRhuyFJcCFp9LrPkuQAankwD83CtgN
WSx30DlGpAhSzCw5N5ThxHeBxGbD9hGKHbtN+Vkj0FlSBQU4B+SSS40GCClI8DYsJVUdG+AjEICBFXb/
DgLfJ4nxSLgWILJAxogkVQ8N659EPQQ/iXyITIty2G5PgBD+XFYMehgDKg1iKViDWiHf02MUT6j7GVzY
MoubFoCOYvdaQXX5VQh4FiwRlLG7XRPYqICjXpSPGLvRhO7KML0B35FG+Ie+zu2iRDUGiIsP/JdJO3p1
2wfoA37weoL4AqWvFqJ0d98MXWwW0UFLvQQP6XCrRNz+OUQ8CHUaKQQ837WKhEEc6w6/XNJ0yYpT2OAx
EzLJkQ0WCheDJUW/xU9vsYY65U592UC5weEEBC5KEJPJb6tnv9dB/1QMCPdc1MT9IlgBDcBc4eswdcgs
GKo6I/gBNQ2G8hQQOEoWYo8oWzzpNmsoQgLhcHRrYl6AIPCOMb0c20yEf9tspuo8HIiQHHUojMXbR7Zz
NYh0HRAEVB0YFbeuD47DEHjIV+s7AzC0v/I563Yy6w9zuVxsHrCvCBAhPsHlBC0AwI2f2S0IjnUCnYnI
gAdOCUxh3QnPYicQEU8FNROFAh3DEA9QkkhEtEuFC2VQJA3LjQqleuAlZvtGKxYaXJ6eGyFr6AbxdJAg
mznOPMIY3zdkd1AEEYAQKgIjCC3JcyABBA3titbcNJAMZg7Eg9A/tdEcTzgRHq1eYr5a6u3BsQJ1DnQT
SUKAv7EDmhEEkwaLL8HuFTHSL8EOTv5Jcg/gH3N4ats7iLq1QSMUiFYELC+0BtFAt04pznQuK9N9iCkB
Mcm6X8+ilWr3PbBbdxh2af8BLtVTUXcJtDnGdeQkAQxi9odZJ8ncIwCBGTJk7b0VmxU/FW0uBIJczw9T
+KNgiO9IgF+OQXFTbVBc+el2DjUDXFduOxGWVwjhUAbffmvVkXwKFAhEOA4hdgJ1RHD/Bxt2wjFg30mB
+iIBTyYEqm0cYPP+b9H6rnirso0cEO1BODwbdR0ctiNJYG4hd7TQtge2ukzdoeDP7jZosG3EE+5mBTU3
D41yLzqorcIEs4LylqK2WxiIPts0In7iWsIC+ErbD0qGYumfI2Efg+d/sgiAi902RVgJ9zl5yi7wQV5y
5AJgdMY2QK7kyAk3AjdDYQN58q8AYQnv5MmUHNmiSTdCyJEc4zgXsNE+yOLX623FJ1uEiboUOm7HTdhP
bNW2/u8jvu8FPwfUiD7ybw1HZsgPUBwJxwsLHDkGgeH+pJet6u9oHg90KY2PIln9Jlr9z+0ich4Ky0gL
chOBxxD+ebO2oRU/UT+XwGRqGdCfdsXW2abHTInW3pCDRzfCE74Wkwv5jHWmrBWsrwAoIb/qPVJAi6fZ
nGhSB5+esUSMNi2mpSW6Cwh5JixI/x+QDhAoBgPVTxD6IQ/R8wXd4iNnINAhFIU4QIAYRnVIzqsCCPSf
QJ9kfwfseG+JVDtMJCB5JhvsofNXeTBbOOzdkOgVUXML/dgjAHOAQwa7Ao9YKAEG20VnEnACj0gObQZ0
AGaQvwOaVa26SWfHor8AQq+svmNl+OoQsOqLL76PSGiAsL92/+QgrDovv3coOQBy0y73PolIGMEPH/EQ
LTxoBkLUHfnIMaJdRggg5pAfcRfU3JgHGtlBEIBwMgC+Q3U863DfAe5+roIWM2k5zh+buUFOVl4HYDsI
ZkEHdDZ2zqBcz/w1ICZKMSTMs8E8GQcVgeyRIkP0aApHoBQpSlZNuIBR8QEuCotWNQLAKKDxNJkQAE5l
fKBOLTpjAoCNNAeAl6ILznQm+w4BCo5UDQSfUsjpJwAM61LFL6Z3jAaAjknG8KJtXwhkVSfzQSCuGUIA
rskkZwBGVsBoXA9LDKMevZHvrz5StDYFWSn6vD8QAP43wvJnnIA8AQq/LQATJwH4gQdii9wGDE2z0eEF
ubOXEusaZl/2H6I2o9ofievFSm9bAAWPo90S4kn/YPsdqMU0F2a9pOldhAv6dmZekSlhO/un7ndnoU05
4ghLnC6GGBuQL2c8uspD34AlaIwT1jUZqIAAUD67wgLAM7+NPL//j4EA8MJmjj0BCr9YFuOEjvjusv0F
8e4vZfDpt3+KFB4LNrbVnjq3NIP5qLcYMqDvICWhH9cAWrFg/s9nmg0D0h/sXkwByz/zzjvwVQgA7/d2
FUkA+P3OGzH/XnOh3ygQhgttAdjFXISQQN8DKcIxwA/PisMRcmXcyMyn09PB5GXeFRiOcHCkDoDG1+Vx
SQhvlyhXsjU57AXDCMMD8NvddQwJdl5DVi6/fldMf/bwh4JIdSuE20NkILsZIDJWvQ/rSVeCb0stLamp
6wKwAQLctZDHhHrTI5NF4LoIBlQNrkW1iNNWxRgCMOTIUVxD0fmgdsAbGVDTIwhkEMtYz/gD0TuZ+0G1
AXAaRIhr6TZgoVAJq9iUeFwbCwEDxgLP4rT/74IxiwOLUDCKSwn2wgR1dZO5aCFaLU9tYw0U7m6LXTcG
D0TxIJDKQcOSqAKzFqAQqSBGke4D6YJFUBeIMgDebEMuugIAANmrhYh2aJYaEf+SwLrYcFYYomoZoCUx
wBtJc/MzA6VBIi5sqw/nEEDzbf9ItEwOe4tINECKcDgZAIvomrgCSBCSYBVkU3IRj6JosSeueMCJYQbc
bEMs8v7RIwC5WmO8awUJ6JaCeTZg7EGF7LkdwL10oG9ZnVWLK4+Nlm3WM/B+xeRKBASKlo9fL+JCKK4V
8tixCcWIRLJtWcMUo4diq2Y9sSHD0b4FcAaAfcnAiEwVsS0LQkmcLj2z3dpDqDAnGuEPJ+BFs421PTY/
DoAFti07CHO6AzYgEh0LW3LY8CwMO7AIRZAGojvKKJJQf88ULZG8vtBPpIziYc+J8NGjeEQhIg8fvxiA
nAKbz9WmUrGlDyx2KHFGug25EE9PVyCxGPBDJ0iJ4iVDGmsKizjvaAN0pXYdTRdDelZCKNTdP4JEKd5w
XkyLVk3EI3gGs3A9ebQVjroBFA42jvAwo8kViXMgD1JfAi65TwHCL0WE7Q3gD+o6eC5qvYONRfeG39+a
YYZFbh5Bg/1cXW5A/V2AZdVuNl9fTkEn4BK0QEfjxwLm0KJwi/286YPaf+1WsBAhR2l0Rx7NAOCqfdiC
XZ67JoDvPfgd8HI+VKXA/ULrRjHAgpKAhYJlRkfhnOwVtCZYPXPCB2Z6BHuzrnYGJIB/oG0zMf+p+KQe
BuAkr3ARjz3ehA3qhzrLBxI9FkwNUxdu6JNou20CbBvrVgbv6Mg94dl1EAtenHxv6yVm6hKXfg+92/Ac
QQUQ4XGMShi9oZi+TfSOj+sSZePrCAluR8QzAu5ATAsDMKvgiVxTbXQV/GIp2oxwkloVBu3EW7LLdBD8
D9gEtAfAHiUJbGdv0LIW7c50ERlCGja8JNqCufOgid5SfCMJoyazBesdb7WVRN3tjwT1ICTZMBL16AfH
FhVihUewDM+4Q6LLNtMNuhyzy9CR6EKPrLON66O6OaoXWzwRgNtxq2gOsAuaKYiFhoUdKUPQpAIz0zXR
EjX44A+NSDDp1jzRDQcw1arLbxKz1Iu2IckLkHVkZKwqe3O7/Vus+hr9M7tzakx2BUto/HL/IEhsAKX+
4kkpxvXI+OB5+C1M+ultDFouKbCJCwa7Vn8h4GLJ1oiaeHPgzvIF27ODxMngMdtOAd5H2aSIbQk3IMo4
YBVjVKxoGxk5EGohImjfGdQBSI0wUAkwZtUhAAs4SB20hg6v6JK8frcPtwDwVE2LAHEGropPVRI0iwmP
m/RmxMsjbajfL9pCb3yDPgF0hIN+EHpNO4GFNwSpXbP5rtsQBB4OiEypY3HGyYjCI3CB+aMxweoOwEKB
JaLKozsEHHAElkml63/J98KuCexO10kguVj/4ThZlu0BtC04DA/gUJYt9onKRz3KVLYdgSWCtus3HRIa
C1ty2PApDDivWVCSBnnNAehPAK2sWcNmL9R8wQFqK71BLDCKhQAvn10FI5RW+eMpAFzAQmTE9EZ/ADys
tnVDQZaOmF0gL9K5Bzm03W7bc7YwMQJRCC95EHVX0G0Dau6/QUjHQd1b6w40GTARDDgBASx6iwHd2ZS9
OcBEuNVUdwEuMJA8ESNyOSWCLWDE068YCAT1RjlRnU0p1qdgf9ztLA9IquVzXzTk6m8baDNzHD9nHC9y
zHUqdCsFpjx7KM1J0Aa6Lf/oA0XIuAHHbPfJXGtAcr/rHF94AYI7YF3AIsIdoburZ7BjJ+29IPa5qi7h
EXSRLp8u8TaodrBVhulKjRyCXQBYH/1Ec14pBZGbyZ8UFB93h6ZrcnJI8p/Q8L3dsoWAAZDWQJ8b9qBm
N30BuX3EHPuXak2i4GYPRvFND0fqCgBPfWDlq3sJ9wGxrVT7tXsdC9wo5hjigY2CLhg3FjshXqoP8uru
/xXJw8KCCeDevbzmXd8GdNvuRvVN9ZAEs3Y4YOOpBeL4zBy5IQlDKCYP/4wmsbuhBIDgcjUfdPLfCx8A
FkAKcYnrD8sAaGh4QFbJd0x+HaxFByY0c3v599AUGmSqiGab7RzBISnkExcB4A23MbdAyCgU9TVpAUIE
N1LxlwcEP3KZdSe22izsKJoGQsDQtQHNsWV0BdOKQLQcdnPZMdKDhW5BusvtRfN1J1zSlSnKOnWniIaA
cHEp72iKtlrz39Is0Wtv4SP52Szyzys5FzJgB3N8z+/ogLWKJhbP1zFyyVl3xbLVLAaEYTDP6EI8s4AZ
iB3PudFic9kx7YSFPkl2UhGECwHRTe8bAXAwvG3xvR8PR7jEg/7SeDaR+bk197w1Fe7hDkUx9k8xoJVo
g3P8+gPIQTxu4sHuAqTztP2eKbRG7nqjVtYb4ifi5vQVzg3a2xUE7POxtgdvHf4MV8mvFLVqRd30OYhv
1zPnCjwPCe+d7tmGjBgDCgL3GcGt67r0UOoD8lD7A/P9bscgLoTtTrrz5e8Q5z1d090HVuAPw8Yc9us9
Y03XDO4c6OlQBcfMUPGMCgTPKQ5gB7tsBxkGddvKbb3vdN35JfBUyWHBik/XDdZYxyD+YMQg5stajc51
EMwcW1Z5dE6KD7uqxv6RdlyKd+4ZO/vdVOjSCgLaZpudXHADQYwMdAcTb+dG+CW4C03sXNZw22kZa7oN
FfPzafXORwEbwUERflTpURPRPaHrOm/ULNX26Z51Oznz4zXitFbBFMix4xG068iJjXQemxELsZj41yf/
TvVLH2owzw+rqDnBdfBJSPEq+qnHxaBYS/CNiKEUApIe0vHE0nRsKeEwUdfvC0GjV0NZZ+CNsXSwAf16
u8PHLtIyPjv57J8Lh+Adzwoubze2O5DPbBfa5QosFwltyBaM7S8YAwpaCjCeAvUvUDCesTEvxQoEzS8j
2GVbDgcZBnUvGA8uAMLaL3s8qeB4jCt6F5foD+MZO9cKAt8vXAolL+MJQkQKL4gJhAcnXHxU34ZUERAg
Y+oveGMjuFV1BJcaM/kx7QIaBRHvr+DqbjypL/pIHfBTlm+LXE5KOwcQe2qDYIHne+9jUyPFBVNDINtr
e+Q21FRD0nPQU0AXLrctBgonUANrWEtgGNZCgk5yR3BS0St1dz/doQ1jd+dbFz8XeSq6i6+OzRfuUsEj
ZY5swr+JEJBsbMAeFRM0JO8TUWNn1BM4E/cyYWOTOic49yRbgFWxbBNPugUmgm4XdghTbfQEg32KeiDO
AD7wcxV4FfMhAyocBGqpRW96hNt5CTCGBKyiwYFYVUX/pQd2fZYh5020BEKKFBOA+gJ92N5+UnxPCAN0
SAQEBn3AEboJuh40DB4pz7qI2oGhQJQ6W9OK/21jN1779DKBCPAtfKmAwnDZhl9sOTA4fMZAffc+t2Lb
F+10XgTgaDbi4NHZjW06oNVXOn4TGmwJB/3+vTru2w1cKYA6x1UALcAzRIwtgDnfkjHY21u4e5qE0ol0
GZByOH63JN+zEX4TWYINvw9t2duxhyjDD38CD4cqB16gHA0XAoIgBAK7ztWRokdH2sl47tit4tuKG6OA
+3d+bSl2KWSQAwPPe5ayuyD+daiNa90LdxKU23YD+8ByIpAI4/407l5MgQ0bEyaQQd5bijQIAwkHKFvN
1FuVRsD3JANBAqaFEerHQAghJ1d3WnjZG0CMx0cYKTnGhW0XfCR+6pt++3AUf3Owb9spzjgQAnAI60oe
fwyQZVvofx3rMBdYMkwC7vgudyC/E78jhJmxwWLQGz8zUGSsG7sCeAiARwZPgAE+bAGHf2Fz/RB/cg6Q
3TMAczBZob6GY2OTySuXFau1WMMeYGRpYDk6ZEBGmrz8zeHQBIgLA3uCAY1gzpQUihJ2kLi6vZ4cyZE1
VyGw55Ed2ZGmEJUyGZod2ZwhixBrgBzZZVenJJZyZEc2glqJNXgiSMgAZApeRECPAIUIU1z2QvEJUdAQ
LQWq8P4HJ6hVsU3xNgVwrIPERMjRgg+2wRDqCtZR04AAlga1cFLvkhvrcZD76KrQhYpn7bItGnhYYd7H
CP4pwfbBB3QSLtBy5ekfVANq4A0b491/41Z2TAbaCwwGTIXZdOkgc7Mlbqi7L4A8BhyxMyBgROTCdfGv
uwX9XwEME0GwAYD5BHQxZnRWBJmo7mkCVIL0aNfmErWNhiAlLvWzARsj+HbFgExIK+fRIm1gAz9AiiwO
GHRGFHVVstmbLvHFcPUwcmrpTCntIPCb7UiBvgeB4y2x7cjd5eAxoHR5QIQgiQisNttqE9UkEwovCtiy
WgnAKe+Zw84w0bEOr80nm22aJQNzc8nH62vJ0/12PnlIeHNCJAJO8221H0KNSx8Nwg0sG89q7y3A0+sT
jhK6dQWsCw0U/L4h6xxjX4CD9VcQjOs9J+sGswIIB8T/6wKzAw+3TCQKZsra5CrYSAaaakSIYHME3JCI
X+wMEkR3awCUBCFHFj4BEi0UI9oM7V1vGxShCO9Si+Nt4cZOMA8QdUwABiB1dCgbfFpg0E1kyYNp2ZKr
vgtaw/trymQoyBh4Ai5FVqEPMUFdEDsAkS25P4lLKNqG0FSDcj8DFC9RiZAwHcDoBLGQQzYAeVfXYyAU
W6rVPFESyYQNPzcGaEgoPHZuoTgEqBxp9zwF/90puSYFPApzCAQwiEQMWcAGSrbjyQ4JFB+AsdclIgQM
7G6JJDuByVftHgNSkFNCkTvftqKBAZFfiGUR7J9YfJ8jOBWHgu+ciyzUD4012hn2DRyxLVFhHBbvxgMJ
1kD3BfEQIJdJTK5FJ+rrbLlH5+IvVO6DKmh8gHwpDgh0PPWOlwoZjXUySAz2QDAE341gSBf+dQ5nGBHt
nlFe6wwNuhv2hN4gZNBw9F7Dvx3UiBIBe3tdSMGSAVUYZ8gO9LwFiBkQgDQPkAyLCQiaB9h36KIJGUcX
BE0chkWgTU/yOICFaJqY8e94ZBULP860hhZYgCsju8/ykGDjI6uvzynHDscE2w+MbNhkKd8T/xUj32Sv
BQp5ByAjCGCvr8WAXHJZDAcZMxjBWasIsMqXEfzitOuKIgywBxV/yCUJ99bB7h8IGoHJZwO1qpHwybAw
W8NmL3KhFRSzEC/eSWMvpODwv+qHQhFJIQW/hLktHaELA98KGhLJ4S/ZvRGaTt9DVjwuSwkISMEC98fd
hbAAOVjdLi0QKwR5KwssPFcUBlLcK5sYLICFKx+ctsyS9Cnc9grSNJpuNUTbwEWZxto8hN3SEjPa+WIS
Gy7Go6QBLq9MFqRuNEAarwJeCCtgk+kkMLOYtS8rBzGp5rOczN2DqjS2FycTATkzJ7AkCQ/kFUjb/hTe
F0UqCCUPoBGlit/IqdKdYtuiO14ubehJqH1DetcTc+hcSCnZQbZTK17DKaGIgg07rS0fdg+s3cn2Rqol
dSwn3RZ9VQPJnMqwuExwAsCug/CCbJGdjQ3rNjeJxCsp1iuEBiagAOHJ3D181Y1VEEb+UDQH1/3tFV8c
TjRBilY4GwYDKjEDYk4QgyImENCoNS0QAE4ibVAcGQEIcjGyPnRVHKPah3eIspIE3JaujJgTnoBwEorQ
iLQxISSr6CEeuSaodsmiD1qJ/CSo/RJP/xWBw39vJuIBMb+Qpx66AXYp8IZkY6tg4/EB03JkgL8J+2wV
zVXIA1AbaiBqEBfxOlwpgDFt3m9KR7XoglgpXEPi7BNVHTH5whQU4EUVgf5DbXuRgbgAVAYCQDEkiF4k
WQTLmOEk/xa1CBhrslAtClzkOlBrhKNOuwapU7QOEsEykzZl1x12REVgxmCJP55OSAT8iwV4xiM/k1AI
2HBAjGP5k8sImOwzAjvCI0/P+SbkkT8QvyMgKBIOVdsB4EkeumMq11DVB2GGG3bsw6QHZb8oWuDBMSLg
NV4lSWshglB1ewsAx0AgERpBkKogAb72xjb9YMdnaghZRKzhEeEKy314FuSictsId1jVO1gANKMjz79I
c4mAARls7Jf05i4QTwIAc0VgEMboh1W1HgAsQxmJS3pvRSV7CcdDKMyAG8eKOBFD/kNAOQkLiTEuDMHp
/vUhiQUJxVY92sQjH5whahsZ211crF6EBjDhuCoXSwcBlx3GwEV3kSRqkCiN6JViEYoGxy2a1Z1FHTrV
x8ABJkCdUUZo/RjVEaLPMcDqCkSqOkG8nXW0yFWh3ff6Q7U1QTpwkaSJQQQB6HVnn1D9iDbIy7pvi7z4
Sr0mECdiMGiiD9UebnA9c5LpgpbxVpIQ++sqtImtEeV6v8HIJISCD9lldKGQTaO3IFA9ktU6IzhNEH+6
UQs52dqObEw5Nru9agIqCkiN4+6oZBUwAPYcfCC+bfp1AVdDCrnt6w8BPI+kiX9BawSUIFem/9URtjeJ
94SDjulEE8TuhgiQTNQpNdw7FlSQXRWTcUU81lAKwPxcJDCxvTBl9UzXmqcCyAb2QPEV+NeN1/Mh2DQL
OEuNYR9UD78B2ViPldXIDCz2JmsnqNEnUC1Ua5SwTBFwOmv/2IsGEBAhcvXRIhV90PBuFCh4E1oQCrMd
X8CRiGGDAY39WgUm2EgsSQQIPRZEoQaLjhPpQRiE4vH/iyrA9yyIyb2QIR57YlSTRD+cOxUlGro/QSVy
zxQ0ABrwEA67JnzrRRVzhKYVALdW/Bv/008ESIvCYE9ChhhIi0XHzzzhN2xZtDHJPzlcwwD6MPUX/YEu
VKrbjTRfKcv9NEPcxSEZoB0SdVY00hJF5C0Th1XUYquoB5Kg2AiGzyTavGCp4bbFV04FitskdKPzIgEN
OeGgHntYo8yImIdcJCgSUANJSMZaLt/IGIy348J0jZEMiocc5HzvUBSSEOhcAOygdcgoBMK4AWm7IWBr
Z3jrBkbrAVURvm/scnBWYPhhEqIOFTBAzyD2YZYnj5ODLbEH5QqwCRMPNyi9m3brmXQsMpOWi2ooniFu
ak7WEXiSryDfvFaU6IAJHCLlXnsCLCvcRZVcYA5JIOCQEX/IQaDcQDa9vCO8MG1ATcdzHpb+AGAD/UdE
ScdHCx8REUCgZmBuulVUos5oR2zQBERYiGOUOxIA7i6T+QgNjCTwvHZgm/Bmx+3vi7oMW6wC3orl6gyO
zgAaWPiQGDgCHRzeHED8SrzWzXgyHCe8IwD7WxYMbwtiJ7sUVrZlYKI6JgNM3xCiOplJ6FhYVE1JVQZU
rY5uczpqUOJd8F3TO1F1G+JoDFUj1RSDPN8MIPAwO9x2TcxABE1QLGVwqrEZ+7iwRWj4dXBeIJabOArM
mAjS6tHfSARbxBaNZdgSYLZlCxSvtMeHhHDbw42RCI2cRC9BkVoVMKvL9jOATVIHBBOwFB0GCrCAGOQC
cpNFshU3CwPiWRu/KHfFh2AH0jsOWAirdI5DFkQ97SinukBz7Bj5Vxcm+bYjJGOBQBbOJOgQfZsXORTg
qnsYQK1IR5GM+DZ6SwkxwjZKtY2AJARtj74u6iDYACtXaPDKxgo1SMZaEYGAIwHfqSO2RFPwDca7mb+I
ndBPTBU1ucMMD8LAEAjLjq/DJYGAolW6IFVB4Ag1igyvAHfUXWm3FQuxiVQITZTgQqoF73yeCI4ARroQ
C9MEHpMC+KkiQzAPEP5EsKocGMMRE3pCD664uSJW1bd2w1xQlcSTwcaWAyOKdSCEjEYWKX9sig4Agmhg
qRjSJERPDBDBFkGIUCkCUBwqnsWTkm8Jo1/3DASA5+KsWKBUyAJqH2+vOSniT6WLtJ04CjhjCeoGCLM9
RGggENlREZmEaBAhAY6NDb4rxAhAdQUteI91eXfgI9dFX87JctIggRis85AfEgBTcoipVeA8AHAOuAAt
wJYqPi7jRceZm6VIFmZfggJICA+GDauKzVWZoABSGFLcXvxBjUe+PBeqGon1tzcCQjzX7wK3NIXJrPuG
dE3LkkFRxlDAJYJ2s0yYKgFzp/tA7dUNwolpHu6pqJ3dmn8bKV8Kz/uQAhhB7pu56VEV2xY2YVBRYdZt
OxMaQpkCEAFFAGFuMwUtDf5FeR5Dzrqx+mHmGzhh5tTNLgRs/8VNYp3GulI1BTPGYvMUWGwAsN1RThAD
Ft8IyXKsRXRGFkMKfVu3wRYYQWJGRsCgXQgZwQFeUMPe+ITwD7ZRvzwacoWAx5/2PRTfA/8aQb+2gytA
KE+qfsb1zZYMQbZHoEE2kEMJY5yCDbQkh4RjnbUKwo6CIQEj/8YCGxTCTp40ekJ0vSSooyMbGA5bB4bs
kARAoEEiTgeJI3kBA12cM5vbagSppJAkFEsgfrd3p0sIdgqjCEUcnUSg2MCa2x9QbHYsYK6cTKq+3Fx+
tQgGVyWs6QJDV/Vhbzjn8MVurHjeLKBsejgVQ4Ijj55NziAV8GXyi3MYi4ZoCeGjHH+LHkoO2AhCDua/
BiZBsGk++RhMrZkAngDC6MCoRP8WSg+NTTCNVVeiSALYNoHJAtLB0GPQ78W+0biEyEg9XgL4cIMYoJEV
dAYsGTSDh4RyWNiEsHwqlYSX6H1TDukn9UG7PksVo6loz6L+oY/xLaCBQDqA+l8NS41K7UJVotAjhUqf
BxvDbP8acwWAwqnrDwy/pFsQXxqJeOOJ0SB+ZffjD4C65Sh4FQoPc6ojGKd7EVtnuIFia/whX2IpoI16
0ED5Y2yDmW0gCJ9kEA2/Y9Q36Qpl13ppBnGKdGXgIFjpXYj10HOmGd5BuWbq5mOPBWYEODxlnRaNcLbd
tpf+HI1QyfpkBARjDgs1287Mv2IEYcbHhtkGoi2k9+FkiK1hv3RnxsVzpet66THX0FALmwU3Dqz/CN6x
cClkyE3CwsEYi1MgihcBh2rhC0UMPuRI52hYNIOASFdWu2EPzVlxiUHYVHQYjF8PFWQS9XQM14RZffuo
DIQXMkjHA7/dQThSBBNGBOGk4qNFMWdbZLHkhREIyANr2LGBzmOtrA+F2W4Au011GWaJP+uXVIAlKQ4l
AL1R9uwbix+Wt7bhjWzzaYTkqn6Ae1AD0nZFAANNf0EnoKdZCGVRKwuNysUAdUP4GDwtIzpkhdcC02ED
aSCpwhVIwpGIEKBB7Dp72RD8CIM7lkRaE9jFNy2ZCbCemaOCsU5E44P7hfQMwwP9QYP/Q0gP2a8bdAlT
E56ZNuD+AnIPHAlAPoKvpjW48Uo2BCnPdErTMA4yJjHLx1SjAEn6TInwMBKBkGa/lcoBxnOp6elSGMmG
QP0IgLKqL8IKt/KKjhm3AEaHxsIBXOwZsm9ZmB+oB+YEdQgv6xagDHYhJOtswOw5SsIAgUNkAWbpsCOB
AAksOBSJCiSfqx4J9Vidcmi5xwfzxcKqFqJMdqcMggIAd+hkQXBpyCnu9ww0Ra6ji3YJNj78YgKL/tKX
SbDrA0yJ8pxS7LZt8EXyE9KwjvK4WBQz9bcUVlVBnALE7nMNDDcT/+t3Vh127AVkKQRQa/5jsOoDcjiJ
AgMAYI8kGhTszAoAQZhWBixQ1e7AMjxbw01LmkHwjGaTYUwsLgw9YD+D7EA1lnaDghJR2XYbCN4m3cQG
0XV1EkYVQbIB8mtA7xh3Cut/KSJ3TAXgLapUCATQP8BR17BqJkA3ZmpDoNinCq8rwVtAqep1CIDDbQfD
vpr7CXcZK3xwMRi7PfiD0xHZ6yfSVg9Bd3RHDbtfdQgk9AHCcgl4C7jOiVaWynYRBFkENDV8QMYuR2Si
tZan4MIEqEzMstNJtdN3jIWiroARkAqCaI/oW3cKZMBuZCIJOdEaEHCLAhHHy4TSULR2+0yibwwUEAMb
ChW/cvbj99vfikVhFnfuv76wG1vt0ymOQRdfZ1L/dewyUT2oKx24FFwqKdZN+Y00oLbYgiLIFdDYdoka
ayLEdB1783krQEvV2PwRmR+KpbNtw0Aagtjw1gYnVRnnNVyaYvdEdQhvTUEnSDLYmwt5eHQeTUXk2sPZ
A3waAUbkBvcCgmjb1hMW0RzJBXrbduRlysABl85I23UwruO2bfqhHFcPAl8IlhfWbnthBc2hIxvIKxes
4HvkKjfxMuAwolgYHxEYMCAOC7MgfZYFdcekfCQYiAB7QcUL9DUB4hAVc48cLEAIE0hDfgF01OT5/dG6
AG2ADeEPZ6eq1E0YCQAHQzRDIFzTs+2kfBRFYESKQk0kPqJ3KyGFwCTKQAnBhsYmlgsx/x+tiq+oAzEZ
BoVcAU855VG7Z8SA5KRp/qcCRysqJE8P7oByQTQ09vWnqFaJncj+33Y7RKTWRLk7GgDdDYpCD1kJ2hnw
BB9zz3I2RmUZ5j/rPwPUyR4SOnfFuwB1MncTMdsUNXPKUbGD3bzqidaSdTKO7iZANTzByyrqCfJifFHc
IYH65UCvIm68wcCELFW8SG4Ev7EewdGjjGyLdSpIERsVVQhWkYr+OtbFWXIx/zt8LlcQDa7gAQkGgXZP
vQREuJmwXzCCyEHVuIAZkzoCdQhBFboaVV/wbw0f1JwIg8oBQbwknb0WlCyiAR9mtooP8fhBvmwPQ+/+
UFy6N60PRvMHGkPyNSJmv111O0w5wcCMtNoC/IaNQp+UNwaMKNAeAV4YcADRqloZ0IGzvwh/hOVxKxv/
9sIBOpHs2AYaCDZzySa0B3E7dBhIAdUI195LASZ3JLugkX+Ri1tDxP/oJeNmubYU69hkD4EC/Fdh8TGB
hmlhFne0OyFBjwVg9z5s1jgAHW8yww+SYd0soB02gOsgais628LN0W5pf7OBLkhUrW0cF8LbQoaLOK74
ET0A2LC4K3YcSYE511tIdiNnrojBn0eEQtSQo1bgi1S8+wPARQTqW+7Id+JJQSFcGPtlp+tRQo+MSD+O
BaDSnwYD8G2p2Sag91SJx7lYig0KsAH+ff/IX6ASBg3Qt7sP6qBkeGS8DgLvifgTRnNxUyfB7gWemGA4
wKfgVz5vd+MYVivqfZ8EtTBI1TbYWsUmHmNE/fg3VNAWNu8caLgCAMWGNhg4TDVRpOCAFxgC1GrM+QJV
U/CQWEC16FKgaCAC2sEvDABDSfz3LyRxBmw0O4we8B1YqSUuKEUwSxhmFEzYL0iADQyqAhVH8NEX5KP4
nIxkFBXdHfDeGOsiiwO5FJaACH1q7hcwBAK06xoJ/FjeseuioQou8eCeSECFBZhhZxXJGeEKEqpWQsFM
crXhQU1fDaD7SAeanhXDQbS0+fvYltiIrUAziD5Jb61NiJsxaxAE8RenTDw/xHMQ8xVD3oJqLYDfrmY5
6Teq0Xk6HO0FVwlEWgZpDvYhEax0IKygcztY59oJXCAuGas1Ovq2rg0J1wMZPjigqtXesv4bgAbuhRBw
D2+LS8AGuKeiQ+MauVqgvH2LavpLdB8ETHQz2IZnv0Wsf0rO7EPN6eR59iGIkUMQGNRcg2vEpLQxgA0Z
YottdhyWPjsWJSDwB8zNaXeW664xwJ9uQBeENXg+03RHABM0quPVajlk2c9q/Wr9oDqgRaAsz9WqvZbG
9j4h5ygUYsG+aJrVvKygHcx2LwoW/ajcFUMyySBLyMiaASHIJJpG4m1gDwvUSAiKRD5M+N2r6ygk3wS/
PBnsJgRsJHv9zCShUBhru89jh7EhNFQ2ODc2DDYhCDzPvPpMMiST+v//WBA5ga0GUYZhriAvx3/A0c+C
LlOsZI1aGz8saLu2Wp8Htlq/gPt7QAwIgNNcfEv4JkAeQtN/GMCSBbVgjmzIqSy0rRJjlQ0WDLOoZIAc
QHK26GPCwUIdSP+nX+A4fbr4D5P/rRVqAhccsgJ0KXR47ASVLPhySInnEzJgX6I4z5TE61wnUKYelzFK
C3UXs5VcEKAg+VncDcjIgDEeGAyLEDRgAhDPPRLayibDTTM2hxzS1gnP3TwckA4yIQxzptlD+pC+4HCV
1bjritIgiHCk/1Osmg5gQJBCL58Y9EKio73mUkGt4gsNELAHn6WHUY1FwzmwmGmORLNgle5erOrYeCDA
QPsA8uIJ8TLcQbdEvLmyu5YwHw/mQXUzO2xg0BlgBDgpI5I9wewPUjtkG9qO8TMEvgROHPGK4SHRAlp0
UgPhJXIPdkj/jEx1PwEVEhINICADxqIWESVxjFgL8GHyNLQ8XTBouvZUtQqriRvYUhDikP0wsu6NVe2i
3VI2NiLp0Sdl8NctLIS192dQGUF8BuKy2MvpBvFtA5t7WhqBTgWTLbhnJLLDEEoCC80d2YB8HANeEFQ7
ssOGjRClIW1PIxuwAWkLfyihzg7Z/O8QY/AtvioqwcgJs+ce90J9WAhiyWqzByqBUC3CC2oKKjDUCNOz
r2PkBMArNlX/M5F1u5FJJZYMb/CAzpEc2eYQwKsSXgjL/qmL69E9MBLCqTi6H4yTF0JZuplHOIa8EGoo
WbSjXUsJ1QpZTom6C2Qckl417uk2r+QN9bU9HTVy7gK1DCklDSH2iMFQsVMs9GAOyQv7HbUU97VrtdRU
LTapU/cNqY5Fg1NIMrNxU2y5rA0K9//HTvfjdN9jnesf0OsxDRyE3WWw7esjCKHtuusasD4kO+oN+Pzt
V+y+RlJENQkguenACNghydDuSB7pojb/8LrNMcBEFx0kDbPqjSuorZKDDrPaMSc24rKNbnbiD8g9LGoV
jet5/VEhCLGLIgOGQeNli7VZN0Nt2wCBvy0EX8W+IAgGntjhVTSA9mIX0R66IHBR1KVVa2OBRcOEjvcH
sEW0Uxj7TNACDvGIzREY4wG2aYmg5xhBKqLwqlA5/W2IcbN4SLqoE84xwIcZDEJV8m4utFVykDC5FzEL
NoEgLmXLFUEtIFS8DZpBpZDtLe3aIoNGOg3xLYNaAoPxF/EEiT4sMbofx5EVCxXSAf4wWBj0qOoCIbYR
hCEnoPKjgFBdy+rHBHWl07ewbTCkV9IF7VlDRQR0NDIvWA8MDufmcXXUAoq+F9xvRIXvdX56HHckNrh1
q4nZEUTIVIoGpu228RJRlusQ8KWGAzGVFlV1dSYDNPdHiRYt5PQ6LEO7ZUC2wo5Qd6l6EXwftr2TwU94
CUFGv/wGtZVCvtpzeWJ4cdXrgH2cdLqXlVx2Pq18cEm4S3U4eBPht4L22wwVIxpDX7eCHhF2hxi57Rbp
Y04IMf6320WE5HQvmSL46QAeWGRQueU8Q/aEYLfkK9YDCC+BhWG5dF6VPEDgEOlhuWwYwAt5ueW55X+B
gFFbYeFLixANdDQkdBLQXRhLfJHoGAkzPCH8khdn6EQpeyCRyH6Gj84FHQ22xTQoCFlzldYI8uug7ZDj
iXlYAmAJxDes4GiMDXgOUgUdfIBFuF8gLqnoBV+TZiAR7M6aAaVrGKhaVAfhynxLvrTE8AKAgQn/xv9R
YBKKgG0cQKAGAKb/Nm1dQJRNzXAEnEGjmAADgfyCElYn1C0WThYLMgCsZ72xYGFcgE5JiYcsIcwo6+Qe
z4gFsbiksemDVbBiHZKzvSIRcbDmXK8mczolFDD/62jnxoTaSNE1uOZgxAsbL23uOUwyYHRSyicdwzBa
mrMUyu/rAUam6W3L4iPGsN4DdAwqU48q2cAYLkaB8VeS8rPGdT92EQwQePDlCx8R+IbbD+G6zDaFrDpk
PCbi1YUt96k8ZSWqVUruAGBYBl/EjHBA15BeaGvQ5THtgyO1QNbuu2Emu1eYVjnCGsNNeYyY5hsWAS+8
uZrzDxYEK+b35AKzJTRgtrUtpJCCX1kjvZZIhRfYQp69ugNLTOW7Fmoc+8hcPAJLtUHEO+SuDezAXoj+
DWIHCYyxcDqIV44bBAp+QfbEAXQXnUu73sOe7tDtHrXSzeMWAN4QoqbUNpDgx+G7C0yJ73sVivRFNRPa
EIUk6VN0pgOLc+/yANsAYnVe8F7k/QUEDnU/FFOg6y36AGHsqws9dynjAm/RaEtNIru3RIn4LVJSAV2R
EiyBeBpjEICfA1YQ6b3mPWCbwhQJEmkUsH6BuDn1doA8MV91DRNiwGLTLeuBlPVDnsXJ/AQxlL3ZWTwZ
kBgKc3KQsHgWs0yQcF6MGtgQHq3rUNHNCQ5JR1XrNU0T410JKxID6cFPYQRPxl4gJeICFiyEIUwESDyy
R5niarXX0azBpKBicTCPJHiGagP5TIlZaYAAzbY+dCkLDiniOCe0HeQuALo9vRvPgRIoIRV9/4PQQhGu
+QR0kE8moXEASkx1QS1s1cLxH3dMZt/AUiv9yL/BTXUCaEnwC94UtjnxdjsSdTRriFrhU6gTS8ayxmLp
Bk9TTxPJDWK1axO4ExzB7Fn6WjGsWI9KUHIC8ZAjdDk/GhOIIwMLcyk7CcSuZm9HcBc3AJ4a9rrrDRbZ
JYFHwsGki0faSuCllVXDDuCu3wWLaqLtKGIBSbaAQz+AaFWcnn90DnSEvgAFCenAKUGLbqNwwd8wKd1z
SEnHq8W2AI9sRojB384XGGQzzADMfFQW2Eq5q33/HllhVjdXr86cN3YYjbaEPXlw7MAuS0eEgi8ZQyki
fjwEGxG9a/29ckAq+pRJ0QIAn0snpOroj+spdrdgGxKCw4HzE/NnDjmEx/z+bAPqMSpf1Xex4cmhhKDq
x8bQ5CFXMv7/nNCAEASZ/sPgEAbyxeACLGaxMEAof6+JMBVM1b0fU8YgApPFES7C8XBQKnBhCHxCdUcm
URwkpcL7FcJF3CtCNYGbqIFTOzv+TDnRBbeDC/jDJkKagQpJjcQPcahCRtHFcklrCDZHKgRsMvKxoAVs
f+p2dYoEK8NNIHjb1O9MBJg8EXdja7TdxUG/AumWPKyWO8UfhiMVXRAqTHDDrYEiu+xzC3DmAl7OHRh/
Y4tEJCJhNoZgYUHixPtJ5SCByzgDS92PSAmFwYADRepM2FQ4WdExwM/pdjmL+Bmwzi/yxWCNckk9DHIH
cp8IAXK/wAk9jQ0b1dZlawcYinbucAmg6kGe3UOzI4DfrtwDBpDuhoeTxOtGF5MuNRPybMPYBBZpkKOC
lS95FKICVhBitic8RC1ISMTfi0xDuS4oWzwV9DE48EJ8Ro150CPLoXUTtNAMxwZyx6HicASxFjBBNBGC
Q6CwKASY7Y4QQMgre3QRCqC5R3ClLBWIbA9bblfSdAo4EgHLFWqEX6lR3qwuxVPAAVgGj57bDZtqsbDf
gcWrJq0CIXaSxzTpHu1b1lJF2tsxTYw2FSPAdTaxJeyRDXp1dE9dETwAcfoOXg8ALQB+WMRjMYRPESHH
FOwbjAwIhcLQb0JM20IEOFRIQRqwQSIhiEyJrWBhLAvoliEFoqaq2NA7kBQbFPx5Les8Afc4/4hahk8R
xvrFfpSATbThawn1xwHgWXufjSx4EWcb1HW8jXfQg6rWpsZuNHd7jIgDmNZ0TiVLASHB21JUAglB10GD
4raLjUFhSCQgRUQhFA4K3gtCZfZBwVuNRAnJYj8gWhTPHU1nH8UB27YowsnZw0cstovqd7hB6BZFGD5g
9ta9c8EXDAzRic+a1bvFLufF2PEx/0C0x7oW8x8SL9EJ+SRjIzBQX2lSz6OCgS02HozNCGK+WxDLjyAb
QV++YAs5sovLRXfarHgDgx0UpBi+O8BATsl2vg3LgCGDWZ8/6cgHgyyfPzQCgwbeSQnTxj/IkwUwpIbK
As2QQSxBPzTGplmSJ1zKKYUY7A6DND/xSoXaPyJ9TVoX1w5LAtGTKIQEJOUZh0AcCFkQpoCBRcCVMgjF
YrJOKF2NyST0C1bJG5FHCkNog2w+kYO/DhqVgVZr9irKKb/ohEU9dn85dXjCxIFFNcr0AshtLlQidh4V
u/bakj3dejmJ93DI4mF2dSM9y9Y2CA5Jr8mr8Q7FDRrLNH5aidjLoK+apAXDL34cjOrLMcA/OdlayixA
B4OH4xsUyhydQC2VBzEHw0AtGNTMXjYVuBW1gAcNH7MBiErxDAzJKUYwIJlbGXa79HUaWBP1ympEH+cj
xCMhGckXN74mINyw3A9fihrWghGZYo91bSEMQTBWunaCFV5kuchcPU0sAmITiwzPKGilr4B/Qc2/XSxs
vzLOmSn47ldeR0SjBm5ei19i3mSxiLYPK85udki3BbjU7Ew52RGraDBAg49LQXkCTJZHyOA2FLEFO1MH
Mc+NGEFsaF1p5xsFC63QLyrw5cZX0AyiTDChd3SQiH8sOn3/dCt3AQsANDn5AUQ4uF5B7st16ASl9oYI
bkTg5wFYbwPcuYtmqMwbTMv+EIjimIHby8xBVvBsHXd1uhHsBZ5IuwEA9a/DdQUdCIpXRES4dhTp/bdB
oNtZL9YFuAI/8wwcOWCMiK2L2MDUOERcCjDf3OiGCFeIgBTdWEELdAnd0cWPNPYwMtcKM9J2Sp6wAbHV
NwUCMTHJ/DiQiv/OHc5qfA+gVCIT3epoEIiGg8cqohCBpheY0IlYGTxsyBhFuwinjUMb3LOmiMA+viVG
BwyiGwCCKOsg34IUG4bAKU2JO0BQ+9Z3C/FPjSSeAPyOrUsKYDfjTCnrcl/tUxN35CByWPsFDc68Z3So
xv48Gkg7fCQYNq6cFsD2FVnVNt1nnDt27IAjecy2gR20B1oAaBDF/jgzDNZlQnDqda4JZpWKNmPmKWop
NwBunApLLSJD+Cg7lzwZRNbN/L3N2wgowXRg3fDuKz2IPn48D0gDfNzp17QoXgFtH45WEE1J+48vQ0b7
1xcBujjDdekDLdcUYVYQlQgwunrYasxtrmpv7zoDg0H0zgyjesATFAPGvTXV9qswW4w1hhR0VTUPY2Yv
DDrI+Gg6jl3U0y/KzCXN3cDFipgJ6QnrUWNlEL8vhkV0Br+FfwBqERmtUw+iFOEm5LMNQtELOPpFMU9M
w/EYBH/MXEJAIuWMIN/u6j5JC1iwHzq4AU7zC48CLnRYIO94QA3BtiBctIYQCND9sWqSfcqQQcZAQUPC
CxUFqHtr1NpmR0YBWgAdgjco3Uwg6wezqXAjSaoGg4nvvsApqeDDbCMOZpBOOohg7txMSdtvxwqW1EMQ
A0GKDDg9dyjBVh3rc/rBh2hV8SErz/dE9RgAOGDC9LgCXwmSUFPQPNPl2uuCdx9M5gpAsICDNTo3GtD2
TXjHCtoKtj/pJmYEMyi/dRoL3PcfgkuTcuPBSPCHATBFddrtNwkEw47h1EUz/4YYQSwToSPEJYd9JFx8
kZHxEMBIdwe90iCH7EJmexA2qAwvrJ3n0nZHCs7RXduCtWRRCs5G/lJILjnsdj37++EtuWTCwh1nsEn8
sNMAGA4xyVgzH2mKQhVXMNInjVgLpDoQvOsQhKVoLFrDMLBF4lRdSBZIV7AhqC6gAcGRWTWRtQ9kRFGx
QMYWZceRPflMw2amwLllZfEQgB/SXBdvCEBbMR9qyg6L2ffhZxanZIOFALnhHbBocrxLG//BWHQ4k5v0
ZMGTHIP5/wUX9ptQA0NE+P8JAn0UarzkDXkW8VugW0UU07hW5EDaEiSQD9BUtQn0cHU5FcQJg2JQndRD
wAZ2CcnAuYQL9kc3Vg6RVXUHJRKIbuPnSUt1QrtGEgdxF3CBTnZi4UN1W1/EM0EXS+tDkVHBEuEoj7GH
JaTPJ3bm59IyiqUBzN1aexYyiAfO7OesPTtgH3wkCAsYAFnrpHXb3YCdf1pMdXkRfpw/B5YodNB2wcFf
8myTjd3GA1zPpiK+GlIJRVd0HTl+OAcojgzIGgtzLCK+5E4Dx2Oi9+ZwG03EsM//vOsRFUQEwGxYRTjK
cYoSBv/rhCMiV0V0ipOCUqj21aIF/Y0lN0KKBA5N71dX0QBIRjcBtF9DtBjyuj1AKUVX1I8buqPCoNVU
lkG4W/DRdh9CFnAMBNqCWiHxTGdiNglx1UiPwV8Z7Amm6GlHEObjLMWeHgZy2xmFhNH/HKMIAYFLiVQd
OwhBnTnKRfZMgteCFLIKeAniifaoCp4pHaaCvbABdNN8Bv8WFQWDr+hEicAqw/JdLbyvYrQTO4wMqQIE
qWp4jzF1XbcLWRSvLlBCvAYSYlAWH6ApHVwERE1Ag4LQFd4XoR8le2pYFrcJlVLUsE20D5Oh2yGHFA0o
ETAEmBHQOOLNXBgRLZ/Ibqg9FCDUAgYNnMqpRoAJSAFndsEoYgatQHH8BbUPP7RgAQ3XxJIUg+AJdYus
bJpawlV1W0BMTFbRMQIqSEyNgJ5BMJzyPBhsFSP9yoP9sdlDzwgGRX8Q48xMc4K+2CBJaKh4QBGq6EiJ
16EGgFql76hzywJaGN0b3Y/A0hsb+0lV0nNVCusqNggaDvrzug8BNrEZv8ZzS3UzRPXfwWfkZDE3QToU
NkJUaKFj798VYqhvhvjzMe1KXCNyrut39mUPrM8BwxuS61vwqhJW1N+fduzYkUzaM9U5x2OiSICsoO/U
H5kMsylsCYpbcDF0xZzOfRQs9ousy1gt1qB3THAuQ//jxESKYUfBASeRi1RJnyi6BdYECkTrDDZOBgFP
AcYNyiwVDQIMRMEBnBV98DCMtFBkgEk9wnpGq8I/dPnkdQyxxej5MuIKvW9qRtz4Gg7LHDJKCODDBQ+E
0t/ab1GMNswEqdvNACKKfRaZiLgCDBiL6GdHvdfsm7iF9kaCq9jEEwaigwKuQyC1d2uMaPQxfeU/ifhS
e4xo6m06GsN0R1Ibd7ERW1HS5QjdOsJ9H3dBHFOQb03RyTqC28M5d8b3SFRH9sVj2EvpqMwRpagieUAI
XVGcc79OxS6iiJ2wKDH/EyNhu7NW5UcJ/SCQwzAEKbiQYSxAhJS2iy+ZZGApiq8p5Qj4wxQMh/pyIWDf
ED4K89pKxCDeBIR7c9+r4Yu0JLAswMiC3yYr8DJid0ZzJkgIsxZJN5p+eM4oOlQdR1u70+syniuimvzO
DwoZW8FeW4thjN0gYznLDMeLRN2k8hl01k/02SAgQCzZ2IbGpCejw95Mi+F4MWzIdhMo8BmCljxBm1xo
JCg6cQabFqRjrCOSEXvbdgPAh4Ho2zZT4ygA4C6wI0x7EXVXNIrG9CPrPLLZhFTPyCkisVRE43gvJPrB
3QZ17oO43r/buGYuormXL8p05CuZkIowUT9MTlMR7jtKLBh8HUOiP2tEGVKJOklFRutLP49JKqLIQ8Un
7OEfs+pw7drM61PDyEPYiSqRRE0iAYkyTzAx/0vLipOo+klB39zbIGAxf0DrCERvpIi4hguKV9FLvQNz
Po8Uxe4jBFnv5Aw6RaDimwLcaZ7QIhdl5QUznYuIFgoPPXIMwQtFBQXUxIjgW/EBkty1nwM1X1qk+xdG
PUsl8U5mCcF0fiWxRLN/Buw9Wk4AAA6j0O1eRqffqChBXBH82n43LXQNQYE7X05OMt+zwAuKZQvpXoI/
IsgUx8P8YEG9BLLvt8/KBHR5q3sEv39y0ds2k5EBGQP9AzlAluYDdEIDOwI7hJEB/gI4CzYXIAajAn9N
AAHjpQSqpU7GK89vekSxzxFFY0ABee/UYlSx6fHACKjYRLTtdeZVAG+h1JE/4cZkvkUb1ZIFxeI6yScq
YhAfXAo4OoCWjLYXZcFRI3ajJHEkV98gRHFDu/6NesOA7dTs3p4frx5BtjCh1NMcdOLWWlTR5GgTCC6q
aODW+cIU13RAVigaHRHd7e++U91uhLo+L3RMGzYGscBjgVzm7xvyVPE9RL1GHFQWkYEk9mBGPUQx2dY9
d8j6CErsgpZ+3b0krcUyVx0jRZUk0R4YkgwjqNZFMWMjsvLnxOryqLFB+BrdsUvAyI5iu6XYuoneQ4x1
HRrsErgg8lHB/yD9ap5skfJMjXY+HtxNhWoD1ro28kkxIoGG76Tm4y0dOKAuLdsjjfSD5eTqoDLrQuRN
FxEPMyx306zsLzFY8nF121kx7U2J1jGuSPOdchJMIT4XXPdL9hnB5gwx0t7I8v812V+sAl078gn68thV
5X7eu+saoAeJ1z12I/wK+kUJj+7iPc2pq4AjRHJWJMF7UvXJEad3X1KSYfwRxk7dQYpDAjzLI5WC8Y1r
Au1MJTz2khXrGXZoJTV0DrtUs68GwGSlO1IVZECO7OFjAQEeA2kGAf/Q6UAquYhGQpA/AaDXAK6FQMAI
6FxQXDBgAswbJBdQsaDBLA+IJQCpL1eAaF0AIb9rGBtkH1F3ITMiTPETVaxVElQkOBSvkhGLCLsTchvg
FlkF5aQ8DtFSfwIoEUkBzkn/QToG0Vc6TY/iUYSTdQy14+14D4ZEyQmcHJC/GkdfEFYwM1KXzcEakIZU
AwPdKsJuCVRj4GwzKLEBmCJX++dH53DUiNbtZX2HHRIVjkj9P3Is6SAk5CHOcRYVEQBVANgSDTvkNCND
FiO7qPjO4mVJB8+DIrjrjP+Wd7ZNKfK73eHguE0KNuFG87jCZhdiP8Z0D6g7Pi7odeBCK75Uuz89r6Zn
BC+NR6svntUIdfEi60GQ8cMDsa3qsmew4+gheD1I4LH/x4npjUHfg/gPJYjr2I8RKHji0M9Pn4Du5K3h
4e6D5jtQdCgwVZSqkfGN9Rl/ycHeQxlQoeAkVA3rSYlrMpGs1zrP+fF22QOfOHNQ4paY10KcHHY6c73p
ITfteNsFyecn8QkVAdztgw0sms14r8uC7AFQezELcguw7dZFCOAZwL8QGhz71oftpQsj7+KMTcaD+QcX
oReIMF9tSImcZN1jEglshSXbt/AJu9OR3BGkiW8IzF8HLLfbdkcYSQMgB2coA3cwV3ihLQT2zRIFgcTI
jAMLiVKlIuGg2pB34hFrMKj4lgfwOg0gFrbj5yIJ1xyqOiC6X2BuziAJAcOJkEYASYK5h10SAgaTPavY
ZFUjxseyEMLGHtj3URWeE99lZJN9wORAWEh5iCV7wFCuYgsObMIILECbSAwiYclCOG98YAGFMZi7Ao1a
WAEP5d0I061kpSWQxZ8LPLcPUSyuXPc4wwQ9NRHRjYhoH3QmCP6il+awYGQ99GZgu7snzs0g/xUPBesc
JeydeTK4Nc6WLvxkxmLtvVv0AWQXDCUeCRR1WEC5cAkS0MKONQBkFB24AhO/hILeJ6EIZA8oSwA0aBTl
yBFA0UWFVJtSyDYKcO9jCb6LFiNQHAKuSgqIDlYUD+wMIVSNrAjQAQQDKN91sCK6GI1IHuc9eCEKF9WZ
AnVZdFWyoixJ50CxwVIZO+hmEUWKyLzdIsIDSdnHQwiXNGzFjq0RQy1zmwOwryhGFd8eRJ0i+tk9AAF+
VPgFG2YAq3c8nco9RdzVDT1Zc1YGhRFRo5zfODly7By6I+FY+lgYAlBCipVfGLCECD4s0UpNxB9CQK/t
Q64oQbgUN0Z8KYoIEmYjAEWHihl868ZIH+dQnKyAdOXsnHBQUHJ5m8Lu5sb4JYYeWDlLLZEG3UJPiEk3
6WM5RfUF7klQuHwUcel9MR4GxZFUBmbXS2UBVsVD6ZeUMFWOgA45w6BYok9laptNVsW8ZYfwFgg08VVx
72SHGG8bY28dBBCJB2u/MGbkO7vQkmTiicNmIGrXoKgNSc8ie4IpAqED6bkUnJ0UlMaPGXSxY02c6rfm
bwdlF+FsbJB4t0ayLHxK3ct0BzaLiIt6kBsAetnYv1BTU5DrtTR0nFwVM5p4N3B7aH8GFU2aQARgMMZA
OIM2o6IAI9o/IEJ3e4lQPGxYQCFIIlEfA1lCgEnPRRt1yTXBe1etN5yxBwIF9LcZeaAIWEHpkUBxyHG/
MLsiiEDBRD2CaBBkTNwFD1gztukFXAQTgBgCEpThBoGCWIwhb0rIZAXrAwIQE4B4sEIXCFjbVyOGkEPO
TvBcfnRjQk4hJ90DolYeciWHuVZ45LHkCjlAXiOQAeQoUnxTyAnkZd8CpF7IoZBV61W/UJ2aPTIMKdhQ
NtaOGH0qKNhfJrafF4UbOclU4gY3FhCXdRi+L6Fmr7QxKBawQ7NB8YMN4xTGtnsYPigujagQKjBiwzC3
swWK12EJTGSTSSwWEbcCPP/XMxdMBoUbQBDRDnXHAqLOJe4fW2i5qCYYYPpUahWOhtNrFJmtADQez8bO
CmYvP1CSXwJeogYiZ5zjdVWO4BfcN0j/eO3p6FXxLQXQBqwbYjCCLut0JI/usKky8A/nW+119GBjPWgQ
KGYXB+t4FbuAEYU7dTy70WxXh//HWa0cJG4M8t1o+5RG32Q4MN2DHfI5iUxB6ysfTa1AiQ2jAUJ+Kkgn
Kei7fqv7dT7reAzsX/MDSyU9dDxyUAlVuNg1d3JZiYCT2/5KEWAaMOsMBDv/Sh8ZuBRRMCg4+nyTsZ5R
jxSscmcCEkLFxljyVgEdrx9B0ZKYEMADNTBa2hhY/KJX8Ozz6EXEMMdzdD8wqdNn7z2LCiB6oYePeUhj
xiz3mA9M+CSiQSgc/+19JRQd7+scsqMCExJxUk/4T/noIlokn/yhaJIKz/4fKBqJGP9R14JJnkofOaMC
/kLRC4HP7/0j+idQcP/P8BKLCEyNggsQiREGicg3PACBvonBttXrP6CYcWA58O9cxWV7/eZATlY3R1oM
ECj9/WDIKupA1IB1EggU/F6wAr3BDlMMj24Q+mNFd+02i+7zv+8ii0aiAigKMgnb/sAi+kjXabICqFbR
LVlSGV9Kfx6hiBRfLbICsRXIQzlRP3Y0dhAEhdLouMiwXghARxVRcotPv4SI7klUJAj2NQhRIwHiULIA
WYbPomKMIbi4zfWyiPp4+7pdZMSLqEKFcnQ/ZDPJDIn+AnZZwR81pIiSUcHgJAW4BUELRCwJgjCiEMSj
Y3r4bAmTRVTb6dWRI+FBaAmIWQwDXkBBLEa/W7Hedhng5vOK8p8IC3VjYklP6CLjAFRQuYEf4f5GgD3x
O0TyknAawVe3BdoOAXJV6mPLliLZ198kudmGUNSwAaARhggGpqPND/N9i6i7CGeOqgJjD2YRLbO+H2EF
9QX8///0BcdOWEEdCB8D2KAeDFbctk8j9fANrNjnXQrFljTPjno9EvR3TylUAayi29EC3BYY8DqGq6V+
QMj5AVuwV4I2Yfd1O5g0sJrHySKqC60OsiOok9RVWmz1ffMP4AQ0L9wHURMBug+scixgKH/jX2ot+m8K
0blkl7Bw2ZQQEQ8THhLEdTDfiUwnACcLqFi9dUSDbYCArAbrT0NLQAZ5/sqQ3LiBzCh4EMBZQD10vD7H
A9Eb4fRaSFDXwgXF7utrHOZ8TAEsRcV7VUlw76BO6tNEwXUEIja8XSAJeAgZ7wFzChWb6CEQG6Mx9i8N
izGyIOzvuAjJe1Qs9fiC82Qfq4sCMNwOLTD3rksWEN8XWbgJAAAIx16MSapS1BA9MyBPkO6wD4UK98Ex
vvrBUdiZgAoWv6ReTnZNRcEXFWAg+6wlNtEqkYp1aFQiWNAVJGD3opTd8fWMFdxNMYgdgKY/YBphEbQT
syW7ZqBTRRtxEvUANsCMbd8x7XXpE8F88hLw9Swkq2IgBKPlNWyIohpkFUzCE7nJ3ZI/CxUWP3wtXVts
rhDUHwcVACu6IExlV3YMXt2GtvNMDEjxNUv5ucHHj6BCoa2YQ+Bx7FZEBZAKA7qdQJ3EE1wHWOlWhIr+
OrA/dY4CQI+iHtI27JzjkW0GVHt6Gy6G8IBNjCJ/r6BOxhxX6Pam5eoBg9H3jDkQZHsa4ez6GI6dXO10
GoGopenfEDUopAjiANYR0z9idwlD2vZwGApFFfVDCF0FzlAjvLAeYYOJXBPCUJNtjIXbx8GabsNPRb3/
dSXz0EsRYDIiFcTRvyP0TwjWOcJyK+tGqsNOsxNuO25WSArP4LAZIsYa2pAqc2wULFEZDJrBHnUVP0oP
R9k2EZpB/MEXuDnadSxgQOtLDRZhSGVPUSUdLQsJzyQhZw1EsWckdNtsqIvGWtVhHfuA2cLv4ZHaJrDi
PWFZuXMzKuoZRHjGB4196nCg2R8Vr0/b5bYIKNWzY3MgA0RPHSYawYU26tpAw7MIvAH1RjuejU+rTjnH
O4A/MJ5sL0FhKbMBGgO0pP2XikUzGIE/ZnVsbHQI+W5jBPAxq4XJa0N0Ara4gPsFg8ur428ftOfB9kkI
zEiHDYVYzUkoahA2HyTkAFLP/1XGogND8SvgEMYurAI6DQMJQMQK6qpWMAK6rAJuCKlKWSBm+hIquPlu
ig6cI6LSxwPN+ed9bRA4dqoCKli6wgSkBCpeRBmPWUExV9NUKaLhkOBgVPL5hMaICFU8wPRNQhWuVPU3
jlDFhSjH9UFKh2SygjYQswJSPAJUeXcaPBo3ihq4o7stdXBe9OwChbMDGXbmfb0jDIASynTfmc0RhQq/
Qna96wpMQqDiexELsWIs9UY+kVQjiEH+cCOBKAJpDgsqQgEPDxVLoKLsLydxGwIP4FBy5BCSAQN2C0xI
rwIsoSYZCAGsy4AHWvBybF8MpLirULdTIwAPMYhRfQ8QfnKAFQ+LwKT7LT0qxj7FyO04ABl5q9ui2PhA
onB5WE5HKyKRToxn4oYpArOffsYgiEScWFSSVMW37iiKBCRrBzmF4OFAUFNHU+AIRXz02OMQW8BB4BND
AS28QfqrBqQDF9wG9/cxll6BnzfIgY3Fv57gDXlLd5KlieK+Ro4ce2A73Igj3UT2RBZBIytf/wQBK1Y/
h1DBB8P7RXcFQT6EELDTDgBYcKJD3lEPELob7AXYGjgLREgjEcJgEBHXYNeA4BsbTnASeINIRUexakCi
FADFKKJQ/mgQOhpL0EBaL0iCqqnvSPOhilc88VEqB34B4FRG74oYjUP9UbgotmDI+wOGoE2YAkgpL94O
QlR3oP23F4YFyKldm+Qv+Q+62UeFowHyILul1HP2UJB8/rVQgMq9agg87lJ2I6BrL+kJkYi0U6SSxdYN
C3SIGA+prBuEpxcmQVgLQoaiihArgDIHVJJP1H8BwcHYXozlPlAFiaor00+gE1jBtlBZrVAERMqKI2Sa
IxvjLw0/PgpbYFC5BYh2Nl2wqhg7ZpAvuBSnauFB+nvBeqkPTBRjlXqbUhUNxegW2VBHIw/GgebQVREB
k7gr7yGLCLhxpSpKS7IJLrympi1oBkVLngNC7x0L0lvD72+B+Wx1o+QXsH9tbD1OBlUDkIPvrOoSA/g9
A8P/ooNZC+noe3wSfqKT10m9CY0tPHSgVYMG71MZ9CUKOvbiPXIp6yQhoC8Q3YsYid+BcwWwJYg680O2
BBSsNyW66tOKxhoipdXNyeq24D20J72CM1hFr5ohJHKXoHuJR7YGBgPpF0YD+QwaDKPEMLocDEJWUeeb
KtqGHJtNPWxskkFOFiAQcyf4o+jYbHR5+A1/Qwa9evtOSHxAEA4tzDCRbPsTiVAUERENhzAC2rr1M54C
HwatAH6JTgGJVpmtguAFiILB4yCFjOpH/okeSInwm5dAwEavQ2JMQCupiiy+n6JRBt+VAQKbDEtAksuh
mtJySFFbAEoTn8MvUnDHbCGB+7oWhnDGulfTg7LUP7QVEYQVwYDB7yDFbwSPJVLs6THJ6x+wWRgInygi
izgagGBA4uf6AdAm2DLiREwJv31fiHzqKUWE7XMBEMHoCDwPjGrDCH2/wAH6D/BHx4aFKAIfYcHgBAB+
FwqZJsHoBwFJAgJ1A9Ex/56Lig4KTzK6Bn4VvDnudxY9g8KCu/cWVQf4deUHvjn7LaizH0ECypcEd+AG
sY0XVfuBlynNxzaiFvYXJekk20xsvwhokGaJClUoC7FhfGC8ubEx5bRA4Q4J2BfrjAruaDSFTInwAy3k
jI81I6GSIKDHSQFLEJc5GScD3glLkQL1ehlPBhAEJJDiSgPyjJMUdovzQAwIFoyOJGkDigzeM3Y4xYkj
QYogiwt2ZqM5iwOMSdwCDYyAmqqxQfIsONgvg6ACABe+IzuMqpWRiI+T0VIk9nSdAg5g1G0CSudSnQtA
972wQCIPgHw8hQrC6IRdSijQn0NQm8IDmeRgUMRJRDikQU4EYTDWIPmwsEtFnCdJqT8GwxAmEClHTRiM
Rgg7qhIwepQ6gEnUBaKdSKJq7lAnSsRiNxmiHArrDDIZpxoVxztIAkmPqn30+YKEgi+tSSMkKA4JBz+s
WAQtI0JOwpF40nQfNm5ILQV93wLqAXbd0XIP61Aj6o4ALzHtDnOaEbSlUg/aSQoFDQULYOu8HQAysd0K
GEw5CSe1J/jJVnhKk3UQ60f69lHQsxMPdDml7SZfRCooeKdNiC4E24kmF254XhAaBoQEdokACeMkxu+P
5TMI8E8/TgiwSMqCKFj/3+KPUhYfKVcQw3IWFEsfjxAzOtEESNdYUAshosddrYyIXn9f+OKdRF/RO403
CzUaCbv+sP4DIAX0EYpOGxG0caEKjXN+Q6hTyCUEe7hHFJUbhDuuCTZgRIOuBnuQfygaahor+3gMkyoY
DJIMikWgAYgPVgzdOQyCdjEHjlUfBgSCJgzWDWcQ9IlN62lLLIBB0CQMCgQ9H9gNMw65AzVgAzIYQQwN
NhypB3IOD7l/izPhZQgW9jFCMoQQ+RpPIhAzyclDHoRGekYgIFZSNDCvEHICBA+WO0B4j4T/ix/P/6tk
kiFFRSK5Smh5/wkKZJKrREQOgABE75M5b0EPQLEQW4P/bql6Kep3HbBsFaF+Ondtb7E0uo3W/+aEw56w
D8OyLNv2sQqJyAcJAgsGB+KyLMsEAwUNCMMArUCgP2sFwR6fv1GpXdARsEAU10rKVPAnIgGEJJRX///h
IAhIGbBVd9QDunauPjAjAdBABg8IhzAYk68DXzgBaNUCA6DDr1TVHwJT9USKL0Svo0G0lgZ1W78ERyeD
C57TQZoPStUl+xUxG/BxQhnlCKhVm3o8FdVRTsaqQMei3henhyHTAQ1nASwBKsRkb+6IoBTYxUk5xnH2
j8YalhQPVk2FKZYBlYsAtAi2WFXvQEtGEXuRchsiFxWvk2AGg80F7RSHoeexu8MAaPYggzgiHYB/v7EH
mru2uAG7jS01Zrgsgm9BJRgWAgBvGyGgFA1lbYBhiA5g8cwtpk5VLEHX85aIZhsoOBU3d1jCpo7uP6UP
O1LsQxyA22SiQJwlUY89dRokQb8BT20B72xS1SaO1AsAuNitdXaaAkiCScCx/9YMbBZnD2GLDdsanoTy
ngUg3AhfP4/CCQekqnXLbMg0F4QFIj9BgDNIGbRjC89vPTWSxz4gem2UZwhodZvWBXPb6yM648a5WMRU
R+xLzSjyc8hMifsrKi66ddBwNVgbEUzJhQWfjn2mdec2emXBpSAvlAKB9VAAsxQW+gf1JEGZAQ6nRlRb
SFGQx3ODAD5i6+xY2MdaBA2ncIQkAwFvsKhqeCwMkEOoMSkG6XhRIwXkkJYoooKcdQOAT17bIApH6j3f
D8W0HVZsBRCXPvUAuCjcfFv/L+pjB8q1ASoRT+3ooUeC0aTsiegloWFAfVYgGRDeOAYAdUIsGisAEkIl
63oEwAF1hZ1Eg3U4F6mXeY8tFLgWB3bnhR1S1SAR92kCmqoaVjk4lhZCcKx6YDdlCQ2Egm/fBABLXtA+
UAejgG/NibQwFXEGjwe8BGxgKVVO8TlkEDw0vNMBEPeMDZEOPAeGYxKLVoXENIMwWFUhqNgOoB5SVD2J
jBVVEEaYjYkIYKOCKU3IQ6onMG3dNCPnDbYf/EmDPwF1BnjrCgV/hCMR/OAVfzwbWP/o2KjzAlCQZT8j
JwGoN6YVKSKQ1TwiTtaTI0M/5RHVjEOKJikAcRBIeMCoDhijBaUmo6meTtRAIEj/IUIqFkH3DcUGTKtw
txgXfw89SVJ0EgbdEDBWGmSdTQES0RT7xZW+wN2LnHIEKQADT3GeGhYApee2eNWGIqd0sGZI1bkRpirK
F54ip6VqpsUrQxSzbhLBqCTWwxYM0EWCPDQJTNizW93rwVxJrt+kVxilAY50h4XQCg0SvwQiRCxjEMHx
1NhWELHWASNzxs63BaUI1oAS3oAdBPfavlwS9Mc7L/u5whMQ7MZjOxWCdUU2yrwxcAHb5NIOEyzQnSgA
B1B7iprxAVrHOtNIx4eAWRUMfQFqVMEexJRIo7hjUwtsQBh82BiIATQKYCxVg1fAhTcGGwAHODgAEJAA
4GOEYReEn9PsOSMABIUR7wQLi5Etmk+BQcQHWZx/qxqMID/2/56GBJSmkxxYADyox2P8LgHvFiypkfgE
ZBQoS0hVNI4YMhGFRgSXpMSIRAHuhI1giA0fN7QOoA/MpU1Biy6aw2QQtyY0XhBWhUmh4BCgKVyGQdDh
PesIE02KhYbNMDVBG0U9BKh6ESMftfIhUpRjm1ZPKMBKIHIoUxlBfQHjMu1Hsqp6iee6MWHBquoTbrkN
iDoB3VSECnsQG0Sxk2KPATCBjwY4QbgcEpmqY4whWK0V0EUAJgAi697EpIocGW9FDAAXWx7aKipWDu4Y
OMaGgVbn+sMXJipiESomdr1ZUbWnNnSkgHZ9X1Q4KdciiDBElQoFCkCc9j+qUtSI+g+jzXIduMM47GDb
S1cDSRXDHHMHULcC99RMdQICpWpHzHHB3amoLstzUS8Yi2qLiBw5LAqIbxEURkQ6LDu7otw3cnTcSANn
x4nTUBj6YF1yputNRyWp+n0P+joX34MAOFi3R1fcH4QYaKQO6P+yOhQLdNNMAwWLExNac9ioghpMNUXV
Ah2uGHGKAEG44w3bTItUq3gHwBsLEusFn8hEicuDh0sA/ygFMBeuIAEkP8l7RRsAAsL8UjtUrWgq/AsK
+HAGgALCdBbcFcFmKm+fKcIUkIvDD5HVANCgAMJxlkWNEZPmZUbUFwDCwXQ8RJRB1AFgwqDeU9Rb3oY2
HKijqAUPCR8yaLKoJgXBYcbsAeCOVf7rKLfBNaC7EbWW5wwYD2p3FtVNRuYnCc6JgAhRZT/6YxgA27UD
mB8jJAOguZg97CcPDIC5nAEVuYDRDiPZVRNefFAHgNpIbABww2RjVJmNJCtJ2CLY3usToE3s3hjbCMUP
D9pNizcBwLU3Uspz27EjtoyzAWApvyNJR8E1ARHgDXojCwBtYUP4HFO81sj4YuHrsEgOkClHKxFRruQX
12Cg2ngvWVWQg4AgFUI5zvpwL+sLpTeAghDEDtu5wC8UFizp7LGk6EtSGS0jAE4YhgnCMP4viCQFB2fR
OUhRLAS09ixLqOIL/Swj6oABxdgPH2QsX/IKI4Cv2CzX9ShSd5NCKgIWSlRKz2eFRRh4CSlFz0RlANg1
qqzBYRk82A64pJ9QQon7Nd6xAshqLuroNQahDqCUO5t7TRGjRxU0NW/DXdV3SIDD38gBkP1A7MoBPv2s
i4IOEfwg6kG+TgI8qS1FRXMhY3gJqpFvCMlsCtVBYWwvG2yKyUlPDVY3prQk4BXGo+gXAWcQ680xwVsU
gSKJB7IBzQ5BvHEvdAJgFp0EIlibjIgBhroJBPsHxrOvgUl0BgY+UBchVQBukJmgB55GCLpLwAHJwSgC
VncFFnmk3gmyArHnlKoC3bfZbJjcBb8bRb35BrwbA53dBgKvNk8Bd78CgAhRTwkA8EZs854rABCBoGUF
tBkPFKBoQyQ+bF9+OgNpBR0SgwARIJgoEwQAh1EytvUeqIiRhyQFfcPGGqlJMFtkSWZ3vdfeH4OLb7wk
KAh7bnsXVCkBReQqB8FuaKqqgD5dKIiXjAKUcfjerKFYiGzUzEk7DADo4B/cKMYIRxw6QRaIIpid3dGV
hGeIZgkCZhf0CIhpmSW04w1aXCUcJAx2LMK0oRQPEFwQFHRSAKsQAZiCYjcEHwo4QhpdMF8RTUElYUN8
RQDGLRE8NAIFjRyy+UQwBJwJ2wxNDweLX310dPwanGsoqKaCNWgdL25cHwwE+DU75TqrqMEfi/RwSXIx
ohlBT2G0EAFnMDBaGPS2Fukub81zSffvS2AYWHUBnMjewek1b3QKKN+xRudidWkoSMF3rAoRdVonQGzn
hgEymj0cPFIHxodGnAV1N45/wBjGGCBvKY7QOgzycAFgvRyTnnRTqhVIi3RMi4k4yFdyWLBQfw8BADz7
zZ80DyhFDymNBWNGMUVwkOIwgifHfsebxM0c4GiiB33aSMMIgCEwfIkhadgPKEkuhAHrKDyBx2RJpCAx
CQCCHaAA00fDeKIOIbgxu8rRCERalYpsDWwC7UmKt4gDSr6AekLwH0tGhZswAPEJQfQezMKguABf8Ybh
hCqGUDljwSRUEV9W4sKD1npcyLM9L3URt6je25TCgPu20kcoahdAAcruOdTAieoTXyK4TO3tO1EFcUcX
x3QggIFE1fs/LnQa6Q//KOBTxOK+ddE+AwU0tjw/XEdVr6DW7sP+F2Ep/AZGHizremaQn0LEY5LADAqf
a00Bu59MB+YB4J9j95ApwnMTgSKV3x4kkyV/IXWIUehQKoVSJVIE/IYtkiBs0MMCAAwjBMRVCxJc4iCB
6Ef/SQuEckGiAUInb9jQl2z9LmptYAdLgyBIXWQnSBcnAOwCaiJ4KeOiDgAcEA90BwCFhUEXTQpwgwNB
8W4uKc6wB7AQLBZjR/QExUISA6XWNiiaRAba5nj2tyIbdQzrQDHSC3Q2REdUP7h1ckOEWv2FXBmNBYA5
LnVhO5DjAjOto5LAsy5Vq4gtVKwEJNimaNsvQlTyjSnTaLNjQcCBXInvxgVuK6qJQMMNSrkA2J0fjNZK
RXpIJVBadRlUijCJhRQZEQXBkIJfTxXBjgkQARt5hQI40LDADcZYsBQsdgL4o7sxCOARUFTAC817FkwS
zwIAyByg2K3ZIHHwJLA0wqg6QIT/ndowih9xkTx1JLhiWQWlTQhGBIzARDpxkPhPRvAiEMkvYPCzgbQk
qAAXFMACvHYve1z42fZAE5Gir659oLUiDjwPVDjWZMWNSybydet8Zt/ghF3Y5jg7K3RSropLAFuzuaAP
66pX0sYVvv3/jagGq1iyDa7YRcHb62Z9gDtS0JeK70CBxMgBpRajohdMrG/O4vsEwfNK8ugTiSMYmaEe
LQOcsKC6cSMjWJAjI4iFERSfkkTEmBPfPjFIVZikGPlmgqJAQbwlEWYs2Q5KIvtANmNfdvghz+wiW4TA
1F1GGDPgUzxkhT2ZepxjGpAVlCwXPiOgG4ofik85g1YoAIEkDJOIRhS6SXQs1McRircRxgG4Mf4B3a2/
W4mnh1c4DXcEhN4pog2xQjUkJMgcogAsdH8QcY1DK6DVqI3pIeONSFGiV31nAmaZArh9Yzy4TN7/5w64
iQ8EqwHQh1nDis422IC5UIv6Xry7AQYI41cQRU+ixmN7PAZJSdFRGxQ5bINRQU4Wam0tRNkB/+CJ9yro
NtpJTkxYKRiEETrtRR7PBbkRC3aAqG19lIOgUMkvgaLSU7REexx2yFS2wQghAkFRMN32LnBzS+uRf0Iu
UgF0jwrbLsLb9HUb6wCSCCEpGCPoJEK87woCt4IjXEZFiYqwFl9gKYCy8caVwk6NGyL89kwIAUwqynUW
MdJnCSNgXV8g2THJqQZAijJJwRKA3ypQQ8IMRYjQQh/uLtDC98/rMkk5wZkjVjOIsQjAIbtRFN9SBfi4
mGC40H9hn2CKRjlEilY0ONC2QXt/jSjEPAN0B7b6CdnQggi4gsNlEUu1AcY0JX7uDly4EXuKOrACQtEo
DoCr4t+EoQgGdXRI04gWCjDmm9ppu81GstMfEzQLdgvG9m607RFp+af0Oi+7GmL2Zu7rExUKGQlBBaIZ
EUOLKaqvuhPHB7kzXnqwLcHPFRwG/8Gn5+vfRh0BFY8gI2pIZwBn9h65NKHa32CfKAJ/A1bVHCIgKLhG
4VoUtRCaCn1JuPu93A9FyIEnNPIBsAEmqxYwDBSQlfBuDWgHKMCVaOn32eBFESSrYnTx2+3/jRyj+/8k
J45SAjWri0myUuQPblHcMMQEg+YixkFRHSHGtU0EKg0FHwQas2cnnUG773TsGDb+Ag+lSaWgFriqgcHN
G4XcpoXZwglMLhTdEFVjcAMH4NUGuN9F6VZ1t8EQqAFyPLdESWMF7whwuwXF2Okw7eLb7cNJ5WMsSmMU
mEH/4hUttO364zYCXkGqm7EncQXcIBzD/+Oftk0tZpHCBLHQkSkpGPWnDVbjHpHXTInGJjrbBTuJzsiZ
JtR36yb+s7suBXd9tgoPtwI9Li4+oDoptgYdAysgDVJREm2YQAlqWETvMg9vVSSPTCn4Lykxbo/u+UkB
dj4NlPsFQMF1D43QpLqGeVznvya4E1CestbageqHt9/rTvwYlBpBmrRataBCvuxSjsIIJ7frJjwSLrkC
jzKpYhBttpBCWUMBTUMLZqS2RAhzpDq6h26LeksDzwWjsV2A9iYS1PpXCAZ34fY3BnIo+xFHGANPKCpb
jG0XJSmDbwY8RSh7mMIiaQKugiJhOfLsuKEdHxSb2vUAoMFY5IOGQ49QuKrdKeVMhrgzCtIGhUZ3j4iA
pQq7e09NtwRco0YRVyGSGSmxYxtMn6RHOLu4Bi3W7oR/SnO560pBSZRRARi7QGRqB47ACCPBppAHlesm
ApIZJJ6ag1LnHHfGYGPhLqwTQ84T8R1A4oD7d5YbJc6sYmQUPT+C6OjwiwbAeEENpCAepNjvvRLIkB8g
/4VUfEQSKL9EC5myPzAzikMWHzwkMEr1BNQsanXVNH8TjqhNOR3wCgIA6xwlKmQF34Uw1C5YNTKLNy3e
BtCBvGrxrlsVxIC/aTRC0VQApRDQGtuKeCxMkgIJMQ1HKJr4EVEsPcQsDthAiFkPM4NJqVDEgky2A6N4
G4UH6gcHQAyCZnXbP5aoahCWhemoo0Eo/8Yyy7eKd6pPB6I5/rgtBR9jLVT+QOYE9satmhkuhv50Rind
SavYirHtNQgH6CBEGC7RsYaRvonFKsdAiqQ2oEN6esM+XlciGivXx4IJF3WsAGOLfcaMqJqI7UXazBbe
Nj/8GCrpCpsqMBVq43UclyBSBdWdt+mhqCV4Q5IUaATBIgbkDt6NwFTVdOsHCChW0SJdKqB4QoJeNb92
xYRRzD9jUKoDcggfQKQgVwjFwy4tXh98jlD8Zid4dHUfiRYIxcAq9R+BWbCK9Q07uhGKrYkHQy5AEkNB
D8kq9eFxGBU4Vz9GRqOIxQ49GsAXaENCRSIfMC2MYkkDampaCAESH0CM4hEIDjBbw68Z6SI4UE/gDo9R
BGdf/IM94keOLIIfUsCxAFggMDx6Ib8fcmTIIlLAiwAm2IJc4ArQXwGL4O1XyWScDCXQVF/VkKLIw+EM
FZyiYwp0KptVS4pO7qAScCvC7ah+CM6lpMgN1YbzHFUlm8zvrbGplggrGM+DPwtS/UsTB8ZHIAJ0Ig5T
KCZVJGIAQgXHIXofQ1QhI6BP2wbwjsw9bSyvews1gmQRmGmEKTpMlI+xkwRNiSpAHTHTEosrGZJuNik/
R4DeAQQJuB0jAAMqVMezMmrgEPSL2n0PsT37K3QMpZgdFqF3QuVHCLmRxo5f5NseSDDzgzB44eNzkg6a
HQkyWccAbEk3EsFQCDmhSF7YscudHqGlHRmykW0sy+1zKXsGaX4ry+wc7e+tVZFBL7kf21sWwcwcF6mP
ESRDNiANZRV4YSdhW+MdKescOYCcQFtcHJ8dysEgJzwc69L9BvWgdT07WAh1XmYFJzxY/0ZSpRTx3qgD
wbkQceAwAO5hGI1lVQUidCVFmWAQBYpKYTmAO6pCQynJdDKcsBDF2G8cuzSK3wMAFkIw60gkIn67RjJM
vuQbKTzIyDcUHc/MvggMooFAaLgF3OhtiUFJwew8iWUXRBdL1uNvPLoSAtpQGLxFEGMIeAEUzgAGwUFw
yGqcEfIC+UK8//8HDyYQCXnOFFF1A5Wy+pcUIwAgTyFAYQVwApK+iwpFDA8LDx+vBbXhFBCwNGEE34qq
yOMPAwIACYKEVMCeUKDG4ni953KDbggQHTJNEnBbF5SKCARc/xGww2ZRHffcQEXDoWjfT8YShhaIDGE+
/1hQJUzVw/B8jxGDqgtadAZghew42dY6G32sNht2GQ/kPho0cNYMKfJjJUMU1oUZI81JHjTvyBoOZdcq
aJEZrzcKybqZCBeRqBoyh7yQ3TLca6AaqBl1ZEi6s2yRMiV6gg0gB7tGjfcYOo0cG8k3PdyR0xjpgBzI
iBCcK2gUcgp5pblqDHhIKDgxErgFNhJgkDzIhIBtUASQgA/ZWwwe0zpuNHMCL6TowOK6IccoK04CLzkY
3Re8Ngoxm0KKK7YmNMmzKNrBxw0LPSEKUh7gBwJ126qCEIQBA1cEAAUqV6EHCwAnDpEWkQ9yiSEV+xVk
GIIFVjUwIzYGkTDvdh8CRAjawW9XfiA5AepYRXQDckD0CRUl0wE7T8AMABwLRE8IeAWDk3tcoJ59BSpN
+DstBQjCyd5Ii8GoVLRyBPR9nNpKI/9FuMzuAAGpolVx8bp9K1CiGNREidsF0kgAWkCIkBJURWoDFcXA
EdEH2+uJ6JNNQbpc1KvY8FDoSG5UjkXQtm32zj/bE+JY2wrw1PU3cOd5z7EittnmEB/XXyuoW7/Pszpe
bkEBm0ZBfxssGtazBUGNRh78DEF9ATgrPm04eKUCFnX/OM++qAhC8Ph0TUQcAloAYGdK74FiIVTgnUMe
VTQMRL1O3gJec1oceNFBCfYFoq6gojpw/J4RwXRLhIPiOus+9LAdBEKJ+EJ3vZoiuAHr6xSW+bYloMs5
cwEMCsYD6N3JpnY2mDdSMdLXAuB2FinGAtZBZQbcEIjjP9jpENTfhzBBvHSOWtAuqz4NWlM2QSu2UQNO
IHRVFBkBtVA0NCPWTdhOeKhT9wL0VhFUa6ErWE2lCEH9kiNxOVCtviGjoC4QWgO+DchDuVL1RPhMifna
hAjDVOzhX5M5Cuo1ukmVNRIEdL9+Oon1PY7zItsbhNi/I9huyIR8w5s7ckIqISMTcnIzZsEIiBF3js1C
2TpO2izg2FEKDtlK2rMEjqVr2GrLgcArSonBm6MpGacQQfrDul50RkF7YRopOMYt07UA+ffTVog+RX0P
jU8wkcJXijduuBySQtFV7gG5cxQUq6hvMjDrToEpGslSftuOVjk2NshYe+oC64bY7OuPdQkDHxziBMsX
c7KtD+7eeEL1gQ9cJCixOw0UkSQo9kUwq4iUJy2DqIdIXgTUfqqAJd3xOg0jwCMLCrAFfWAEooK6igGW
DIDBE3jhEhycBH1UJDCvw2YhrJ/hkX86bOtAqNaHBkWAxjaBZKymChISbfhU3LqwfesC/InIAwugSZq/
HBxYEe94LQENuCiJ0jtFl55VVwE8brZXGSwVvF8FQGzCFrsjSvXjdVAKFJZjaRjRbVTHSBsQ6GCJMvw9
ZIt3BKV1XA4mBoGhPXxgiApG3SkDA5KJTUWwQy9NSVe/MaI4QC92KXELJQNCRcsD1IMIH1QkSDytFtET
crxQPcmc7BJAbAs3EiOkkbAIYMm7niI6FdzOXt1GpoLmhWvQEXymgiFbEBLbDeyAykfyEOtqIWZAviHN
EA2u+gxUfQtf2RwVwXm6BkJ8DXQL9kWyW9kFURtYLg02z9NMUgkXRO9pnyHgaQw2QA0JUcDTPCjACiaC
YZ+gBZ1pRe1GNKu+gQ0OHWY2BAxhU6UtzYEckBOPGPEGJJccyQEQAYAUQTiJ2FpfK3BVibba8yiYEcWC
FVEiBIKuuorXMLoiHQUZgFukG7R4RiUODhDDiuIkrk+7d8kggjDQEQF0TASvilWWkeKVglVGHpKxy7AD
Oj2gIPJVCfSARQs0ElwV+gNJoFJCQgNPAY90OjoN4gg6+xXAqXIGgiiLOmD5ZpDfKoZVxY+sKg6sR2YP
FbvqqiGOYAKIuxVWDyAk+yIFZw0kOh9Y9SyaVbUFQDAALgoD8rpSJ5hVS9wug6JXNOHQOlxZ1TYDUKEh
VmUKIhl2oVWyqhqaASCGVa0D4M8ZxOoQSQ4jAIjtKYkSTYs2PUOCUbLHk8dDCI2yakYvKaIBDbRck2KB
HjCVAhqjLYA7B3JYINgAqxn/K1vRqNl7f/4CmhWwQSziVNVgwW/+EOy3yJ5IDCT/b4nn/TnMQQ3c/hiC
AXIISg0YdmeKB09MifDCBAFiyE+40AFDNEavUN28hAB+R/dDPDHAWcNvLKphYlCqlZLU9wboXcpJO14I
60KoxYq4o4nffwuqUWGD5wQ9EloEiQUq+DOFImaxIoMLquELuiAMcf5vDBB138lLQmVT6Qi76KAoWeBt
6EIAHKPlcypD2qK2B+U/A82CbM99syDLOKlnBwTAkYrCC3NOywYyIEToPmp4FkTCV01JX5hV8IEZ/Aq6
BMDCiqSBDMgkXOjomAXRsljiUByhI2n3S+sVtwWKIDEoCCIsGAwrFkqGpgH6jSwqTnRMQA6ERd/rBF0S
BAxP1QQBjxSfSSn1agGohFJWc9hEX6q/3E0B7GdD+qlhJAhS4dXhH9RggOIp6TAhDx/RRfsMPDY1iRG7
D7HHFcnrLyPrMUER7NMpIKUJIBMmI4JJLL8XGAkClj5mV/4qcpsADxVTMYPAAdC7gTEINCUkIZBfBCuA
1x98VeKN9EISJr8Q0i526VDwAXuJGHsNtyEJdDsEVplEjIGpGGFQEPHfW3ZPcYM/i/g7/wNZNfIwCg5m
j/psxSBEXLhkwwmqkFUvG6wCNiSu3EnQUShClADaqoh1VSoPDJRVRbIvDqwqdsR1v1oCDquKJ7nMAUp8
dJuq+DScRoz8qAReUhVjCyNy81rMLQwCpipEbQhUB0bcqurskN2m5FVGuzTRV9AzUWBV8UTdWxjmUvLV
9SLUcJY9sKpbPFfFCOxdw/VMRSvraZSqQgKZQCTCIgwDMKmawkBYcqFWS4OUVcUDKmEC9gtgJNGQ383s
gHHjKN94ED0kWTvBR/W1uyjLs4BwjGfHR+k1dRnSAdu94UkMxkfnicMGSN+GvIVBwNBbhz4A4VEg1v7z
QZwQOtqTvBs3aVVmBcGAwx0LOlXgsApFAQoOQBrMReAClKqJwx/jJDybGCaJ2Ah15fusAoY9dSjsVDBI
BRz2V9PCRfaEAzge67DxMOQi7A+28gs+BIsUgO5fSAxD5GHL8pNxVJzjgHDHBy3bdReiN1cpQYcAI6eQ
oKVUBp89CUFbAIOfjgII2lYGnywSQj4IMJ9cVgKQr5IvKUgCTVgCI4yKrz/wIh95GEJU/3JWbUT1cMIQ
00sDCMiIKrILIARR/QDyAUx/RwIAkAg5FQn/RwIthKjap/8CISq3EFPX/4UByItUApfIh6i6I9BL/0YC
yIHkAFYC7iIRuQoCBTdcRbA6D50ZV9JgEP1SghfGRzACmgbRKyI1lcGDaBGFhIKYAR/fkA9Avv4AI9YA
IyPKjA0cuV/yFwUkn2hcArUkoAU/bPUgUAABTn0bqIMkoGP6Trk6A3sA6QFPKwd3RAJ/eRFJQD/5Q0hA
WwqvPT9AAnpLEFKLDz9hAfIgO1GbdQTAbjO/TmLdQ5AHIAE/KVPiFQKHH+sfiweHpmiSPEibPzZAAaGg
vE9daEWpQQlN+o48CoCBFMYLUh3NTN8+HTtAmgO2UYAYjTQQzwDSHAxaEQQPG8IOIPpZMfIYQJ4B5Azl
CbDvCBsHlbwxChgNyGcGrRN7pt4RdoQsl5CKGAgH7CsdbBWZPTz2sAE761YVabzrQBUM2GQDXEEqFVFq
DsjzBRScWA3grBqQboiQEIgGOClVGVggJRUkpK+PjCFUDFVeEj8Y1EAMeWBTT4pHAaLggHVjC4O5Sg8C
BEmIAwFVCwsYBPD2QzAEixUCdATxVBMkTShBPDBbK1QL32flOHGWMVSt6RmLVgPWxUcENAxulWECMHtD
EPLpp0L0UriLyBL3IhXJgKgNTDxjLIgoAB0lVsUaRFzFdEC0kbMxAEwSEwVLFqwvHCR6goKS7xyAy5Fb
MxRX7Pa6B6OgQaCp6enGLlQYeM/uaAjC3GKGVuU/1RT8jII2AsQD9AXbjYUYyFMFStaMmwHY9lTUHmF1
EIoWpCAOVsb3EkRddzDAOPc5XgFhxh44SZZ1liSIDndgz0VGjl1sKWBWa0S4A/IkBYB8U9VlhdflOMSC
wVXbTWAP8jDD9lZBScMM6VotNBAyVvzqJeqLQ8YMAQBHJqOowwxLNBZBt+2KUzgYAwJLEHNIGEV9ZIhU
wUm9LAAiPOfOswBixlg+swOjqB9AdXuPQDggwadIWnVeVTx9CXU4U3rF60OVS3qhimSfl4hrCFGxALMa
0iX7UftjTnQd/xVw+XvbNTsteqoMCzXacCXEMiKv3+0SB4J8y0L8PXe3BQHH+L+LHV0MLMyIAqYf595Z
0REWLP0DIJRAHCmNVpCW/RR/94kFIjpMi2sQTDtr+VYOTAVUYdZ9/zE9aCsruK0B6YMaQRdQK4N9XFbg
jlEWdFQqgnfsIAdc8PeCdF5mfRtQrtIf+7sYRYOPwJq2F6sC91Dw+ydPWhXTEbutZ3FW60tpNqyg+9k7
RHUt6xcdU6zACgabIhiirK6gRBGIq/vbUkX1CAflBE6JNCgDnt0LcXwolUMQAYj9+o8oRkbsQrABjhIC
ukIxkE+AztgbZIUJmoeQB4RPifcibvdiRiyQIv9oRLgPIhAlhSwqWAqoQzaGNQXE//ZVUceKjlEIjlas
VvHDXMhcEfciAJ/6ReFWtmKJ9RF3kSDJsq/2IgPJkBC2LO2FKJi1ZIIg2mODuFEydTBcOCTgR+5/3nUG
TTllKHYWChZYUxretooYQFAwMduzYiEilqD6MDUA+BE7ABhuWPmbnkBdPH8GyVml9li6xZJzUA9WYLoc
VU1GEdC/sApuCvWR9SJlvdEE9Vk3s7bVgeMAItrtH/cJw0mJiUnHaN8vKD6U9sg52IxZoLYRxb1IzgNU
oyosi7eNd6Avgj5Z0YquDNrhFounZKz0XkbUbQ0AYAZN28inog3iAPswoJAsFgVftMeW1IA8GqtYpUEN
EN6FxiIB6QlLrVAtixjm+ZsBs0/0QtQx/0mn9OnwewIKaQ//4iHB0TAZFNLwVljx+7oCByeLKQlyV9rO
QLFE4CBPpkWERpMBUlchwv8KByoIg/kJdROKezgqYgd1KB/CRsVlVNLxzhnQr6ILTgg6LKyIh5p9OhDf
6G1pT6c+uPAiADMKGBaS/lTAIOi88CK9mIASAt9vsyjgUec6iwJK5x/0Itk2IFgCqnU9cyAHRETciAxQ
2yc1QTwcPdFGeAahI0gmrQeATESQYiOgCNuQKJ0JRZEoGCQ3TPo1hAEE//MCgn2LkgjU8yIAZ5uQYoMY
o79IGQuig3BuEBFbe5eSKlyBDrT3peBtRfHGQxmWQxg8AiRB/yLgXI07ifZNKRCuAD81XKc81SMC1YYd
R3VAe1uUvwDRAkMzd/4FdJSo0DQR1r7BeBbedfIRFjxJFHVAFGmHWxrdCqKn93KLAgBx1yhPIUSLIKAI
3xsDCXSeJERATMEFngjaA+Qgp+5IxAUSCE2QXCt8EATfhVwatgMHYGIHAYvNGJ2sT7xKBqsHIZPxLAo4
GW9cuFQsCvjkIEQkEFUo4MIGaCrFU5OJsVVykWcIN1dBlCAX14LbdgmzE0EQEQNNFGhARQhCgFABhiIy
V0CM0Fz9TsnpsASvIJVnO7YoGEFsbaUIHsExkmsQBhrUQiNsDGfbNtxiA4fo+kcHByBmigUi6BIF0Ag/
gI+sND3kRBNJ7nlICIIim07uIlcWBSwK/wkhCCaPHEAOAs9A8QvxIA/klVnsQfEAaC5ImU2q+FU3OH0o
pV+UYwFHxaECByiQBAUN/E2NZTBwUCEiPuifOubcx+h+BggBXh8fSKtfuhTxUA15UG53JC5jXbEKodpR
78YeAgXqYbh/X9S3QKyKkWGDDL6AYFjbXURMEYdohEpfpaKD8AHIEOxej3h1RBHhzGNcHcHaopIQq3Rf
EASBqnW/6GJtFolCFUEJNkJ0Cb4MiRkgUqi4VCC0wItEW4DKwUpGCfBOToBbAAlIcjKUEcWIB1QVr+OJ
pX2M490fAHgNQNoImYnNkEMIDwkBMl81TShREG41UTG20NgwDuggamCWEDbpKesUz6ChWCyTJEZu2AwU
w09lqm0Rm8io7DqoiN0l1zExCPE8AntyLnKERYA3MwZAMPge/e4I6BxUNWJF2CPtFB1JbQOel8cvYNPr
2gbBJN/C4LWQCuIlntvgIlws5EgPt0EsTOvAIzUVV9wzSusiCcBkBLZLD2qSKAifGBYQQaJTBgYiRDBO
/6Yk4Vj0OcF2KGeJ3os0XAl4FHgGF96FVgV+mnV8/AsA3ACsdh/jPAUgCADLqnYEMwCg9BZhHRO4gQei
iqEBdG6lAqWBxGEpiEB2CByjyNfE++x5FHxIPEVJv4tJIcc4jKBDyxdGGTOKy5ME/ZKANypIRMnrJlCZ
2KrP7Yk3WCCg7TF06cHiW5VpEni4FwneCTRsfAkpweQOuVIVDKKIDGshR3hIQG7d6R+KWOAAgewBmBCx
jA6B5aABRlwv4xKumMWPFKWNLcIHAqEiGHsK5cAvvBXFGEzk7mRzFfG77/0DCWXemwkrLkX1Z2tc4APn
H8neEFpnhWaQEeRkIbkMqHyCWa4IHlAxzMEDQ1HFKIMKYgV2eCLGLhzo8IaxHnkc8EE1iWcMn31YRSco
mHYM64zGN2BAl6qHn2INJIhYwU7AELZLA4TBkPG7fShs8Ex4eSh5Y+sVtCIVAyeImpC6aoPrKxcEhGhD
ohcfJXQ4EAw/6sqAK4CIiNoUDCHGVJXDAhgDlkA41mbvgA5U38vFTSh1XV9cGAS/TLY0b9MxoCTlcUjZ
OfA3Nyi2gmVYeVLVDw9YbLK2SgouxnW/656wsIA0f5pmaBAvUQSetYdIKLmgglSZtIQrwI0cgqNI0IA9
BQs89hIB7O1lkSTGdwHrHvGJKGAVb3KE2FjwJupWEnTCNAQp6iUawhm5CL+AgGJ8xq/JOEI06yDUYlwE
1LaMs0pBQwRmLpwQooOUYaZ/wLlsCyojDUmpxSF0YEl6nesXLzjrKiLSAsG8JEUJTrEcNtq4BdBPHkmH
BmfhA6A6CDNOJ2gkmgImObIULGBESzQo9TkBoA+RlppOResSTUEaJE/oUUeL1YyijmhcCDwEveoZN2e5
oz1S9bBaAcxg84dBKAhPEfD4EH8bxJhwgnhn02UNUPXBBkFl0Q9goJgwjhzR6LEfSEAxJJR8vNEKYAU5
yXQvimERPGztKWw2QAKnKnQIVeZs7V5SYxMaadnWhWTsB4ANeguV6QxoCHOsh6STPWhDxkbjCiBJRDZ2
wWaI+HOIbyLbMDkGj1gNe+J+NOMDG1hRWC4CyJOTrExl4oloju0l2UJ3XuIX7sKKgAGEiShuFESHKALi
EhFMNF/iIpMQhaTqmQURA1LU0TvUAKjdhVX/YCGX42YEMaytnQImoSKfMETALyk0XwX//1EQ7yXz4OF2
imiCiDQ54LUDF4wBC9lnOQbbkhXPEPgYAH5nFOGe7NA/jbzCZEVF2PZ6gQHAc8sqBxPyndEG98kZOVxW
RM2ROWfYXkEk9aRLGbjF4yuA7U54PQ1qk4S+HE2geAX0g8MwgnLkCJtNlUS78D+Q4BlFAjl54bVBiiV8
dyYCGNVlUD0VQuIWORAOydiw2MYDhAlECwnEKsZJwMXXRUgJ1JGz8Fz/i2Chgcn2cMYzQeilGGqdHUzo
can3M9hT5Qgqix3zGFsRDIGiZnao2bEhqoQgAGpRxH87MFfkdy2FtQEAiuAHI0jVoffZ1CEexZcwFkUM
u1AUAcsgkGEsEsNxsIyRKo4Vgb8Kiga3TbgOfOVvzBXrPl8HVShCmEA4WQGAtS/e50Ckbq9W8JLAErjH
LlG0hMjj1THtGFa5G0Qyl8UH0e4JFuJbAVTfO2C28MP3BjUlyef5bK4tveegKdxJVyQbu6lJAeEahYlr
36ZKUbRRDZ8VBA+qSLc4Amidq4v8V8GpBgRSSZ7VKxwBaFCNaIueqI7mXQIY+/Y/QED6xBBNOfx0cxeL
gCYOdCpv8IQinqpbjG34j1WPvZVanX0VEvV0zhDV68YrigkRv7EAl6x6FOs5r08HWF2A43QnMuICuOx7
FDzZL8EiRL8NQwTIaXwhA56rCNoMVu04oSP3uvLlvh/AGTshXnM2GZigaCAU3qCowULvcDpS0EjvLzwk
6R3BiM7medr+/ymAhKgPteAiNuDBXsRqfwVA5uAIUz0A34g6ibhAav/RJpBTxRAor4kQ6iiK1/5yD+CA
vG0eqGik0ZJAwEUAbCBcwrAER01gUnVjY08JBGx9AABFNoZI8UHCRQrLMskDAXJFfbEdlwxFRU9dIG9g
cTtE3gcxyWGxULXsbTZNow4iUxsi0sVtfqVxAh82F1X2GLnrRQEuqiGgy+gDFB3fSXLKd4L6FGCLcW2Y
RhjQEl3KeFZwKvJeBCRTdECgC0iJtChuqghEzOAiCkaRJAZFAMTBHhrFuGvvcgR23D4BbKc3Hxc3INNe
GQQ8OdMiHP8zkJMjxyPE0t3SGCEBHpnzFRDTw4jYBW3Y7G7eIo7kKSR60zQC5y3RSaovUP+2WWFMSER/
YCEzhpB6bs2Uw9FVB2HDg8CLSxB+dBOl6CEYRnhu6Kh6xlvSAjHAn7k2HFLQyBNijaEKUhEJfxfVLKic
9h8GIQFi3iI7FSAkRQcQuyHoKM0OInor0yGjBzkIYFvDySRxZMNuEV8dMijRPlWSqn4VldMiBYv6IAjP
XlXvPaNSBcyfcQlaqthBr4tHM/sWkKslykXsXl0knuhHGNDWUr90KFUcqEavVQj+YKuq7g7QicUBKhrN
5nqcD5gRLN/4lQAXRHyhgijVADDRBK4haLOHTMxsFzRVPVRnRRhUAM6KJEIHKEGLeiOIBncStjAK+EJl
gUwByGduXbFAejPiRx/FAVMkgO4jB3XWi2MBzCDicPUJlCDYBgXUh7s+Id4mMObHQzjCb2GQBB3gDoxW
PQIGsBGHcDlOJExQlaDic19t3a9aG/EPiFXk+fOLOKGwLkwDAYkNIEe4YN4Gc5Pwpmv9IDG0dJOLa1OL
twhOxFM4uB2JQyOIr70YE3R5Tm/xuwUEJjwCjHAj4LFIBL96A3MkBTQ8ourC2YpT/PjzyL4xMcDAQizW
gMuWNQ9jm6hgRoXJX9wlTFV9FgTyZ1ARC8I8AgYTRkqqHqPfD9QC5AVzGWA8Mk7XFFMoE3LIyVgPHDzW
8iqQE3g8cwXnZbRA5g9xdSrkBMhGO3L0vrYy2mwPdHleAjnyMg/VOnIzZLRB8sk6NQ+AHON7cewWFA/O
OqgYYLQTDwEImo8W1f2gqPYVtYPsP1BpbEAUi3pICFQXVDSgy9x1hxgVCykPKuKU+C8Sz1J8ixCD+kCI
2qJSI2XvXLLD9p4juPgouXCwg8VJRnm5N+vLNguKgwfHA6M4ex29E2aQmK3zmDP7/f2+clSFwLopeA4r
idBbXUQAh7fpWjtIfVL2P//TICkIYoUFIi+oVMQB7FiDYPtwA/qJyi10rAj7oegMltQJaL4Tt6aim2yr
TO3nBRwkC4cUFdhPxxRdHChDFvrnUKDOqogIy1AtFsXBDFAYHAgiQGSeICgkqMWi6AgwEwihjgYLaVBp
xHwLvxphkKaX9InPOdFDmrDYMcAWrwhDwQpFuKAmmiUNcliECH8bpOG+IiRFr/FHilYEzENEkmhRldyM
P8UbZ9sfFyLCHkgDRsIs4N2Fwg+TJS+Na2EVMcP/P6rJFDyJ05Gz4Dmk+4boweAICdAIAgPdiiqwidd9
xa8VOwA2cBjW7Ex4YhAD4sPHRFR1p+2qe1gQ14awJUktWbSZAx/Y70ldUwXbA0UDc/oQCGvb7Xa78gRj
8xZr9ARb9Q5T9gR33+2+S/dEAfgHQ/oWe/tBAcYHU/5Fy7Zs2wH1F/AF7OgC5eC579/aAesJHdoBw0ON
NBE4+A1qt213gdBEA8rQC/E3c/xf01eg3xv5jtQY1Ltt6y7JQRD9SsgC0Rt7/92a221Mxw0B/gc1BgHK
IrZb2zsB1wYP+gEx6AH+j4aX2GN1zLhxgAeAEdTfVmHoDCzg6EH357Hd3/Xe4EPB6g9pwvH/EynHKMIG
MNn34xIpkf8+tjYRLjyldbR92TBF4IhtZfDVdWtOd0aD6LnPOPgibO/iO0fg8EmNhBBJbA8JAAcHRAN3
7XZdEUYQCG/yBGfzdgtF0Aj0/PUMX/ZhtzsYs0MLV/kET/pDjxC6nQdH+zf8R9sBXVfattgL2gLYMDf4
hNDX0RW2A3XQBED9G9QNa3CGBjvSMx+OyFKwbZuhfzpaASXxBMgcXffwL8A38AvQgAEf9cATNoZ8O3cU
PvAKfI7u7vNka95NhnVQNODeIOAfKYoZEDVS6J+42jYYDadJ/1HPE1bRAjKKS0m3CLvucuaM6ErovotO
6PexK7yE5mbBRFIP4RAIFxoBGWdpwI74y3E3MZjPRDu6kA+UwKNFVTDYScVQIpg8eG1s8AVON2F25JAf
07IAEAAgCNMgWs0pG8wVUd5fMqAIq9lg9PAAGPgIp6hQfDC9feK7jYLo44AlNFN5/BW8C2PXZstUCASw
/epGdRQHfmaDDOjDvR0VqHQ3Ei8fbn/Z2i4XfAB0zg+3VCxmQQmLvaVnVh46NlptIup1yUSF6knrVSti
o1XpjOhA3YKXB4X4KSo1FalgG+dYeG+5iliqKfm+7cBdwbECgcEAwekDUOD31i5BSdCF0r16HINe+KW/
HNPnOfp3dCS3HHeJ61rR0+Oq6LjgC6tj/8bAFBALL0G6kFEIuNR4YQfDAKE0LmEqyHBRRAnbqIBGQPGA
7XZrt3aXdFX2gz4bK7e3qiva9xQ0XpDHDFbWWjvsSAH6JVDg7ibughhW1Oc/+FgWD8CDJZB0VTAQTw3C
fKnCLQZBv0n+CXRBI+BNPQd0M7Ij/5CnfdOvnJgLfIOxwIXDidqo4J/w2HyH0eqF0HX6AR4idyMSEnk6
he6+YWzZAzW7AABLVHUAPEoUNfzSdHqNXv91dAqCCsuC7wcoqpWWKkrC7oCx/9/E8EQpydPiSSn4dCuF
wmR8wKwd2C0M12UPagX9rUFx99ch+I15hn0zuLt++XLlOiw399JBIXYbQK4CGCpJGKRFv4hozJYCToP+
YDzjvxANeny4AA5qkAdzJ+h60bBbHcC0/L6z4kG8D1yYD9oJoEJ3BKA1FGUkaXzbE9QQ49O4ipC67xqY
RYg6E6NNqMc3XsPWINCURvNjHeVjwse3UGqcZvLSO8hrIuLA3cBUdGPuU0XwlTYlBSSDxiAWuh4jFcYV
SRJQranvSzUcPQF177cBe8B9P7CtzW5886kq///iH2Ltuzmgxgz4AfsgyEtoEL2mGdXQexVUaIcRCrCN
dWehUdWIo5TbQe3d+LZFCeE5+HNmYLwBegd2xGzHfH1oPwBZKfffGGy3KpZ/TxhNn1HEJWDeFEejOxo9
YMgVdLxHAGNcRqTGd6JfAQ1/DX8Ret9HBl4JSUiDIQFYI8MPOahIO0OcG0Z6rOEPtgS4luCF8PdEL+Vo
H/fR6A1fe34x9jjCD3zWuAmoTIkKe7R7dFDYnuwXQ8C7BvgvNnaQARZFSIn+jUr/IT9TMBZGwphqBy72
BSz83sQQYtzBZgUJtShwL1aB4f804Z2wYamNczszD4JXySuwFdgxfAo7R86kC8TAgOLIb0dVCob9chXF
CY4qVKd+KGgFS4df1UR8BNCUqWpQbdRnpi2Z99QP0Yp3GI8bHOlzEDRVZ3PIOgQ8EnGWbG8DXDkFmIIY
Vlt0C5TCssb5QCgQIJkCV1J72AHMlsXDvyo0slYX+8mhJhiBKmTxz0lVxQk0aJv9BfggdlEcN8jWD8ko
glcXu4uAQxFBRoDDgjoIAPBPRZ8s/NhMKegHjjRcQG3CjK62sEAXFPcPiggMvI36EIH0aIgHHhaNqNAa
dz6pqv/b7AEgGxLISLoRQgghhBBCeEX1K5334qP2FHHbYdFUAcJLiQyI2W+hRAUTOcE1gwLgonpmlwxB
GL72xQN0HMeMRKkpCudIe/sVgFIb8Rl16EpYKBq+jZwkogDi+IjtYOEsCHPznP5FX+yIEIncPIBWFNyi
8QiNUHdUXCKCdgODLZ7VIvllR4IMWQFsfFCKCDED7oK2QvGV6C4pwki4ghj7KI7EtpSJjYo25FgEkAn0
tpG7kUOJzgUF5g4yzd7a8YQ1ZjnCunnsW1UhZT85yA+HEIY1OEBzUg8FEaDaHercANAGKnGnAd1gHwB0
lUC0QO7tOSDPkEjVQOlpyP0MFUJojNTw2ZP6FatTfyusKeqy7AiCdos/LcUEu7kXCuiJGEUASEXW6Syl
WKXTf7/f7RPYOoHBYNHDeGAIBPun+CCLHEWFyc9khqIND4r0TCdIRDpgBTACbmZmKgj8wEhzQbsPeaEo
zoCKrJ8S0Ns2M3hplCSMQDKKiHGQW0k8CGxgGC8EWIONf0i0uYoHEWSUe09RfVVNSO3SEQpwRC9ZuxH4
djAsXicwkGAPVF6qFB2J7rTT5ntwDUSuZie3nkUw5BCAdhR1ALHW6eNNq3gJLOh0gJB3wL5tIBCA/kRD
dt+bYASB+gJIQQH4J2hMUQUDKSbXQGPsBINQKHDK/GjohINBCeLHg4078IEnDYcCPHyGdTNnsTUngk5L
A1T/RYCigRbIf/DUJNBFDzVmguROLYhVp4C/JWoDC34Xojd+keNJwe3aHIdMJvoOFrQafUCGyHm8okbB
hUl68mlCtXupfQ4FAT6Jw5OE6yIqtwUY4OzBEblJQBIKKlQ0IsYbVxHsttIeK3eKoIhiB1SFi/8ODBJU
EIH8ADBYAlHGQELbGEDWxgbC61SIjS6Fh9LxX6LaGbiCV/SJqAyIoUIAs54bWk4m6ZwUEMEGwqhzmUkJ
gROw6zrDwT6FJMXOD1TxHYcknRsFYSC4A4EKTsB3KtpEdR2HtIP5GnX30TcR7FZOOh8c5p6J6Xf7HRvj
t6fpmfgGTIwQGRlZJjm5Bgc6GVkmObYJCIzPKCY5ugxxjAQK3IUJBWL4CiClMS4Y3p9y8f0nalAigGy0
KbvJMmCuCSWz5/3OfgcyuwtKkEoZtOxk7MCzDBlevLPATsYODRmqs7Orm2zsDhm2sw8gvTw7GUr4jVbx
aX1WtRAO5AiyEGkOhAM7vrURabF7JOHAtRJpVYfVkuBj6lm/b37l4BG1IqkxyUQAwQIzUR2km5kHEBgA
aQI/YYS2BAo8D7CCrSN0okQqOIa0Sye6F9GMRCIHEEltm1HQg8HC9xMUegzisbQrdb5JxuExwCvTsADI
JnFmrh4NU283qgZWDRtk5ShqMLFEWbHrVU3FYGxfBHeK9dtarRbC84q8aA4ug7+DQTn4aShe9DV1Rrpj
j9I1cbbVGTiE/09Q9+o9CtbZapDA5AAGq7OUwW5mHW3xZ/1SjJhNN1QGO8UCgmAoGxZdAdAUS1FwcWzJ
VgNBsFM8EW613DjWuOPpRRGOVQB3t4Q0DIRDV99DY0T9DiMsZ4Q7AUhvhVxgEKnYOYWe3+Bo4uEIW1fZ
HSvjbjLi1TKCJpCLA6+LBrS2+S8L6PdGXxIvSZJMCcYvrJBE3EW30JktbR2SL0PvMGZF1ERIAAow5LB4
RWD1UBskW+B4GMXRFsRCQUMXykE02uh8v+J6EjQALqeA5Y2josQCjpyct2uCJ8DWWHjt13dMv7uIUXT3
841HAXNBiAHwHbUXVDDHd63rgWt7AJM/vplDCKsbsGNH/Ynw/wiD4SFXwQ+2wbSCVyX/Ohne1lUBgRSD
0Hxm/oFtzoeCfQh2domB+gABP+H2BCaQVgsIAbGJLIHqohZhsf5l+WwXg71a/kaiicj/LIawVHvgADzZ
EgRhZAQjwI48tJjERXkKBiDxkYiY4Cn4OcIWpgqY1JQEl4AW7L4BAFzBr8a/VBRooWNCi9/2wgRCGzAS
vGqKEtwXGlvQApV0VQBEB9s2HIn+FwHH4Idf5B3wobBgB4wcV+SOTnILGglBdNZFmbgUAWmNRjQaN5PJ
yVqGCo10nLs3Q5F7tOZEIeriAfLnht12f4hZS/gdd2kJiyVaC0sJdExtgL2LoCujOcAPh/5U0IpiA7u3
LVojJtsh0HIuS4xGAq6Ofdeo9YwmRp5VxVj3tg6o9w8R5xVci7UGKSH0Mi0OLmwUhB9DRsCVYyGCCzvB
ci0OaV66vWB/7VgPSicO+EtyuSCW7w+siBBj3SiCAcGHpYQQxkJOH3fwDYxtRnxLgHyVEcF9b0az+3+N
kYCHC8J/xholC0wQ6qBT1Ecj8elbWKD0wImqPgRwHbMeBWo/Oww9qN2jcpvggGYlhlwALf5e2OILhlXF
d+7vfyDC9mPBIIBNQdmTjN3RJWREKe1JKf88Pph9ORaKgDwJkIXQDNZ7DiyH/+ksDAc2NRWD1EqnxWFs
ioDGWNHuLI1bM9pBHy2GdLjOXHLuAdITMBgh6DjsNjIjYPByicSldGxRYZQpS8341QhoOLCgAb88+Bxs
e9EnJCTxWJvEUnzphRkLQiGGe7oCV3nu9rpds+EPQub8Q/wTihYpBiZTAUNpUxGHPKQpUoz4zqlVVYvq
ZJtZfRtiNg4yBv5+GjFkSwa/UQkQO3BQw2dzBTfqgrokBEPkhVrKdOAZcYJ/91d1cRq4UJ+yhjTqO2QC
lBQGCv4OgfZNVtwuwgKf/GoSfmluZTzy3bz+Zr3+SIsGwTpF2MoHjPghSxnNAVU4OMzCsSD2hCKJ8pYy
jc1AsdB1PndMaRxRW7Vz6klrnTGCBa9WqAyxzyr2kMLR6KwdwjHSMQu2H8VMiUaBNUPro1QfYORwSJaA
xaJBQcMFxCywK1P9dXgSwv5Mi3ICtAgLGQaLUhE8cotKjRSwQQ8LcQG104iPqDIFtP/YsfjhRlB8gusY
P0CIMGoCBBxCWMYio3ZbJuebQQOPFudRzZUm8S+qNExm98YAENgclmWptMrmsa/v508CJRw3mCn6i5JF
O0Lm7naLBRB0bYePPAkQAMOiEjgMlzK0O9Z6f+F/dj9YL7wnWgs58cyNeAiJztAxHkJ0AcbDx0agaBVi
C6pp+DgWDqX0SIn0jWGfJKKfOcMPhGGWMUcxAkVhAwOkTVFDM7Zw0RpZxn6PxoP5Bgi/BM3dbhsA1ogx
AnEBikEDBxg71gcCZWaQVtcygyw32+EHVscEjXH+6RK01b0BTAuQMGMqK5yC+AHJ/+FPdwbbzxQEigqN
QQYBe80lsAANCa8Neu3aq1oH/HqR69m9YM/wBMbKRwYy2CiCzgojj/K8imIw2jETAkgwwCHxAxt0tB8h
YgOQ4pR4fIXAHoaKYRp3d/Hu0YWdhCRNJEyJwUwElbCfVN9Mid4vU5F4oLtqSB2h7lMcUv29RFN/9RN6
opSs+llmUfzkYlJET2SwMBmkaDNk4haYCjT+6TcM6kvWPQ3J1Y5L918Lw00xZPR9ygHCGGFZU/dxiwZl
Qsz8aieaZ8SDEKHPif9B2IpaNw5VUyH+y2hBLqp7oBAVbqtzuAa7FY6I8s9XHEgVki4Ypph8DaBFndTl
xwcBicalwqsix4GEjaE1VbkYDPPZYjBsRFWi0gITVRAN/lSZAli8hdhAF/xonPuSVJLkMzb7GP+UXIC8
UA08eUgzSQgcCZP8maSZpArcC7yZpJmkDJwNfDHZl6QObw8NPAFoURchE0ieut+JqNkCrllsoEGwAJmi
5MLaEb8oWgTgAXNCBB1MyDY/KiYAE2ZH6RYwoZ7vixBacABwaXhItkjcqPG7ZVi5YAIhUAio7y7g9rUc
BYg0t0gSHCuwVJNopKRMC75P3Zoko8oA8ngQH3D5uq9OGF0wNDwUeODdVTkg4ot4MBwvTr4NNtkbgDAH
WSnqFDFJEvcqoNs4PkA+zg/Hjj0672bk8YG8pH9F1A/gx0xGpJR8eMYbpo5F/NPfMe1lkYHvFsJLVNID
AAAvZJsQ7BuSCrcf2AQyyQOR/MDJBDLJ7qjgMskEMpDSeAQyyQTEYMkEMsm2SKg5yQQyMJoQAoNi5ACM
gCTUIxnhGV2IDx8BZLAImh+YqosYGzyEHPU8cjzxISeWDBqwlgNdqo5UDN0kGKbpi5rioAJYQOI4f9Wg
ckUWA0NUuLpy+v/K1nJVDSgPlbk44G4IliKLHTQc0u5SBO+NVDeJ9suQg1xuw27a0lLVff6JU1C/Btfp
98A2WVheDghxkX8FADeb9TABEz1GIBokgXYtigKQKRKw0fQQYPuUUHi8MUa6GNFgWPmzxh5WR+NQOlxa
pasaQoQAilnBIiLER14eJ2QIDB9zfpFCB8iHhIuwAYR/ISRHSGhXGgp8ATItUdo4BQAA4FQQIwri6UWo
fipJeFG5isDYF4ijVkFYQVl3gQQXwURBCTUcaHJLVdsH7o9YCFUPQ3+gC/NisdiwnXSiNBVe9O2IlRNG
UHUlBwgTAGJoEQwCukhIaLR2LwxbXHw4CiMwBfgXbkBwFOmgNousKkcAEehLgF1YYY2CoAt4hiLIiHoH
gIBRFKc2BxQsoTJk2NmzhroGLBgAV5Qq5GCXDYBLEAdgAQ0PG+x4LrRNlcDMCWND5KDCs2VQiNPAqeJw
ywB04IRgdEvTA+/MJ9QGcyfUh40HD9gyyMlBMALgSIQ4Ug3oBZnWfwLuSpHzc3gPRAIXVJjCA4hAS5TE
iJQNFZ9xeDvZgqA98BbQiopJFR2hNgU3mu7zpjGSwoAh3bN4D77AIZqRKNMmInazJBaduswcNqSKFh0W
7PI0V9K/4rYL3ZU1E9iqW84WnzzNhDwTxJsQGJDmgZqMlLhLAAx26BuRly5PPcJjCceAvIEAdDSVEBFB
qVtd23UrKaoLK1xnl30GMfatKQS+24XbdCdvdM+iYxILXnUnNkrzDWPyDy4+wsCnfkA4UJvaiIXJPbBv
E449Ki4Stpx3l6DHf9owFXQ1g0aDQIuou3t1CDnWHp6+QQ4EWQTwrKiYDEv+4XjCtPGYHKo9AXfBQe6N
ou5GBAF1Uj3WFWWAivSQBXWm8QB8RWQUof+LWd0YvEwQWMnNFksRLZxa0UYAirHw9iGJVCxjMHaLbojB
vs/cHCAMQBzgoB9BILOIv5CcKnaoCW7KIN/ZS5oEEAQQIAwYpSpXwQjRufdCz3QSKDsefQF67MYdBO2Z
JsrBPVIUMF7yYEzWmsEpyJu3aXYL6SQ5Fp/4LitpJuQN7iVCvhtQ5T0cFgqnu7Jm2hBb0BYFCmiVkBLR
OVgyti0UEhaetGLDWLL6E5rl4YCcECUwBTgFEjBkSjgmwOCEk2CYvcbAXl++mPUAMOOURcZScIQhoMxg
OrklqgnxD+sWF0yqD3BV5D7BAEGLrXeDxPCDCIZWRnAEFPRnEJyZmIsEAjerKhgy95zrmrnJmJdxl/g+
DYtNhllQp54EzEbYW1taKqXmPKoxEyug0j39qNsJqXScOABBdQyrAm7fY5++kIA8JHQWP/qCBA1BgLeC
3DAIZB0gQMBDWgHD4iYVROmJ08chhHQkzC5M2A3ArVh5QVmrWouMFt2xj52DeQgDETNEuMidw+wMPsB0
M4sgOxLWeuAC4KCv0EVLQK+hC4CGTgMQCGL2XayFwB6F7FawX5JkuAmnuAYJkkkmmQUEA8EHMGQC4IsW
s4DYWjHtdExQQCQGd3AULOx1EkMlXbwIG0twxWiLIJYYkbiatYEZXzlVfZi1VYEu1QyV3PEAi0g9kZXc
PmUfFue0JNAh67q4B8VmLc3Hw4vVyuB0YIjIKb14EIGf9Mrrop2DvH0BI7SLZQ3oAXgDYCpIBscSjtCO
Ij5FoQEIdhG7YFBLNnSeBhC72++DOQRHnW0keQwodxA2HKgJR0WwYHx+AsJNIUtBBI1YQ9St0Uk50ocV
RkFM+IPBEIn9bWUN8Q3pF4n3EMzWlsXciXVxEo2KYRjfE0iJyzkAARHIQx5GAZu3m7dtGA95m7ebtz0J
o/bqBgPM/7P+gQWhJ3woRDlUBJaJnQ1OABumgmudaCbYqIQIRdcbsggIuZ830yA0hUXyGF5CIYQGXCFI
I+Mb8Nq4EbOGVQgNhGHDixEBKirNhBjU7SMO+jHtf83BGEYv6AHcEz76AtawAIkzRMJERNekHoFIpq54
XdYgQJBQpUAzN3sY9p4GL1dFZg5sUv8/mDqAOFVgezHGCBYk2j7xvkSAYhw29lYg+DAAQ86QgDfSER+L
jIW5JSehILrXwIeLQKGoGFUSW3VsLNipw0ga9/Fgg2hs1klVQCNRCjYAPv6GW1wCWg72dwpXOTRFGAwO
ZC4BFriFdqgY62drVhRCEHVMTLKo4cxFKmh2VqJhBvs3n6QkTIsii30rABPStclNOdh+lKT7HaVQcgRX
o4yEYy6Cq2zavc14AdaWVyqWSINB+ggTLDulzYusWQeWiGAjpi3mAjFksCGrMN8gcEWzMTF+ookNnQxr
GWOkSIUgFLsb9fh1H4ekTA8QjXUwwUnN40wRqYBHsEBUbNBGMwr+QaUCBC2aRa0xqtxC/XBXQYD4CTDy
51QQ/xuMRI1CMECIcP6NciICA7CnCX0LoIVuUsmIV3uq4vvYhX8DxkcCL+ugfHkGxKKGixFojYALQGl2
VTFAK+6iA8xr9hgO1G9Qa6N3u1EIdCJNaAOiAuyrcv+A6I2Kyk0DuNJzDExtYwG0KQy2FEIDVT+gcnKG
Vgh6UO9Py4lWEOldMyia5EYWwfQULypTRI7NqKQgeoDp2cYnhMdtdonuEwy865CkmjSMWBq2f16A/pcu
ZGViZsdABHVnZcZABo54wayBIjsQnRQAOsE2QW9SngzzicXhHlXJcmhXwIAISxKImrbRGAQwBHkvMPgQ
HHQWSGoAa7cOaAHOLeBqAQoYphMmWgO2aow9UrBgCQaaTCRghAmiJ2qQ7CN2QDDbyInEtdySMSACPyJF
c8wpV/CxwJgtvE/ghpeoDbDP/z/HuhhBkHbDYCJH3IIIFvUUb9nbPIvqwaaJRQjIRRBUwYpg6nxRTyCK
PRGmwtJWEBuXMD8wb0SZKA6immVBMBCwiu8mECGkWAk03w+pAmJmOAGn4CYciAE6kVg7vI4FTwEOpJMf
pCBQQBw89xgPYTXhie8uAz29R8CBXjsnsgb+BH9E2BXGqAJnA/9BVP2w4EMacAMwWll0a/2jggNcOg1U
CgL9jPjR7sh/SAOiOcZ2G+EyEDc3MhBBFJsKor9E2EQzBJHr5fwFg8Vc0uY7RCQQgG6VmwlI99AQ4SWB
+7LWYSSogtBfFtKHQMECY8dewkgA5AAnseCYwbZIH4tKBxxjE/tTUHAXGB8cHpA3rVCLKGIEWwaPxgjG
jLeRj9k7INAw7KCF5HA0QMsUwo8kSCYKOEL0sjrojK8cvRAQVhe5brRVKtq5m5fBh2dEFw8h9rIfk9wi
IlZJmgHxEkU8QXxM0zJgsdjyPFUtULfkBTIEWAUnTGBP6FAFebKELQQBMsiQBJdghwzZeFtwsy3ssJBM
BFvGLQ4ZsgOYW5DZYSGZwC0EWzJkB9jsLbhbsEMygR3/LQQEyA6QJ7MS2FsygR1k0LMlLQQOsMNCWzgt
+IEdZMhb8LGcLcggQzIEBMKDvJAHGAYQBq+GnEwgBSeMYxvsD3QK9KQJfQO3jLywCQYzMAY7PZCyrwl+
MyNtXQTUAFZoZT0u1UFH9x+ufuWBwqALAacL+X9x9KJISc/CPKA0oQkK0P8Q6kPcvUFbiZGBNA2LZ5UX
r13l7DahlR/iF0G8IuoIfBBtvGG5Nk3VRCzVMmikcKkKQ1HBRofUGxGT86tISEwTQBMA5NupAB51LPCw
YpZRoBWY6O984BAGPHggtrBWIwL3JzTGhAQHgI0lABdA/suCBmCCgyMGjYjdgprDICJ1A8QdEE4JdZYH
sFMBs8WxyKJhAJwx7ZvBa++ncI2MJFnfqkUooEKeNTOA6AE1kr1qEkGzcyIYEdQycLXAVsCLFl1I9Csg
BpZ2iUzHjvFn12hKgzwgPK3gNEqLAG0SwSwg7BF2kHpC47Ajlv0LHnUnFMUEmoYglbaCYkHMzgKISTAB
ynZrAdEKVRgd8FZBPMHjzlQHBJyAu19PCdP6CHXlMIDUQxVU3qjHKqKxbETDjXWgAbhVqdhIRPIrwtGB
DOvxIfbucN9MtDB+HIXAKdfkitrveMGwrnJA7NkWXYdOeyDfiRwIFEQSfmBCxwQgTQGIBDSFHbTVqSJg
ELldhocNlOPEILw4q/hJ3wAeSYH8KAFmrMOLbA0LYARNaFSgw1MAt4uNg3ASt3hOQRxGP6+noi5RLvsX
wsHYRsB2Ch0B59WgETtV0SlUwBQdIBAmBYxEEPQqYKog9rvaKAGAEAGQ4M4wRL/lQY1gSexiBH95dBZT
UTAW6Lq0WUyjQJ8gwBLxdR6CkVFvwwF0GFoSDxDMaDECP0boQnFoNY1Ub4GLsePtlTQECEk0AlF4VUtA
cEh16oBVuI+OYAJNf+JJLW2lFxMv+87ytCRuukdMBqBTTIuygruL1YNuKJxIzO4gJQN4kYEduZ7FouCr
mB6KSIttB1XMseBCEANoQDTLWghRSY6IRxBcUiwCUSia+gbdGdKNfBez8mwQUYlsKAaOgEN1xUwb+8Fu
DNiJFBlJ8wMAFqHdhVfhVz0ge3WwkxDFMiQyagEfxu6RkqxrsL60E2EAooFb1mYPSdgTri6HAOnYhJ2e
yDKs7ovCMs96FuuJxRM+g3uHrCehZXUnSwMThrEBRcEa9obbG8C69HTCgUNLQEmAA6ILGivw6kRxjvQ1
VD91XHvSpUhFyZrpznUItcN2JA2WESxNdpAuaUddQnPoljiSAemrbTCRyKZQmn5fq0wjNq9QQq5DTQXR
7IYb5EwrVCCYDdgkMIYwIRVBaue3iq5I8SQdYRerPBgGrmuwrzwLyUAoxgQ7u43Eg2unb48NqjoS7Bnk
s6o9EAaWmSXN4BlsBBJoa1RUMIDaCqUpQNBGSLG3zHAalKiKARHYGFCIaH4fEG7fE7sYpvReMIKMDagK
w2g3jCIaqBVU3iWIE18hMdIVMDrYJFuNqDgl6wNG3xpDSHUyMdI2vkO+7+QYUGRQbhJxw55BRgScn2JF
vsO+OBtwLsoSzT35fYcu+BL7iJAFqSb3HeTbEqkpJZCpVBJXJcjId8iwghKFBN9hzzOws9Al3hLh1OcQ
InUMD5AMACYK65LsAwAvKtQpAo1aIBRRRkNEroL4S4t6OPokDtRGnlLMJiHgBUCDY4qNVVCHUxgTY3WK
15ssRQ2glmrCefDENT0hMARlX4tT2AWAskr6FGswPNorPCDt8gYBbQeFoDdNQwhdBcSpqAyrPhVttYU7
ZnNTQFDOUS8D4nSkJwdVboSgnOxUjG2gKlLciYkQFKSAgHkPnIJNRBzA/0OvorhQDFVTyx0SXVTVTLko
Qb2aLUHBh+bmqMDU2EzsODSlqouKOmD0VXUiEs3vpx8Bu8UxyZGptRd0qhNApAjUUrEpegxajT2cUEno
r2AYBBLVAYpMpziBSMs0FAuALFjxYBQ7HAB10yQ0gi2iVL4nRgByAeDbw4q6FMUjo1MYgMDtTv4Q0MS/
Y1S/BVhbNzi4/nQtQMgITkvXgj8oeGlXBSHIcCq4YN4z67TH2Bt7ALP/ATlEFKQEgu907Jh1H783MLT1
L0g+bQgoQ7RJiYIvvEP6+Cnkw3UYNxOUGkxA5iUEAndr2Io3FzAHPEcDNdzFu5As72FJiVbCjThS5Ytw
E+5ykNGqiu2LMAtAD3btS0Sx7kwB6CMMiXCLahER3okA9NTsDSSMAlHlgkpBZ/BWoohWSvkJkYPCPQ9D
8z4ljsLABpY5iMkZ7LpoFN3erDYsFGsI6MBMvmYAUL4o2B0pwx7rgj/uPOyNArUF67vZUgNJURuSELX8
XwxOCAg78zeqIEJ0x0Zm1RBBkUmIO4qGfQF/zXqwqPoJ+AN0OeyomAVRAcAdAcGmBkiJ6OGFW1KPQTZB
7IYUsOvLn5a7AqFqCpie69FDyIYtjYn6AAVLQjvDiRYQ3ojCR1uJ0K8nk1XVsW26AWWJIJMdpNBeRAB/
O7BQRIYWabx0g5YRf1cXSJIR0L3LGHIUBSB8IGQEzB9/BLu9q747BnIQBEYIKxA2YASnkB/AxgUyGAYF
B7CIQlItvxAc6RcfcjgOdzb2haoO5ytyLHclC7MdXddW7E8DQklBOEQDUsCRn0zCT/P/SZeww/9PIB6L
RhQ5RxQq2CFkOcc3VLENpH87AnWBgibwnDHAj6gBUh8hIIhAxDZNdFHh06ZSu/6tzUnckKqHOGTly3rO
Xgr3uU2PebmrqgBJqN4rAs86gNiCXvfB+gNj0VtYeKyq1nY6RHi2NAU2CwK+IHIT6ywfEtlr6O53IQUg
dhu+GF85FOklHvJyrItoEAGxAQduof90MnvggQ0IboJVIDsYO9AvTLG43EH+uPcCGtAHJE1Qn6pChndl
8YsIihYDGkd4H0ShZgB5R323FYoDY+cK6RYInjCMn693JnAnfBAJchx3KqpHA1i7NgghOHBfHM8kJCg4
uAGksGFkBf9/MfaFoRbAgeZTSJNGuFT97NBo5H/7w4MGZauTI4tDOCb1Lp2BAbtEgcQotYHtgZ1mkO9R
XugBgHARLCQ/INRdAS0+5Sl3HwTdoFpvDOB/9oUq/jbGg8UHonih67qnblC7CG/rQUIrS4qGqA5UA6//
HKrom1AV2/4BAAQELyoyLIsUpQpaKg3QoYoKYQZ52bJftOuxz0Cw/mZJDhmaSD0KmouA0UCIFXQSPLqX
X0IGOUoPU9InzRDyvFxB6lNqgZw0Qz8RKHhfneVAdLYsdb67VUCHlsIiTAnwhNIw460I3PDrmQfyskLU
L8vm7uv9QAZAOKv9L5ElDDk7gEBqLyMVRB67p3nQ4HVWVd5ML2hV0I3UdxfgCMISUT7hfhYUjo4T1cMb
AyMwFNFaJyxWTQWUInNlQQQvuAsTaQIELMHlEGuDdU1xxQwBOlsNPUfWnUCBABYpJ0GKBjayAijfvJHd
qUffoPyKBlVRACvV4lhYsCBa4rclU5YwX+8DF9JMyVYEBBkl7GFL3CmziehfD+ywlxgPzRpEx9j7YAmS
I8L7v8EOK10Hn79eL3tCVLJI+OfoCMfsy4akCEmuSInoL5K1gQUYyBsR8mTAxxD6+qRJhGyX76TiZ1Ew
TsAEfkcDbxcKUXQiBAh1fX6MFvZivkx4QC+R7BA+Ab2MIsUbloBIEm9xO8N6UhIp6sBM5UB4HA4NCpUH
UMXptStjGTuSc3jpahUG8+eAAFAfMcAx7d19ICws66wBdmoPEkLXewKDAo09daT308DMSQGJ6JEfD7cg
AVEDjL8fCO09tELmySsTjMnJkyva//n5AbNgfOswkBYvWvYzF1ElRPkBAD3IIZnAL0y/RwhZi7mXnaSe
YQnDMo/TPczWBFsFAeCLhi0K+iDBnF/BCxUdlIB4HP3IRAQG2BrCRGSL2qrDY8hOxA3jx/528cIsHDru
rQ2l+LSP+BTESlna1iMcGcDJUkph8XdAQFpDaHZnSANDViygA2YkYjOQsBo2349kABmkgQQDVEGF3RXB
N0X7XfqwAwRJwnzmRQBmd5mleHsyspTtien3BkEp6cCyCcsfU6YsO1hXFdSOMcCL4G68GRdk9DhJYGFD
ANhYwXAfPE5gr6O8/2JDkEnNGYL9mA/IOq8PDsGtKtiJwBBtwVNDQ2C4h6/ImdRMIEFs5QjPt9EChqho
zAzvAFcUiLW+W4R2XEmv7PEpztQezwQVb8eD+bAEJA6riK6KVwUg5KQoGjAv4CnaFR10atfDnN2J4sN2
dE8ECDLDtOGchM4UyXIwkxABYQ9Ch8MfvCQo59ku2Mhf0ibnw5BFxKJupfLR67afFJRaQA9PNNqFQ52C
fPYnzyZjUwUiY/Yr37ovakDeif+xMdUBQR8Sww5jExVrFXxhvJERiahgUafQI2xAhZfr225yRBh2Tuuo
P4ZwP5agqEf9icIzBTHbgFu3SmUt2AmvBxkiGpwAAaGvb9XwCCM0gOjXnICD/xc+fVoIUy/OdArFNPhd
+NsdDA7H1HZP/xEKyFztM7b9lMXsDhQoVMeMDrYPF54SyXv/E3bHTFQHIMSiEQXv7Tx9ZyCgTZnHHIP/
Bmysi40/hE4/CQ40TphtY113B04ECAhOCGyGIIZSBRmBCAfFTbP4CCw8doA5rNE4MZQS1wHQCHiAfL4G
UaFwiJFrpoBb8DnRdX7AAi87A/C3gyvPFESLZThVONBfPgCgEaWqS29sM8yUZ3Ai8QSI2X5j28Z8DhyX
RKbGPA4fbYTl88wUyywgE8QICHXksCH1A3MI5I39um9WQFcDKsucOWxz2Da2DgTgJAgF4EV3+31IA4P4
AYHJtK9tOKZABcei78+Pxn5gh/9jYpCD/w6ZzPaxbyiazKyD/w+Z5IP/EF8Qtq1qVgJfCOAYu0Rxy3v1
ie/blLYNbDDoQ1A3GRy2X8M3FE/InxoOzQwIGx0Pj89Pg+8bEq6G9/A8gOCO9K9jBLoabDf9I0csdkuB
/wIflnt2cQkgPDnZzznMXHnPNIO8NoKbUWCClxCohGeOiIeO61Q/1t5Y9ylzhSTVPHaLJQW9Q8YMYrpc
Q1hHs205kHABddsKI2VFmxLb6ADiXEQNiXfDKGZ0HJjgC/pVg0IQZ5S44NNDLWaNzkWckfMKSklHeHDy
8qUMj+Ta9v9VKLw4c3d8DZ8VTsozFnWyj3lLrxJRYsi0TALchdkkBJeiIYsMgjFc69oIBB/ecpHY4Kpr
lMQkz/GTSBgmvchzi1UAeE/iJG/F3KjUkYOd/Kjd8cfxCChgk+PvpmtD4ub2psdFcD9nlqRXgje+TLyH
i4eATAcs6+DFvmouRVWzIVLc2my2Kw5P6a8eOdDRDQVj4UFJAUUQEWybBdk0GGMpkZ1ADwuHcCtsJAzf
H31OdmQ/DZe9jInAPoa16ZmlyKcr8IbjCA8wAYTwWG7wAQteQiJaxxzvwCkhJD/uGIrQ9gjFDCCgqDY8
oSFDdc90S2EBgBs4OLBT60EJxGx2hA3s5F1mkE/LhaiHcYtVF86kaq7qSMUx25XQNDou4U3CKdhnEGAH
B4IhrBBHHsPYhjWmvy8CLYz2wHp6s9EJ+42O8Mh4/3XZiVPvMD3veITxMokxwIvrmrNkt8MvSXjrjWfc
dmwC7dDwRBAaD8pcaHLkWSxxbObu0O7pdc9e65NSvJzL6TT3gW0EJh0/aAgekKyICANRY8loNPPJQQOr
rDB4IQhAf4P/AQGBMFLBN85LsIQB478cc4D/PXwQkq86ztSLdbD2kocXjNAQ2EBkGEnwbBLT/O2uwqmC
A1VCPUB9QQJKbugQoUkgCOd8ZBWzop8HtCQQOYaACpvEEsXPuQA4bOewLIINvE9lLQgsXyHQ8lMwgYXA
VNDM7JCzQ+BioPNeZGx33WhYWMYtkA8Ef3bZQDq7bKdjRLfAurFDRmhR1ksgtJzYIJb3rhoiGAF5GK6J
7t7EMqAIHwJSkq1fTQYHwEfGMTvr3vbQpESRcYuahZ91wPgJMM7qWuz/7Pg72Y6MgevXW13bD3HskfHN
POv661/k63gD0oDroD7pNJgAwRIP4dkgkLCkbw0RD2YQ4ciSNwd9FkpgsIMPB08vlLBBDsYdAz8QUYRg
B/RFSwYj90ows1wCuBH8thradklJtUsIei3JUh/SSwLudSAyHzItAt99e9AhOloBidlAweEICcsaYhSA
3dtId7fH/lwCBgtfjWUpwf2KwGEiTWHGKGZe9oiRn6cPzNxwhmRIeCSQwBM4nKNhAaSMI4+EskfqMeoS
sCM8DHkc+Y1cLQH2YJhD2WRkHNSQgeTP6syHwkCY5/MrMLF2EQo2MRLO/WvYZ/BcdzvtDZ/ppxnNLeuJ
6XIqLuIylpwddydh4gYRTAV2dezxLJZGQiDF0UJopAxOruzFIIWFsGMYQS1ZUOP2GAJ7JFrcVMB1OmDF
QYjaLj/FDMDaSnBMymkX7dAot2hgBflgSD9VsgAB2BcYARgLn9Zb9Ufw7AKfxEiodAGHIsdByVH9gE4P
pEn3z3Uvm4IntBo4XNcbyWgAoIFVFaIgRhekUWbSj1jFEQo0QRBu1SNahAxbZsGlCGp2nQTtCboQnH1L
1VMoNhQkCzpohamKLQa7bHGno6hWhLeHX8QI+PRmkE4T3y2iNvZDiQTnC0MtSYCiQADwwaMollZ10cSz
ZF9xCCtQSHUCYgQPxnCtIAJ2Em7gAQ4BdAvlFXcamSgEmIi33zCZDC4VA3q2qbGoAUi2EIJYx4EMFluH
AynQYICeoMhQBEDoJBFFwqoE8KOKwwiIgPYlAdAB0ACCoAYjoKJYEIwZnud8elF4VkUDMLidZEoIAfVt
OEiGBKvhI2b+POtXwCzoAn11DszwqSp+CdXEOTl0/gqOVN7U1JiLTyyKbq/eA34ERQYERyjDE1U0tbZ1
VDtZwW7aVdXEDJfWnStitoFqBvSii75bEM+iKtWslXVwowC2oBx3V5WwHVUcjl97MFnAGRANn6jAyIPA
28EQH4OgktlNA09Apfoq4onB1ibqSFvhBTXbboOFyinKK6AnI++MJLg0A+BCLPhoRPmKYgAM47KAOouJ
ADQFg6DdW4X2cQwOBI2k7IFA4e2weEk5hRnWDANFWBr16xUk3A7TrjGIIEFnjDgRxIT+ghJiXWNMjgAg
b19ZPhjBugHFDCONdAUCwAoMMSSWNr9dj0JGFRXqSBgDYaAJqBglgCirAH6pfvrGBCgvub6IFxtEXh6w
dIPYxQIYOAzw8DlOCKgoZDnyootFjLJU4ihI1yXjBKkw9xRQDwTFqCe3qh9wBCIIo83TnyoOkxRviGZz
UR8WMyia17mmSL5JVbQEwvwrkMbrPiD3h8zU4poEfsSFvnbZQeHjlRYwCnLL4y2CwmEU1HgUlNRRRUE4
McCKzxT9lktV1Lb2GM8giAL0TY2sIADBSCRM4cNaxLZiaGmJaVkDJIFI/wjuajdQQwro7FQkYJKQpAkQ
7BcLRO4pj4dSMcy0UDwEn0il6gDewLgchcCRmmDFD7R7B9Spi3n7cSC0CqpUExTwFxrWxLbVa8ZJHgHF
ZUfoIuLiJ6PivbJoMCrG7lMvgYHAiYAx7UNIEn0GzrsjgX4juwNgUuRCZ4nvoxouYANgQI+SKtirKDxo
BtHZbkFA671jqr8UxBgHyFFGBLOC6E+BogJgjlzdHPBVnL2rTjnCD4MS0BpCQd9djT0J1wGl4BSd0Czx
SblqhKohVMdBAGdRkKTdVExQS3VQGtFuDhQpGFYQblA0SQFboAORAprjolLcPg0DDm7dU2NXcK4gujXH
/wd3eJe88aOiFRPhBbRcDuDAAI1t6AMlOBqI/sYDl8pv3///uSBsQlRIq5QLWVQMOQgxwFiQgMtNo2gD
qgAOqhAqfkmA7xbcjCtokSsNqLvEYEHA/lgsCIYBr6TEJAQUBii1CpIVik1Bjththu9X6yLvwdnXAkIM
jUhZPPCr+BBwOW+E231xBExRwN9NLMW2dRCRRQcwA0VQAS1TO+65BgzfmHAIi3gE0e0IAwsJPBBBKO6t
v22Lls6/A2pHDtrUq9jw23aKCm50Bz0HGnWPQA6Kg4EA25yW66DUXYLZfUEwBLzALmAhEP3eoJuJAv1i
VVVA8Y6PB9H4H9wZBTrVAVJUMI4JaEUWGREQqjjaU1QZ3GIBDMMp0BMHYsw+AdFIiTAr8YAhcaSM9ESJ
U1Vxxoy9MoQKQeohUtusSTOG9hAMIze/m4/vQYId8Nuhp3sEIOIqRjhr2e8IGZzFkyq6b/u33BwGUDET
Rv2krNnxIBdFmdwIfAhqB1GHcCioDYzDQlgrNYthu6rIhfYLhALiEPwrVhhJ/FvgVcUkConcMRSLICzs
7lQRofh42YvzYsAgJjcuhCBxssnxaD/r1gcG4V2w+0Haw0yLOysIGKSCxpw9GFVMqNUNjt4YwqJjU+7d
dLwcqwhHYP+UdF3bgsU+bFbPyUyJ7uSMn3sAedQjYZBNxsYkB91ESbdAUR4fq6A9TY1GCF3Qqeg6rjgD
IPOCEexOTkbA7LfGZlDUNK97Zm+IQcL/yZn/2v//ijI0gUmkXQAE0wT1fpYLwRVBNZQwBjFmv388ShLG
osgczNAAwEhedkAAHyLfGLZrEFkH2Q8nEHn4xiNIEn2TgBNRSTgFkBHCBkTvDQhJFtyN5ORCWIugmMBI
XraG9N4OgZQAz+/oXxC/CHp6GB0wgGT0rALM4N7FRHS/2gBwTxBEuDydRbLe84lUJAjMZ3TRCBB9x3xh
KBiE6AiDidiPWLuBwCvrtl6LVUigMAK2SPS2YgO+Z1QCJeTlrAYENhyY1rjZthgEwQYEqiALAYHOEYQO
KLkGol7IEAHuHcDQoQhTOPW2KygV5r2LnA6RADIxiRU8BGMbRbgHQNdCRYRcH4XBxLDJGG4wEzQW7FAt
GNqst4owQU8lMduMqhhSvLyLLg02zUkk6zqH2T7U9/hyMuHH4cwOc6+hehtsCHR1C8cRDwJjANTijEtf
/gg4KjrgLI/+7dY0zU7lTkakAeqYwKdlgXL6elVCQVQLmHiA9+DjMPcE4lPFtipjG2wk31Q++D2pEOD8
DuIsgYlDimHHgXWCfSUhBUSKi5HKo7Ex4Il0bHhKij+Z+qJqi4f1WAfpsREcStD96DOSo4lXTI1FE/3h
okym8HLYiarZ6XcOB3yDIEibukz6NEDRRQfkfsYgAL2wuo90HqPoTwwxiic55OQP16yBkyrH478uCEJs
UMCBDN7BE6g45IyweBiKJwSPL948uNzoAe4mBJCPiijffItbFQ0zVR90EAoAJkRnFEjvwsrehbk46RA3
PIPFyQAgtOm8O2CxSEo+N4O8NmZjVxZoSClm71tABsAvQLhV2BtjZM1o/NEIgaAWNgxBLyiCkzgBvsSz
SVVB24pbjHEZBR8SCnx3JLxrxmp0mYP4PQFmEzaL4OZseWaYhgzIJZyQjR1hhx/kUCGQADvYkGaM3+hg
b5ABueSosKAnLIAQBPmLlCCIDUa6nKYgcQzobVxp5Sx3BgFHqDbvVwhi3a+g2uasGMQ0wCPUrMKY7CdJ
CsaoILs37U0A7Q0ZHRvMcqxAFKkgQh6SRSIoYaT3nDAENHY8dJ7wxLsQC4XJDLKJO3sCZlqmAi/4D4p4
QQYo1IPeqbdzi10sKk0d4Aj0gDMRlgNF6kgta9LCnf/uiMMWdgn0TQOZdfCNqtlIjZbT99gBAATeWUUr
3xYFdJEC4P68hTiCz6Afdh8AoOf9RMGxqjPyRaDnrSRR0IrFu+9PAA6g7KhIh8GCdTpVBwZMKogF1VX3
bCCDzlUMm4XJ3b72rAFFyGfgzlZIunYPTYnWB97Jl2BrRQG5YIJFgGUEGaz/ZnzCjNXz4ziLyUHo2RCm
fO48eaiHgwQMhcA4EMYW2pNz7uzAh6wfrIy+QBCP1QNNAekLgGgFVfmAD4+lXQiYO0yJBQATznqJW8P+
iuJYeY0UQCRF/ERQJETQ6EURFjBTz9Xc2VkDS2VK3M0MTClGMI4xjBi+GKA1RBM4IqBPzFREBYJNj9pk
m9hoiVjjaBBkg3nBsxaAd36P4MIQpLEnp4X/Dt4pMDuhm9YdtCj2DgHWhfRG3m+YAkpIAaS9skDE+J6p
YMS4qgWNAPoQ7JYFYsClSA1QgsisjCR0LywrPDebRk1SF1hIXJRwDQZEPQHKiWiEQ7GCIEZ2kYL0hIjn
i4RQGBShoPF8ihIEhSeDbBMEx8a/HI6JxQ0L/X4xswnH/O3TEDDI9mvsg/oCC3Uh7LwOBEUdi+iGg/vs
0RmbAKABq5TBWsUhYrcQi5So6H0qGAs3lorl2AB6FhyWz9iaHtJhhdQxVwjS5VAkehj9/5Qk+Fng4ww0
SBWRXZR8jA6K4rqEDO88PAfipfgP8+xDSWNEhaHo/+CJTHxErq54sy5kxHdSLo5RrKIrgWSlchCRAgwD
hKzeQyLFQ6SCQPeATS/BjVpMAy9OjQzvQwPGyRj8JgP01wh2xghPmPTPDKZqGMHs54Tjkwge6lRMJGj0
j80BIcoXOPXWm6tqBmNuAUyL8+whRAyLMORkp75hIwT2xw1fSBXRWyK0B6pAds8yBhLoszbo2YA9O0LX
66IOulztIhqroOUDbCFnP1AMEEfXNckEHz9IY30w+HCEsDUDC3EPr0b+zz4Yg0sAtjn6ZbQjDcaG2omM
6cETjTMg6uk9dMUmjPdgEiPplCQoGocCKSWdExwSkFcl35mR2sTIRkYqT5wNq0CuPTbp68z3kkdVMJRw
ftaUId7sNgk50ZS1SQ2yyW7BirLDgsyawGXhwgvWB4MGITZo6R5tYMQW3ywXoV7Ah7bQnlWX42iBkCOn
sJiS0G/NrPkBg+0g0LyWYGExaf/ELxV4EG02gf0pOQ+kZxS0545BPAKQWBoGv0XVPCA5kCnMzCRaARA3
PNkuCKzSv+c0uAcUv8j/EI6/6UjtYdvJdP0RSDs/9MKrMOHZSf+DlYx7hBwhHd/Mi5xpEi0WEAWQtchZ
JAKIPc7YyQBGrOP/KhWHUsh/r5ELlqCk80gyTeEAiJ+pBigKgr1DZvwGA3YPHe28XGDCjLky9j41SlLp
pWqDAR2EFQ7l5HhfbHDYDuYsoukIDw6WjC8k7SESAngPTzNpiukIAtBhk6+vTKSyhb1sr0FVsKs3oWCQ
JctTARSTeuVxRIushGNt9r1FIo7Og/hyFhIBvOZN/3LA4yGfCJWpKsOsCK4evxcAHU/1SfS0ACAIUUJE
kwj4VddnSBRNBnAYiNRGQgxwjD90QgxJQxGMSGqoFkxDLAPivLnkQsQNiC/IOFpWwC5AC2gQX0LMRYUC
BNRdmGADdUMImDH3biYgWig4UUAAogepAskCBiufDhUNwcYVD0QaJAbphCRYWUipQHgAJ31hKABZMGpF
vwEBpiDY9UzDgApJgU7OTkhFibkHDCAJcTCo7HsQ/gpiAb9G8nXldRCAhSE47DHtSXFkAXNQDSDOqCrg
MJhBdJBQ62RPLbbaIDVLbPKqJFoiglMPAnthZPvx9o2C9MQOWVwVvu1M8PVkpA73bghYdRWDoh8QKfDH
+DzfhUkiZwGvaxA/8g0C0IhsVvZJAGwLBPNFBzAW7YLC9YUDQxZtAI8IGQH/EDJiRsUf+xfPujODewXx
RFVCgzwwDp4EMwaLUVX35AL0LCAx+hEBmwQHe/GUGvunZxFBgGBYoanqlkBRggq8/QwaEN2wqvGiZpB7
DIiDUPjra4M4AA4jQRAayWQq+2bRs9nHi0y4+0ZdsG0Aww5LEP+1wJsKZkrei6QkvGwA9yZvbGRw8ACQ
aAL8AgMjZynF9uR3he0eMAEFuz+cSvDcQw1MRzQfTKKoAY/hXUpEDQzfO0azR0UO/lUkRjEcUXgGjz4N
GFwHR9QPBVR0wOwMR8wMZkBBJoNh6kRAg8IxkDDg5tjARIGaRQgxeJEANTxG2IkjwHMMVvSkbIQIgXTG
x5MAvBREegOvU/+0ekRq2MxuCRAFe6BgAM/hUJpmoIGx72xKakxY0Eg6dGW7xR1s2S4ztyzNqIu0tBag
WdYWxW1JECdBG98ZntUkitj3WhiKJUHdA0IgfzhIwUnV78l79U6BHxGM95f2hHURKKrjg8NcpIxYMh6o
aQ7rzaJfkV/7erRb1CKgGFS0lWg4/arI5XcsThFQo4rZLCYHirLoBQRBvX2Sqto9T4HECAKaaiRFV4EL
kOQBdoX3vEJINUKNvYdSPasCUANXiqZqil76uQu5ikKiCcFNaIku5GSS6vCIYPiqQxCaCPy9xbMjR4sA
ARABPxgB1bMTUsogAcj5ifMQgiGOmvmbEJL1Bpv3xGaQ3IouHIJBrencEOkKwggTOb8xGDSQm+29hfYL
FIpHCJHqIBmDetM9B6T6DQgP/YbW+tboqR4m0UXVUIykaoiXwNUWTWBIOehNfcmoA/GURAuUD+Gnmine
fQhMCIuMXkCqCDLjLaLGniqFAtuQsifQM1n4fJj5XLvJE+hYrfnxmPnxZkGwhCVyjAEZBFHk2PwhYcnc
X8V+up0RDHtkJCiDH5TVXSmC7TYW8htmgsQkJm8SPmIILKEepgBDQEypsf1cSQiqiVoCZgSP4JF/+XTG
gE/8FFc7VjjwBPMQNgUNPQvC+Bq8MFh2QgiXefuHCcvgIBb7G2cNyIBccsjQwAGLI2GYukUY8VgRxotT
DKCyQ1aBOvSJ+hBZCxA47giYkKiQC4h1L6JDQhoR8HoAfwERnzsVu9gDK5jQxVAR5BQN0l/NUUyLiyvw
TSBY1kbp8AW/5whcssASBonfkRFgIbtcIJEyZk/E6bNgGRvwhFVJY1eFjS9gkK6uLNZ4hEe1BfAyj/r+
S2CKiiOxsb2JKcExMgZcphy1lUhoWD9gSWpiAcJoEEw2YKdQWF0wKLAdJkBygAFDMlhgkRyrFo/CtjCS
vxnBnpxIQALkDCA5gBiaBI4BPKLXAvdFgRFCxkSVfEk8EHLMdCQg3MN2AyN+M/j2XiUsgH2ITmtgMIQC
CGhdJRQSmrUVQxY16ovkOkmfh0GiO/3yoeRTOBNfkIIP+IXJpi4CpWFRc004q8QoeLDBcE1beDlRD4M3
O7MBADVEibgwaJj7zfB2TAoWZjBjSRl+CXQstgABeouUJEg6ai2BcD7bLC1CVAymnHnFosakqBV4pF50
rIKVSwWco6rJgs2YkWGNilBtEcahdP5PRXFoyWSLJ1R1Fk0VO7Sujb4IIAjiTlSavVSY6PQ1RIvKpCE9
IzX1THqK9vCANIKlvAGC+Z5I1RDojUlM19qGQLOMTLJ8BEALB0xgsbAEithzwAEn2QWYgt5S6xO6VpMv
oHXqaIQVLcBgqBgDDEyZp/M0IWaGRvKyeqKlTkcnBEdVccKuAjM7seRIDVE0YBpMamQkbafDJDj0uqW0
tQLp46TcygcwwNIBa1LYEjHS1Qh0JBpL9UxUxiYgRsEJwg2ObUg0j0sLM82iLRJttGxLDiEhTbRFSxGB
S//UgmK7EIuUdt+EoUhLSZjZZwz4mlUWUe9mjgIKFIlwE2gTUT0QTn41doFBcdJ1ZCWpYCfhygwLQZEi
MvLtpB4Fh2x4peTUjp0tbIscYBADwCBMGHYAQQgs2MCeuP0QtAu4oNkdNHpUJBBQQCaywzfSu0TAvivk
RFSeTLtuZKc6eJC7q2KzFsL/lWBaGF0IQ6LcdUxLQRDbvAOMJmgI2KseBBh+wWBnYxfRtLTByQywXyqE
fReLVMFIFrDtCAJQwahp20QkehJXSAO1pOiqAD19YBYjWCEdcbAvQVYtSKwRDnv1TERMnQOUggEfxllM
iZRDTIB8nwL/JXdLIJYoC4G8tNiH7y+oTYnRu6BMA4yzCbCtTOFBB26I9K2QYEmVmEYGDQv3bUjou671
UCL8FUGJyRAKg44cJLoBt238ioBQEFz1ToKl5FgFsrkeMGoewtZFifBoOUGRQ7bW8uImPCGXr//+2khm
UCftgiUB4rxHjwEsmPRa1+0WuGTUBgrqDFpxAohFlkhnwZX8KGQ4uptAwoJkMrsWGQy6/oC6mtex3YZB
s8a9EEw5DGocKEB8CauqzaDCzasIgzpmB78f3et9CRwhHGG4a0StRXgWMO8k87BCdclOBpb8pG+V0six
JYdvUGPIt8SjAEYAVyiqITxPjQPaCoCutP2FtnAMNfJPUMXYWgGEBwc+RaoaUUmrI2JLUaIokZck6KkJ
5tzBj9CxDRV+OXj082ka4nUFiIbIzekCgkDwCC8C9hcxTpZohf/sSCHfMC/HbwgW1MCXksYK48KfUJwG
BvZNCs6UAbWwwIQlNsTKWBU7V5Wbygh90Pf8hQyAATdYHECIIB+B7LEJqlkpXYtWEdF4HwiAEAMhxMOO
kHUjEscAak4FTchIkO4wsCkoo4t2XQHiDwBgBRixwgSIRrAMJJbDAW0A1QPPuEETmnBLtnShCRBLuPrr
vskNED86fSBXwfiKxhTRGEVC+BDB33V8TKA7SxhzCesoBwh3a78IdyEFv1iZq6LD/TQ3ImiAv2Mq2kno
owlVvbwLU0XdIwlJQ6+Xaoc/DjlD8G4JA14II9rQFYMrcwvXz7uHnD3rGETTdhIx6HfxVQW/DDd2BrTZ
jO2OUe4CCXn9/wmEvIpTBcaUCQ9LQJ+wCe4FTRTL6IuQTaxDBADusBA9nhsSXLYk4A80sJBKWxj9b0an
r///uRiKJaIkQRxTEAkjUbU9XwSyRYIsjFERq8Ic8ogoYEDcP08QtzVzOxY1FOstZSEkiGYXOuJEUWFX
vihA8QAfWUAkoo3fiZVXQTRQQo2PcfaMYFMgCkiNB1BgqyJWy4GAj00QMU85Xl/vIgAL0Qa5P4vbFHWZ
goyGcEb1vpuCxwQk/9DpJF/MFVR3TXdVkx+LaLJYLyJJ2eSyiC5J0kmYRcS3C4DPIhVgILePsUQVwEwz
aKrYI0QtAgwRJhhhZYa1J8CNF0LRM9u5CX9IHKAoYJH7VExYFf3GFLgyndfovxsBlkYS1o44cgXCET0L
7BZIcUjEXZb9pAEsQQeLiFh25UyJIhCzgry1LyZAVStofYhJzognwIwYVQ0p+mxQYBhNxx30EAUFYoD5
RlF92Ag50AkSdrxWMKoiTIUZwBtgWAyoRIuIimfAIcBIEaXAGcCyUa+ogMeIJseIDceyt8JijP+uOdQM
FpXs/5SpDCAQPDFIwnRN+UKygg6KNXglClZMAWkYFCaGQefjRAQ4AlJIi1YIMBbV8MUY+ABAFAT4tbxI
i06wMb4dyon4KmCm9y2MFKzYJziOUZ9me1CqEVbSB8sKcBnQ6+zvtuGVsI4KYdDHUR3S8XFEclifXApq
Q5IvdB5oYAYEHVR2cXkiHgI/X+xMie9CX+wVzOqMIgiDKi5RHRH5RygCQH0RsCenqZQkaldAie5Av0Td
BUSNfC5A5kHGBC7W0FDBL01TwNnCIKhdyQ1DTgCWCauMPwBMvdeNcP5MOegnoZi0ZgIP1A+2hSoqUBfe
xUCwVUR8CYngky5D+YkUg+8CXQGABYcjkWbZUR2onQkPPflQjI5CZUokLCyA3xPqQK0PMUKDWAI9wABC
fQQikjE4/c14AhyJtLG0JD2fDQYAv5SnOchMkC4IVIQqCEEGG2TQ8BcQZPxmsNgPGHZwi7wk2HMwDCdi
ea7MOiCGEfP/rFUJMEarzAQxlhAbAoqeEXVjAT+FwAtmf0G4bxFBi5R1lhAn/AIgnYNeA/tS7nYhlg+P
GyLQE8Y+RsyIq4gP54uUWEZ9zj7SI8e5umcwgydPI1wZNFhGPUAiYOEElFzwBVn1ICQLis3cCfAw4Ycp
RYXtKifoHeFJg7vg9OiqJ9KqwYcUAj+S/5T6ZOQmhkWIAg0fSKdwWy+skAF/R7xnPBJCIePHTwAAmi7h
CSdcRQENDK2sejZgxaOCWo1EqrmKAYteRHMLhIRQIbrp5PjcRIsolgz+AwlwxC5SBBIM3ZgzlvGJ7YXA
sndZEgJ+sh+BYx0q9xCAQ74qM98L+M3uKg6JUkuJ6RSRsIxIVYh2MjZhiblWeekrHFUnS1a2Ev4NYUaU
FT7JoL1QPJcOR89JjUROg1EIUl8EDIAfsZMkvEdhE/IaWEAhUZViL72K7OGYgD5+guIFCqKJ90Hsv1tN
4isp+RQT6IA/AAgIchDE0VxWwS9nfAcOSSJI8bPtAcdMBcotPAIl6Is79hi4oDCGi0mJQCG1FMKmOOEc
hHZE5ImUsQ5bMQSEohQefKPBNCRGKUNyLHOMFxg8DmaxK6guwxqFdBWo5JRhoOh2WwrovwM4uA2BIU9Z
hWoCB3YQTvkkzQ9gsriAWFZVMRuSc0xleql8sSBGegCDqwFEDQ72AkE3YEG7AYm1TZ+C0DmbpVDNLiBc
UpAOwjH/zCAc5M4BkTgNN+zizOAGHTXVO/pNlNAR1Rav5XqLHYI6WCQcL5wGAA2HRwb2D3/JhQFxBgbt
pKxtIx/MzPEzjnB7ADXJr6Z7maZVRwwDM2IgZx2qSaqcOjFwoBes0jwQOBCzok11MfbtuqAqVtYTM7AZ
7wCldCRIi+itVQDM+hCLnNpoWE+ig9wS2eYsiZcCPU2J17oj6QNdDga7idiaQV8H4eufuGYRG3jgKBbA
IW337atoo6vC8ApOzwBugWHwAzPuUDiiNhxzpNGMoiAIAgGbRoV7p7OHb5TIybcsREE4QMHYCVgrNERD
hAqCAoDHFA3CpiZYAfAemgDFXRejvQG+FFWxgBFAMSGav1E1jIBgBt8UNSNSiQzVIWBJhIv4DCJBF24b
U0hsuDEjI8dy/444AWOBaFlAiAH6P2kBLgHscagYEzwMBNyoX5UXzeFOqZaKar1oYxSDePxNnbmXAkZJ
g+o2mEyNfWBCkAc8AjuJGu+xfzUaHzwDDaw8BOMbbxj2MP66XNSZFOQp+LCBAhotafe0iwaJI0FEi0DB
jhJ1RTGmA2MVvwQwAQQPr8FB90SroARQjEG5rQEGa8gNjUHFIMxMzoxAaVJAo8YA36wXDgmLFmQAwQJr
PIoq3Lv1jUT4CDsYnRl3ZwvgxpEIDotqO3gQI6rYZwxJifKq+LiDwTbbrN8x7RpA1bYnMR8cj2x9sEj2
kmUv8QqqJNxwGwDoursB1g07YBM/K7tsG8EACNbeOBpNUFCwYNnSsSel7PjRrDs48MjhAqoTTynAQYoz
FPcQdDNItaoT9eDCM+oRxEi1FYaiRkTlVuSAQlBcdAlh1hAxiRm2eKKAZdsmtJiEZEe0MdLYv0hFQYRv
sUj39jHSr9577PDH9phFuP8ANUJgGGI3B4u8RFILIOyStRhFRPf39XSKZC0MQ/ZGABR47aKMgHCdxQKO
FlwjqFGHJfw3PeLHBt+ug+0BdfN9IC4hhM+bxYLwpEFeTbYVO/f2iO4T8hpPSExM6AykZnXZ6BuFUqy+
CGEQGbTT4yQVGzckAVG/HBi0crEDGJh7VosqAxtrebS4VJMUcesLx8JRCCBXQuZvRdUUx8I80nYkDTth
wIuECInBjhERINhLGHTOITnYFYcp0njDYNYwiLLgqAsagbxEGEynygQ9s6EP1GHRssUMw0gMRvpe4qAv
Bwqq2oth8RsxxbUNEcSTqL1IYKgI8J2JaGFIVwV8HykCxUyJxxRwFRAyZpzsUT0IwqT9qxohIXhpTIkK
OMC36kg/zkUAwBXwmqYE1Owk7ESmZUwC/HRMicZsTAYY1hHeSO1yPAGxDghRGI48AQCQmIUEbC/0gmJV
B4SftAAr4AXQFWmfYYCxwmJYqpgGSgW4hANwGQGMhAOslMIA9ITfHvW0wksJowMDVUkpFANjBOoBrJmJ
7KMYfAStlIE8CJZ9GKtmYAF6GbmTxb3hjUUvFeyOPL8vJQFQDMIhGXxg/CBk/d+YAFMXxakgDZx1vRjW
+Yw8EOpQFVsSpSowwSNeAiZUC0Yxo+7lLpadrFsJFADNtyw34REVKySlhCaHRDzBnG/viCA2DCh5wbNS
5T1dQR7DLiuKP3qNnCTg/QABG+xDAhw3C/AXuoBEsvgLmFrGYhLxBujDkgEAXokoAjimm7sC3uHpZGDb
yRQOXxDQxuVIEFCQYiOT/dQEnWJHmomEtwU4gHqbVxpErAzKOmaXQcyKYfWI9AgMEtyYR/TrNhtULUFv
U7BXqEhNBVzorhR8Ub1GlvcQ7IWE2gGnSItCdADbFg/HMNv8QH2moj27SKN1vItgbKzio5gYNbtGbAyh
+UdMFfeoiBwwi2fYF6Nqtpx7Pig2gDgDIHkYffhRkKVibpz1z7oCIgxWxCi3iENNADG+iK2QyUQ0Owmx
R8RgJjv1O5bCiFguTIllEDphxGJWCLcaFIvx10jDiW9ZwBnHUUmJeEmtEmcUwU0VTTaGCPQLOAferxKd
UHUUe4iBILOAsRhFxJTpWWEA4AIGfFDgRBhChHCDeoUef0AeAh26rIvDeKSgnR9cJDB3ZhT5dhwcY+Rg
UgQZIJ7DndMdUsJyFCHvTMlLHmTMt5qcmjXArhWQidHbozUBTljVJDLqs8OCY3ONlCHgfuQKVZ04jgbB
snJBo3mzehFiIYSGexWsGlChfIN6ImBtjPDSeFg9O/iMECMdExPVVyYAjlb9I0UQ4FlCXSGESAjxA0SL
nGdfIEgEa9voapoQ/RU22euQSCxFVcEA6UyClrUuxa/UsBorAvC4N/zY6gHR3uiihiBEQAwuBAqj4Mgz
mR2ZQwewJUS0+jHSuAQxYPwRkFYBNOkLOFrWAfFIxxJJiklRzZoW+y9mLt0lNIB+Aa8Je+xjwb5ayEkp
0BAqgDoZZIsNOCpjCp0CBZ+o4vgCOfhVuwiDVsJuK3kLsgu1R98n+3j1F1SRXgHfwRwQ4Y6rJ8IjGJyM
J/2DJ8ICIULGjZTGiENGceiX/5cx4hAijtdxY8gJjCBU0ADZgwhCKeF3CQ8dMYsgwh2/5GzAGMxrfFWA
SoUwx+7jYMQcpDHSyX0NM4IiAdmJswNJC9+ZT+iW/2MR0pKWTUiIPoYNklCZZ1NYMh/7b3hZTimwIftL
CzaDgs749smTgexPagTulbBhKWxoznAEegIEtxAIsyFBg7XDiafMIuCD8Y1pWDwwGfQwlSihHAQpKiP1
wAaUA6ObCwyrQPHEkoI/OmBERwzzCTH/yKBhxA1k7+hZA0bPghoClQ0IpBDPmukuugFYnFX8QyPrh8Dr
qCMhcjH22cSADFnRYKwPxmcjzn0RFHFEoUWFyQQFkxHH4DQRoZANGYFsAgJjFUgwiqDrYSXsTCfLZhQK
BJEkT0kWeAIjz8h2Y0rpCI/kMiOc4JM3PRGw4sqTSm4YyqgREgw5j/gIUGyNVAUAhHCAhBGBJMH4XgXo
uIRNYPYhwCdkDE2FyRpSzKgTFVhb0wyEIcDDBnNk1M0CBgNJicVpKvpQwMSTdHOoYFQMqWpagA3aZRz+
VQPuLILVjWkcL/IaMahONbnDCbCsiDDE4iyqL4TBJ9VEBkAkqhuD+Qj3JTwZsfKnp2QkGBVoVi+Ij2Nr
dVl9rXMoL0xXIiWIErYmkojl9kHYBMwnDE41bpQBUwDCg2IrdkIPY/fB5gMIJTagJeMtFHxxThhMzHGV
qCBhH1mD8VS1xk9zCIkoYSIASoO7qIF2UND1SFDEOqDoKudT1hyKJhM1ZSe6HF+LqI23LQYaOCpohxT/
9lmKuih4YE1V6sUXCkXSvBhZXnTLCSk6ATUPewYwUnLn9f/VIaJJUSFlgLYtKX9WzbLDEkUV/k4CJYJh
UcAC0VAwgCZ9A9UU8LQQKob3lAI4e1jISAEHUBosDgsrtES0FRA7A2q8B0CDdQgDvLqEEKaiZiqyGINC
WEKtEEbByiiyr+pCoAacGCYVAQSoMBPYJuWGfwdo9auGHLB4LeAANwJ0UDA9AZO45EoeKcuQcEGwwQAh
2ERBT+hg5zXhwSucEbiIgqNcFbgpTljiLL9BypEnT347SAEAAkABpLDoyKSPjo+GYMHGPnP/lNRIONyE
wQ6JzlDImBIwIQIE7MWHtAT4E5AB2TKJQQYZ7IQkoA9oqAUZZJBwsHgLEcQ+J4uMBmFUeTYIfNqIDoDS
0Y5vcoUcu46wa8qCnH2/kNK4U0iAPPIVbg1Ak3WEw6DHcKIsmlVFguCGwKApGC9sMdtM+eTdpgB4gvtw
TiHiUhH//0xycEGwNDTwH8VGYIgcLOkZKjAArVjcgqAV/TfiBIAGggPPUHBYEFyAgHLKSnANAO/CTDkT
eD5nAZEIkYN06nPDcGZEGwt44AV0TctdzU2BipmrUC3MThEYY3BRv7ShIlg8KI8amBQQIxJSyAnBwb4s
iiTw2g0LaCFJOL+AgPV5/8SJ2CzUQgHMshoE4DAgEw16iYiPAExjnze2ixdS0F0ojvr/aoQIJvA+XFBa
OISjfjIKEwh1EN4lRUBTLpgfQLDBvipoX4gyDMbDiMuuiYx+jIMxGIOUtoyGjL7EjCB/l4u0JHgUrErJ
qIHxjAaKgWrVjI9ASoB0K4xiWkPaGGnp1SkRAdiuCRjC/wEjp4b/RwI62HeL24n+Ne4CF4R4SG2FyUGd
AVEO4DWMU92wA6gACc9mQHoPt5WpMtwEjU/+JoN33CJRQ1L/Zrl6BHYgmPTZHEjXNaKLG4wdHx4mfHY5
DEF8ANGDWblgfJBMPqwCDsYyvgj97BeJmMymOCucIBB0ADCSoMWqCAkhm9WsYOIlnRSIZwW7Eo9tZAAm
N0AhHobctghyMSpGmxUHzCcFdEKENXrO35MBAJy8wwlo8RSxBOFAxQgPIztSMTndR1c3YQmiGvs4f7gg
cAGwKd2V9RhtpNKs5S6sJOhVVQSCjcIFkSJ4ZgPAqggWHCegaBTACggC8HoJyLqnjIqxCLCJLBRBkBiE
CgQQqYgbB78EinhI7+11W4tVCxNyW3wjRYgoCdzgTCQI1WML6DWQsSyJcWmFEBy5iRjW2oNwFJuDTE9Q
FKDf5e19uAH0AYP7P/h+/2sz3GuwonaQidmMwiNdtlZUjBmIL+xCA3tSlznQk1Uo6AA3AbaI0zdsNyRH
GzOsr6cV9GRkiX4nEYmigrWA6vWpNgCYvZ2p0EFA+/CJ8w8fF+1FJJ65HRB/dRsKhjNcQbuOCnRgyy/c
gWpsBp/P618+5DmZzzJ86cODxWBHAH54tE2cR0JcBXWPgG9fUwHqgDXpjrjQfbQlEB0biLhYiKOCdgNs
tpYw9CAHWDCfl+QsFHgYZzErkCGiNkE7QEAW6xSefWfDnyOJGUi/MWEzBfXIXHbZb8DkyJMBD9eHl4co
gT0MQRDF2E0VxJzLEOuIfw7YsWJJMUBcsnxgSk5GYDoYMoBNIDZhuh4BOBr0e8aCBeVZt2fYSPBkQEr4
hv+I2EXZhmfY2CNgsKXARWoMF05GXhZv2nt4YsRFQkL1MeD0JFW/TY1+W0Bp2Ai8/5pXPIzUBLp6UdLF
NICoBhGx2MH+WNn+K6QPH/cwcIdAnpwMUgDahXjvIPtMiVTyTONasg0hAu9X+SQjRx76eqiFgubcDSCL
RIg9ql9AKYoET/HczATrZSzPixwR1LkzOB3euihqdGACV13+RRmwxiHlrXmADAk5OR4IC6FDjZJSB8SD
QxEBlcN61sHgFrIx25kvKIw2xBDUYwACMMRIVCeghP+EFBBKIc7cC4o3YCjpWC/RWlUkzs5WFLslXh0u
PlAYUqYgpQOfxEKVcBeMl7ZSAlHUFBHf+/Emtlj6trMFi5wkeARL6iCzKgXbIgahYMGRjYh6AcGxGiZV
AK80Cg4CNISZPouEGAwOgQUwrXCXUcEoN3gsIQcWiavKYCBgBzaJoymkfYx6kIi5Dc6BohECd/ZMizhM
G6KjRz2K7ne1TrOFxAG+8PxZDMAjDmsddKJ4IAJQEppoFEniTkdoQsVuCe1w7ngIcDOgoQ1MEwO0OAtF
3Ih4xHg4+osC3GIEGzyA0EjdkssegNgK4J432R+6ik3esP90C0iLfgZBEbZNB1wsoupZxAgDOW9taKra
kiDkEeA5Y+p2CUWvyhkKSD4KSuCUgLoYI2jhEUc1Q/Aaux3iu9E76eTPD8oI6IDEgafNBy2RUAMpI9vJ
UAiNxIGJZH50G1R9xGLOc/ZNgLNkWUGLZYjxLhjORzJBixm8ELABgxOYI+2WPVMFYlQxD8u7YRErzTVx
DCr3VISCFJZrakgEg6MBfgg60zClBi4t1fdoAy3CRVOCBAfklF8AAQgBCEbFhbMBPKQD9uCKP6mHK1bg
EOjIgb+AqYBElEshhd6jXrDbUTfCIAs3l9wKORnIZ1dBLYSWEGRK+g1zBfhlEzvqo+5HkxCgO0IrfOp0
CTIM8FR3CE+AhmHyV4SqQEgiHFYRZ5TiFwA2qJeJqMdHS1TpjFi1d1OsA4gtTEGcf/h2MHLHFVcIH8RH
aCdY0Fl32go4Eoec2Unqfo1EMAwPiEqHkAqihUF0mCE5Yhgn8Wesn7pjLVwrjEcQFsR/RygJ3xwUIQYw
VUiN7ccgosRQKadBVQCdVHzW2JXoREOAls6LNQyKGW5OpJgFY0pELShpw2PSWJNxNdFlkQ7iABrluJPp
EMR0L38K7VnwUNL8L2Dr0ZCE8RhdQO0VKn4Wgd2wWkd4O2ScZsES4CA7JUCkit6QweQFrgRMKNpFicNm
V9QEuJJYeElbkOEBAht/aTNmdQeuYZeLrGmAEXXQRzqoWDUVQQmKf5PgYSvkA9sd2Cl4BxuE0B1HPUyL
NdHsCcGebEKbf4zQwVZRew4gk3Bi0AEE3ngAJIOiHkLwT2YbilR6E0iJZokungO5ZlEixgyrLeBCSeB+
GKFCVDcs5MRDBb9cPGDlrERFeEgSRyhIGNHsYdiLrLiwW/gNdoTA7fNC7+K0xbCkyBAzbMIPAbzw9nVt
PIwkyMRFR54MwHt8ZXz0KhpZ+/eJE15QYsboGSpmJwQ4nNGCmgGzUSaIgoN9mb4BmMABgBhRwKWTwEkR
xS3UhEE8CmZv08Gpqgk9Bnew7wcH0kUC5No+zMRuVtAHEUDjrBQwkujfQSqIsAAAACCkomBEdjzwNyTi
vKHkRIucgAFYmCXFeAmeEDVQHAjMiUgIGhT5CYDuiwDBh/5IEB0IuCjKRKjcDSPAAV+dUDGK2pQ8Wh2c
FM+KFfZGky/DYymoB3+HPwBYKB+gexhALDzhIMA2DIEdxBpzwDPgPgyCPh52nAgGHEIJZndoYYQGv/YU
BNTZYQZA8HOuzgkDOXKsepZ6khgLDoTUfCYQxYJokZNFh+IVcoCnjD8cQDBbiJ4hhkS9wz426w0diRPW
dMqeuz8hWXbXb9O6JKgnRxvbeYU27BWtIrm0AcYKqkKRRxl5ZC8+8k6yeYzhBBQJVAgPk9UCTjgS8kd2
woBmDz+aX1LKEiQnLE42Qjry83jdeIdJbEMiWqymKhiwiFEdb1jSMuqzZ8HmBH9VIPXBbjBGgBDQP+mM
B9LYoOt3X0QrU7XAkxtFKkX/xqAA9wJEoQoORCbwQwByQySLrG0CPukR5UUCTZ4+S0UkAFgKSkHkI0lH
Fm5Jl9rgNlEUqDH/ahNYUhWPcwSGRMBBfFhIuKAJvEiJr40GQR18nkMb7nSBpaOrbOag5vZLNjQBhZe5
ZEGQ4QDWkyU87/eTd2/WhpQcbXdtMdL3UAtCQ743SuRkyCYLTTUfAVsJMGpNIPgCAi1TkSwB0yGxILzA
T2AI5WUPtgCJGBS1m8wuPcIXbNUqIR6p6J8mTEbmxxudREkVdRgJmC8DAxVez/ODTOnIAew76Fx2Nnak
pKhZAOMuBjuyWehkv/JCJyyJCj+jQ+TYC4RXWOx1b8Z1EgISDLFb41cEN+CsoUNjlMcGESXOIZjIfkC3
A3wk70HKnMHBCMaH30VTES4CgiPvaBS1+IVGH5fk5GQAeyjjqTIcASOFJaYCDmAHCImQYNF0Nwobof90
YFBciEDGtC62OXcgkJJuEIn+Sel+0FbQRCTnwUSXtVhU8T9oLSgKbbQSlvnTgnhfaIlOhIsPRfLpIbMD
LMZAdWs5wVgrUcb5czyVWrCSkQO0c56QRFuFfcLM0UcdiyaLUM1bGFXd6D0hQOsPDLqLaFSJ2Ezq8CgT
FCu4ZNQPIof6AfDjm/2LaJE503LCXxYKYGFvBWNDKoBYBLksJ0hI9D7NS8WzEkarSoneV5wy8Hqcr+D6
+hVAiZfXg8cFeQJ9/XlqVDNGNEt0NRs/Mm6X29fwI15SmLlnxmdyL2DECP9yxk8SboARx2SfT4qtOHiW
e0SfMQyKWgkBX6IcEaZ5UlwEEKkwNcESdAMBVdY2D02IihN9yR+jY0C9Qv9CkEnR6V/pVvVND6/MDUuN
yclMCFcBjlPcnzcAfCN+EA+ewZGTwgjeBlC/0RtW3FYTV9bYANEJb/fe3zQvCqA7VezyF5ix0AQFG3gF
iFWZX7fqEEEBHVdD10VQU3dIIQIfzkj3SwJPAYhQASEC7E3TXYDSSAIhAwMCgjPSLAID3yxN090YSAMh
BAQDAzTNM9IE0gQEBYw0S9MFBAQFxdI0TfMFBQYGBUU7I80FBrgKaZquQcshBwcGaZ6RZgYHqwcHYuku
lFZ4CCEHB/OMmQjuIZ4IZmm6Bw0JIQkICKZpnpEJkQkJCmekWZoKCQkKhJamaZoKCgsLCgqa5hlpC3cL
CwxGmqVpDAsLDGppmqZ5DAwNDQxpnpFmDA1dDQ2525WuDx0NKEgOIQ4PhX2mvq5QHA4lDqchDqDYTFVm
HQ9cRAM+sk0xBrZbi6rZE3rwBvNQUKEgfSA2CjoWH0moeGuhDkngDnZFdRHxjUs3TAHOIwGmduMC38lm
kW8Ep82ALm+78wkMDgQpDAsRBL0VgQt8z9933YhaQbAowlOxzXiLYk05wpWDMqmKTVDviDoI2W9FgYVJ
OfQPhhjRbQ3HclpyF3oDcGmaA9t+cQIcAgICpjmQpgIDAwMcA2maAwMESyBN0zVlHAQEBWm6hmNGYBwF
BaZpDqQGBgYGmuZAmgYHBwcHaQ6kaQcICAjmQJqmCAgJCd2maZoJCQkKdnMYCjxN0zQKCgoLWtM0TdML
CwsLDE3TNM1BDAwMDA0qINM8KA3gprvg44s5zB8NDXYP7UZADRY/cA4NHKAajXIBEVshqAdUAZIAdaSo
vWgsBxGIoLU7Tb3nJwqC1F3xZTMXcOvi3v/RCY7HUMSmgFjtcE0579UM7AADWy4khPfaRgTdLJUkjZEu
1yCqawaDg9VEBAmeg1XUAtqQfAnOaKwvER/32oPihU47xlqiZzuE+gk4iMVYO043Dl3yu8y6Zy0VLvKD
+gIV883Y7tYiHYhNY3gCILzzlm7HWYL6C130IALznNWMvY0grPSB+thr6XYPXfUgA/SMIG7HWc2c9YD6
E132INWMvZYE9YsgjPZr6Xacf/oXXfcgBfaKx1nN2CB89376G4y9lm5d+CAG94kgbOl2nNX4ffofXfkg
B1nN2Gv4iCBc+Xy9lm7H+iNd+iAI+Yd2nNWMIEz6e/orXfvN2GvpIAn6hiA8+5Zuw1l6+kJd/CAK+5zV
jL2FICz8efrYa+l2O139IAv8hCBu11nNHP14+k9d/iDxir2WDP2DIJV0DojaaH3+kCD/zq/X0g3+e3dV
/K5A9eog/3Y1H5Pnspb//3VM0m1FS5zRYEfsx4gAU1QoHhVsNUB1TGGKVoECY0QK1eYqwQXe0c8kY7mC
fA4KDtUq4jwKwX5rqKJ8rgHuAflJOforVAAzjgYCFgCgazN5iCVRrK6zu3vUD4YXUHtzd5kD23GIU2tR
AhsCDqTZYnYbAgMDkGaLZXUbAwSaLZY5BHQbBAW2WOZABXMbBWKZA2kGBnJlDqTZGwYHBzmQZotxGwcI
CECaLZZwGwgJabZY5glvGwkKbLFMt3ZxFwpuFwrFMs3TC1kLbcs0T7MXCwxBDGzTPM0WFwwNKQ1brbUs
b2sebhGA9mpwF/1Lag/wQ0QlwNJNAeahoEC9wuVMO1xRnQpKtUx0++hRAjpYl1UsoLyYnXTN1BcTxkVw
21zDBlI1k8G1IQ/L8klXFgkLBL0UG0n32IEPoAoWYxkMzuSFxScijXDOWCCPLEyXHwLOWDpkYbokIQPO
UQEkeVgtZGGgwmJPzgvTJTlYoiEFzpguySNYlSEGdEkeWc5YiCEHS/LIws5YeyGSRxamCM5YbjyyMF0h
Cc5YYZGF6ZIhCs4sTJfkWFQhC85huiSPWEchDNMleWTOWAYhDVySKQvO+SFDyQMszlgT4Yi22yNNKcET
cfAGw9VUAy04y8ZU9xu0uJxY+0ZPzukBoPYAiNBMCVaDq4tSQ1LHwlJddKd5A0MDE8DP1oyuWF9S+lVS
+ZcgOYTFz1UsgeRAclUsVSwHkgPJVSxVLFUsHEgOJFUsVSzkCDmQVSx8Qo6QI2NKhOQIOTEYKOoaVp83
NhARi7uXEHN1udGpqGKcgy1DAG2aSZFgziDiFp0Bx9/oy1BQDXMlJQLgQkEBdmwIeKAe7U0bSAAsULFv
DyCLoItAR7kQ+sEGzcF5ccxTRAH3AhrwdecqZkQBtyS/YX4BUoQbm1F94m4gCGZb3e5m9vz/hdSDqo5z
lFsiAEZW7wQAYHfMU0paL2goBjy5DuAdH5lsMKrc+A8MIRmSIQsKkiEZkgkIBxmSIRkGBQQhGZIhAwIt
ULSQARAnEhAkwfG/WkEzioCFRWA4EjNy/2sQlnJNXuYxQ5AfMhRU+1MpSjlUgOqwgA8KiFx2kBqDwjf4
IBQC1qt2WVMQDggtDFBKWk1AOCAcSlpKSlpHAeGAcEpaREpaQQeEA8JKWj5KWjtKWhwQDgg4Slo1SlpZ
QDggMkpaL5tgATs28O+5DAzCDuzAPlMpuQEmAwwCQA7kQAsK5EAO5AkIBw7kQA4GBQRTRlVA74kEDIGo
9pZXj+pJL4Psul026FdVbB4lNxljTbVaqgroDStcTBTBhR+799+dlYAg1lPDNUsVOBYxAfvVCiFVxwji
+zH/0DkDKYrTF3wo0Z3YChWAaER9F1UxKBIaCUEMpGG/UJ2IeJJlRVBL0RiR1KPSF0CcFF9TforYCop6
ze0KuBEJdiQANjp9CQAaRC7iahlAEC8YQUwg97hHEZWiBxQ1RdBcO1sjPkA3GhJED9218HEbgYj0k1Mi
nTAmIihUtxMEtTJFGl2gPlVb3Q1NW8tMEe6hW98KwlsMAuoGfakZJNtQEG81haDyNb2YBj8IgBZPhYWI
mKwCdgbrGe/ugGO/iBrUhTZazN0I2zENHSwPuJKOFPxqKQJ2WH4sztGHvYANAbrednzDfva2nO61Ug57
fDHALLfiG0TMBSXbISOFsIKtIHog52R0RfE61JWWQonAfsUGMThnP06HbBak7oRyPaevVDcA4p2LjQ45
gcQEATQOAtWMWISBoq8nbUgEEHt02YkuUWBXCqLyfus36PdBom8FidohFcpjYseyDuniipRaBih3MiDf
NYE2myV7O8kFWDAmiixRXwbVTpBVvuOPCn7AieWOjVXouhSRhN2UeOye1qICGrv1S/tgojhN6DkVidpZ
ZyxFLADoi8MpOjYEDYlfKk/iWAiWYFdXfyB37e12K+dvMANnOCVHOAi8l4AlgEdvTxVXULvdbrdMLFhM
GGBMIGhMKHBMMEXcLlB7NCQst4AholIGXX89YBE1H1UxwHuSAIgRr4e4ACbZTFEwAQ3Aqj2ooF1xC83Z
jhGrRvGH0AoY2NKcNCcg4CjoJ81JczDwOPhAVLTAZG9VlYfw3QVzh4R4g8cQDOk2ICq8GR5GZl/1Xx5z
ERmxbwYVOn82CMh9NWQNqQL5wKgIvabYIZMu0gpvTw8LGZmQQRQKmZAJkFYkopIJ+TzEYgQBBhENWqSA
jREvxU8Z5XYMsg+WwCocKwbnsF3DD6PcJgAF/iIfsvozQLVgHEB3YwSyWkTEAoXX7LKI6A9drw0PhmRI
hpqEbkiGZEhYQmRIhmQtGANDciGH7mLZxCRDMiSvmjIkQzKFcFxDMiRDSDQgkEMyJAz4YRuSIbnl0jA/
IRuyIZ0fiQ+SIRmSdWFNGZIhGTklMSIgBgNvXUA1rEHHARaIWVCcLuy3n6KawwdjOdB1KYufShyMsZBB
da4lNITqEtAqrUVN0CLluo7EIT7oXEOBog+jmytd2GeBu4o4HPYgidCzQAQiBd8ux6noS5SJw+umV85n
KODHEcthdJ1OEwqADsuxwOsFxKZAPFdI3+yDDDKYB1hgaHAyyCBweJci3lkR75f3e2EvqS+XkA9XEDdk
kMEGKAcgGF5BBhk4MLxy5MiR9+9g+V66eiQv5DnMXrcO1BCQghqvCEi7lw9ihFTxYNvbhLECp0cPB1AM
MsggWGBowskgg3B4hw9kWwhtBw8PkCHYYC9HEDcoBw8mT548i0eLR4tH1ZGT0AcP31/pXcjzhFiID7xd
e0WNQF7+0oyKFxYv7CjT1Gij4GqteolS/RhzMw0wuDlCA2bxd8T8OmPcD7dHGGZbx3ZC0AyQTI0VXwGM
/W7rF6+B+lDldGQe9A0iwBFgEOhCEWwNt5EUzQkqxoqUyn/qAKIfjQzRixEMzkpRmAB9sZeohYAYQV59
EC2Bg6JKYOyXogrAUkH623Kuojej+XS0X09w28hdD0XIU5bPvxd3DWBJAFIjRV0VwHQrNyYjQPFY3HXI
SMUoYmQRwbgBciQsbgcPGTHA9ag4mwBHjU1vlyC+EnnzURgDeSCACogCxDoBDX4Nv1gH0ew9ZZK+WLot
oq0exTSo/EFE7oIJSX326f18CgAmX+WNSrwVulUtTbinInXHg+jjBgSu+QyJaLYiWqIXyf2OQQDipV3x
/+EnuiVYoFKRQpVNKXCNbH9YIEtpvHZuCkDmboTlswhQZbwwpBCXIkd2mAQqsF4OXIS+Hy2zI3oBoRiv
jCFRPzWCWwElIf+3rSmEhglfEHWkTANVuIB9x6gLRIsA/jRaAlS0UKDbaC8ydAMr88ZUSBDsdA4KBc1I
P8GtPhULZKlQUQjwQiEYuxhaEuuzgGisFPK7bhW3ErTmvDN5GCKI2VnfzxcBIbZ9MHn/d+1sCRQ7PJCk
dBYFZU1BQQc1lRYeRjgWFIfxzxJKwpGAsTh3oPVaGBG+OzxmdwESjmTUTA+/clYQXb0GDaJyTw/wvdn+
g/EaBY5NWAKiRltpfxXQ7N9p23kpkEw5xyMvAO3WC0UnWP+m1H/T5oG6X2q3MWP2SQnyKHgZEKNdbOOs
WcfG0mzsWBfV8mtMY3gIDIA1BnJEi0iTEWML7UyNhS/787OxKmjJjgXZMYRfbb3ykNd/XWooO4Iy0RYj
QVrbXRSV2DPB4QdvypNcYGcxAioCDiQXyCQDA8kFMskVBARygUwyHAUFXCCTTCMGBhfIJJMqBwcFMskk
MQiBTDLJCDgJ0KAOeAlJp/HxyNlbsXjhfMh1GS8KjuxIciGEbM3eWkuOPHkJcFjRdJORs0P+Ke5dghSQ
k0a3OIGDncaMMDh2ZYc0BqR72BlwARoCz7lAmksCAwNAmgukBAQFfA+kuQUGdHgWBtI8E9IHYQcIE9I8
E0oICTN3wHQzEonOVTcIsIWn8gFAOO1of/kqGxB7XTcKjhUaXQhLEYB8R//LUDgZpOfqWWn/VnNk5GxC
escp8HRJDOTkyzwifqO7wWWMAdIQZQrB4D9NCRysJYC/yDsNHTYc+xUANY48Pdq+uuiR3TGqCyMgHv5y
2Uuek2+05wU/h8mTk+fOWBxDlHKYRLBg3/W5fjei9Tnyl2yWr8LRxAbYSiXAnoiO0AqxImyMVncWA9wg
Qh3BGF6LCAhCJJlkAOsyAigCDiYZQC4DAxVJBpBLBASSAeSSHAUFZAC5ZCMGBhlALpkqBwcGkEsmMQgI
CfuSSTgJfn8kGHAbmAkOwieAAmolDIfFLgBP9o1B0XUSTDMKfksmCnBAK9QKyTrCZ8nX2VYEyXGMIxva
aFTJcBTrU4qRSiGWHw8zR0FNAh9PFLchwQRUCk/rriighBBfKqDDaCgPJDyjFZ9Y4B6rcIwEYQQgeKJX
rcASCDBEMS81aGApzIveFuVItKCq0vRtZ/tsy282CkBwvAhQRi9E1W2cEXUrTQTARCN4cR1uERQRD4iP
KGAXg/1EP9J0E1HdlqjYKhB0Ju0dY2xlyLERzA1v6vhDgIDF4G+eV0EEwOI14lKfgMQzV8dTalbfRR/M
2RVZhhOxZrausYcfOdOuGFQ77Esf6YEmHvjC/yJw5kg5oqhUssofVFjnltRcIiMwAicyySQDAg4DTDLJ
AAMVBJNMMoAEHAUkkwwgBSPJJAPIBgYqMskAMgcHMUwygEwICDjKDCCTCQnMlVSAzh4ZUEVIzjYKAYkj
dDfGz7NTKsXDOsJFUc+mbf1tdGxEMVh3U7e3JEE3YbCFHgSf5EBO4PHF/1NQXYwH2E8EQf8UbAjYBqf2
D/FjD5FjQ88/cO7rE00/XKocjxJMidBEknkvZocFELfRJx11pqABK1EX13ILI8uD5+f/N/guIAXRPxfi
QHQNLJPFtu3T4hfQTA5r30lzRLJGmYB/z54NWDzNUiAlz5Zsg2PfSP/ELxpT1Ruw2QH1T/8vSHYweNIF
Mb9OUn8SATkbwzEUZFhWRCpo72wfpgxPyQh4nwx5RMVYB0/NDYAWNhvwR0FP9HIswkYPuAUDTwwx21HJ
I7kBT2FTckQVyDJQfXjkRfJ5TMMVUXGQ5BDIqXa7eAwATp48eDZ0DHhjjLGjsbTCCmBfDQEMOMa+TQQv
ak92LRHIMk3GVJRRAvIIA09y+ZADBhQYT3i+LzCgJRdPeAygBeQheDZlgyMcMk+hwRL6T29DOsIBpUwY
FmkdLTlgwHMkT3LMoKUyoINPIwvJCzBPcswRILdlQE8MRIte8jJgT3LMeAPAITxCeHg7AwEhC2VPKgaE
LJBPKk8ZELJAKk9kQMgCKk+QASELKk9ABoQsKk8CGRCyKk8eZUDIKk94ccSRHckvhBy/jkyWHOOAJCBK
hIFmmIyM7Cnyvp5dkAIy1kYpZzievDDgA09z13gDAwZ2SHPXwU8wIGQDGk8BA0IWGk8cMCBkGk9z1/IA
eYBz13PXyaHkAXPXdpFAWwa0Kk8VFkc4YE+hvVCaS08J4aQDpUj/ZXoNEpGzdymgeXtjQECeKexkT3Tx
GsiRBHNZOzy2wCvsLg0+PD2KSidnFwZPrh4fZGMHDDhP77yHfkLRAYlKz/NHSIYEBCyHL6IKHou9/Inz
hQXgT9CAPUHhIf9yOEFHAtwFNwkSeaOKrYAXd9Hki+/QDmJQEMQXzLNAq9CEgnZ2W3qkCPrIefztFX/o
l8e6AkTQJO+Dw/sRWx3ofh97LBs3QYea8EDqRInfPcXeUfXAPkVnxgW34L0Vgtp/Af6DiAWrOiLiwQs5
eWoKIyLX4OQDsy1Lr4UMoNmDJN8GcFdBg+f/0jV2qPPZJb0V6ueTSwQQezZWItDrL4hOlB9BcubS2xWB
qV2CiUUYEIAgEejv6GBQECXr29kdAcFPa+vOZh8SdgtoGOu+DyEfmAGzDyDrnrDdhDwo644QzXoRX+2C
FcEcEg8fLaCEjA+A0RapImEv4A9DMiQHWEB4IEMyJHBQMRoAItO6bRiDeowxYA07RYhii4ZFx6EORa2e
3kHUKt89xt4hsQgajFZUOTxkx4fzpnw8i6vefGMHY+QgzZzgSGZ8jL4Rgg4QCAMKwCffDCjRC8gQc/Kc
PNAY2CA8J8/J4CjoMPCLavKcOPgXUI7veHsIARFdGcAlazLA2ALqv85Jvw1PXvL33evde6U2SpVxYIy5
v3uavTCCQbQij50qCVF1kmbv0CtisG/0mRdctUBlzms6i90P2fAzYH1ULX3dfXsawV9VKxVP48gcpCcX
LGBJfaSn1+Qhq7aTfcwTm6bYrHpSp328qAyKFXE4jRXruBD1tqysjR4xwAOzKlgdpke85IHwPe1HF9/c
09zwAlGcfP4FMrgBQJGOF5tI14JaQtgjidoaJRCDoic38dzhooJH9aU2FIhAH3aI64AE4DIIP98iMApg
lzx9Bb8iCLeQNFZ8EgDX0AMwTAnX8GhQUOvRtwW5rG6zK7EhCUyyHQB/PxQKIYfkkKBI6dsKCBDk39s/
7lZQoo+rPYkbjUB8AEHUuSjqhSPcQHGAhcl/lAoV+M8bVK+Z7U0GL2x22xV0M1UniTICaggDQPAo4GIQ
LC383K1fBxXLJUARhSISsgoCFa6rX/XhU7/BtnAV8mY1DkdWv8P0izjX6XwUItwfd4s9gc9rP0MlqgJC
13OtoQJAxu8k9wIIuqiHdaQvX8h7RtQj+dWJwWbaAgq3stLW2BCCWh0q2MV3ex0n9lG4LRANKs7bcSGA
MQNNdw0MDWySYIOufrDXGacvI/LkSvNGFn6dtsPdD8/GQhgDGf+48wgagLhQ5AxWx0IB1dmxnUIoBiz1
hqb7oEIwAzEzpjKLPkirKAwni4JQE1E/iXqF/0jhgoGLOd9i4Rhbglzmedjn/UCAkGDD2P8BEEzoeQUE
7iiqvRiAEqh0CpB7iH6sfjkAdfdMBsJPiAMU8IaPmC5EVCgxYdlB7MfiIS77hYKMTDnAIk1Q29ULWgEe
Yn+se0sXHwfBJTQDKbnkkgECDgTmYkMhCEoDZSm16sIMFf5NH5NccoAoBBwFJJcMIAUjySUDyAYGKnLJ
ADIHBzFcMoBMCAg4yQwgkwkJTbg1jJRt41bDMeM/crKVWo7YdDbZCjkGO0Jxp7PZGUHGWAQcsT5YW39W
sAQ6ND7UgPyoiBHyRAHWqJYFD9YPHQ0oErVuDJfsHyc5U4ASMcAfjuDW8HtEiUookocn6RCpSAEf0YAz
RtMUhDQRswMWjznBKyWq3oeHRYnQ9gp0xHZX4U1jwPDDidY7oSqIuUkdGbdWXRdMhWxaLFYOaGgq/Eks
wh0iooNFVYUcWhadxVIhQVUhv+658SQzAiiE4nLZsihVKANly6IAVSgtiwLIBFUsCiCXKAVVKIBctigG
AHLZslUoB8hly6JVKAiWLYsCVSguCtiLVSRVseFwjUySJ5uoywuXquibN3UWktojSPJgMgp+TP9Hjhyj
sZiAPhg8eVgErJIjmzuKFLRAD/6mgsr1n4+HrUSIUjKT2G4Fl/35eoYp8I5CxCkIOkRC7RogYmDeYtEA
Ed3BiodqMxE6RoHA+IochpSwWGNBPhpR4hsgl72GAskbSZoh7HUDuxsEBSGsGUIFBm+kGUK6BhsHBwiE
fZohCAl+fBdV01PTCX9NWuMa4Lbg3gugw3UTJi6sUSocoYNIb6+s0zySI0eOazrMVu45qIoHrIvmluja
NhWGTOryBmhb77jh6UKrOHcRP8lLYwy2AUhV5ODh/+HNobgFFYbK0nXYI5oCmhaFjwhdRNBttYhKeOEv
MF2LKheswL0pC1tAtfEUQvH/cmPFSYoaiIo5T49lrUEE8VQ+NhM38RnroisB65w5BZZkrIsq/67aFRkZ
OfKQOeFVExxMUEAiTycnI89CMDlNrtBOYcuoOOhCDUBk+QTPLZE/Dbo/MaR4Ax9ND78K3AJEifH8rNgU
nYl6UYlZAPHkCfSJFgqI04i2kWNNQHetmVU7EujZyLM4JGs2OBEDAkLYmfLFKwi4yesgxBiFiDDYUS0V
Dkbg0+OI23k5oNixAk0qdds7I09Gnm7JOkSVVMf7FauEN0uxgOPR7VZsHIfUBssi40ljYwsUsekObqxf
M+YgcmfO5FFoX3aUMHJnd6uXQnJydnbAoqFCEiRZoEQydMwMeikCPogETQWE9nm7XY2CVP9KIKaGvZ6c
nHRjMyw9rlPChhBHwDaCY3bsoZBY7wT1RYsLhFiMAw+3CAyaILRFRc7IRBaGhWgh258NiVYQ8EZ0eQ4S
8K0DYuUR0wI503VoNhTBsKzptctbf8cIY2OPtEpNYwhlR44ce3SrviA5fjbvUkcJIyMBXWUx5OwYZ0Kj
AQ07QpwMYJX1vjUvDxhNgia4T59+BMFtWWYEK4se4FhV3d5lyA8Ci139WIqv2309ActBVZmuBFsM0GgJ
CA7xfExWAQ0sKk96iqADdbiy1ypFtKpDrDpFAYXwOMcRoLapvNJ1wfyIoqsKLkWALVqVbzFP3NVEZAB6
BeL9FbR9OYMSBM0CbLzbABeLKB0a9vc0V+qZq7CWHIB9qhAgalRVqEgFtVWMdTqgIHD/W62LRbhJKcRJ
iQcJ1+1oIbhnEkcQC7AHoX7sNnUDL4lHXIsQF9i92xb+DB1eBPsVivW3AFAMQg+YZm7fHG1qnFUUWZhM
AdATVZCCDRDwtpgZPJmbXSpwicGckp/fW+yxmEiFwDA4kHQiwhl7sW4gRMgmI4rFZ4CuKJqgOpKsFAWE
C4+JyZwhQtSwrVNKQQSkRHFDlf+JfbAB0e1K2091oKaoAGLfApghvWbPQBHcoup2KmhwELW9JMVJdeEO
oO7S83RZqhOLBr3nFqiiJoUzJTIB4Qjgd9YxYGDAU+HYBrclDJefAfPATffBlsODWxFtBvW8QSDSN6pu
QEFdyDnrlyoYBkAHMRNQjUMNa0GLENDrlyqhNwdDuEFduPV+DHXFBZkADpDpqLA7QsB9yBZIGERgDLpo
BeJo+mqQxIsOqL98sQCIhlbBFriHW0RLrQVHCCoPnCzgRInKmpNYu5D9ybOAip6TsZOHgPowI0c2jQiC
Q+2nmTX3iIDAkTJoT7QjjGogFDLAbNABUBlIOje3QcAgqY3X31wBLFTulIDFs0eiokGDB8ZVkIYBtMYH
T1RnolonGitAf6hNLc/CPtPiz9JICdbAsYZyLs/gv42Mvu0NGAvWaxFj+gTlAtbNCwiLhpcKAKesyJaS
6n6Fa0XwlZuQcF+wg8mNjI0eVxu3NaADtEhLaMYiTDJlMUsmAg5MciWTAwMVTHIlkwQEHExyJZMFBSNM
ciWTBgYqTHIlkwcHMUxyJZMICDgtYCWTCdRTVE290Smd4NxRks/ZFioKlKpLqGM0/6V16TKkHSQ6xnsw
e9xMd43lZOTMBXMp+V0UBOTkUcKiGlmiTTD6jdQUGNrb/tRxNsEWh/g+d7g88HEVELT6KGMUF8lUtaLw
RDQ2qp6OFWk58C6NqalQXeE8Mp6HuHcRNdDcEB0a8X1/ChLDpIB4MQBqk0zfVkAubT6o2fUAxAXdKeN1
WA28iHDLBst46VHEA1GMvyS3GURBSnDrjWMnomiG+gyAZI1dsosLLJDHtihiFQWxD2pwIIIRYzh+MEjB
RjjimJNIwWELRsseeJfByt4dyiJIjUgCJkMGG0iWJgMbSEGS2ZUmSMHKBgRNlMFKBhsmBUoGG0iTJgYG
G0jBkiYHdEAFSSN4ZLCBFI0iCFLgALhTGIjgksECIgkwWdWwAx5JieX5Vzdy9iHRkDYrCtuYCZhRsRXm
L2F1JOvY34V430oCX6+73ycABa5rsGBH2MBkfLUi+FZImI/X2RSTKPp0DU3AhAMfX8L78WMES1Ufomkw
saCXVEtZLd+CYrSMSffLyciZg1cuf3eyC8jJKpsp/KFycjIyJXQAcZOvqQJpTJJNQRNd0EyNMHWR3p4v
JtHBn9MFfaDAqYkPyZ9wOB48+ODCzAYEkQbyghiLWA4L2jZLFqfkCzYoIohIHEUfRDtFMfbZWnyxbdYI
GS8ZqCw1SNagYl0d6TMDzgG9pHq8LsExLAUiYGNISPhfATAGC2HOKWZRi0ZGDxdiq4B/JI29sO2gRA0U
fSrx102Z7KIVOOhYEgD7WpDbkQNC+o2oI9UIvgLftpY27A4WbY/FPpYzilc9ELRgB30VEHJtl9hEjjnr
sZPABucAHbtEUUEIJpXwtYULA22IHAEpCEy8ny93FNJ1HAIEDG/Q9+8LHaHgNuY/PIBqvNg8wAeo5vb5
1M08QNU2lcDEdbtwa6HjPZABAJeFoJrMcKK3iJWgSzESBEHEWgYTvZu7+7IFizTGBYUFfD19QV90U1Sn
BeSfTX4Ng2KxPEguNCn4cOxHEYHEDkSJx20RQQCNMHKSAxa3I8QXxA31pDuVEml6GzMT+im2gUGaH2bP
okH8Jvsxta9OcAEdoFmpicP+kLDSDkk5xx5TsIwdgwnBdEMCJgFgCYmBsCaWkFjJA7AmCYmVDASwkFjJ
YCYFsImVDJYmBrBYyWAJJgeVDJaQsCYIyWAJibAmCZP4mliw1inmsJ3P2Y/Gm7mFLgrR+tWPio0V6TMH
SsICzo4nPLps/TzCDdWDi+ffIyad4AI8ELEP2boLuBAMAEnpnZDEY+TmQQaVmI2XtVgpCMbUDgYI+Iid
HIsqDiMA3wMjD1YY1g+MqDhSUsC6IaKAE3CCTBdwu0DQrxPEAiavRjnktgRzw6ajwbxNutmulQ2EwKOE
kFBUzJ2L2pyOnm3nKEDCeJl1T7cDkGaSS1McRQZFmwuG602vjN1oLkdQIq8DTgSqJZuHucz2wL7CnKMV
NlUFOJyOHTAAH0yLF0yLoCAJzyiLlT3FySRFP0cLyoBxhOA9zMbiD3mSmoryyEfCg/kyyYUlJgIOMsmV
TAMDFTLJlUwEBBwyyZVMBQUjMsmVTAYGKjLJlUwHBzEyyZVMCAg4vaaVTAlHzilKTjIkR/nG23iBAsKX
xWMBSA+eRbFBO5zKMFnQ7mAeQwEfAkiUzYEcdsomvQID+0bIJA5tBCakOUImFQQFkuYImRwFBkmaI2Qj
BgfSHNiTKn58IgcIcyCDTDFZCIEMMkkJODbhg0K8Hi4q5ostuBak8SY6i49BAWfRDHwLylBnFbAoHzTe
ALi4AetCAmNH4lJDFQSbaL3tjAV393ussKScBbgHiQzBXAcIa50TsunX67RBvaotDiEIYOb/mGqEtZC2
9AMZkwjPH54EyAmQ6p7dAXIC5J7dnt2EnAA5nt2e3Tcv5BXdA0i7xwQHOw5SAJjavQ0zuzEwBgYRBoJx
AxCFMgEADeREwhvinSxmkN+gyjkBcgKgvaC9ToCcAKC9oL0FISdAoL0vYUh63M//ud/GR5BcaN8ZAV3Y
SuNPuRhJITlVMMdOgLySf8RFxEUTICdAxEXEBMgJkEXERQFyAuTERcRFhJwAOcRFxEUC/EpOxD6/KBIA
MiA0aQjKiHEAQYAqUwAGHoZE9fCuoHhwwwkjRLcj0AMeUBsuGqOAxoaATEmAoaUacIkQJxoCk0nt+AVB
u6xGCLczlTRHHmaSLi4W2IQAGt8YWyxZLK9KNJsCRLQJQb7QFC72MJj5xq4raIjIF5ISdiyBmdvnXLZs
zkceyWZcObaXkXYtigqVNBU5kDQMP0fCFU6AnADCFcIVEyAnQMIVwgTICZAVwhUBcgLkwhXCFRidCDnC
FcIOxyfA4FCnksenhQmQEyCnhQLkBMinhaeFKRBhdKeFx68WrWO0rLK7RRh8mgcy2DQFoJiytucphCtp
IW8T1/aEcMFSf6ldq0Y1CANT19ERDcIAWybX0TDAllEQJrBlVIPX0Q8mGdUgDNfRDjUIA2wm19HCAFtG
DSbXCJdRDdEM+tdlVINcU9EH1SAXwvrXU9HUhXAZAvrXU5QcCSMk1tf6/GXkwsjK4bB9RwREiV8UwGrD
WIZHz8iweGqgAkPqiSgPq4ewfItQBH8BjK+KAiEgpGcAGwPHvFgI5dJBeoS8IsHJ5UpBrwAFMIKRwDoN
0SYNYIyQwSYODRgjZLAmFQ3GCBksJhwNMUIGCyYjjJDBgg0mKiNksGARJjEIGSwYFSY4kzOe3iLx4hny
/GALFNQKLt+CSTnfATAKCH1fQE6AxM+nF8+akBMgJ8+az5rkBMgJz5rPmjkBcgLPms+aToScAM+az5Pk
lZBIl87ZOQFyAs7MzsxOgJwAzszOzBMgJ0DOzM4EyAmQzM7MFHIi5M7MzsWAnAA5wOvA6yAnQE7A68Dr
yAmQE8DrwOtyAuQEwOvA65wIOQHA68DkRbA4hdwVbxcgdxLg1kW4J5ABVAsCKh/AuyjID+Yk/4nQvAAN
CFbGq9qD4i7RhQBUxsB2LCWC0CVLlakWSE31BPRYFIlwCLu9fAoSC4mpS0SlJG6oGSEBAEuAnMrYr6ms
R8oHICdATsn6yfrICZATyfrJ+nIC5ATJ+sn6nAA5Acn6yfqhkE6EyfPfAXIBwsk0lycBcgFyJycBcgFy
JycBcgFyJycUchFyJyCAnAA5zErMPSAnQE7MPcw9yAmQE8w9zD1BwrEEJnR1k2eDhLMiUo8iL5DkAQiL
zDZPCmBGxL99EIFfdwIE/AkJINQ8JmzgWXVupJXVhRtgpMSBgwXZ104bhwERL+LHgKDMgNtMALioBnQJ
sBQuGesuuAYZFMDI6y4Z6wYaFNDYBhsUGesuGeDoBhwU8JMc6y74Bh0UAAEIdZeMdQoeFBAYCh+0YFWN
FCDeCrItCBBPCTAUMtYFwB0EFEBdMtZdSAcIFFBY1l0y1gcMFGBoBxAUMtZdMnB4BxQUgL3sEF6IASWQ
FJgBCd1lh+agFKgHIE/ZhO6yFLgHJE8Uu2xCd8gHKE8U2AfQXTahLE8U6AcwTugum08U+Ac0TwJlE7rJ
FAgKOE8U4ggA3RgKPDaVIwcgjxLvxpfGAcgDkJfGlwDyAOTGl8aXWNkoecaXJmJlA4TzJoiVDRD3Ji8I
cUj7dRz3KiBYsIqQzzDFCAGX2Ch8eAkQv4JPxDIH/pMjCBAfCEw1rAY+FvyqVnczDUNykoIF1E6gYcFB
oP+VwDw1BO6xJogFLx4+TomgCgHfiRPJqWwMT/6f31fJyJGfmP+TriODXCSPCENykVwlXj+ZSo4Mr/ML
Dhk58iLvnrDIo8lE8iq+np+Sq2TkpAtTbkZUTy5PozwPkBu8PkiDsEgqNzaeOWTR5tMonhCGeQRg0fKP
FB/f8f3V6YsbdANwPCBo1iMRHSxVhsVMH9a0G3nsSzxQByE8MJ+G/3huw4COKKsG3wwDBDpYxJEudCAt
uaoMYMXB475b+9uwYthWFfwe+xUHK6bbPL5bViwskPtN+1ixsBEm+2HFwkZ0+4AVCxsm+xBWnGx0dHX7
Qlhxskl0Uvuvw4rLIi/719dWPCiA5xX7YsT7Bip15fd1hI0CbnesPwIUZhsG2wxWM2gJDe8erK8KNkCM
RA+fvIPIIPIVzQwCsAy6qOpJD+OxeyCDNh+xSQnLJtgIgwH8sSaEpTBYsSZGWMhgsXRghIUMsU0MRljI
sSaxyGCEhSaxAItGWCatjkUEtz6SRw+/IU2QEqP8M+LQKIiiqI4keANjeSlm/3QaECRZ8LVS66oA+tl/
/eaSBS1SBBpkqaCWcWMhTz0ZGaN0Xp9d9/9YxhhFaBxeUktUCLKN8tzBgu0LoTg1YJ5opuzu/oPmoP95
KJ98+AdRDSyfUfEhCzaf56BJY14sgAUsFNzejz6EusCbUeSYx4lYBLCCDfxa2xlazZhzBYyQOBayBEj0
Q+0FD3Tx7ovO9kkBzHFyY5VoHggxkGQXEgvYAVBIXeuQgMPHQikXCCnjIMAtTYPj6MOZNhSYpgFIbmCB
fQpwcBkJ8yYRMkkzAgMOR8gkzQMEFQQcIZM0BRwFc4RM0gYjBgN7MkkHKn5/ImSQSZoHCDFcQSZpDggJ
OMwIMJA56M9yQ4AHPP7oOoYTBUNitYOMCweMw0vftdmYlkvAGwgOdXJHAwEAstgGWPZElRKzgFlAyr4U
OTtBsyOLjM/mBkw+ljiWMJZAMB5ZFWWJ2SnGp+LGPisIYsGeL5wAeQDd/8XJJ0BOgMXJxckJkBMgxckF
TETIxcneQUzGRq/7PC9CYyESGiYDPOCIoAbiUJQXQAp4bEQ7SShSgBxjofkBUfUAkCOfE+yT5pPekycg
yQNxBRH6HeNsN6fwUBA+2U15hQTs0ZKTBTgLnFwZCZww8UKpCB/k/tmlcDQ8GANwnPeD55PnBSOBdZz5
JpxIciGDJg78RshgwZwmFREyWDCcJhyEDBaMnCYjJ4MFY5wmKn7BgjGwfyKcIiAHRpAxnHADGWSwIjg5
etcqeB6vIYPjAUgyYRys1YP+nPgH1iBxwSDZ1OlBTk4Yl7iRAR4A8hiPZf4AXJEPQI58VpFOkSkB4kBa
WOFddBAoGMpIL69LSJTFTx3ICbcXWriWkCECroKPIBph+3lgKaSQFNKWBTmRdArdayTLiUuAnADLiSbC
UkgLJCa0sBTSJCYgLSyFJCYkC6SBXX0iJOhIrpJaN0npBoLm4yE3TDnHJUow2wA7P/NHWsjl2aKOFU/7
QcAifgyViBNJejZlCosgi50Vz6aABQcVRo5A5AHIkY44juMCAVsFK/nW6h03Uwu8dRhNx0YgBaiGMAnQ
DRF0kM/5+4Pj3AUZMqpnw7Wv+cswqoUtJvmqhS05yyaFLTkw+csmLTkwqvnLOTCqhSb5yzCqhS0m+aqF
LTnLJoUtOTD9yyYtOZCqActAxYuEJiYgMGUsvMhk+YpgEhEdw2C60AhYfxCe+ECMdlWUi39c+PicMWEE
bID7XY1kAIFjPIm1c4AQGJnkiJC1eiRHfrzhi2Tbi9OLbhyAgilQegEDUSGs+63AaiEiB2f7CQxgLdGX
pEOBwEMqDx+f9jAWC4OKwbSpIS9ANp/div4AVTIlTctcBAXIBcgNDQXIBcgNDQXIBcgNDQXIBcgNDSWA
AMgN3U5g06sKHFyuosH7YENjklljDMjy5IQcaSuNGFqd9ZAjnwOGiICIeIiHiIKRZgbIjYEE5Waf+zQI
6OTOmvHv8pXFZGY3BvKD4gKbSB7TkPomLLCURQYmxQJLWQYmWSywlAYmBpTFAksmBlwlV8n6+vogZw2U
+lrIBgGTNdpT2s1oi++F6o6GIQxQDEeFRTsAkfMAEAgCQWAkMsjnYMxMPkeGQYbLmELiOYb+2jrRsIrI
ZPxfFcSsah1TNqAqWJ/TECgFG/zbvK5c2/MOctso8Btd3IXXnT1gxAYOzoX+BS9hyqLdF1awW7oPVuAQ
ASxMckWGKIsKQgXvKwZhet2Ok7OoBrw02SaAT8V8AQ/W8v9kwMCihe1aCrqBfBL9AGj2O9ht65Uo5vNk
/ITf1qRLwqpCsu6EWVB3TzqMipl1/3rxAPMgOZTYlYR2hEiuku615E0sR4E2PLkovByijF9m0MkI+OXt
AJmQ6hAFSz5mAQc5GTlrJymLdGbIyYQ81wY4MQjIyclpPK2nsk8KHD1b8NB2gxVHTiRXg9VWVhnQBB7w
V2CSQcZUIYiQAbclAadUAh6R3gjgBVuNBV9eQyDNMc/G+hmdEIcxkJBmtXIq2wQPYu/4fYJJd+REXoLU
dk0UE8kBsPgoggl7oTqQgp1cPbjuqeREcirTgbSBCnsDaqlkPWruqcKCDFlUfqnXCvIcX4GNFFtyIVdI
DpUiOsjIRQOVoPWPwBqgme1bxoDzQE4kp4DGshfJFEhWaksOgDghz2dpL5IjsOxbDu9/CqR5IKesnk7I
RHKyf5PJxyRTYA//W1bI5oRcN58R5uvIieQR+n7bflLMiB7Bdx4VihdAcNhD4JXVQwmufkfcP3ZCoiP/
fjj2WQ6wQBCD8If1CawJRdVloHiVUTuJzOl2LprF+3gH0VVdmPLk2YCfJ+ccnOTwgUAjhck9wOoLYSuE
Jdm1JWFzE8nUfbUez7Ulg850B9uvhRJiq84MgiGwukFM2zAIJjA+2SFHdl/J8DPeWE/uQJonA6rT7UCB
NE+GdvfyUySCjwxCNUvxAKHm2WEpKxZfL/Ds2CGQSeJXM3Pv+whmQApkPDMQXXXF4/9AWu15NgTWP3Rt
M2bx72QIpEU5utzNkyGwRDMFvutHyJFDINFWou35fvgVDbX9AKQu6AA6r2eTQfSQAnB+Und59gqM7CsN
YlLb5yKa5BlcOsHgAqomzNzFrSgCBD5U9pycdDIvqCkqhRCekQP4VWE+DCDNsyHEMwXqRoekAAb/g+cL
aEhRbRSG4BNBw+DUy4qALleEiv94GFBDLS8IuDcpoqFgW3cPV6AIyAj/kqyozy5m2vKdADV4hJ0bAlBX
a/wDtd8AdlgKg/ZnBFeTkZET2VTyoRMZFMHrpk/sZLoOqFiwOj2bngHVRWviq74BUfQyoLAxwIwgWli/
LwD6KpjJgUKpXhHd5BwRid0jNCJoD4gp4izxKqIsI2nysUREIyz25bcMqrgF5v/m/yCOBbHMicgE4tND
EOKcmuJcEAEcOXLi/OLM6HQCYxFNElM54aOsqEc4+N45afsAdngYBASfat5lQZxCSmaQsoyg7/vhlA8f
jwQLkJcIgTmbgWwtcQFPeHaFcvb6ZZlmqI4jlw8I4b9XUkbB3yUI+v+34yxEBkCgunt3q0Ac8gCpzgJW
1P9vCnI2WEUmFW+GPSSib6Dsn+FSRp6MjC86d+XdVlg9OUCx2uCwgpScDbUvJlwRRIPT0ixRNCiYK1UU
UG9QoEWYQYguQcmyBLJFsO52ratWixbXTIshx0W4uAOg/sSIRcYciX2IA1VgotASVxVtBdsTx5PoooCG
2uRDuIJvhqgtOrBJ0euNCDYCAAOm3L9UUMJVyIB9xgxMaKpMEDM9P4TBgIu7ZikEh19TDBgKAfgww2if
QBc6D7ZaOVGEAMZ2RzWMrYB6UpTofdcpokUEGmZ1/1i1P0kh8Q52KE0p3q+4HdJw2vnjeE/H2Uz2MKK4
MevMh/sBuUeqgN/eGOOC77BMLratuYvov9JMDJjQkHYuishVlcY8BNxDF1T38O/IxdQStqD38O9YUd9W
Czp0z2eqUTF22qZHsAchYgGAcqfHg+wwKJ7nLofzJ6LDEMGNaEbGkCEhrsd9gw0INM/Mx3FEiQiGdW9j
fi8J7JAFDw+3nwQi9sgPQUoBSJpeAnSy3WY52R9CAUWwX0ADz+lKAidYQIAGAkYnQJccMgPLAwAbLCBH
JwRPgwUEaARIJwWAAA1gTwVJoAFksCcGBoAMFhBKJwfBAgI0B0snQIAGkAgITIgANlgnCccPBtGgIp1A
OPGlCA7CdRZl8WpaR3po9gpMOdMp/07SUNwlR548CeLZQ/apBSviDx8HNdVJ1ECBZQE5VDDswvELOd4Z
UJDAdiRwAhmgIIE13QMZYF8Ca9UEGWcFGRooSDLzxQYKHvTAM3Ry9A96YAWXL3Rc42jCSgHyFUbCChQ8
0n8VW3QCRST690GgI2NVlUnmzxHFlv3xcAqHFZoogoFfUybBCw+CcR4AeBfe0rGDCkAAEnj/w4kRCmgE
5CVnA1ZH2P9Nd/XaMWoiFnKE2He79IVEdSTo4mhff1umikQ2MNtEidCBrEMSA/DszYgaBMF0tcb0M1UU
6aeV4y8Ze2oBo6ovU2PirxX7BOuqDGQNAuucQw3GqbMCR0E9MljEcLX7/3kpAStCFPdfLGITFROJ+LXc
wqgv/3jbJRZG8XYGGoLol2fOsbFlsXUQ5wQPotiqaPN3OURQMrbp2O6BeCvi6NNBg+ZHBGrZB/FTSDkg
YbgCFATjO7nsAQHEKsPJlkAtZSqWQC2QA2lALZDJKgQtkMmWbSoFkMmWQHEqBsmWQC11KpZALZAHfUAt
kMkqCC2QyZaFKglALBVqZ38c4Gnrqehy7T9uxxxUgQg3N6whloQg+pIbyIMkQMW38vW6ImpEvnCRDHfA
MCnG8SkPyAkXDBcJygmaJ4kTI/wxlukJGxbVAAAmXqzb8ZICd6WIdAoQEEv2RMwR6g3XW31pAFs2Gy5z
SEQUiojFDpqAiEYU60W7GpEkrBWKzJ8iGvs9RchMQXIFc0sA/oBJzuznAKapwsXTMcDnNK6RriFtQVL4
OzQNSBT1PwB5HT/YLxbVgBt4t9eRbQgIMgHrcteKPuqwN0SmWKATVTAj2cEIoKZnLl8KAxCz2yfQXFVg
ohhoABqyqG/2RbUt3Z+A5rsKhM7YFQqaaOnC6+Bao2xCaASUZMih5Mo0Ag+3QAcJYSwON8YZHxFf/mZ2
oRQPqkiWVYvUVUf+7h/tCNkC5cgjxXYCK+xXEaTAAyFOrpCTAwQEBQo5uUIFBpMr5OQGBwcSTq6QCAgJ
DWqqpbcdr/dZAUK+gGSyqDAKCBhcUqVmb9gTrkDfi6m/MDirljCwDJsKaEugYVCezrQj6AFEspoS2wLU
IxHC4vYJcmUfgtahUAInAnIlk1wOAwNyJZNcFQQEciWTXBwFBXIlk1wjBgZyJZNcKgcHciWTXDEICHkl
k1w4CQlBqgHqhBSi5hDuKup70z5FONb2QFhydgneOgr2u/ERaJA86MtMA2c8EAuKAUc66buJdfRz7F69
vbgM5GUAI2UcLPLsEA3vNRLWhvvf6Q5NO2AYchwFPJL5aO8kDonG5gEHPtE70BAQ9IvAWAqr2eZiQhcj
1oa0CXpmCbKHPGTtfuvc7LQdogpGbEkJmkQLEcTvY2+iWhhIET31wV0R4P0fEgAAEfySELHQ9KRxooAJ
tRGWgFYAVuKtWwF1ADcvcFsHDUSj0w3uTZ2dPXuiwAOFG4UQDbiWACgC61rAWLeBgNK9GA8AV1NUV9S8
H2eaSwUQ+3BOhcAT7AUC6t/uJFwhghUVBjnCdhkfgnAbi3IKBcL0XN3tERDSGHfnP2Cgn6Im2h9Bxgso
GKGTAR2DRBQLtzHxFLWD9pzWQkL/YAOqODr34tBR0MCjvro6QWxR7XBJ6EE/oA6VQLnEw2ADs/nudZdF
o8ITUUysTSsCHFF2Nghu77eVeO0DlTlAlQhqUeFGmYAGXc2C6tiKapTRZ1XBTxABlfjsESp4TT2FKNN/
OHbjApS8iEyLGF5f5vK1SCvd2AjBnVjcSIX5YUDQmnNnWlAGU11asIM9VNHYQVpZOpdR0HOLhUkhQVow
EkFS88d1SRSV+ZlJj+AhFDKFYB3BDgYV2YVoDvZjkJPIkNBPhcANJoOdDdgcQA7wVD2j+7BBDuyF8r4b
Knhg36ll03AYqG8sCLqy9ibXR45wjC8xQaRa6OPgVI9vICZ5xwcEHhjU8hS/lSiKcMIIhrWNvTLGBaqz
XPVujRC849AqdySENnCC3H3PBRsNKPcMBZpZ6kORY4mLWSn3dxtERIn8JMbGrSjZ6xtvnXUSlDPGBwsj
OQh16bboOv5F9XPiTGQ9smQhNoXpZH/BcflMi4Vxjk0iGMcooC3YlRiCYcOHbZIgSlZN/Ynev4B3tbCM
bFfC1FhadVmzZPwguo0grjeYewhqLGreMi9VPcKNFVleYmXrJKjGGDsfVjBB8fQEfgciV+D8CPTaHcM4
EGXj3k3LOMJgW3hOnQjqfAQjGOPZjE2BIE4VlLzAaJS7iJX32QLq2McMvUFapiJBW0yLJCYiGLOj7erk
wPgZ7UwrhVj02S82IdhkTFJQb/awn/hYQVlLhWg6QaSxzQEJXGAQjUeljJD0vRAk7qS3SADrB5QkwENN
IOq89yHSxSBqJBKKDgMpIBoL6bQhDZQMBygNjkhdFXBsJCPR4YD0jmIhABb1p8uRIy1VAz4RSOUCUg3j
Ad4ASMj2RtDFEEj1OgXtPTGCYXwyFp/dAOzVsAGrJY0xqvolALCAPUZinquCy3/0hoqCmlvVKm0rYnSj
6se6mYxgNaXdAACi6NdVIYc8HXsY2xDAq1y+82EQkKvKsYPnbYobUG0FB42cKUkUVXYOUxB8VRzG+inG
Baghk2zGqGJDM4mLXMHcdkXcOuL4xInXaMaDAth+AcQp+ggBHQZAx82DuB2D7gKoYdfwyI2KMBhF8SoI
37oDKNhq8dxeXF3Dywh6wI9VzADfwQ1G1Udhoz0JHVZRwKr4na9RjKKFE9JoXXGJZSY5KAO+F4oeGEV+
+qQZRQcydfqkbIGMogP6pGPoQEbR+qRa+qRRdCCjUfqkyCg6kEj6pD8OYRQd+qQ2fm9rRTmKKQ4bDSgH
EdH6iGBHAf1EOEbRQgVKhM4zH/EGcX6fBVA7FcKIjqJMauHGH1gAxw/iANfUxQAAOx4kAcbRuPy33UAD
uMZ4AwkNUoUP9EEBu1n324rIyWynXxQdMS8GcuxVTIhqxF9+g+BTdXgBreoDgPqRtSLihmwDBuQ/JPgL
RMmRTAHK/+K3IuiqMNRnSYqA7g/2EGaQbXcCLhC5cjMoA+rTAYQPOfcu/MCBiMIBJv7m/a84RK+ZAwg8
SDnWmoSIhx9HAU5JYmUbOuH4IVcCJpLJJiF1DiYDZJMQsXUVJkmIWMkEdUSsZLIcJgVWMtkkdSMmBpls
EiJ1KiYHRHQAJGRHXDLZJHExIghSySYhwm04ImNV5pIJL4rCU1XQQOzieTdytoE8+l0qCjWXjJoVsRWw
n6JAYxzhOG4u78GqpaJDAk84Fkegev+r36P6gqQG1Um/dL8+40RLFsHLXwRNHQDVdABPiMteWcdHAiKB
ZRG4otrDwSEkO0cDIj1PsLJXFsNHBCas7JVFw0cFJit7ZRHDRwYmyl5ZBMNHByayVxbBx0cIJuyVRbDL
RwkmkdwGrXDOKQoyFoRdGznGvy8KQsUOO9pIFek0xyaW3A/3RI1xkEjhReOHuiyoP3v/80HNnuj/eSu3
8CMFtRBnd3jX+oLaqIF31f8dUQvkd5MJntO2UES44hMlAoSopcLTEf4Jg/uLXRVwoMJ36RAla8BOSZcb
qQoRbJKL11erVAEMmxNJRCzQ64k+Cz1UwfuvSez4RVDcat5eksALzEG0DwjLHxFChpKWlMbX3QzAGTgA
nPjwCBJHRbXGD68k59smVTAk9wIxSiuYc0QXRxmfEF4ZC+MBXrMsLIUx5yYnQE5h6wFeAV4JkBMgAV6p
jFPJAV5+fecI41TGflrjfjffFQ16G48M/ndJNwiI8FKsSQEQjgIIbTBPABCnlvEA+RcJ9xAOiMdCxg8Y
P0gYbwo7D69ACDttXZAIT1SZNTgqCtmDWUmJEB8FS2AlwY83BPIlmzRXLyGAXgO8p3iJE7C7kd2lSYn3
MEiLAKTofg2XF9cbiRAJ8PuKrYKV8NpQIM5cADEvIokAQEno5okKQu2JgF+vAm6mCUGio2fQtx80eyEc
wBpEAIyQCNmEhwAm38iAnDWLN/dhXQLV9gfGjytWFDFwL4/bQJ4L9uZveIOkJb0Id++vAuQEyAUcBRwA
OQFyBRwFHAxOgJwFHAUcm3CVdAIFHLNkSA6SZgOzQXgZAYRfiVAFH8FAoP8wq34xAm/QXwMD1sbHCAf8
479jjwWHA+OyU4sPFghfxUK+As0wA7EAtgUPtxYvgE1ZjL7wL7YW0pE0KXdzgDejgNgCHgg/9k9tEFiv
VQgkgPoEDrZIBDTTlQi39LFJ2j8Ry5CvjUQQA8rgDJKfv5XfKWQoG5cfk85S1k+mSdNobxdgMZIYQngH
UtRSAGkui9wC8jDPtyUzUjiPkwQFH/rpfuvYzmwTQn+JQFCJ0P652dwHUmjr2xwF5WDr37u7u7lY69lQ
69MdeOu9CzDrxwW5ubm5SOvBQOu7IOu1KOuvCrq5uQjrqRDroxjrnbv7sF3G65gEgpfrjxNw64kF7VpB
m0mDfIwHDMdiFbAHkvMLUigccshhCAgQGHLIIYdgWFDIIYccSEBwHYgccjAgnwpgxoP4gPoBDRqLYFcB
GwYiCM4lYgKzHB82WgIjoUKrHxABCxKv8TeIcMbQd3BLY1S1YA0tQZ7qrbeBPEfYgncs0tfNFxWk2YCL
Is4eImhBDzz6MnUB1Uci6Lk6vKga+5dA/MHshEbkiU9IB+B51gXemF1IuXuwY3UszUy3RS3UazfoodVI
N+vfBWgnJyNnL/ccbL34sJGQ0w2Mx+uGB+EgfMTrgMEJAa8JAYIc5CAJAQkBRrBBxggYEgcdQw4bGxxw
CHgEQOSQaGADCYCELyquKGrEpcAh6uB+UBCIlZANQlCGMDTwdyR6QdUT3BjVVlUxI53FpRgCZ2rI7Csu
xXspQYLQ7ClxBxEMGMeFAHaKilkRmA0DdE0xU9jvXEnq73qSYoWI215fdWRl2LhuCggWBJjhGlCSv7ko
bytiXcgDnzCoBv2CIN6LjUB+taA/JGruxVtgKHSvi4XFBi96rXr+bFDQg2oNBlBNUfxzAxxB9/K6Tf8R
VwL5HEmJvkZolFDWXkD1xnuyCifNSXNwOFggSHPSnDQoUEBgNCfNSVgwECBgSXPSnEAwGGicNCfNEAgo
GHgeEDXSSAZfoE9x5sHx9imFcFdF4W5UtoXyBrGJigpdj9Vg0SgIwH26HQPPkq2AGhHxhB+PhXjsjE2J
hYIIBveHX4H+iviEAwyMWUVEb6ug3zniDw3cSQ9PwSNFwA2snQMObEEBR/4rDcSD+A5Mxhy0wcZWDgQj
o30WYSSi/PJPQMCSaTeHH7xE2HmTCCcIJnXvTUBLAqD/jSAqEGMDbzHzdTIhUgzaS7047eBinH0G9/2J
QxzJydnhlzANCBDJycnJaBhgIMnJyckYKBAwycnJyTBAKEjJycnJQFAgWMnJyclYYFBoycnJyThwSHgf
YtDJeIC+1rgBdGHUSCul3ZCigJGMFnIgGhDhX0dtAYWpXNU4BKECNuYMYRfgIJ8jsQ+sD4wcHEJssSh4
Ecw3OdaxTqknvqrMuEvIgwB9HTzOzGaVNTAWCdAtsocAcM9cJIKTkEGioJ6gC7X4ZxqWAVDf3g2lzAC0
CFB8kwUtjL9kSIbshQgPSHCGZEiGQCgwSIZkSBBgZEiGZBgAWCxYQ4YgPxsJm1ARr/tDgGLkFfHLgp89
hjDpg/gBScskzl4Jl0QAPzX1Q4YshHAqR39ERM1wBUogctixA+AHRkAIEMghhxwIKCAghxxyMHhww8aC
wYaHFEgIDjnkkFBYYGgIdpBDGHYYRTQnUAIVDXa1pDnpnnYICgAoGE6ak+YgYDAQQOakOWkwSChQaU6a
k0BYIGBYk+akOWhQcDheiHqYeHbvY420e7K7o5iNPAGyC65GOK+gYL8qSYtOSLMXrBvW6a8VWLMVuWDd
MK8VaLMVyQXrhq8VeLMVJjaDZwcRLKJOELymIPCsG5uNpk4ohJJn3bKtoo2tTjBCslnDUo2tqVJNSBZs
ralSsQnJgq2pR62nGSwITp5OdukSnnUpjZ5OCEUoR5Zw0gUcACBMuiU86Z6NTkBMno2TbglPTlD8no0w
a1jCTmD8E42eyBRylD1gWGVcMhRocJBCrpCHPThYSw4AmSBghGQMCNFwfz1IppCjUEAMCEumWNFokCsQ
lj1ISy5CpihQKxBSSQ89BkCmkEAwSBBSSUsPPSzIZIOeOJrJYrOWpZ6Xk75gAWuel5NKgmQKGRCIMBBE
1pIjQJgKuQIhiCBZSyZkYDCYYYKMEMYoPQnBYgIgxj0IiUBg1j1bcskVCCieK0BgxifWIsBUCD0IecYJ
6RA9KFOFCMbhKBIGPRDNFJBiwCMPjSrhgAiFaD0QbAzYon4gpY2MqWdng9wIrb2QfkjBCsmCBb+0UwjC
sxNMvZd+YFeYPWtJU7StvVg9QBhCMDVPSKQGC0JEnkZCVk0VJP8a50W9hDhxp9Z1pVhqQowfwqaAKdmB
1CSeNzAPDMmQDCBoYJAMyZBYUMmQDMlIKAhdyJAMEBgGhAWphQ5XMVxYDdlwD3huQC+EFALPVA1nPgW/
gsB5Fbpizr1JQVyqNUgAwOQZeTZVHva516teWFQ0L4C/3Qd8Cu90BddVNShCQJuIRcJPECU8gwoIL4uX
u6OIRX688HVGCHbHCGq3oHsIVgn8CKiJiqkRwIAVTRZfA6o4CESp/1A26G+LloNsg/ABeesGfAAAT4lV
g/q6iN1NQRzWb4sOxkYUGwJ566WPSAQ/S4SAPQo99R3PBuIDHS78PBtjXZAQ0N8YIe+mvgCq41FVxzNm
F7NeJ91PhXQDHhT1uw8Kw7Jgsa/Vtn1YIv9EAksQDpP09si2LvBtC7PwdcHfjhDEQaSvVac55MAK/zw8
3AkAm8pMpxhDgHCsgGZEABcjIZjiHe7RGhI+ImJ3ly7QRzj3ic9oMO0Hi18bpZ9zWAjIdd0IsF8GT8NX
GahVEBeJi28HlmXZCIuLi4uLxJtlWYuLi2c4X8NqIHYNcXDHgf/ud8KHLqqz9Fljx4iiVkT8Zos8QmZC
DwB/Kqx8xwAWRMibougfmCAGZoMvv8cXAoLYD40Ncf993RcR8DWB5/+r5jE4VPEoolalAGqHXWg5wsgl
JAQBjlEQQRE79g9JwkmNV0irolgTYYclhUvQClyCQXqRKGIRFKnILWYCtywJgACt2BtyEE4JdBXPqIAg
YedM1U8Q1fni+vOrxuIRLgHbuMwvzw8FQPGGqBdAijQKhYhuN5sNjX48wCElWIAIbg/r6n5I0B+hKmd1
3kiY60cA6ghAviU9RCGA2KdoFlH/cBFyAYP7VXUciOoXdyDrZ8RDEC2UA4XHrih4BKnzb7wAVHjrCTEX
BbhpDR9cwRAD4WNbw26JCSA2ivoTTDd1MQLg7E1G8wmg+wK4BeRIIZ8QABcVUaA8LMBREA2C8lHEI95j
BfFKISQcQG8Nl0h9JXcJUCBioQLP3CBV9a7LEOvjSE4QQJHuhfYukqCA9yB5BRNLDqyI2P2FBc8adRYP
Z1tFMW6xNQ9fxC6ARMOYOeyZ6QsNfAaJkzIRxopG/3pRDbG/BjwvdfLr7a4TdArgWS9mvCToaCAPLxXE
MBh5eHUdxGERBXQ5AEGMQdJ1UXwo6oXadG8ABuET/roGqNFAEe6CSwi+A6cCAIIFbwCzqsEJuJELUFQo
qrarAUAUjqb0ZEYcbhT1YwH2RNgGIAyJ8PQ3PNsdSB7/wx8DdeTHBbFJDrEAwn2fZ7276Rd8U+hq3vzq
HZMT3TsdXCy9gwi4BnMIXsMI6+8YKrq1H0GAY8bORcNCRFHCXMMCFH0UdfzuqhooeCGM2uoPBcCO4v/U
KQLriqjCalXOQ/3RgBiBmTA+MgaADqfqFlUiqKuipmDesU4E5GBbgkaiqt3/4Ga+PYP9BfAl6ileF8RJ
KewcEMAXjkLnJuGFgkkF00b16BQcC4pSdOCeFEAfDe8FdRG4AAC4k3wgPRi7UNiOSkbu6wbM0hVFj6B6
E/42knoiPJs4vwavxO/D9zr4Mf8GrE1IIRJiWxjCWFTVCJYVNasgagjHFhz/l0EXuA2N4LsmC11MqGN4
OLjIDhYB/GUFv7kIIA977ME+CLgOGfS/CX2/fxJQLWYJVitL1SGITkLxCHQBADgr21CRIOBuvD+mJNBg
8v8JQVDbkQvA0hGDKgZ20UbBbVjrKMabW7yK4h0KA4NJU9JEsARUdubvrvQfjjB1EInY86xBAD0EBfEo
iHVZQQFfE4kwqBAiEDUgSCDRH97ugDxj00U1agBFDv6//xvQswKyY0DeY/haWXgXD7rjjnEK6BNzEVCO
uEhF1BDF56QMIYuKDvnPS8BGAyPwDHdy+CLwwFBv61mOGdU3WPffiTjcpyAwCLdJF7lMh/Kf3HWiqr4m
iw3lZwAAYxUBdvh0ENFYC3H9xFBdW0RFwQtM6IqKA/PvMQP0CQLhYEnjAG0AQMEBdLoBxFaEEVkGdQDc
RoNaaBUKVxBRIoxzBE0FcNm8//4R1dx3UBYrQRDrCBqnvAQAvBP5Sf/52evC8SgINnWpiNMBCEwFo/5R
JIjgZt2QAMBA6VuiIEXB6Qoo3qLCA0cQ2FEESVFX6xJFDaSINAl8+hiqiee+QMr/0yQi0AgistsiImw8
sjxjVEHRQgT/V1qJCkgg/1mDmhXUVyUHVXx4NfE0I2gIzYhi8QsGJjh/6lHUKUkdKAHhGsaHFwxSUKWi
peK/LhT1TGPoqQNNjIsF9xHq231FP0+NPAa2Jky4AW8F3KjghweGjV8QRaIBD7eLKmYPu7renqI4uxEd
RbopF74RbBf430tMbfp8xhAAYEIF/EYoEcd+7t8N9jnFEScLQYspoSeZu+coIO2uFyWMomhCECz7Bjaw
v04xC9BKbC2bE1RN90mFDWiBKi5iJaCzgIVivKH/PR41baDxdzBXQRy7QdSABhQH/PLalOS5dol07jcl
tXm2FCyvJBw3HQnETVA0r3wD/BwMSxAxECcuKnxhLxxkbQA9kEG8XBeB65738AXHI+AoKGJvQb0FH+JD
AcQk3VMQEbFFgDHD5IJ4cVbRULosVB86Jhilg+V/yNtCE1GiCCAHCgxQkCHHLwHt6Ipqu21+8A0kABVH
WA9ha5wm18qDvoGLgmOLiCz/Lt/rchTU2nFZ1g3IiIrCTDPIRhhZS3ZvT75h7TBzIVPSb1QRBCpPD4Al
V369/pp4YX+JwEYhBXEyIQDvi2sQu2R8JSchAg0mYCMjhFFfz0I9jLEhTyjOKQcPF8gpI88pTK0TgDyQ
QikcKiQHY7DgzADOKdsMIAfkKm8oXEBHGG1kzz3PoJ+HfCQNcbZ8AX+JZTwwvnzy75Eohc+MNgJ5ObY9
zywoaIsfnbwIaMeqKeh2jfBEFNrKGbzBhB67ykoQEIlRGKpEQcdGfuLVyXC06EzrNgzn2kbJA8jVKD9E
tIDRIdUMmZMxkv/XwsLGbtgbFy8hAOsrKfgBkIjqGwwwv4hQBC3qHdADoJyexxQBbES8/jgSRLHLPHg7
RS4oDDUst8sOg42tTKhE6gBDvQSLOAw5COcxvlEUrSNFCKhUfZ1V1CzcycgqSSR9iOImW4nIFLgE4H4t
bInHHugEQEEBL4qlANQFiNE4Y8eCWsEgNcDABO1SA58pgz8IBdxwAA6KhwO2ispRJB0EIlpSMEcf0TNT
EHIfJ3XjNSKIQZOXFAVs70hoA8Z3J9vvpKst7FgqNzAFWjQ+CAVjCysnPUk0IY49bMJe/lsFLyp127Nt
Q8D8sS40UBVEawERhUHzBwuNky2C9hYCKrfCJigO9CszIfuKLggTwPiXL8667ym3i+gyRgNCQ+aOjD+E
IkG4NMDzO9F9gAM0TBwoLC08AaA4REJ8kwxBHOD+RBxEBgpoC0VEBaBoHvFLLLQVz4AmdgQxH1CFgcL9
tEJHMYCAxbTPSFU84yVcritMLagkB/Z0JBg/Bii22IONQz/9gvV+iGsBxek3HzmstwJoDVGyH1SQ0FFD
ilIGLPvWsL7IwjmlXyeoaNYwWMURPwFaFVRd62AygjFGPpgsRR4BIhZBFxV5LBihihr9A3kYQ8PaPdUc
LAiHJfoarK9Su1EsS0hCsGC981RHxGxEGNwxRwG+o1qoARH8vrj4CktHCtPggwn3Y4sIt2DE7vMvCTL0
453kxxsL/TH2MRYwqggV8S9BJxXvSJW3Yj3PBr2gMhBGsgLo3YbXCMcYEi8UgGtLvSEmCAhJUICCSJvF
hsgY7LNOdDSgzY6EijpAJA7MEGd8LEcP3KcFcjLGJjENgKIWsIoyDIEqHF3EJB8/v9SxIGjgOIHnRqeR
7XgG5ildjStlw74r2TiWv37WUhQQ/8NIuN/vqIIVC7bKHquq/qIDMOwEAzWJQ+herPMhBxzuygHQqRAV
i6BIAOGpDuGDix+XHkgjGxAxfOIQQLtwvNupDDsg4hIRT9xjvyxbIDC0IKFfgKJ1I+8uCDHA7Ui0y6p0
LRBvBJA4sJZkMO6v4SRawQWt4dCbiOC1W0mFx4XbLgjoY21sTAH14YNfDHaxMsd/FjAUN6MM2gAVN4gW
MGghNwy9amABzS/b4OegwgEFRgBdPTgrJDMy/QjawrBKMYEnEMMIBwl+uSKa5ZNRNFLRui/ugAq+YRWA
NYsg6Fgn7ZdYHfHDEaAQpWgYqUiJ2N9bCRTP2yCJnVXRp2h2MJwmwHQhUkAkY6g5kyqChw00U4PbMALg
A3c8+hXaQky6AVOnKF3NRDQ1wN1f6DNrwGHQQKYQjShQDiIVg3RGr8NEipl8MrnY3bO3CsdC+CQVYRKL
FWMYBFQUiPzBTfKpw5lTKEwK0V5SAKkfMC01MQFDBKKTCWsoBYwtqaFbgR0UoFh1VfglIFJEHSnDH3dU
sXgw0GkdiQQUQQG0YxKNUJyCWBW9AxB2Lt8sNsEOXTwzcinykl9UdXGDypYPVomdKQpoXu5tKh/4sAX6
w0oxUtmD+QUNO6AnPjO6HRwoKsYuJznBDrFIjH1mw3HWSCtd8IETE/hIAbqbjRDYQMQ1prGsn6+pqOVM
OS+FJaKGEAUTsRCQq3Z0E6IgDEE5ANfrxhVIF0EHibSb1Q2qcQggAjQTjRPBc3XuZteJjCmhgVAiyGx7
Dw9fmz3pPOU/EWd1yGo+qTWrpFOITfgm84lohxeb0XZ7rgH/hU0Iw4NoM3QXC3GEZqCyWQs0wnASTkFr
DzStHkJDEburD0QCo0BUDm9EaEKwqKIcSKYYfETo0+AH1gQLeopxixgGJs3VmMkAqDvZ+yUhvxZrIfU9
6SUhzhs5iO3CDcwcUtjpOnQxR4ucSPuIGH3Yg5wHEYnBhEwkHNa5jYSGw4RHa31OZ5P8OHQ/4XElahYo
AYFTGOF1DbU4YLEbYjHbBhMyP/jhdcpagf5ZNjLz6XHCT8xXs7k/AEwzHcN2VVNUqsNcgxGHaI/BwRdo
eJO4QVwADGppgI8e9gRsM6juGL5hfELGqiQhAAcjy7sJq6BfhT34dLpFVEfWcAJ/8FcqgLbuxj8nS9Ek
Yir8r3GD1Jaqpuacx2KoGwIEtGvmHDp9D1SEjBgfD5APjjA37HhWif3b7wNBFjnC6zbkJV5F22EDcOPg
wwtNgmfkLuLGSW8iN3StIvoFbfBB9scBXVAQrqk+bx9/tu1F0RcPjx+sDMVo7BN4SYJMOe59pPEVl6gG
McDpzwegHohCk+qpFTcAimnPTSkwBW1E3miUhH8jfBE3Xwf2cDhDuyBbqCdF8DZlX+dIfQjNCkLcN/xJ
whCpAwW52BQABgpOvg5serFDOd4rs3MKVgS7InvwXW8VQAUZV41W8IpgAEBXouLRiwYyEG9RUfNaTIng
GrX6hCdOjSQxVo/dTkD177SQ/EyfBM6CZGEkFTnad3Ao+FBvEOzrtr9T8AI1DSOx5tfHo8MOC4ZIuxCe
AfSNEGVM75wSgHoZLy+8zyR4SFhzLje32EH1QH4ZfynasGuQEn5bhE34BcX4In8ypLmgMAwXEbp0BJDj
tyNMY+dTMX8ET1W9Z/K4LprmkhQjAOv6LYJ/Cgjqgzv/dQcFxRIi0RBALHbIx0OqN+hjb60+icVggzgm
dbjmuKx4LMJhALlEg83/zQi2BFQ+Ff0NXg6qBPwlKkwA9P/C67TocQMNqS4z0rgchAhYSLAOXkb9eEH3
wWx0DUvrGg8hqDbd/gzGduEQVLAWGy3Z26VylDuv9sFi1SIOBPSJy3QrAwQCqKlPFOzv8/3pPNZx2UyL
F4uLdKMGFQuXPGPVIdOibYP27LgJjoP49yWFBGCBiKUSMDBr+y3W3VqMlWn32GP0a6/ASI9taunsjbQ3
F4kxWjoBax7gNRCjWHTZCrBEO7BdQEEpxuZTy8lFVAEkpMJaNVAkYK/Ut7UCW9Drh37SAtCKWRRFRyOA
WBAgZcwUEcmI50G9KuCNSGUFBV+TfEgLAjXBQCMgWOkgqoSwuBl1J5yMeGnDRok0KbgJi/2qC9U0JE4v
REcixxjDOucx//YaiuqyXaVVGQ1yyAEv/tI2TKITIev0ifveQYAgRY1s36KTRZ+wOsaTY/OAgmTLNYcE
zYjJ+DpdEQqGQD9fKqoAUCdjAECRSbP2v0BFX1U8pz4BdnyNg0Jj0U//fo2fm20jatFV6WMdaKpBRaAN
yNtb8AU9EIM9mMMAdTYI4wWLvp8kLUi4jwOt3IMdm86FMdLOxwW0K0Ek7v5a9oOLBRB1EEtUQAS58MAv
qh0F9VAaInUUFORDxTVd6C5ZjDYBNXMId2EBDeU+EIuDiApWBICCBoheeHyIoFhBWuqViQBqMw6kH+q7
yBjLBOsHMdKWSWPFa0uo/ZelfGqsoy51dR8wGpAUDTaYKeWC/5bgBAsA8FE/eztPtYsEF0pISZIIRSY4
UZTIkgDCQFoSSAStWoQx92wKqoVqR0brhFDFYSxV/ThYuFTUJ72NR+CRdg2JWwEIgwc/d1QxpEn1O0s8
8QsKmNX/WiidAelS/YF/EP/hdw0j28KW+OsR9kcIKxA1gLgSQIWsg1ckgIGgdEGm2GqEIwEWuSZZ4gUh
CBYoiZyyIqCdB0Q3QvAugl9cPOunFCR5BKQqajB+G9C0sS1a0AcDD2tAdMBU3mKBrb0O9MQS2fe+SEL9
rXSGY/rrML4B9fiMPx4i6uoFif7sdoy4ydCEqE9/aoIhogkoggAl+GCg6VM+svFRGerCXyKlMe3U7z7C
C+A9USKzPhmJxRtjECEAHxjkYRlXEAm3QREQbJxVHz9JjDGii1Gwhwuc9A344HmXQbNDrEModAqsYwsW
UDhFAAgO9H2p4nofW3DrvEsqAHo3AZhHi4dIyY51pz5KB0eJxUYQdSCqH0b4UEANZkjtdQ70sI0ouF1M
61MqCk4FYsGogHuYxq8igHtG3XYvUIVTx0MmQzgHA4uABihDTZxRFf90C9/DwMHZMe1SA4Vi8SNAFfGE
wEiJVIhiSRDUGRF1LMp0N5NAnAKINmMP0kHdKaQkkAesTqCAyCSgnCkFJKOIDhOCIkKooRCsilUIGgVB
BxXqMABEuyBvkll9hhBQJ8DDuXaMp4A+09eDeuFLvAKIkHgroChQFQwKgG6jvCYMSNHpEHzf7ln2LQAa
dg2N10x7m9fRAX0WX/RWg7uQNOV4Fl0igkeffi3/IChtEfJFKQxFsQkh6+qmC0WaFXFJlY5jKQpegijh
LOsZ+gigIwSWOcVIbwC3pAHtTuvOWpwqYhkoi+eKwg0D/bCDL6q2eeqW9SkBXQUVi8yTM3ZBVIuBS/Zj
wWyQz8Z6aT8CogABjEwgQoVJk7DRaI54SpB+XE9ARwWG9RDEN0FCghisLx8hAN0OIFgXdQV0D1pLiNV9
GGMI6annR3IUCOJMGOpDDiBbjYPuCbqrRwLzA0MtWkmeAINiEoIDi6fbAkBrL7scwVMDoQh4i0KkCusM
LdnPUPeNSGNKDM1C5ycKFmBHiyYAeAFWIygPtwBXWYGCTb5iKitENEq2SGUtCChKEFG8g7EHw4tKIl9X
sOSvRA4qECr2F9YTK90A2z/DEO+t6Ipbg9CNSBAYRlEFztsoy9xBtKMpFA9D/84vVQULS4NoFuvsV+Ai
VybeTrcC4m2LD7wRg+qsCXf/Q//tJj3MAAx3FGvw9oHGfDnyfwdrwAopaMDWAdA4REvQmTa6VFnrzEQH
RG0Bjk1Z1nXRbccdGCp97N0X3RR172J7+nU50X1xG0Ba9rzTKcu6jKAaiQCH/WzEhTH4gfsAbdw5RtOi
PxDUSkmNYZeB+4gUe6quGC6EgIjfH/xDiYHrEOvgAKqAmSEWQHRJwTKWRUHhWlIQRAjXuC1PHR/brM8G
ABM4oih52OjBog7ZwNvb2xNQHCmBePlMHSze0NtddBFBvfjvm25HENAl4GgF5wr8TadgF0GcDA+64Aty
IQDAVVWwYYLAtYkeEQVKvUK1KA7kwl490Q9EFEBIamIX9X6r/8hZXmmrRXvbAucqwjN2lzrgAhTwg+d2
RdizjqraAnvVjBkC+r67gQZFhf8YRHpFdlFEqTA7viAKUMWsYGD6taOKgP/+TUOgMeKnCK9JY9XoDTsr
CicR3g9sw9yLQz83Qj/wlIsQRX4/pyIwQBl9vYc+bMhN20+JamjJEP3/y8fBDdjAWFrZ7tnJ2+l6VBSl
CjDCNu6IolrcySBB32F/gKgniEjgQNkF0l0JnoKdNAk92UQIyhVEehEaUTXsgB2gsPvwdza4D4sFmyYp
2Bo+9oeoqtjJ6/U+gDgtddbaFxY9yoTY4t7CbQcDRNEa/usE3MLe6kwwCwV28Q6mmStvTN1XBVDiDMH4
Uzh3aNECJW1wA9iIKF4Q0+DAg4VMd3MDIPoJDFEU27YLxj96RsoQFKrgLqkUggBXCoIUkOES/zUscQHo
C1sZQdQgwfofYixFdXsIg+K0witmQQ+6260G/tlZXmaAXupFBYjSe4A3gfa20BSXXOzZYFzbXGy2gaW7
B15EiDRjI9pkA0cbBMUKNTlvKOCFf0IBiArYynUdPA+aweIt2gXOhMmOd38FRaK23eR83UICxiEuHBe+
v4tXwuuwdfnd2AFINgy6ouogqv17Ywugto3Y9VXLH0VcaoV0bn4I7V1XiEmoQRI1jVwrAiP2BndN9Mod
fQpJPU0p07iEEhTwHCtGvv4rCoaQ+w9gHAHHC8wp60O8ZMJIMzAAATCDKJixFMTbYg05e1WC2wl27MJJ
Ez+J2mxYewJERLI9ZkyB8cRs9pg5RdQmk0zvTx/jCCxI2IkL2A1mimz0RUEL0BykjSCCWUS7Ng4lWE88
TLRrR4xqIp7XyadJuDBEKETsysVwKHFAwt98HsI6EQsBEQTyYIoloq38UvA3dnTt30fe6afb6nrSddCq
IByDoItg7XdEYG47QbsAypo7Y1oEtcF+T/MddgT0pagQ/A9OzihVwE1V/XcY5KAAbYuZ71ZTcEcQUV1e
84lX2lURLN7jxolFQlG0DSvtDH4RbQu0Mk0Jfu4NEdBbHu538CLr7poooK2xidqNQx0VaC+orzzWrYpG
QPdaUYsgTg2SG+QKF5rNfEkP8EG0yXgpQWL3gFoYqdly6jzP/HYbBoHx/0hMvqjT/gAAAxUr8BJVUQgH
H4s6IgpDEEp8I6IaItMUxoly/MO7FjdLTCH+4iPr3IN9ULYultpVvM3qtwcoNqCpQRMicP5mRAUbBtHV
1WpvFGrbVILB/gJUiRZA1HqX5wjn3nCyAbRJLITSwqxhgp8AnvVzJJ7oBQtVKQAUYqtCUGps+0cQEKUg
FYOFdrA5CH5B/9L0rnt7o9pa/5XAQYfAKccOajSiqGfMUhJU24WOlcGrIcQWAbmlCyuDcQuPG8BjuPoC
/g/SrW4NEJaNd0txegUTIIBAEKsL1PgGmffx7oyGWlS9plJVlL5+FPzeWhrRa/YKc4s520KFRrsxutLi
0zA0VBF3QYggmn0iP0tZGQR0eCETE4H+QASX/hv9Oc1zDvZB/AHD2y2whNvYresGasgHKtFLdL+/STnD
cg91F0LZ6ER19xBmW+JtHa4lx9gJqLMmq6NFqRL2CO7eXmpd+sEFNt/f6Sd6BnWx/cIXODnrTwGtMYE5
/8l2dmDhBgUJ6QQMBCIaHyO8zXYLxz4gbGzEp0L/LtlbFAaKBuQDIChEM+kDEVaGdWfQNTqVaUxDa3XU
0d4gLofDfvv4/Hwuv7W3UlpEzynD7RDvAv/L9ozgZk3CCDA/bXYGtBIUsFSlHEKEwhitZFZ10AqgI2nB
6z23rUssdGOvY8nHIFZmdYCBQlOZ88tCkeFYRLrB+8stKKBRZCq80Ta1KQbsSDksUdrrLzb3U1cXK8Fj
2EjZJcioVEULnJJEAKYKyHoKqmcjSMEFTtGrcOuN08KwAXplsQGZaCCwbrqXPvEbaX8pwjnTjkccSEwY
gO6YuQGOiKVMdR4cAbVwE4LItFUiIsYkQ+eG3hwEmoLI62YZg00H20yNqnt7id5EgUEziEF+du53Oy5V
KcKIfwibxgAw6+1BKLQNChHjbYgDC7cCHF83wCuY+9jtABRbE0D/bX12AWLDOcNvRQHZApNsgxXog8Ep
yQjMglOJwevAItAARrd/4TYk8DTBg39MZrgmuqr6TlVIm0zz94GNFp0TbB/tTBIKFVDhd0vICRQEtAiy
qNpo7pzforMNIGiwBk0Z3vMQbVRlN8pHRETuAhUkg2mACr3a/glI8OZ8rOCgnw2O666F2+Imxij+LHRC
NaaS18vgMd17ugEeiU0eWxC9W0Aofjx3+glhCapidEB2TmorqA7zZbrDLkWgt5lO02WoqD/7Y9KD6wlo
u41TCUU+SBjMCntAWejFHi4G5+zmAXy325DwdA+DGyqJ2IPospE5RzIK9+X7obCwCEh9C/l2T5vAAYB5
ycYB6CQoepO0/3QhPOgWlIXb+gAYQAfFHrKRgKmLBWwoJmcJHqBjV8Di50gZORHsNc22AtDtKTds2z28
w9ROaPES6fkgFkHiEgA/qsaEKHgjMOwaQ2IhRyB3QVFXVUw5KyoaNeXYEAaCgUAcSB0rIihEsJ4zk6ji
DP7IMxfECqpsdQ0VTIioeVGKklDNxtCmWkDTkBQAQ+qJIH+xlWbSgEUEQUgBAqInDeAUWL+LVQX/aUEB
3EF/EaLdFkVsbBGKRYyi4jvdIDwldBw3IhYq+HDr5SslgKJNIgITthVws4QEaCXkWE+dWygf9VsYNHfF
9KoKZmLeiggKsd/rQ4CI8OQpTPYxrdhGhKgX/0UH2/FSib59xuswQYx3GWt1VhR9AiR1E2oUtoO3YTOE
DEj/xMv/DUWg3yo2vokoAQBjrQWI7URDCEPpdVbxvcD5H8SA+ipfUVdjtwL8D6POc/BlO9PiOQm2vzfg
1evOcUgBSC8wg/lyPxajCkY5RHftAe4Dx4SXQNwGMU0gikazbAQ0CuD9cwvh6BLTFwBQL3wdAysMgSZG
WB/0UrHK/tfvdC3iiwZ8xoAPu8pXEAtDR2fRESRWtkrhu4q5bU4IVDqqY7F5IA5f/ceBzUVB99/rFURw
PgRBtCrVdiP2qfBYWL/7xMn/Z2OG38LqjS71Uq6t/1LYtku+k+gCMhkD6CyC3gyAtszuFrKVDeWW20xj
jGMjRE5LTGHPTQHREfJjzXQyFuaAomHvhdQkImhLTQqXOCKqEOz9WFOtGj0TmxvSYtLYsO/aQcMQtUDl
gG+ODegTDoPdEIPqB4hTUOw5D4eJfNbbElR0/b61a9I6aVsB0MVBjAHQNBeoUFBn9Qd3kWiJEuqOwpVX
DTZqMUUbuCB0Ir53eGrpDgku6LYbbxSxQok0s8Hj9ANFtYsAw4sDIBcwWCpJxkQtYs966zL9VmpG/QXJ
A1loglUdQWRQQkQqaI9AjgNBwLpAtHCuGRIK8TCCBN3nhck2aNHQ6UCpw6epwAvQGqIVA1Ac37AAEbVF
FwklPgiKHYH3xehF0bdt0c8Zv8Y38FesgA0R4dmMQ1gXVLAXh1gC2gW3GKCNC89K7DY7DL+LvpMg6Xuy
GQHFcRDx7LA2gw+U72PEdeFeFUwStRATNDpFz/ns2DcqABvIg80IKD0jbmqPTI20zTVAAYZo2n+D4RfQ
K1xRW2/+x4jLJc5B9F8gAKYKHD5BiB7r5C9UuEq0CbD+iwC5peIIFFWTkwgTyFCbmAzWBLu2rB1oiMsB
hxOocJ9KNmzfiMJcCgWEC6DyLthbIY9cFuvnSV1r71WSoLM01ay3eDdA5cIPjBagSgFGpihhXKw2ZhOA
4PfYdRRvutgX7g+65QsSVExyJ4nozbHAdApCqTaLRBU929DdTNDrCn0iiwiCTRLQSLQ2SIYhEx/5RBXA
bYjqTIsTNQE3ajIMCnRG9sIIglE6KM8FGVG0I11F6O4aFVAqqJGCCn43K4TSJVdkWGhQwa+XLslCQS4A
etf3kN3tOciKTcjbV1qB5UyMnXW7mImKrLnOrDqInJpFBS8vqmHfErwqN3KmMbpoq4s4NlvNw6oKdqjr
GfaRaxAFSEyDzm0LoUmhwhqYvgEedkfQsg9J8UJg7FC3BMTp7AYheQJmX0UFAONQIFmhM5iaIhjWIix6
soMLESwrDP+J4ooYANH+iEBBCJFjPlhsjTX38WhY04szLAhok+YJHxqBPxHTeYKFwCTKCYAWvtmYJeoG
CRcKFyam68F8CwgGOYDi/xYUCgoWBp+IgkdVv7XRU1FOBESfwwdKDrg2WFoZIeGlh2C6v8AvU+sO2wxU
wbDpDJ0VPkw0ehcAWJ0Eoy/dQVc8f+lMzSnYhdEeNjIKhRkxUBEFQCNXF8BBoiMK/j40QBmAABM262Hx
UhHA+r4ghsExgI89WFnTRCASXUBa3lSRa7Eg3xUuPQz5gpc1MI5Qdo8A4h+/vojQibdg9OLsFkyJ6p5k
5JANSSAAIDDEmjU03DbohhkUCiJ/U0ZMoEkEcQaHwE8UZXetizSAONEIbOcuMUzCCOAtFSbDwCCCRUA7
KHXZg7TZLeZLFxN07Dpkg0QELu5067JdS/vx7BgbzP8tgf16d+OtUTHMBdepZgR7R7QwRTH23zdwCGU7
MXcx3X4UjSgowB6F8SO2vd/qXnTJWtDuRoV6OgHWT3Kw1ClmBE/ZaAJV0C+bWFCnLIpuMcDoxYOGpVrL
AEWEgA0inoAJEHzWqoD2qm0E4MpQxaCNktRBDwEzTTREfYIjfAnHS/OlhzH/PGN7EMiom+9a7UuqEkSl
gcGpYhXTgRUGIEdWkyZOQLBmvYZDA1S9wBx/RuDfQbUAlyAgZX1gBZCDcoaSuAVUC1RY+2BQ1ewviMVF
IAAHhF+pOCzpGygA5xAkNmp9ZhwPHgBfAfjwQ2yhqvZ1k8EPC5bgfdRf2PSoPD4Fkam7d1VIQ3EAAFuH
bICctVdzAG8A7zMQbsa6L1a1L0A+RdoLRMNGUaFmv8F0CGr/QKgIAMXvRCMQ0TT21diDRLuLn5jK1TBh
KFulOMPvW4BGrRm+tuilE0BswU47q5Vum4LnASscawjIfLdq1QOJrOhrCCIVApJNmjolaLOAWmLGlYC0
BK+rxTgEluioqgkVItUoF8E2q+yhpSJHd0HRqQNUnaq5eVNUPVoKYI2Qs6rgAo25Oq0GiohRMBI4OFWP
/virMEREBxTupDEpKmZlfgkiihCSUzSBKDgGpfRjBkSnWHYQxzqAgFDVEW1BxsYLVn1ozluju1a1qio1
YpFqAVh11aeiaAULADuzo6L7rM7vSdEK46QRCwREP/PORPREQdAPHFHQW8B4DwD/zU76sQVaRojlMuXr
wDHb6RWkpJW/d7iMAqBd8pDiTVWX4McHSXUf6yxwjBiJBwdJXXzVO0IUP+oBIoIWFsJoFeIf890BVRO3
sdJ08SrYb4wudBVj1km4AQDiC0WhejT6B3ZqbQ6qhsUzxJnALLQIth+AABKOIQ3eCkpSt0lJuawFoYpn
AOsbr7ALjeIyFk/30CZE/bpuG4UIjQhVd91iso0ialLqr3ToQkUry84B17ZUlCNvocgfxC4CCBDBAaFq
GwDu6baPKaLcN7UqNKtfsB19OMF1KdjrDkcSyI8owACLNge7bRCr1zcxwO8pyKvqE6LDx1QX/3pYKkHV
wYCQOYDqoyDqlKWqClHDAmYRBeH6de0k7zwJR+UqA0dfDDtEQCNMNiEQoN6lGANyHukIwGyywWcDGfAH
YaF3EdD2wwd16b9itooqDG++E1QSXgDaz0m6VkChcEQ85gpbFLVPMRvSO7b2YSNXymsp+gsFCSgsRRtK
0HWP2ImqWFVDdJ8QdWCowz1KuxlG2L8xz53KgMz31wmJKLRbDwn6ODMnCxVBbMObsBIF3bFjN8MBD3QE
wfHBA2cBokDpX/QNw75iAdhbw89XFjjCdRzYELovYnUG6yAwHGEbIVQEP9B06inQjwABAwjKFRGFZk88
Q1B99tvFajnYcuGAHVAD6Wl1MGRRkAPHbASZzupmkNDuQiJhrwcpSCFGY7MtD/8fHEE5wsBC9h3/AESP
vx2tFDV6hARR66LoiKIFPWdbBFFok6igBxBUQ3gJXEi+mYC3hwdZkcqo8nUbEvYwCW93EBqojsAVB015
E6pRQAAvwB8TugI5997G6yctAaiY74ddVI+GGb5cT43wjd+958GEyQXARYTBdD7VdCHrOIFiQkHPp6sg
aG/GHxTNgDh83R8eQRmUuw3oAdzq8kYKTgFG0WgN7NBf+cNQCh4CiPIuRA1CRx/9kFxqggy1CcLzZdiS
CIIlYsLfE0YK+FOJ9e4Ir0PQAFVF7iJRAF6Hmo71AAT8EoT6CHIU96izVvwxdAyklwt1WBH1qOlExXu7
q5Z0BaQZdfvDMd+PThRdpmFAI41Fv1ClfJfhFv/986SAVkBtDUeHGlhWgxKVO8BRBO/uZX53eO1wQIg3
+wJAazExG3ZjZoktFwAuUFEX/TR2VUsR1W0MAwv5y3ZrXrrbSUgMB0gN8R52Ow8D696+rxcR4QTpFj52
JBIfA+f7mqYnLzcZwQTJI7G9ntHZfdEPFvgBOrt7EQTRdQvZqw+du1Riw7ang+JfcEeAflcTLdHO69+L
BdcIADTBwQJi/sKABxS9BEgPsRfWPPhBMxS4jYK17BrvDRhI0I2KJS0lDzmd0aVvS2D/zol931M78ESR
oEsHwQcpq6IitWG78soXRCz1eSJT0AYaoFjByMm8B7HUAi9JTAVMkG232R/jjYIAWkWxB1tBd0dUurZ1
wehheTO4IcKAft3wXT1+dCMSAAYBmgj+w7V6d5/KdxkEYzm4i88Xragq7f5GjQ+CevBTuGVD/7zbG6ig
GDEKixc5O1DUUGrQ85CoN8PvgrYDqnwDBPDIe2MXWL7TEsm91rwFk0SxAFRfGrAOolybEs55xWG3b+nP
4Azr4DkIVfemGdXPZItHDBVdEzk2EKNvDLPiK0DtR4C48AkZ+wciRDV7/0MI1oKIHRYBnNYFCiLeLaKh
98IYVf91Ws/JJFdjRevnWlvhADAa9vcMazFIAcT6Z93CJQBgi5mB4b9iqXgh1EoQeccCUgSxp7jAmGOd
HaS2/L7HaHOlJmyEgZyPQVbyjWbE2iVCugElMz9BU40dIQKO+4nQBFU4YtslUbOKnsS6Agc2dMdi9A6J
6CATft1YwRBBx72HB2DcdyCVAJj/drxQHAoPz/YGD7maUQQjR1HEAt7/IItGBMEN8MOzNwwlDDtBOAVo
HPUWr2Ge4oF6CFeiNgvaKRYGGKBOKhb5EF3zRA8fA68DcdJJyxootAjdAUWLd9Xj5yUIYFY0YoAQwDHo
jWcgX2SdCdqNSr75SYsqGwj0jXREApxvC0D1QRuxe3UGEijruSg9I2Djs3u+I2TpH4LVEqEUNjFuo8DB
dgBgLL8fcYdg2IUvvSwBdQxRvwESwlXsCLrwAdwUX8Wsyev2xAeCEb4ifC1oGABO0NHLDUTBm1oLQffE
lnQGVOCozcinKNE11VuOXgp9ii59lGsBCCSMRDjgSW2BjjYVDHLw2sHx+BCpAKOLRWePHW4WwigcEVxn
ZkcIooIAdbjlQIUyOTXorcQGNdYWximGnSDVVWiYLD45LcOLWqAIIoT+E1UHAQqsdAmYdIMRfggjKPdV
hS3tR0lHOCNgZ0TVCKsQThpiVMXpdew+1EKl9sLBBI0zgOGKWRoOboMoGnITP/o9IbZ9FJaOatK1xUUC
eEKX5OxFfGg/NzsdI8J1BMh9beCATUVvtHoUgKn4sRU/gPRKFO4wTFHF2ekEgcmuO3oxULp1EgF22HW+
g2EPFiuAKhC+Aw9BuBXd63xLmv19tNc4geNE6IsnTh8XioER43URxzYDgYKagESQUcEVRQaI2gBjBWr9
7Yn0AgpanfI4AuAJQbMJi1VQFRsveYPJkdooYnoTLwElCmpqitdynQ12Gap08O16GA4gWAC6iQnrecy9
VBAJvnYS68wqugPxLhrMLAf1tA2LNQ8ATgjSO1hVsEiJatGjABjCDM3xBGtXgGy5AVUQjmIICMkAJnQE
YxT0tcPEsjQDhWUWtEUw2rXHBwyK/gEFDUVRFfavAjf0H3UO1yCACcYxrS+J4PU3w7gLAouA0Eq4h4i+
/xBuABRLIogcIAgqzja5uIit8xgpdm9xFU77IAuQiH7KCR+pCtf59iAAAer9VNTYSYsVxxEVUVsCpPcG
sXEBoI/yPPFFHb0EzgCnGB2JBaWheET9IYkc8YzpxAJRYRpNTTkExVy3eNElqBwYBQYH9Jla5rjUYC9U
MUyLJJrEuiMV1b7n+zrGMnVtAbtBgARplyzdKA5GQHaLiBZBHQkWBBGlFdyoYMzEdbGGiG5CeXATfKpq
wdjePTUGI9gKeipqOAmb4AWAgZzBDI6LCkpUcM0EAhdmQ3DQDRftMfaPau+6r9VgHewvVwQI6xwnQSgg
UJniQA8sRJ8nCYmEvctUMi5s2esPPIkbRMDLP8QI2SZh+xSRbFUwCwVFDaKBIn3QL1QmTgWacc8IoBJh
20SJNkEHDRR7JspTzgZUkCMCjKio0ggw6FIXbtHW/jfawwREnXTpatcFBS4hDSNJWPeSCit0YBFuc6v6
N+DZRcllQYDhBHU30VTVS0QtHnIHolpXO67TeIkJF4q0xVYLB/sX8A+tCDqwBUvrnd7YhKAUmO3pVVGi
paKWA9xBbRIvHAq4I6sTIlPJASB7ypDck4JgiekyoUXspRh9kW513isaFVChOCAjtRiJimwG5law0XL8
uBBFr95KxO2Nc/n31YFggeWAIwwDgvBmdbo2WLhbwz8/e8TibQuoGWLadP+LGnuEjhL9FFw7Sjj9D9MG
VPD7FM5GFIiggyexECyKaAGDghiDr1iSn6lxmBUupAigU60gSDdFRfpkTFKh17Ddflg4Ew92JX5yRYnW
rUp8wQgvVwB2G1FJFBfHRwii3XdBLUDmbf1AiSU+KQPJdfbCBRypZQ+B+ejs20x/0W6H/8HXF+kLPdFI
VZvwuINNENauve7hbjvgCmcE0A4J8PHCRm5FSbiYADceA3fEt6qACeT1jbiQuDJUm4r+uBGLeIPYFp9y
/d/KIIHLcKKicQE7yFBUC3UgRRD7/BaIyiOx4a0J2RqaKnS0SnhCHNsMgRuG4VYA5gx1RRJEtbGbkes4
8D/MOILoEpN0OI5j/BgbSwQ399aB5oCuB88xsB2sDwVAfMuCLX7UbV0K60WDiEEUMSDOou0SjCY5T0og
A3Ic1IY3KXIgdHNx+JxQ4IDFHUd0DIcxSE+NX7iYW5kFCdiW9E/odxMQBykWVA2DqZbsdoO1i2cIronI
pzpQ0KCACBjV9gl6A29xH3+GRJwogFUPl2hSLbCB5pg7Co6i33U4wXAdNs/cOgo3rBGL6n0KColHFo4i
PsBwG8CuxLEq0RFIG4HjkSEKPg5F2N7ggy8QfEUgiUx5FKL3SRdAhaAQcgOLE8ARBBWxZDHhQiMjBIHF
ErB1F9SiBtBw+Ouh24MGYKFAdELHEk1PaoWpHrakt+sQb/goBSTYXbvHdeDrE1q0HIYqG5SbAGIIjNTk
65EKqm0hhyUBIWwUvBWVy4Jb/VImvo0LMEnB6x90N6FZxMoeoQ9rmgRVr/BTuwSQCyABeiEVK3dZBTHA
goFBSEPbh2NQIqrBdwu44AgEg/zUdHBVePpRQFYWcN7sb068ABE6EheLE1xgAUqxNCMU6xSbtSGrdQ8Z
LBTAEhCYQEm/EUxxe/oFdeH4A7BjKwQEGzNEiLBuNMDpJt+U8IAAJ/3g5ASxq4sX3n+pPm1PkH95Pa50
Fu0FrWBAY2zRkT5MzW/D0cNEJQDow5ZgT4FEVWFggL+xFQG99o1x/yH2w0JQY4E3HtZ4QFkwVTqEaOkA
BYRbqsCAaehI2ADaY9JfCh8hVsPH4jF9nYP/IJI1CE4a9ccCEJhNWkI7LN6qAJpIMcAsxhJBDpBc+l6u
ldjFMtuJMoXVJDogjgGYcdGGLyjcFib0ASUFV0DggoKmHRAAOgq5cevgLshdKHkzBQIX4DsqlYn6emLA
De+MLu1yCuovi5L2IE4WMjoMDE7SAKAFA8MsGKEaDH9RcfBQEMGApcTBgNjuvwOmWllBNCAa66nuK1qI
jXH4fV49qlpg+P8BVRnSe3KpaEU/mv/C5+IVbYq4DyXwvSnEEjeiqJwadBX80YBQPft1E7NDohn8VBLj
uE9sEWzRstj3JgyhuhHWOy/kAfEAESQSqBgMB1R9e0PAk4kXpEg66saDKDlFuCe7GFUsM74W0WriEbAE
tfcxY1DsCXzC0LXHVMoiVKMqTHIoixEtY8oUCaJphVw/mYWuQR1+LBnVSoEAH4HhxwVaw59DY7tnEU89
yBG42ruJ3eaaoENwexA5W2tbFuHYpxg3g7Aog5AqBm7qFT2J0Fs2oghVUy1QMyJd4iAXf479OosdIQYt
Co2EByBJKZrowvcsIcP0KUGgOiqoK7HfDlCRKYE2LNTWqlsSfUVVaIAIB+J0bUyUo1tx0lDfVctELKo2
NaOTBSu6EapjCA7U4QCgepsvuxCxgMLxqtqgKAR6LSgXRNtemQX82jpMLy8WekF8Xoswg/4trhRvAgK6
k3XalIm8/4BtAU49xPF8SFIRFKJBrqUAeKEggf5RZthyANB1IgD3xXdpKSpndhOB/mBCtSKKct2ACbaq
qvAuwFsQW0vJHSDrnblbqQFIWysFinHAsDVfTEUgGkpBdg8FKIcKQu0N67zAyfYKEfQwiQX99QXA6SaM
FeYd+zxrdyPQ9Q3JKhXKaRi7jRTIUQWoJXJN2EQES0C5yAq4s+3jL6A2qQZqjh2r61iUCAgCFY0yPaZv
pIDHBoQQ99l/YATRVAWGPdV33Vioxj1jE3YeQboiC3I0OJlwYL6zl0X9Mf+4CbR0FAdgiFfEc7OqNYqi
G1CZpnQbS1D1FmgQzYQAQckAR4/dsNBt++56a8sAhA2AP4UlCMiBzPc3DqKtiOtGdjcxoQPWdzeusLAI
iiPbUlljc+e6PNAGxKpiV/n7BMAj38YHLwMVjHJUmLqB4JBBVHAfIKgJUYnBgFR0C6LIQYi024USINuJ
8s3NzADAsQQQER+zFNUOAMj34v3rOmjUUfE1uRvGBAcAEa2qilc7ARGtQN4gRlF9t5zBI40EkgHAquhS
9O3GMC1CiDQHct3zi7gdqv9sAkFjAtSBXjimC2qUIipeEgUADoIWDr5Dfd0FjeAz5hgCwAIN71I6FvCo
mEx4jDXCh4iSNXq9/UUEq0ARzoDgiwKzQbhEFYeRb/d5xDbMNgiB5h2sNUYzahWNagJCTxB8d5ciDS0Q
vgAQMNOD4FJjmdGL0+aeBI8RHTnWiA9D3gOD4BjBid6jUZRj4Xikg1/yjLeFUbHcAF/QBTlaROAYPDwy
hBVweoEOVYBZgfgBdDiKiFLeMKjfUhCU8NN3odBtBDGcZQglQah8pSa3AStJQQS1JYPHK7u5mIs9K+He
vnbyYveLUPU0CvJGiVXKBdTDbzVeF4nISe3Yk6okX2QxwBe0EQULDGIIRyzBRnronfB9jACoYehmVH+w
EReqaj8uCfBEi7aosFLJO4iibBtYwx76Wq/AjA7fGRJKbBcoiEgBIJQnFlGVyU1EgYJO0fYPD7cTU42g
oFfUhVuKutge6cFF4X0wwS9ER5fd2Q8c2A36cQcp6jqTBvu8gys7iar4eFle6yw3JDbSW+1q+Ri30U/d
2GYFOyhE1YAUumYN1GaAbgWJFwF7LAICPhDYW8M7U0RNVStIgalJM/qhWmeLj4y9QQPcIKqtMcAnVjoS
xL/AekUVIhDE6yKIlwcbAE90CYGfQIS8wFKBF4PEF1MlCjR4dM0shBVwE20oAXh1C1sUUYFYD2cxaPZb
2LriHnMsN3BYKiAWsEDmD3pgkNrFh/aJ0evqps+ptonRZMkv6gsV8KcJ66Prv8OgYLEACZIjdsBbaYcH
nXMmhAuBYitKccziVwDgf3g2DAkAXRQDTGPbAmhVEOIIFzAGcA7phNdcOvEEeb3MkkG+q+KMTjp8KJcU
0FaFVigGLg5Y8OVJP3huu4gougHUVXt4ljXxKIWt7nKnJaALmRn8WMk26D7xA1NgSEKJQ0pTGFJdCO4g
HyeDCzL9AlgihFU0D0xtiAg2+QijVQhKUWnhcyt2BL8RRTug4f/NVdXtos7JRQjHe4ixAlymKfhwaMCA
25fkVMBLUY0J0ImCtto6gF6oOQnYogxcRIkHxKVHs6olgHNHmEHpzohHykelR8CqBq6+scKSNCoZ9VVT
980QC0MVCvQQmOoVPkU8YUNHZ9oFW11gYUC8aEgVXwEoCM8+Z7iASWPuY0RQpyezRXdCVA+6WIF56RlE
zyi267jzfT5TQOFVMKYZtngBRAxquYXoBLHrNYsOddlNkasALW4yFwcJKBxrU0iJI+qIdgx5E3EFDooJ
UYHE20FRL/7puG5ggAtqo3mUedhw5ChTCQVqUkA9GgO/dCYMHYqA3j8bURslVW4mWiLUmBURs9RgNIt9
kckhLJN0K6q+KAQE+G7uD8CtlAR9ujpFwusVFp6dusR1EHRw7kwWRMKrJisiusMsAiJWMXsUQRuv+HIc
qg2qeLl9RCOiRLOCRY/0IfYWEonuixyAfC0gUFcLRxxXwzKFAF3AKP3DR8gJkOZ+Fl9+FjIXIcAwN8En
iFCR5HiLo2KhBb4Dw2UXpIDdDrieQ56M7ggCuTXubHARwWBv/Aar/BN6240i2EnwSEcVT9FCL6ANgApj
7lyPAqDR4lqcvoJEUA87/eYEhbENkyUpwIQLINh2J3ROxuoK1YWAb+qbPdW45KvhApi+6qsp1IWDfXUo
he0fdR1CuGAo6G6H9mnm6AMLmDDLAeT86UkIcDRk/+yFAXzggcYhVoFqY+z4EaR1EbaAnIfRMEGBexcL
vbgU/RaN0Cl15g/NGBcBIv5hixwA+SK6AbBARe5LC9pJXCyK2C0gzRSQoSWjSVkvb6dJBE02LVM262PH
ooIaL/gCLWQLfBVAuwGBObRwC0tLIKcCGO36VVFdtd15A2ojAJ9tJ2oQH3XgSFmA4E2iik/uCYAJGCFr
eqBvAR4A7XJFAgH0IKLkfxRVN7Z4BCiMCQXehwjgZ99Y+DW9u1AA/2gDEBoGdF12pnu7VOf78KlvdFoI
/AHigHQu6nXR+mUqqreUwug/FPESLIJIBlAxwIUCBkjv4T1C1a9C6X+OV9Hrhaq2YFFfE/5cCZsEX9EP
vK4VFRcEUQR5fMMgaIrDOqCLFDBUQU7qJFFRA5jrL4JSFILXA7wV1IpDFdgPhqomqjoS+QRA9a0juQ8J
o/Zz3Kp6xwujvgYEvqPGc88LosCNW38Gp2gnEIdiN9RMDHD61wYbAaRfHIXAqsIG4FerdTZ3bUG2tEQB
4DxYLt/n8UITuCHrCB+39kYCgoAWVEQVtJVY6ATsF2agKBAt2RqiF4OPZ3fBTcy63yd7Qds+GQxVbos0
gR0MsAZxpuhJyAbl4kM4gFEmKXNEsCHAgrHa36z64LSCsjO5+oC3GOE2B4mwDDn1Gy3wK0zUgN9+ooKh
BvHsFjm4AYWCsCyJiq6A2h3pg0tARBD5BlLxBgV0gIOBRwG4UYDHPkiIDySNjgDjdBcIcsvxdggy1+y3
bcucwS8MLOCIConBPP4Wib/hP4hCArgagIhKAetTwXYU6T0A3Xc2aGuRl5ES8AO4BBdN+pDv9+E/NU8B
DQYC6w8xi2AwFFSd4AgNawnEOEdTihUQKw4MgGQFfOJ5l1GXFLCsCvUSit0TVb3fDlBbDEGTAh97T+Cy
AqwOQoK7NwJeAXvVPbm7wR7s5yAAET1V3QtbDGjLpQDqLOlMBjmy2QEAAAcSJDtscsgA//4HgADJgbkh
wDMDgLdLlw617JjiBfwfFANeMbu1H9n9/yK17QqAHwcfDAObHLJuDg8KAD8ABx5ZSA7/AA8AdSAnTw4A
IGH///+/sSkgd2hlbiBzbGljaW5nIGBhbHJlYWR5IGJvcnJvtbft/3dlZGNvbm5lY3RpBiAYc2V0K/3/
1rYLdB5uZCBmb3VuZFBlcm1pc3P/9tvWH0QaaS9BZGRyThxBdmFpbGFibrDt9mxlG8bvWsUDCwdlA5rt
YMuixFUHyMsDsbhBltvBBxzSAw3Rex0BFrDBCwM9umU3hBP1A+jQxAcYabqm64flBykyA2981jLbrrQT
FukDDpcDI8ACdgQLAzvbjbC2E2sQ6YNHA6ZpmqawUWNao03TLJsGjv6owtz2lew2NvcQb5QDjRWB7S7s
+hEPMic1EStsuyt5jRW/B8YhA+de2CvZeiYgIg8zI91VstkDfHom8CdubLPcdgcfJwNiKaAKKgfJg2zy
KCsDYCitst/kqidHlCo313XNkQNWy28oB9hPdt1gXdcH6BuaF4wDuyi7puvODzQDow/MHAv6KNZ13WVH
xgPpD78fsb+XTdMNCwNF+ds6ETsG+4ItzgcDrgfeAHZgQQP2E9NsBdzGA64Drc9sVipY5AdMBwPf5MmD
T0sVRwts5JGtskc3Ax1MwBbZC89HDxea7VX2z0c/aIEDa3N2gAVrbgcDcQcD2JANaBd2K3mwAwtkRwOO
J3NUZCEDfAPWDVl/E4IDhQ+Ilk03YAuLA3VEkbS27oVtuY8L85gnmQNm13XdZwuYB7MDjAsKB9uu+Uz9
CyyUByKbA0blsuuWmlQHCAP4nA2dXTfI2SScCzUtA2ALurLpupOdygfkA+pHntum+8w4C2sH8rOrA1C6
btk0XEeuwAesA1jrmqbrC2IDsbtIE1YDwM62uECt/ZqsA3wLEHYEWAOvE2k6x+2UrwNlsMsDh5imaZqm
qbrG1OJNs2ya8P4MsRooNnRu0zREUHvDSwOtWTZN08bf+BHEKqZpmqZDXHCJosOmaZq4zuT6EMW37b+F
Cf8NIHRvIGxvY2sHb3GLFmRjdGRiOyBwLW7Rbhdhcw1NLXI/36K1cBg9EmpncmFt62J2iy6RSWYRUnUj
by227XArdEZscERjdXLdosWwLBy5oHVnLVy4rQg/YDujf2yLw7pgPVBacL10SLf/3w5mJG0gPGh0dHBz
Oi8vZ2kadWItWmu3LjZtL5NfO6l/7Dbsa2UvSJZzLzVzPi5zcmN+8dvbL2JlL2MuFGNhcGFj+292LfS2
LfNm1XccNmK9dusKMeEvvndfFyeFtrOEFhIp+2gshgq3hWwOYoo8PRFwzbWtuSibBhFkOMUCtn177GRl
eBPvv71tYXJnb1Flp7eXvbeecnkvULItMVJjNrWtvf0yOTlkYjkJODIzoJZrJ+1jf6EEUDAuMy40NjBz
eW1i1zqM3Mtpem1vZIIPAjaMhjAnBB8Hhw1JDQMHFR8oWhC2wmJ5kadPBLZH7X/bDXLAIkJveDxBbnk+
pj8a1tH2ICdO7kVBcm974Y86E0YvVGltz091dI+ykdQIh487shE2Nw8g04zZhwU3IC0gAJicW3i8Z2Uj
kW7DD/YMdzQCnG1heaPC1cMRdr8GY2grYW6qb2anudZwW3C6Lg0eHDwo1RpMQKt10hXdsUZbEmbtjiEh
YEhjVKHwaP2psgbsRqPDQMJzzD9maXzKEWvbH3RbfndGIQRrJ21b/BCEQzK1+/q0bQitZwX3SXVHiL0X
e48IByIUcGNNwaiWL61zLtnXGksd7A3iZZhpqfe22WAVD9psUmFrJYMNC9EXOw5whmUJMA7k+0goTQIL
AmFuZDDmdmcjV22aIGgeMirbDYQxai4BAEimSoYAAoCdIZkDBD1Tg+GsJW8qfGJNDK8Irc0/UGdtBUcQ
0HH9HGkG2BytBy4fNXSIbwgGDNwzb0j2/791MTAAMTAyMDMwNDA1MDYwNzA4MDkQrf3/2zEAMjEzMTQx
NTE2MTcxODE5IhDbuPG3MgAzMjQyNTJ/NzJ6OTT7f9taIhAzADQzNTM2MzczODM5Rlvb1lo0IhA0ADWI
NLbWWvs3NDg0OVhGNCIQNVpr7d8ANjU3NTg1OWpYRjS19tvWIhA2ADc2ODY5fGpvW2utWEY0IhA3ADg3
ObXWWmuOfGpYRjSua7StIhA4APuiOX6Emeu6OVo5NjkS0BpEKi0wC27bjlpDDAfWqiFn+aYGZsEPLfpy
tcdMERyCF+EMWy44BHttAF3jJiZopQYO7XGvMIuxsU12B3n1adskD4TvdnNpJiApZGCAZm1aRxakdIIV
bi////8HkAEDBQUGBgMHBggICREKHAsZDBQNEA4ND/7///8EEAMSEhMJFgEXBRgCGQMaBxwCHQEfFiAD
KwMsAi0L////lwUwAzECMgGnAqkCqgSrCPoC+wX9BP4D/wmteH/r//95i42iMFdYi4yQHB3dDg9LTPv8
UD9cXV+14niB//+EjY6RkqmxurvFxsnK3uTl/x0REin2rftfrDc6Oz1JSl2Ejhy0HcbKzs8ctt1itxsN
Dh0cRUYdXuC7t7/9hJGbnckaDREpRUlXDo2RqSzFyf+31rbfK/ATEhGAhLK8vr/V1/Dxb/92+4OFi6Sm
CsXHLtrbSJi9zcYISU5P/f///1dZXl+Jjo+xtre/wcbH1xEWF1tc9vf+/4ANbXHe3/5boUQTZLRffX6u
r7u8+mz/b98cHh9GRzRYWlxefn+1xdTV3Fj1/+32LzSPdHWWL18m1KevRsfP19+aQJeYW1Td/jCPH8DB
zv8tWlslEAts//YnL+7vSzc9P0JFkJFfU57I/9+g/cnQ0djZ5wsFXyKC3wSCRAgbBAYRLPz//4GsDoCr
NSgLgOADGQgBBC8ENAQHAwGPB1r42y+NUA8SB1UMBBwKCQMIogP/t/9/mgwEBQMLBgEOFQU6AxElBRAH
VwcCBxUNUFv/hfYEQwMtN04GDww6BB0lX8IE8O0X/molgMgFgrC8BoL9A1kkCxcJFGh/a7/eDGoGCgYS
DysFRgosBFB7963dAjELBxELA4CsGiE/TARJ278URX8DDwM8BzgIJoJvf/tCdxgILxEUIBAhD4CMuZcZ
CxDA3/4ViJQFLwU7ew4YCYCzLV/47S+A1hoMBYD/At8M7g0D6AM3CYH+39r/XBSAuAiAyyo4A1ZIRggM
BnQLHgNaBFn/f7vdMoMY1RYJaYCKBqukDBcEMaEEgdomur+wtQdCQKUTbRB4KCoGHY1Ht93eAr4DG4kN
APMB3gKmEP9GewIKBQt2oAERAhIFExH/Ny4BZQIXog0cBR0IJAFqA2v4////ArwC0QLUDNUJ1gLXAtoB
4AXhAugC7iDwBPgC+QK/8IXvqAEMJzs+p4+enp9lCTY9PlYvfOmF85kEFBjtVld/qvm9NeD2SMbGEock
nn59L/rCjY1dXDUbHNwKCxQX2gsXXvE6qKnNCTfcqAcKTv+/8A0ej5JvX/JaYpqbJyhVnaCho6Sn/v9f
+KiturzEVgwVHTo/RVGmp8zNoAcZGiIlPj/jv/U3/gQgIyUmKFI6SEpMUFNVVmPc/n/rYBVma3N4fX+K
pKqvsMDQinnMbw2Fb0OTXiJ785Jm/y8ugP4L/8KCHa4PHAQkCR4FmUQEDiqAqgYkL1z43w4EKAg0CwGA
kIF2FgpzmDkDQbHwhWMpMBYFIT0FhW4XbvYES60ECu0HQBTdooIK8o46BW/feivSCAdQSeoNMwcu1IEm
UhBAt7dOQypWHNwJTi78b2+UQw4Z2AZICCcJdQs/QYw7BX2rUdgNUYRwMICLYh5je7u9GAqApplFCxUN
EzkpNkF+iSB+EIDAPGSFCQpGRRsFbY3fH1MdOYEHYa5H/922RQ0OLgYlgTYZgLcBDzIN2P6/8YObZnXy
xIq8hC+P0YJHobmCHSq+Ubhd3WAmOwoo1LRbZUsEjf8/3BIRQOqX+AiE1ioJoveBHzH0gt8a/wQIgYyJ
BGsFZM0Qk2CA9nbjNyB5bhdGgJrZVwleuy38/4eBRwOFQg8VhVArgNU0GlSBcOyCbxt/AYUAgNcpUAoO
gxFETLbfNgpQPMsEVQUbNB4OW2vf3rpkDFbOrjgdDQpUcAalRmtvTIPYCGAB1yeFL7hNMgQ4vx0iToFU
za0VCkuEBUgcAx9CH/rGByndJQqEBuCDBO3RVhX0kQVgk6Dw3+q/rxegHgwg4B7vKysqMKArb6Zg////
LzWo4Cwe++AtAP6gNZ7/4DX9AWE2AQqhNiQNYTfG/w3+qw7hOC8YIVQcYUbzHqFK8GphcP////9voU6d
vCFPZdHhTwDaIVAA4OFRMOFhU+zioVTQ6OFUrov/b20uVfABv1UAcAAHAC0YAgH/dlv6AUgLMBUZZcQG
Ag0EIwEeG1sLG41W+joJCQEY5gRAMwNAwbT7dw8BIDcuBAj5krfNtdfWOjwOIA0aCQI5bs3VTGcBbT0E
AQsbAID7DwUgaRZvrebeBgEtWS2PLR4BO6YN13U7DDkoXHMFon3di216C1OOcAIPHLptW7ZDAmMdSCYB
WgEK4kLbD1EHYAhi7u9bhYfVSgIbAQA3DgFvbREAC/kBuGaVbiW3KAaS3zwDEJHbRsPNCg4PAW8DWB1/
AgttK7VAV5EVCynrd+durfQCIgF2KUoyA9v+qW/Qtl4HTzQGdLARPwR2c7+5MA9aKAkMAiDgnjgBhre1
bSkNCA2YCF4HbnaJbYFoxjoFGsMhZb+VuvCNAWBoBmnYGAogAlACtrC1rwCFAY1FlysSMPDmXuAmCAsu
AzDbQScBQ7e5u811AAzXLwEzVwsF96irh1sqgAHuNAFQEHLbXaHuReIBlWED5eBvblu4AxelXxWZC7AB
Ng+8cLtbLDFLRQMkYgg+WwI0CXDbDne0AV8DQJugVAgVvbBEi00AnA6EBcMI7uHw8MIXSQaaeOuPGrHf
uwYHGwJVCBFqATwXh+GC20UE2SAC9YcDIixtbgGQawUgdAad3NAw3AUDLmRRBgFSFl/D+yubTXoGA1U7
SGoBb6EZcL/5w09RCy9823DnHwhnBx4ElJc3BDKxbltoR8AWvQ9FEUHoUtttcQffB20FrvAAWgw2wCAH
X9TQVReFD5ZieG4rBK8cpPESCt1qq98AWmUgU4BlTrbY6ltsZXNoaa5h+3VCh9yNEzhpAxgXbU1qqeRt
9Yp5FMRLvEEgLT5sX1pOC4oo9ZV1/7sB3WeoS1FrawdtSmhh9PZzzURoECpAAkRCtbMHvI9SCk04B7Qj
iw0ucMeRLUIhIXf4ShLbU9tlbatyCXuge4LN6u+NV30oCi9tcHT1AMcoGBomdXBBq7aNqHjtde+WuO2R
LUwAbWxvZnlQAhyqLQ1zdCVB2wa0NjrRm1Eu4l8OtVB/XXkoKcwWgPGXLhe5MGAwcS0FEgFkARqA7+v4
mwsd1y8JRS1QKkCbbXxJbuEHGQK3ATdkRGkHVZ/ZxmJ/d1V0ZjgdG1+rXyWAo29lD1/q9KMIEEvA9aVG
bbsNzWVh5mRM7o8dNiBUdKJeIFVUCgkw4EYtOEoDtjAIA3k9bguXAiu0a24xYNQg7AWQcGxzMAYGXLjg
ZmYdZWThJHjEC6gZMV6CIEH97klPIFaABBFMjt/+/8HjOjpfJFNQQlBSRkxUR1RMB1BDQCrjNwr7Jjw+
KCxq5mMtDq1rrVq02tFwMQH9UdhmcQ1n2ZU/W13jS+C4b3tjpJ86I30sxTX+0j91NjR1MzK9NnU4MHhf
qgG6V4B5djB1J0Gzfct2IWZjZmluaQpp4OFKNyJpOAVgWyvRKpTjbiGjArcubG09lA5hniAiM2Zu661f
2yhwDXkkey40dm0uQmy17ZsBX1JSXwNBhnpzGQ7QYvSA1d2tbTGi33EHY+MINAjQGrRisXCAq2HDmwFs
0GYRKEU7e/grJx+bCVrw2tgg82sYxq6VYGVBc5xveRwCVxCAA88/XgJQOQthbDpgT7Z9a6dw6XGpd3Jh
cHBgixY8sLU9SGAbYMYZWgkj4QJGoHRWKhSWfl9WuN2GUSW9JjQ5V2U1oAS3DfIweDBhO/9vW1xQZWKY
M3pjYjY1OWJiNzBjZtcKCekyZTS6CYpCPZZOCm1uuGW8rZUgIbn39afiFA1s+G5+ILUGtBYw+6q75DaG
sIH+cXUY90S0Viy4uPlz6RNhzRUKCBqhMMzF1v1gMXgvZWTpcggc6GFZcnfnLW5rk2JBJSx0SGLBWmtN
RQEjaWjtgcYJdxRymAaw1w4lTIEZGI1zuw5ahZtrsHdotw6hsAEEpS5skrutta90CQrS7N1yZmltxv/b
pGW0wgpSVVNUX0JBQ0tUNTHiQ/tDRTA8HiJkPpOFJcQeDSkPyO4s0231ZWdvLGHeBg2egG4TSfgPBYZu
IyR59CAeGTxAmE4XaW95JUNCYA6agmENU3uoZVosoort1ng9MThTdmmUbnCPzeFMRJBhu5uBNiwUko9s
3GEg6RhOzA4KTZA029QWMO4OIDETbWnd4okVtmQsZ4tg2YW2HRtOduVHc2VWi49SYU5mlF8FkewNGl+0
cnRfHbaQGJSvmUnQMGFUUdVrXBcQvgd3bj4ub2RoGzAWYrSB/vVsEw7UDO9lD+w01iW4XxFcZ3N03wJt
2wT6OgpUcqL+ckRrR4FC4QkqfyHPGJTNogPAEcuYkHUn5LEe0b17JycsYm5u7NpYJ3V5VAtMsFOMwx0E
2qRngmR1oJ8wVqxDy+HAdScFhEOsEUwvWgKLWPGpfAOMBTZbIYUwzgI2LFixPCIW5raWI2kEX3AW4UjY
kqQW22CYKCF7e+8U3NZOYGCQ/mjNI0V4rye6b3CpsNI1mHSo4KuvWxP66Kkd92RGaSYYNCwC1AtYK2Cb
2nBc/XRlSnlmBK42cGzRaqI1BPSsBHM47G4TvTlpcBRkcorDghFEldYUCAIOXLSLdhpIgSkoMd2FFMSm
Q2YvZALDkIJwNbRRbCuYNmx3cD4ewtdgambyKAQgKQYROAx8Ui18GJhoR24YGHx4hDN6dHIKcuN1cmVR
TzRA2u8iqjsslBcXIAMILiLxEk9ceDzvP4bBC8RkZWR1sW51HEJgBm7Fcm9AIPZ42bgZzMYMBtimNLgt
Gu0EYCgG+EBShTcauw1naHQKz+nN7t4gERlgLAoUCwxetEkrfHOJquR4GO6BJOtfJKy6DmUQaWHJiBV4
3YV7qPCiMQJddEclJTEyurtlc9MgsXbQsllCbmeErd1iCO5eUG+BK82EY4RF5XtQmLQsYa1av5qeP7rc
38dubk9Pc21yCkMx2Qi7iG9t7lVURbAZk7E/Q3NSchBnXFY4c5sOQaROqwjEsG8TxHWpaaRtVSZCBlAF
QR4dnkY6RR1XPUKXw+o0WJtJZ6epA04dF1eeMkmyYGGdLk/V3VZgWA8Rxm5CibeQ+GRvd248IlKsAlIr
zxk5IGULZ2fEI4mQaP10aLzoWYf7ZUVPbixj49EzeggnvGXu4aNHW0pzFDJwuxphZRxlZJuvX9CAoY3G
X16rJsdvVSy7VBZfTUFTS7ECAX6Jlk5OSU5HCTcwW9lPRaZET05c2wKjRV1wX7xKCczQBANCauuA1ozI
M5Vut7xaCZoJERP8M3LFDuEteiwoBbBgN9pX/FsPmlcoz4ZTSUdQSVBFe7fJGrcOXwJOKakRbAmlLkW/
bGsi0Q4QZwukWNY43F52ZTFPJkHKTOCjgSEC66uxOnX/VWfVIEjAWCNfogM47D3XNBAKn9BhEQYnzxZl
IIEVm9YrhS7VXjPSvBR7Zi/EXM2a8gAOdwcLpcEOsBIlHcliIRwLpmpLlC55A6suYYB2PmNdM8zoEWCV
Yic8lSyceIs+bJewLRKOXG40R2X3nQPMMMjB/f/QAxDCWZ5smpCg0MG8w8RMNs2yBMSElMTDc8tcBxRl
b2x5BzCDJUcLGmXs1JsQbGdwR7IhcNCC5xixe1UArxa2jwt4AStwmB962JENGyDdIS4/doKlwi8qRnK7
DzTddgsAwuCX3QO04gEzTdOmn5j7dRMgEhnjWwB1gCDxX3NfCQMEC1gGbnO1ZNuwC3RuF1FsbFip9dMN
MnMNsCczMUcmZGRyFlhHqxFgJqBzUW0bAxsusWcSc1taeuofqC4vdXt1tvsuLXBkLR4AHVUAEV8q5ghY
FzlrDu4RZCNhYd1kIUKJ72qFK3xeAFpMSUKnPAogDB/pIixBa0FagmSECGEzOuxzZS8zNV6ygy0h+icR
pE4pNXdMcA18qWlnZSaEeJ1hIPgNCCDNXLDZQpAAKyVsYAAHktkm//+PDQCWMAd3LGEO7rpRCZkZxG0H
j/Rq/////3A1pWPpo5VknjKI2w6kuNx5HunV4IjZ0pcrTLYJvXyx/////34HLbjnkR2/kGQQtx3yILBq
SHG5895BvoR91Noa6+Td/////21RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwG/43/Bjc9D/r1
DQiNyFI7XhBpTORBYP+3ov7VcnFnotHkrtQES/2FDdJrtQr/////pfqotTVsmLJC1sm720D5vKzjbNgy
dVzfRc8N1txZPdH/////q6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb3/WxT9uJ64AigI8bLZ
DMYk6Quxh///f4N8xBFMaFirHWHBPS1mtpBB3HYGcdsBvCDx////0pgqENXviYWxcR+1tgal5L+fM9S4
6KLJB3g0+f7/SxTGqAmWGJgO4bsNan8tPW0Il98K/jcpkQFcY+b0UWtrixzYMGX////ShU7t8u2VBmx7
pQEbwfQIglfED/XG2bBlUOn+////txLquL6LfIi5/N8d3WJJLdoV83zTjGVM1PtYYbJNzu3/NxYsOm28
o+Iwu9RBpd9K15XYYf/////E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX/r///9MCqrJfA3d
PHEFUKpBAicQEAu+hiAMySW1aFezhf///98kCdRmuZ/kYc4O+d5emMnZKSKY0LC0qNfHFz2zWf////+B
DbQuO1y9t61susAgg7jttrO/mgzitgOa0rF0OUfV6v////+vd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2o
Wmp6C88O5P////+d/wmTJ64ACrGeB31Ekw/w0qMIh2jyAR7+wgZpXVdi9/83/o3LXoBxNmwZ5wbHdhvU
/uAr04laev/////aEMxK3Wdv37n5+e++jkO+txfVjrBg6KPW1n6T0aHEwv/////YOFLy30/xZ7vRZ1e8
pt0GtT9LNrJI2isN2EwbCq/2Sv+XIuoDNmDvw+9g31XfZ6jvjv////9uMXm+aUaMs2HLGoNmvKDSbyU2
4mhSlXcMzANHC7u5Fv////8CIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLnv/////ZLB2u3luw
wmSbJvJj7JyjanUKk20CqQYJnD82DuuFZ/////8HchNXAAWCSr+VFHq44q4rsXs4G7YMm47Skg2+1eW3
7//////cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd//f+KWwwke3GOZafXBqD//KOwZmXAsB
Ef+/8f//nmWPaa5i+NP/a2HEbBZ44gqg7tIN11SDBC/B//9OwrMDOWEmZ6f3FmDQTUdpSdt7SmrR////
/67cWtbZZgvfQPA72DdTrrypxZ673n/Pskfp/7UwHPK9/////72KwrrKMJOzU6ajtCQFNtC6kwbXzSlX
3lS/Z9kjLnpm+v///7O4SmHEAhtoXZQrbyo3vgu0oY4MwxvfBVqN7wIt//9vt3QQCAAYCAQIFAgMCBwI
AggSCAoIGggGf+n//wgWCA4IHggBCBEICQgZCAUIFQiuHQgDCBMIVEX2/wsIGwgHCBcIDwgfCD++RBX8
DVAOEA4wDXAOMP1/+9YBPA1gDiAREgAOgA5ADlASBA1Yrf3tvx0OABIUDXgOOBESDA1oDighJ/72//8O
iA5IDmASAg1UDhQOHA8SDXQONCESCg1kDiRv7f/WMTcOhA5EDlgSBg1cHYgSFg3/rf3tfA48MRIODWwO
LEFHDowOTA5oEgHa3/7tDVIOFBoPEQ1yDjJBEgkNYg4iUe2//d9XDoIOQg5UEgUNWh0OBBIVDXoOOlF/
axdoZn8OKmFnDooOSg5k31r6/xIDDVYOFg4eDxMNdg62PK4NZg4m//Z/a3F3DoYORg5cEgcNXh0ODBIX
DX4O9rf2tz5xEg8Nbg4ugXIOjg5ODmznCdfu/g1RDhEOGf9xDjGB/wi37m9tIZGXDoEOQQ5S/1kdDgJb
u2t3/3kOOZH/aQ4poacO126++4kOSQ5i/1UOFQ4ddQ41of9b97d2ZQ4lsbcOhQ5FDlr/XR0Ord21uwr/
fQ49sf9tDi3BLms33/0OjQ5NDmr/Uw4TDhtzDjPB/637W7tjDiPR1w6DDkMOVv9bHdbu2t0OBv97DjvR
/2sOK+HntZvv/g6LDksOZv9XDhcOH3cON+HW/a3d/2cOJ/H3DocORw5e/18d4a7dtez/fw4/8f9vDi8B
////WwcOjw5PDm4SkAKRApICkwKUApUClgKXApgC/v///5kCmgKbApwCnQKeAp8CoAKhAqICowKkAqUC
pgKnAqj//28gFgKrAqwCrQKuAq8CsAKxArICswK0I/gl/gK1ArYCtwJuuQK6Arup/1v/f70CvgK/AsAC
wQLCAsMCgMUCxgLHAsgCyb8R/P8CygLLAswCzQLOAs8C0NHSAtMC1P//juAC1QLV2ALZAtoC2wLcAt0C
3gLfAt4I/v/gAuEC4gLjAuQC5QLmAufv6QLq1l+ignrsAu0C7gLAk4L///AC8QLyAvMC9AL1AvYC9wIJ
Zz/A/wL8Av0C/gL/Am0OAHJlByWNyu4RUgVhdAHAB6n+RFdBUkYgdfQATEVCaMkqCm+BGgxQ4qUTNjRf
nZQwWmGGuCANvSoYkb7Toz8GBfdXX0ZPUk3EIBSE4njhjqEZJWwf/a9lb1gCJ2FIsm2FHXAZBHUdABMS
Fr8XbEiNzDd3iT2KjpKFH2lpQTIDmI9BEx51g2o0/nRfmK7CfgETD/7/JgwDb5fLpus3BwO16Q5ZEt4L
2XYXIBMrthEDqZP6FaaAHm5ndCmeI1bVF9xeBQm6VDllcjOw4qFKkGkA/UJhgtjd0+QabolsNQBhYixh
UrG7GQ8yaWcsb3J1hRAsCA/kwEbZsGc3KCaaNUBgaUxwSGBEgABkRIwEFgQ3HAFRMxqHX1LsYIxgNex/
OUqhy+3CAwsvV0suAxQtehaxaZYsRDL7KyZhQsC6AwDfdzSaGjs33m5BVB+kX1G0VsQZI/d27nasNnsh
RTu0RD8DiEOWTbNc30LGGmVBdV4hTdiydIU4dW4gITwJbmVksOCgbRCzbgMt7nDDRBvpZzHjZWwFJDiN
6F/DrxZgDKxAxw/tBJbC9ytNWdNy2TTbLlgDwxPnV/VWb9nu5K9XCR+3Vw8bGcMCSL7aIW2BCYQbbR5w
BG7D2Ws7BgBsdW53yxgsOPY6IF9VCF9Cwihqyr57n2INPSVwKQovIM11VDLKDmSI1roQBmoy4cNzbwIV
JgnwYk1U1nUxgGEyLBh0IYlsgdNuj5QKV+3fehVVUXA9MHglbHg57KXYtmYlY45zH3NkYRTXgkw0LHSm
FiwRdgoAAKfgkIcwwA5lZI8XR4v9ZW8jSVAoaykgPT4ggTJagy9Epng4Nl8ZoJEABw0ma/vNwcAMkEiG
AoAHc7c6YSAtB6kuLi+yRzialy0M3y6Nh31U41JGLmiLg42P7gB0cvxh0XVUYpcWPGjBYHeEzmAqC09B
p1N/IOYAj1LHRUhfUAK0vYJFrxtsg7BPNCO7kmEgGa2xgEYWJDAbzbLZCo4Dc2F4ZGOtc800YogPA2Ib
2xCCBdMIFDhua1RA2QIxPnHTNN0xMQMyMzQ1AHjzPM+3mTAEMTIzNNjzPM81Njc4OSxjY2OzMjMxNDE1
MdQU5WI2VT+caZpltytAAzCeIBAAukYQtPCdbAPQ03TdZyOwB6ADkIC60zRNcGBQQDMw65qm6wcgAxAA
8DfgA6ZpvqbQwEOcnJzgnmmanJycHy8hGAmr9JYwIU3TdScAVGOkA7S8xDNN0zTM1NzkI6Zpmu5cA2Rs
dHw6t2mahJSMHJ8bA3xpmqZphIyUnKRN032mrCMkAyw0PDZN0zRETFxUY2LNFc8e+gAGLT4TwQXGC0Ng
J4QYK7uMoXMcEg5Mr3pwb3iKvkA4klwDb1UjcFc1eC5laCBtX2hkTgHjJLwKALeMIYGRPbdVwgdhr2Qv
QC9h4VA2o2wJLzCgP+xnmq2iAzYpDyekAw3WLC+woaIcHw9CHjbbCx2kBwPzo46OF/bkoB9AqIOpe3Nh
z7qqC6sP4KsDYMvtYE3QUB/krQP4r+pd2M803Q/bsQNkdjtY1xdWA9Afw64D0bEH7IU8bAOnsZiuHxb+
Ai0+VU5XSU5EN1IAgS/RBd5BUElTjx0bQHdfXwlfsV/6KH5gYAYqThVnTmKxbCUaCmQmiE23HQx3bLRb
/APs3DdN0zTMvKycTLX+vabrvv8jfAc8AywcEynsTdMDXAyMtP7/h4E9yEVk0Y0VlgzeJhD5N41K2KNM
N/O31uhiCAdMLQrIKQo7ynFlP2lM0mR3wtDsAlxmXxsQwGYzaC8o43g3RP0OwLgEKCmUBYODdmluSicj
IYG1DSmjSFmpZgw5GRbd6LFUAENJFElEHkGKHQoxEoll8NFhFzGvM3+Dh+JdROyMcn7wO3AwQ+MgPCAy
NTVDgEm8OSYgIohQCLoaAhxeb4At3MY0IjNrv8sNAzfYkA1eDywHHwOAshBYcUMD0zTL5gmZwU5BNbpu
yD4PpQOzJzgDKRi96MEfRkRFT9ccvhGIUgATaUfd4Apc6fK8AJXE+5lmuyu7xQOrnA9wxwMG67oLJBcT
A5AfmJ/pTO0TQsjfAyMPPLBuOWQD0MkIGxYfBb+oRw/2SW4PBewkSChpDMAweAOOQj/pb0NGQV/Q+BiD
JWXCMcngKRgtd3fGRQoEMmQzlycyBKQEMjQ3YBZsGdk8Klgwow0EdDU9YIxYLy6tlWKfu8DeHwoAADIo
JGosHKnsZXZkKXf5YQmwrmFleDJWAg8LeCkKf6HsbspvdTFmaW7hC05cZUdzp6ItslQWSP+QBbIg9EU/
ELKUXTLPMrKA8JawLUFvChQwDD25ZoxgAzAfKheCrZIBdTwjVAsQH6A8bg4+BDhpY1kIPHAI/EIuwjA+
KH4wKWwNRgyL094iZZfQkadfvigKMGZBgHZjZsayRJa/QR+WkLJVMjICISXAiNeVpcA2t2aPOgEIIaTi
x7JlgbB3Mm9gwUwBkrhvDyw4DCg1JQoKB9iyZXc6dwpbZSGQAOoyEkLYAHLfNgLjpURrMlkgjARrh27U
AgaZHWVnEmFwCmxMGRxky5dCKEybfbssL0FUQ0g2NDMxGA/EQs9fOAq/sTI4W99klbaSGCA3NiN7yRYK
+HALlyvAYGSwCgBSiLaylEElGxAIWSnabQEbtRJY2DDdFQ6wYQk7KEod8WCPEXYlZBpoHV7R0WFyaHMI
ChzewlMarylgI7vgxZAoKaHRCl0wIO0dIChtd4SBqCswMlgahHSudg1T/AMcxqMDvLoNNdQ0L8w37MoH
zDrqagsDztfQs9GBum7nKwOU0yvVA9dvgA3oatn72m/cuoa6Wg/d296v4EfhBS8I6z/CA0zjthVNt0vl
C8Ppf+sDF/YzzWhcD4rtAxk3PtM0DH4fQ04ndFYwEB3ebhJ1BSAUpYCt/uIEwSCvXbXK6iwuLk/ViVpE
HHhCJIqEUud+GBJMCma0IWD2AsR9xU3T/Rcr1Az//3wDxGxcNLKQNNQfr72wgPeEOjoKwyNqJb5UXkVe
7gIE2AxUGBI6q+e67fYcDT+MEgOcB6wDD+7CDtm8A6wTH+gPZ7otouC1vwPQD6zrLuyIDQNXF0kDPB+2
BBUc9A5rEAMX9jPNVEQPVA0DxNrBusYP/2sDNB9IFgPPdreKS/9FA/AZDyAN2W55YQNNF6cXEBgfe9bt
vif9A2Qc1xwP7AwDBOu6C3gXbgOCHxSiAQbXIWBlwFZpZN4ghYUw3zGCY52Sb25pomFspCVQQKzNy8oB
B35PUF9mYozVbkZ0OceQbg8bBLCFQkDbZRtoZEF6Y+Qc4AQDEJcXzJIRECXKdw4Ui3ZdZWaZlF04Vj1Q
a1AkSygws23OngMgLwcI8C4D2DzZNE3AqJBQJNAs0zRNs2BIOCAATdOZbuArLysDiHBYuU3TNEAgAPAq
J+uWTdMDyLAgKfhv4ANN53avEHsP4ChHA6CAbDrTfAsvLwNwaChQJReVSDO8qOTQJ0AmqwO2oaOjgAtw
FziT/C0DTdN03Z0LlQPEu7Kp1w3WNQwfAyPxD+gDTdM0Td/WzSf6RWBd1zXIIzgHMwMtGw3WNN0hAxsV
AyMPpule1wcJA/dTA+vluq7rukETRwNsCw0HBQM0a5qmaSsiGXxzI5qm6wZhB1gDT0Y965qua5cXage1
IbfjA6Zpmqbb0qWfmTvjZ5qTYyPJL6e3Axm7jqauCssBA+8v3xOlOMAwMPTP0BCKLW06sxGEKAjn+Ap2
xELkdNE+PaK2brV+ACljMUk1oR7xntd/YDMiCNbxDFhFJIJmLkgRLGp3EYuUVRci54RRDJIFk+26bYNk
Xuczx6QDtJqmM2xENFcDJBSkrtsIIOEEB/QbuqbruuQDZAtUA3CUG8Q03bbrE8YLHzUDzwdY4M42Tdfp
A/L7BDUj12marusDKws0Az1GT7JpmqYWDcwZfD82W9flLj6PPVc8A1GyO47NslkTyDopijkb2S0RAd5M
A6037TrHZg5vNnc3JD8tQNN1TbMDHg7+D+4D3pruM01+biNeA86+7pqmaa6ejkAzUED/QUMCgxczcNWR
pJYpZwFGpGIJTeFSVn9Hh6VsZRIvUyqBzRJYZBw3Tzo1rCKHKWYkoTr1RUeEDBx0wz+mVxJBIgggRW+3
wgWjTtoLAGFkrhj2ZGQAACcMABFcFi5cuVOLFMSGzscMD05oSCZVRbtQXYhBxQ8aOygpW8fJkh/ikUIj
QQPhOUjTNOv1/09CSKCeOY0XP/S9ffv/BoDBIAAHgBsGAAEB/29gs9ep/wUHAQDbNrruCv8LBQMNBCkA
LgUVom1REbEIA8Mee6PC4AIAEAAAADEAEsSw/xDQXbcF7AAAKQggGIBL/9j2LWBxBQb/B/8SCQ1h77nt
vAIBAWOrVV8WW2QPABQAAFk9K3vZS2uLAf8vOwsiYR8BAXn2ZcEmAQfvKAAKW8JS2BsVpwAHLAkDOY//
/wBcgiatdi/ASIo2cwBBOh/g3ktRKCVzBwPDIJruBf4hIiMkJCUlWScnKAApKgYZpGkrLC0uDkKQQS8P
f/wddHDAg6hiF2HzYWmaw2YLAw84XebAFraDYhsDz1a2Qpv5LTBJAiAIjaABy3h4CyKjAv9LsElORgBO
QU4Abvsida4EcAAtviIbKKxz8OnwOnR2kwMCB4GQARt0A7dbZQewJxOmczdnXlkTD091c3R/c3Truu7C
L4cnMFcWF5BfL+zZAaJ1B8F0f2xym2YwF3cDfI2Dbr/B1mUTMGEzRzY3ODlBzbbw1kJDv0YZAOQZAAAF
2zC+kQAJBAtJGRFn9427Ch8DCgdUGwkLGB8GC+zAgr0GMzkADjlfQ/W9Cg0fDaQJFgmwKQvYAA4fAAwL
2GEnGxMECQwcDDleGEBTEFAED6aww8Y5EBwQORKGnWzACxEECRIcWArb7QIaAAMaGkIfsAIgTQmcmKxh
JzsXBAkUHLgnG7ArFgsVBAkWaAezYRwIyoBf0K8bCYLAA4APTSjUlxWxXk63gD9AdamaVbK1Z2FElSBS
EMkPgjeixqYARG//ilQ9VLYA0RDxxBFDcmU1ZUtloIixMwF0qkNW9XR5AFAvAE+8R8CwyuofxK0zAfkz
IE1jaJYE4gjHb3L/Geo9qUqAAEYhqw51rO0AVgSznKoIDYjfERAzRXc5umOn6hFug3ZpxU8vFhWBhEPG
2wBeAelHcw2taAlV+BfLXkETRm28JdsAMFVjzHKFhwDgaHmcWADAG2ZURStlawBDXtHsEilzLW5KNrtt
4T8RLYJseeFaYRhEYU/lDQvoE8FwAEO5CBsMC4InZXI6YcMACDssItqnai8ASHqQzFEd4SoMDICXBT0A
QQMtGQAPAEIyxGBDCMIvT9x1wwpoQ+pvchgv+0YLdgIXERlpcmVkLy8hGCECxElzwUExYQ5UugiiFYoQ
dHQXQ5gFgXd+TWAtGBSltAjibcKGTXN08fNnAFMWgRqLLmOvEo8iRqEOH3gWCNxkJFQI83lCLPaienb8
gyvczg5Ob4lkFWNyBJ8b2ZewcyDWQmFkHjGT0aDa6dKSQmTESMJhZB6ekXZ437J7oHM6PmFWQDIGWUVU
TAII5CcdAH45AFM/Y2OkasxRPzNQzyGdFtok42UsWaR3HTRjUmwSRnVuY2uACwiRLIYd3GkChwjaw1Xb
TCc0SagzZlGcUAj30m1xd+tuehEKItNvQR7BlkVoxyWbALMgPZlkLoLDwsxO5QJMqXOuMQy8gNNj0RC2
CFpdgmz/hXCwQ1GhAEZ+xuEQh7qXGWjcEkALW6l0giQBJtwUaW4Exy0h2GChTfCbWBSOk3N3ciYWkGz2
irhNHrCwgRBBFjaLTVaYUzREGZgsYRdODT5mG1LIXhZpbHkrmxwcLNYACD0AQVoLIATdaoE0LEk3PHJr
/g+zA6yB/l9uJxxGRsAAQwPoFgRiAFxLbBkBB1vxaXNDgREwLBNYDmIAtFXUH2DCpIBk8WEgYAwD0bup
MAQjzuS3Gtiy01IdFZFOQmUZ3G5kSe1lmRqvLMRRdQ+aMSSCYcb1hGMQXSt1bQIAV/Y7GCNYEvxN0Glo
bwgBWyYgSzSwqhgBye83IDaaVP8Z9gMR///2/0scDBAECx0SHidobjhxYiAFBg8TFBUaCBYHKCT/l/r/
FxgJCg4bHyUjg4J9Jhs8PT4/Q0dKTVhZ+0IV/lpbXF1eX2BQI2dpamv1EgD+Rrl5ent8SACrdOE/9WZk
KoB7X192ZDFfY4JTAQ6I4GKqm/i3Rk5VWF8yLja7GwM7LrWJBlw2xLQUVfQzZoC43Ae2FUQ0uweoXSvq
FDnvB0xDXbeZiJcH1CvEBwwsm21TxzQYByTUJHQ0zdYEPykHrFTE9zVN03Tc9PQnKi+5zbYh6CQtB1y0
My9zm2bZBxRH/EQUDD8Hzm2apiz0XERIXweapmmaZIyEpJS8zu2e+xdJPxcHFA0XB5umaZospETEXBRN
Lju3c28H9E8vB0RQNA4Nok3nPwdMRFHvzbJZdgfUVMwUVeQkdK7bNPwEVlcPnwdE0zSd24RZTwekxPQj
97lu3A/3Wu8XW48nt2maruQHLPREBFyPNE3nPgdgNwdU/NRZdq7bFBEPYS8HBGaUt2k6txRqZwc0xKRs
H2fobl0Sl20HZBK3bxcH3c59bvRxfw9zTwfkdScTaZrOdUd2dwckXJRN07mvdA93Nwc0pGRzXfe5eF8X
fYcUj35fB6ZpOrekf4cH5Kz0Oj5ym8TEgOdcgQ8V07lN57cHJGSFVweUTdO5TaSEhi8HpNwE3WbrupCX
Fg+UB2wUlycWm6YzNJh3B5TkRJkMm851Vxd3ByQUm6c2y87tB0ScvwcknZyUnts0TecvB6T8tBQYJ27T
dK6f9wdUXNSpl51j03QH9KQEqj8HZHRu0zT0hAwZPwckoWjn2BS1DwfEtwN1W0RfF7z3Gk/Cc13Hzn8H
hNM/G3fUlwfXdTu3lNaPBwTdRxyf3xc71zRNHOMc6Z8H1Oq5zdZ1Nx2H+QeEFPof3Wyf2wck+48P/Afs
tAD9NF1htyceFwH9JwdEhJumK9y0Av1PB+TcBAU0TecuFB8fByyURApLrt30DP2/BxP9v1/TFe4HpA79
Xwe05BcP2m7TbAf8JBQg1xD9r2460+0HdBIvIAe0FBP9Nk3TlfcHhPSUDCHcbRE5N/9cB7QX/ee6gmsX
BzOPIT8Hpmm2bhQijxoHZGR8mqZpmnSUhKyUxGmapmmk3MT05AV1O7cMI78HJCM3G7pXuGvjB7Qc/b8X
B6Q1dJ/7Fx2XFx4vJAcfr2mazi8HVDx0VBddYXOGID8HG/1fB0Sdods01MQnNyWPByRaRNUyl55pmqbp
BzSMZKSUNWyaprzk5MQ3Jybt3M7QBzmPB+Q+HwcEP7dpms7HByT8RBwnR3TPbToHPCRCVw8HrL02ndtU
Q08HpBwo9zbu3M6nB+RJTwfESv1vKZ9h5xp/UMcHhFI/B1MMm6ZzHwek1DRUNzKdofsHVccqHwdMbZrO
0K9/BxR8lFc1bJrONwfk1LRYpytpms7RH1kvBzRkRM5tmqZ8VJSEW9cHt3Ndx7RdXyzHX48HRGEnPbdp
OgeklARi1x9tOsPXB8QfZAcHVBQtpnObzvcHLFRmPwd0Z/gMm2zEaWcXaw8Hbue6TbQcLk9slweUbl9w
O9dyB+eHB4RxRzu36Tre1AdUpHQ/B/R1Q9e0cz8HVH03MFd/n86xaToH5JxEgM8HzjVsmmTMhIL/MV8H
zu0MmyS0gzcHxIUvB53pNsvUh+x0iBcyB4Q0Tec2dIlvB5S8tBg2TdPU1OwEired27lNRySNNwcEkk8H
xIau6za0NDelHzWvxy90ruu6NjfIhzcvyucHZOs2TdPEdNxEy584J03nNp0HZFTMTweEtDRN0zSkzMTk
5HSuY9P8BM13OS8HVNu5TdOEbLTOtwcEz7fnuoadBxTQbzpn0V8Hrtt0bjTSfwf0JDtX0/e6bud2B5TV
Xwc01088R9gadm7nFwc05i8HhOyXPS1oZ+i38h8HFAT7btstuz7XG/4/Pzz+j0Bnttvu2j3+9weEXP53
Qe9t/peb7rW7BxRu/pcPB/QkcDRN57b+f0L3B0zkbNO5TdP0jGRxRwd03e41TcyE7C8HDEM/cqbpXrT+
j7cHbJTnuoWblNR0/j9EP3U3B6Drum50djdEP3c3RZ9/bud2hbcHZIE3B9SFN69w53YHlI0vBySQ/l8n
pivsupGfRheS/g8H1Du3c5t0FJMvB2SULwd0n4I613UnRxehJwdkrlm42xuEB9T0/r9H9X8JcAubRwb/
D0gPi/qWgG5MB8THdA8e3UJ1hfsHNOPkB9S3JyE2DEnUAXpSA3gQBID4QsoMBwiQbv63we4cA5gNR0Yg
Qg4QQQ4Y1m3f3wIggwOOAkkJEBIID2wLrjuMGERUA7A3IAx12WQAAEx7zBQOGgsOpzEzf1uWbRgCICgw
DjhHDrACg/SlAOgHjAaOBI8DhtjYtm3boiw4FzAgICy1O9u5gnKwAp+8A1gaLXK2EBsEn0JGbY3al5AE
jgOPQJcOQQo+84w3QpCf9JiLtYZQHjexh7e6rqBgSogXGwR8ZkgkL3druu77qA5wBiwDPBf40i+E3c4F
asMBg7sCsxXE7uxZrgEAr2wIqB/kIRfWzwKvoCgCl90JJ6ACN6Q3wCGKBpyQQwg3kAOhBO07e4GQA0/0
kChPnJBDyFkT0AFIEu1OeIHQAR9EpxA7Y7easE8rH90OCBdch4DRNCgBBzdhIGy6dBcgmwAHWF9AeIIG
AowFR6QGedZ0L5BDXzB+vLuwoukXyBfE1BdomgGk0OzYDc4aaEDfPJYDL87suwnLjw/0gwaMBY2WgnwG
7KT/QjAAphuy7z9gPPz/FG9cF2jIBhuSA3QvCxcbkppmjFgRN6Qv2BIIB0YDrwJALhBaQq7+rkCBXJ7D
T/Q/1wLGC2EhYZD/kgFPbxqsECdEf/BB/P9kQKasTCdSaWRsXad8BA9CNxIfNwhNN5QXENmnZT8lfGTs
EHIFfQJADggfL8A23cQvwIMDzyIDW/dbIZcUBQRGTz6mG+QZb1B5LBcosKYbsgivRBcg3K+6CIFkaP8v
0D3gBmtBX3wcK4ywI2zZFwhHKMdwxth2gJx6AkYlRN4Iz2EXcH/0SXfWdcVa/1/YF06XWnbJCv8XEEpz
TfdBwP8bPBd4JTcw/qQBlwMgAQ4I/x8LUoNqiEsHt/9GRtMlF7AB/z0EpOkXqAsXpMgRQtMXoPgXUOMt
gUwzBVADoMgGj1gCZ8f6S9AKiFHXT5DOSliXlHz2N6Rh3TlDC/83LjYQTFAf/xcF3ReSuM90FyAhJ0C6
L6MEz1QE7iyFDW3Nf9xnCBc4y2hUBdXgAf/7FsJuF2BY/5cMPNgB2K5oF2UCl2CVC4QlQrYBf9ayO4RA
Z3RncFp/L8vadVjDLwJeMF3XHchQTiQDrAm4Nxl60jt4n/UBA6gBtwJVWnZfQ78P1CewXK1WWIfA328C
D09uHT/nJAn/X09CAQL+ZbekSNT/H0Bg22LbyZ0Cg1LWmClkBuxiLBtFL/8vsGJAupGxGv8XuOyMphmk
wGRHYBfOSrA5vBhj/xeAwJruEN/UF5AQRwDJdF/H7BeIr1RtisM3j5hkrBNgbU8Ef0YEZ3LZfIFPXAhp
pQFCE8IQsIdb7dkdwhABZ6xPaGqMjXByygBmVm4FdoFvYYx7/39rxyRguiv0FzDHMljXdQx4KBfNX2kQ
MN1QPC/Ix9m+YjT/wGwXNbo3CDxAcN9sXxcQuDCOEF+gl6qBtIUwpyZXYWLZTXigAf9n0G8qmi5CwOf/
F+jnBtveQQJrNAZ4twyHhdGml7hw/8cECGy6JBfAWgl/ITSE1I62UG8oJJfddE/QeZYEjuxgQW9HfgNB
MNwaubM/tD8EP2oCd2CMkj8sqji7BJJUXUYPJP/BuhXdN2hvZQE/iSEN1gL1PlTu/7cwdjQgsIEfP3Jg
Nd0sF6iltzB2EYY1mqv/JzCCarohW5g/bBe4J2S7HEEPGiogAaeZkGV3lCfAgyYflS2bKbzIhNGPuoJg
yMZw5FoBuewngIVnAS1h2xL4KHVvEFwM34HAzUIDAgF/FP8OdFMCNIY3RBeg6Z4C0glPXBeYYHTKqIYX
AncYK9MtK/8v+C+YbbojpBfwfApfBnwZX+JDDQZUcwPqB7XsgrXFQb4Q/y9AkRiMLhjfL1Df7EKqi4Dv
kY9l34TgNJYvUqcyehw2faZGX7+GhKY7PDdoHg9UHQak6RdwKlT/bANj0xeIXAr3CCh0ehhPm4P21gUI
wl60gdYcAxTUnU1iQc2/xFeQg4EBG9eiVyiBASeAT7JVBnWTwGDv/DcI50i3Bdblj5WABdiCtkBOTgQm
SrrtRttM6aiiT5EF1+y9pNck2sMEYUaWKdsmRSBxFEFH3UgwwCn7vG/YTIABl6ciEcfywnYTSOdFJgM6
GiEMKLFl/dgthMUDQukaAmFP7AYMRj98t0i4dhMCdKcB75QXULk7hIwGpwEnRMwyPjIGbw9QAk43y+6E
OFBz5E/wumYLYQiBBr+AJwh1hbAg1hSLKumBYUOAwt9UeAISdLDwwEcCTwbsjMO/jJTIrUKobpYMHv8/
0JILsFgfZIcZKYD3Dlz/j0cyyIV0YwUfQNZ9YRcCokBtDgNyAwcE7IUQAsEP/0mgUd0TBMyfrxw2CZdQ
AvGYlAlKDbtvSQnnfDeYzf8POGFHSH8C6NkN3RkRQnzXzE9o070Lo9w/HP8XcHWknlAG90BWpwLq/LZ7
4MpfBDxg3R/pFAQJJWAJXBhHkqeX3asdvj5zLyDelwRxipQQLwB0IX0IMwPdAb5CLLuHIdE3fEd44nDh
sFcCbwJbL0ZtwnZnAee0BLDi5zI23cd3zBe4bgF348F4EVd3Az0BeKuGASOXfzAjlqroZybHreCqIV+P
RBcmXgSLFW86kGA1FpOlQFEyAV8yIP9P5ZsQu5X/FxDmLxeMTfcFZ4wXSFgHDyYbyCHwAWfEum8h7Ddw
7Q9P3Bd4CW5hbIsB970LWJAQ6GsBH/93JdE0Fn/u5ywX3YUFTchXH0QXENN9C4nv/39cFwjYIAxZIX8w
4qJ9uojLSF+UL/CpjA0C0wJfXUbKaERf99whWAHYR9jxh5ez5ovQY1tORR/8HNhJmuhpAmc/HFxm4FZA
OPI3H2TRdANCxzwfiAdg011Ir1QXgJEBFQIvQG9TAVTEZXeK/0/Q83oCQAITYBcBD5FroKfv9Bj212Ng
9JUPA0oBEf+kuAEE10D336Y7QCL/N1iKA2DBygBPApvTjbDCtm+sT9hNdyFBGR/EF+ADkA02JNwvCxfa
DWDN9NAvDFjI9zTdu5D3FP8XwBKOLNiQPC8XVB4SBm3Q92d3bHCBwcEvfwCHcMhlN2RXnC8Y+DMBGsgg
XVC+JAzYBQz/NyD598BM9yV/7BdIf1dhu44cUJj5f1S6KQl2N6D6F2wX2MJuSGhFL4QXEPtHSdF0V5wX
GIM/2HQf7QJ+SFe0F5AUBCDBCRAnA1xHbsBgXfDvBPBg/5sutjBX/xdocgMEcoFRXzBGLQTdVDewVwX/
AbbpQheoTQW3IsQKOwLgtv+6CAv7Twdn/xegphsSaCq/7Be4ruvCgCeXBOzQF7pIyahNx9+CR9M9BqPG
ZMMn+EI4wmLRCa8Ed2tbIHXWCAQmX/CgG2EIBHeUZ3AYpFgqQ/lvegdsbKRMbQZhBQKHoPmCFFk3zDiD
IaGNVxTngO8ETggHAvGugAHnJoE3HQQdLxj9/xfnVSg7RTLP/x9CJhlkRBZUYB+BbGQ/F4QfkhdgxbOv
rgEsuOwm1E+QGjoAP3QPM7hz9yf0H7ADMiXQ689WAgZ8A4HJ0Dcs6ARXBvBoG/0PcWy6b4Qn32Q3gK0D
CDkBRve+Ai4FzVlPtOCvggJcIS/AT6sBRCLAFT3/H09gnMBaswDnArA2CRPGLeBQREVQx0dITXdMR7hH
38ApJHphlysFwCQu30fPnE8mZwKnaklOBpABApMSwiUIVgF114wFCLrcP+gv/gdrsC0WgM6T/sBHQuCO
DgTpwCn9f6TYdG8cAxfIkAAvdG8yGnXjLKMfOAcWGxAPAEdwEZcxVjfkSHApueyS/y8IK7IAmG5Aiqc/
lCegWNMdSbesF5gQz2i6BzdO7SfEF5BzhEiFJC/3bGFDEhxeATEwVy9hsOsEIf8s/a9XkQEsuxwXCC3F
F/eIADKs/z9GTElNmFUvdf7rzBFCb4whLxrfmyWLBlE2/x/THUkFl8QXwNN9DAQv19wXuLAnkmIuAvcD
pgEOHihgPAJAS/8ih0DaGo8vRy9vFgLuPlYY1wd0T4Ax/TbfIIGHJ5zIMsYCCVXv/yIznkRvNP3/XG8C
V0cbCS273BcINVf/FxEhiaZQFO8dhQB3L1g1/edELiQB3zdAN/3/EP8XdEMGmThHdBcwandY0OQvMGbd
AYW0G5K/nCf4OJfQrfug/yMEORdKAw0RIGH/14A93cdIogMAz+w3GCBjA4I8WwHPIxDA+ANbAdD/JDcI
gTY9/Sfv2ZR03WQEkDdHeiurmu4jZ4wnuId/gQE8AANG/6HoknFA/0/4NwITGHCvAH9b11hyIRMwMBDg
tqHXYEBHNwLPIqyQCdj/010l7E9QQg+cJ3iQEyBAw/dEAtHtIqz/T/hEdwEcQhxJl0AfGpoewpFABywm
T0bYISzYP12fwAKQK7hATogEwNeEFrE7fE8YTU9XiBVyCB8CHUl09/9POE/99+QOGSzTF0AfUPwurKDp
F4gfDxSRRLumIJAXHQKnNmUwycBOUMCHd3LZDVQ/cFEHAEWHSU0XA/8XaBz3BsJGIcCF2qaBZRcr/ydg
UgK3uYIrBJVknIPDhpIrofyoBIYGIUJsfwUdkQJLCgpDB8jmsEdIC0/kIFQiE8gVT0S53SoeQzRX4FVP
ngCC2/Q5jYwDP4YENCEkUITbSjxiCh032BaQ7gtZEUZPahBG3cla35Qor1ZnVnKHCu8jHlW6cNLtIFJD
GEPmC8QYRTTdE8vgP8w3OKYu1J4EJwKKLh4LVaTpBis37B/IHG+AgvEQVx8f0Fb9/2m6IYERvxwX2BeS
aJohNOAmb1TCphtMF/gfA2eYpEP4A+8CCmFFagt2AXpB/4831ARHLckkE0lECQJFeomIFW4BChho2J1R
Qwt35E9gXvcNQqnnr45PjZcTBd7DjK+Gl/84sg+k2XOU/0kLVhR4A762Wqc8YLjg+2SSCdtXAadERVKc
vphOV9bTrrL7ogSnjE9q4RvAJuTKAEX3UqzItl14YQ5IEVBYBUILRKGrDchaVwW5Sxe6ZNQA/28Ilkhl
GxfOEm/38DgTCJfxwANnReTWtaGjTCtPcE9fItF2ialNrA0CppiEX/cWhaANTAdCEMcKIbqu+wNHCwPM
AiJiKkoHQ/s+t+sqVwcCQxBDQTt4CK57sK5dEFBMA8MDCVERhw3ykFmVAVg0c4Md0nUIXBBRgiFXg3Tf
YTOzRXoRTU/sO9hgZ0YyA1chQop1rttuqAewDcG4DUeryCzY990H0A1UJUd7V59qkMG6bucIRxBCNkm6
7xlkR1OMXFglS+/AusM2jwhKoQ0ivq/puksRR0hBVhUvb0kgVAXrFVYnfxjf1KH/nECR/f/cZ9Xi8TWM
X4a3GAgPxFtuAk0K40F97aNjKz84VkVcUAJbidi2WA5gHGhmXTDodBawZihfhHNSSbstf8BfUAG/ptsu
3BOwAVG4ARbAA8jmAFqY0EARAwmM3c3o8AFYIwKOegog0G2caRdG+2wW7L5/3IeIkgfnFQsDhm8vhdGF
6P8XmJKvwmq6r9ckF5DBP0i6puRFZSlEWHaX0X9sRxiThjwkuTA3QXxFDBIGHSZEOBe5sKabrD9od89B
oyPM4HAZE1cKjjRdJCYL/zewJknTDQnH/BfIHgxgBg4UL38XLDXNANLYROAVGdwNSedcF2Td+8cIUjQc
VtNrVxWMdq//J8CTDyuabiD/F/gvR7AUuwu0EBCU3wEHCAwlz1POAkEElo2fyUdWIAgSO5r/6/CUbxrR
bkD3HBcolVfWmeTCZ0REvZvslfCAAmn4QwtHZF+eAiXdRyy3rOEbQOxH2JY7FAQlzf8YSE8hKF63DRad
23h0DiBFbV1eQvqBDksLAkG7XxoVbIrHaJerNoAFMF9fYVByYINwQ1dKX0aQNM0BbMjJO+wQID1IX0QO
wMFOBkpHzgJBLptvIGpfzDiYyAE0kOZKSmRsYUi3JkwORhBxbifawC59LG6fhLHdqizIqJlfnXfSsBlh
x0oCi8hG20K6RwJ/FUOGc92XYWUU87+cb9gYwFYFm3a3bTNQoDfmW4UwAN7cwxBGYlsIOQhCC2FddkH/
LyicfQ1fllliC5qQxQdh0Dx8E0g/ZP8zqf0ASDS3Br/gAwMsAQI3EkgoGQLQuruOQokXceL4A4AEvRlV
uEkuCgMCIHXZZ1Cv4wWPbttd0DyAiARguwSJmASB0HchbQROFcD15JquaeDOLkRSB+weHU5UG/93yLTt
FgC5mRFlA7R3c123xagEHrBMuCDAdxX2dU13ApoUR1oHQhBsh7ruhQRVA5QDIkUqR27ThOk/QdoEBGI2
6x5ksGZGWQMrCQlaLZDuawZHU1x1FFvQEakXgu8TvAFY3XYUmMXPBhfXus10t2EsAn9iz9gD4Kb7TudM
FRaVShVH+txgm10C7hRdB7pWG7KHEPoDmQM+YFSDNU337wcVWkdCagIbwAawRxRUE3488wXsAKYUZ0ni
IWTfZ7xfFR+kgHGhef812x9tIWdjmcAeBXPiQvt/ba57oQWvkAVVB0EpEQoNNkjXCV0RS1kPTVxosYch
gggJEWeYBbru+zbfBVwVZ0lNFVwHQmv65SA4V4Q2D/ynZIBUcqsA1WHbFrr7aEh9VgVBDEaWhRBgCFMR
hZBN82/0kDgfkJYeCJ+QBrkE57S1tocDlw3dBpDeBtvUsXP8MbAGpwYqBm44Fqphkf9/YA+A3aK/0xDf
cAPwSxIhpA1Q/09IJcCy8CuqJxKawN6UUAJmTkZXLCze8AQ4fyz+/0ynFx4WL6cgVQqnSgvqGE7diZIE
b/83aPFLKDa1AZdEjwOObcAbFboFjAblJrsXxG6jDAdq/y/4Ld+WQy5PAEhBaAJEDAeW3YBUL5QngC4G
5puZSUMjH7SZkEmacAhF1IsUVaZgij9rmssGSx/0sA0/R0BCJkqvTMgkXaAfDkc09jJJ05BMZUWDA7/N
QNIdVB/AdPCB3AwklHLT+zFi9yFHtDkEL/63sHFYvkQfRklp+EbbdQ2DSgST3Cf4ZzkCRwHV2Q5JJ14I
oyJrsQYHVRfgI6fkADAwUunAKO9PRzAtxu8WpSqvAnExRAt/+MEZXhQ73y9DAAK5yC5CQoD/H4AxVe2e
Fk9UH3Ayk04DtocHb00XFlazLd4C6HH5UKovWyLaTYw3+DmPAjeO1HIBVhFGQQtIl90Q/yfwO2YERyCG
1AxFbG2wCNtN/yc4QIcJ2zb0LxRMwEc3g4cUoIhC6IaN3mALwhaLVQY1WorafY9ELyBKtwEbtWJAb0IQ
dgLvYgSzpCb/JxhL/v9hxgTCQgGHqMGH0rfsLpwvOEw9EFmn0nwRDlnG2R+8WNZ0sRD/H3hMb0LDYQdI
/1EAX/q2e5dwaABU/1CQTTeAEKzfAxECcgA4/l2Lgkcww8bMzc7PAkABtdaAdxIifqvfho0KCsNCzEKh
zkLPQcYuu1gQuP9XSFieAbBNFhC3j0lEe8tuEIIsh5wvuFlKwoQFrAjnv2QysMvmSy/M2GFhS+8ehu0O
YLccAekf/DEOuewvGK3BAEZHBsKzs29VSwYCU5dg7Az8ZzQ+PzfcEFd2l/FddTBKT2QvYL4FBDaKLwZv
oCR0k5dOx8+AsVHUvf8vUIsUe8Y3gE/WKUlPvD4ewmFBosVXV1CmHVZjA/7uRx/sO0Do2C/41dcSH2KH
st82o34POAIIQgv6lQC67yTLP2/o9yiMwffYUT9Ov3TvUtNBRudLVD8/6A9ZUzIIv59ivAAAmOwCgZYA
JAAAAP+YGgAAaAcAAAIAAABywh6SAMBdQgdgXydPngxjUGLQXXCNPFiwXi8HIB5D4OywwYY/F1AnYTdj
Dzsb8weAX1BkB7AONtjIBEAQjwgHUDbHHsLOF2AfYFNBB/6OLNhgZ38MFwUDF2QA644OAxQXI8EOmxwo
pAC1D4MdWZABNwMbG3Z2kLOPFxduAn9cFztkgwwURSeIqV8bbLALMh8TDzNEN2ywrg0HcxdVXzBZkLNd
KwfLkBcGv+Rggx3IHwMPm6aDnBzkCdCFEMqER7awoY//0EiHOdjZCzA1F1AHkDZssCE7GCdwF4AHm7CD
HeCWDwdBH5APsLPDBrAXkYdQR4OcHWxRw52gFzRGGGSQkwILL1ywZgBrRyEvDBUX9gL7hjmfPMcwPu/B
Tp4NPQfAQe+nwgl7sBsnCpJDP3Gojx3SYBciH2qHkYQ92IW3EOcwjEB/wYLwsAcAQo8HDXZ2kPCMk0cg
JswMCwmDDxLHAMI42CHf4BemlFdBBhnsrA8izgcZZJAW5A1yngY7e2EfBAjT9icLMA7ZEJcnw6pvsFiS
vvCdQ7cAL7KQMWwEr78/hLNHNm8BlQ8mXws7ITyQQ08nlfdgg3RkT7c/Ag8A6y7sLZW/VpgkF2vIumZM
EQdDF1QbrBsSBqyvCgMcFyB0pwEa4wPNFwNYN9gjF1IDPhdLsoINYS9Xgy81soU94qHfH5EwspEfD/fA
hfTkwwe7nhdS0gukg5/QSF9QZVcJ42ANaw9sQLdggx1JB9Af4AeDHNnksG2PgKFmHcZgFxpWBQfAJvDI
F6sE6xchbAA5IsxHteuGsM0Xv0cwBw+fDWDdhSeAAxkXWDbrANYDHRdjAN8XhAxhR2gvckPYEDJ3exed
4RHCjADXl3CFt+xF9iIwhh8QihcQeCHwtZ+fIgDnGcA6LoeIMReLBhtIoBtHQBfAwwYbDI86PzInIEAY
dD8p12An8Mh3OQFDbBclNDnIMd0AB2FIgx3/N1G/J8NgkAZqp1OHg0MIFmN3AQdHFoQhgLc3dNggMFiX
CwdKF2mwEziMAVNVF0ZvDnJkIRfD5KFsxkFOT9wDZxdpAGmOVDFtSw7CkQUXci/EqmBhvTCvgwJ3NXv2
yP/QYhdbozdH2ISH/R4DRzfwYIMMIW43F8CDMMgkGX8Q7kBNmIyE349GzxzZ7JG/cwTvFypljiwYXxcw
dBgM9vuKFy3HquDIYGHH5wRgDKNB9x6XR2QIObIXNDaURZAhOH+vu5B6JagnoiAPH+zJC4T5LyBBIEIH
MAYb7G3PHR8rDzKEHFkXMDLYIIMMOzJ1z1KDDDYrD6AVLyQO2RAOx58E2zt7gfRg/8fQK7/wB8ggJwcQ
LDBQhxI6ORAvAM+Q/wwWrGEXhweAX9iTgyACoARPEAZBO1gTWOfgt2AINy6wwQYJnwcvUAQeAkMHB0EX
jASGJR8X7GBHGA/gb2AKfxMCPBsLBzWlZ3BAGuykBGMcFxl3HVYBbA0vHzCQzg4ZD1+nDw/PRsJC6qe/
77DBjoQvSWdOD4yHcHLhphFnEUHPIQzCCVAaJxoP2cGObCcwP7AUB9mQMdiXb1gXMDeBYIMNwC8QX89H
FoQjEA8XHCAwhDQUIeeR8JAK96SmJya9sHqlpp/hAosHkObIF/keBQPZjF4g6wLzF804hB3tX8YCw0c2
4ZEXiwN7F2cA0gwhaCKDDSDNdSaDLxYgZDEYX0nnGD2bQi/mF7enVwupg13vN+un93DIBqkKd9EvTagc
MmBhn6c8qIQgcGG3+yvH4IQAj32pb4ip0rMLsD+JF8aprzqyYBd0xxdwrIXVQccYqq83SgSDI/AXmPsi
a5BXRLfgQkGvkQ12IqBFT0YnTiAPdjAfkE5B8E6BxAsk54YDz8jZs3iUAzdDqxcfkTBKIt/PjCc8sleR
A08pqxc5shkvPwKjL5cL7JEFF6sEL8EQIsG5BMMnhfCwIL8HEE9HRcIjo49QUa+RvcjgQFM3QFEf8ORQ
cjCgWHKsxjNOGE8FAZOIrJ8hO6QWx6EvIwQYUscvEUIusF5n55ADLBi/FzkjC1IEHxe9sHjW/QMjX62v
iwGGkCObXxen6JBmAGkJ9B5CCAIEV7f1bDCYat9sB5WtkgrChacxT1+F0ME4KMPfrZ9hnDDi9K2n867v
xmCDdVtvnBcl78iRBRszF5uggwwywQ7PrktYcEJn2K7/ABGD8AhAXpd1GfQkmtdPNSAXGfHk2WsH4nGA
X6+TZ4PAY588B6wjs2eD0KBwZ1tH52oXBXt2sMZH8GAH1GIPG+xggx/AX7B1PzEPJ0+ePaVyB6g+yCaX
Cc8GqTrnJAeQAc8GOzvY5E/rdAcsd1BhcLDB5+9HwHRHh509e8A3D8JlB38nNtiDjUUvK++wckEXmxRP
TsxxN3DnV8jZwQbDF0tsB2Zggw02EK9VZ04XPnny7IBhB0c7QHNwN0M0JSSwn8c0L+zZYJ9bl6BTB2BQ
CDvCJgAFF4MdhH0cfEMAAFIvPLCL7GAHQGJ3AhOCkMEG/wAAAMDsWXHQf58BAAAAAAAAIP8AAABg+wEA
XPwBAOhTAgAAVVNRUkgB/lZIif5Iidcx2zHJSIPN/+hQAAAAAdt0AvPDix5Ig+78EduKFvPDSI0EL4P5
BYoQdiFIg/38dxuD6QSLEEiDwASD6QSJF0iNfwRz74PBBIoQdBBI/8CIF4PpAYoQSI1/AXXw88P8QVtB
gPgCdA3phQAAAEj/xogXSP/HihYB23UKix5Ig+78EduKFnLmjUEBQf/TEcAB23UKix5Ig+78EduKFnPr
g+gDchfB4AgPttIJ0Ej/xoPw/w+EOgAAAEhj6I1BAUH/0xHJQf/TEcl1GInBg8ACQf/TEckB23UIix5I
g+78Edtz7UiB/QDz//8Rwegx////64NZSInwSCnIWkgp11mJOVtdw2geAAAAWui9AAAAUFJPVF9FWEVD
fFBST1RfV1JJVEUgZmFpbGVkLgoACgAkSW5mbzogVGhpcyBmaWxlIGlzIHBhY2tlZCB3aXRoIHRoZSBV
UFggZXhlY3V0YWJsZSBwYWNrZXIgaHR0cDovL3VweC5zZi5uZXQgJAoAJElkOiBVUFggMy45NCBDb3B5
cmlnaHQgKEMpIDE5OTYtMjAxNyB0aGUgVVBYIFRlYW0uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuICQKAJCQ
XmoCX2oBWA8Fan9fajxYDwVbagBoDABAAFBowFAlAFFBV78AAIAAagdavsBQJQBqMkFaRSnAaglYDwU5
xw+F9f7//74AAEAAifop8nQVAdUBVCQIAVQkGInZKfHB6QP880ill0iJ3lCSrVBIieGtl61ED7bASIf+
/9VZw11IjUX3RIs4TCn4D7dQOGvSOIPCWEEp10iNDBDodP///5QGAAB7BQAAAkkUAP///+XoWQAvcHJv
Yy9zZWxmL2V4ZQCD+Ul1RFNXSI3/////TDf9XlZb6y9IOc5zMlZerDyAcgo8j3cGgH7+D3QGLOh////3
PAF35BsWVq0o0HXfXw/IKfgB2KsSA6zr/9tv/99bw0FZSInmR77w7///CfxqB1nzSKVIg+ywt9s+AAV1
+BD6SKsMVwj77e7dCvZMjX8bOrggAD2rugAQn////1sN/kyJz2pZWA8FhcB4BMYEBgBJg8EPWV5fSGzb
//eB7AAIIOJJiehqAOhjBAxaFMT////tHVlZweEMSAHPKc5QagtYQf8nsAvrDbAK67dv3/4JsAzrBbAJ
MsoPtsBTSD0A8J9yBA3//2+CyP/DsADr6rAC6+awA+visDzr3h5Ru/vbb9AXTItHCMhK/3MKv38S6OH/
0f1b+4Io/3QRQUN//8lJ/8CIBtv2tr0HxuvpcFcqKRdY/VVh1Xtrt9tBVATMVaD9UwP8g+wo6Pv3m/sP
hOJET3QkELoMCYnv6JZR9v/btotUEIsUFIXSdRWB/lVQWCF1ES8b7LvufQAwsSbrBIX2dYBgLrV/+785
1nfyidBIOwN36wpIi0MIc2iJQW37rbvxi32rTAhEi0QkGFvC+Wu73YXVN3XHWQw7cnW9sh3dfvt/GYTJ
D5XCMcBNheQHwIXCdB5xAALb1t6+WXcHifDwA3UPJEsaBMmardtuTnsIQdRLFNpFRTb75t6IDYnyswLG
6N/+tiXeWjPbAx1Tj2sYA+kYF7b/ESHEKFtdQVxBXcMV/wjQdIXCsrUpJ1/xyDgs4TZr7sgPlIDTfzuJ
D+Z34bdCZiqDxxDr1z5XuOj4ofAF6Yn/QVZKR/xVU2vf/W9BaEwDZyBmg38QA+w8D7dXODjOt7ZFeDC5
EEjfQESqKEzGb7R3EyAPRMgHgIPN/zHbML9tL/wi/8p4IX0BdRaERrA56EgPQr51F24DA0aSOcMK2CfG
OOvbx9s/Nj3lDjHSRTH6KetBFL693T/qgcP/D1+B4xwQ3ui8/eBuL+wHjRRfKehmJH84e725z9BtxyW1
SJtThJsB1n572wqDfJMAdCUkPCQGdR57GeHt2/AYSQMyvgMoix0w6N5FHd4/t+lXLCQBD4VMN737tv+y
KERBvkBiUXNBi9EEjklBtne/rSBgxXBYSSUog+EHDOv9WNv4c1DxAqOqAehB0+6lF863nd0mCMWD5gdd
/vHs9ywauTJ4KdiZdQcnPLESRLMvLBTUY8Ew7oPKAhrYu99w+N5E1ujQ/Os5xXV5y7+PrzsZSIsgySjE
UMRA6P9nu4YMEUyG99uBQfbGAnQNSo18O9i3wi0A5UrZ/POqPztJB/Rb7JKidRf9QlUMx0UMT865v4jD
kDH26NNFiYYVTrvB2HB5T3T0aw1JjVy73dxEHdz9O2xCcybGBsU6Ihiqp+EI3AptsM9APRi3wVGWGe7e
3sm3Rzh4xDg5DA+MZXJtET68jrwkoK50EG0ElN5tYYsPOwIwVw4BVBM5fsb2GDZoyEFeQV+aC92Co3GV
Lc54VVJqjnakjUCeTebVU7jA8PCx4ew4i5E0JI8QIiDpbW7hnCyJ9iDCB5jN2P2h55og6NT71YtVD9/e
wrYd9z7CTMy6sVU4vgVrbLtnFei6EUFTZuGaeL8Lj23YEfGWDCR4XxhQvbmxYzG+Cb3CLyPE6Ie4QGPJ
Eil9m4hBWkutgtuNkRwnTtx2NbQbD3hwXH0QTHMLb4FbwYFluHgXbwRAO4TX/e6Jx+jy+oE9D37sEWK3
zbBBUGwCwASJ2n3uIULXPodQqD6AKHDvvtm+B7KCBBeJ3+itOlvYuhWQz0U4SseExQawnbVwOceDbyM4
K+AAAICAXUACAAD/mAAAAA4AAAACAAAAABAikAAAAAAAAAAASP8ABAAARwEAAAIAAADt////R0NDOiAo
R05VKSA2LjQuMAAALnNoc3RydGFiCd9c8/Zpbml0BXRleGYMBXJvZGGW/X9rGgdlaF9mcmFtZV9oZHIN
c7fX7itic3MFIyplbC4M7bE2e2dvdBEFHGNvbSl0F4C1bhMACwMBs2AP1gYPkAFABw+yIRuyAy8BDxE/
2MEGGaCgKD2DQQ/JkF0QPxfdhEPYBNhgBwN/HRMggw02Ag/gP+BkyC7sC2gvID8le9Ymh+zsBz+8CS85
GbILBD8zcHvWJg+o9gc/gD8vBhuyCwg/PRMDexbswVjANmQHEIgAv4Ed5CJDAwA/h+wie4AXf1A/QE4C
edYmBz/AAdZCdtgHVT9QPywkZ20HP1i/7GDDjlv/D2BRP+wiefJYUeAbYH/GYSEbMBc/ET9AOrAQBwMX
hDIGG2k/aX8AAAAAAAASAP8AAAAAVVBYIQAAAAAAAABVUFghDRYCCgyc9U4c9NLJAAQAAEcBAABYVQQA
SRQAPfQAAAA=
";
|
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()))
sum_a = 0
ans1 = 0
ans2 = 0
for i in range(n):
sum_a += a[i]
if i % 2 == 0:
if sum_a <= 0:
ans1 += abs(sum_a) + 1
sum_a = 1
else:
if sum_a >= 0:
ans1 += abs(sum_a) + 1
sum_A = -1
sum_a = 0
for i in range(n):
sum_a += a[i]
if i % 2 == 0:
if sum_a >= 0:
ans2 += abs(sum_a) + 1
sum_a = -1
else:
if sum_a <= 0:
ans2 += abs(sum_a) + 1
sum_A = 1
print(min(ans1,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;
long long a[100000], b[100001];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[i] += a[i];
b[i + 1] = b[i];
}
long long sum = 0, sum2 = 0;
if (b[0] == 0) {
long long i = 0;
while (b[i] == 0 && i < n) i++;
if (i % 2 == 0) {
b[0] = 1;
sum2 = 1;
} else {
b[0] = -1;
sum2 = -1;
}
sum++;
}
for (long long i = 1; i < n; i++) {
b[i] += sum2;
if (b[i] == 0) {
if (b[i - 1] > 0) {
sum2--;
sum++;
b[i] = -1;
} else {
sum2++;
sum++;
b[i] = 1;
}
} else {
if (b[i - 1] > 0 && b[i] > 0) {
sum2 -= (b[i] + 1);
sum += (b[i] + 1);
b[i] = -1;
} else if (b[i] < 0 && b[i - 1] < 0) {
sum2 += (0 - b[i] + 1);
sum += (0 - b[i] + 1);
b[i] = 1;
}
}
}
cout << sum << endl;
cin >> n;
}
|
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 solve():
ans = float('inf')
N = int(input())
A = list(map(int, input().split()))
if A[0]==0:
lis = [1,-1]
else:
lis = [A[0],-A[0]//abs(A[0])]
for l in lis:
cnt = 0
total = l
for i in range(1,N):
new_total = total+A[i]
if total*(new_total)>=0:
new_total = (-1)*total//abs(total)
cnt += abs(new_total-(total+A[i]))
total = new_total
ans = min(ans,cnt)
return ans
print(solve()) |
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;
vector<long long> A(n), sum(n);
for (long long i = (0); i < (long long)(n); i++) cin >> A[i];
long long ans1 = 0;
long long ans = 0;
for (long long i = (0); i < (long long)(n); i++) {
long long a = A[i];
if (i == 0) {
if (a <= 0) {
sum[i] = -1;
ans += abs(-1 - a);
} else {
sum[i] = a;
}
} else {
if (sum[i - 1] > 0 && sum[i - 1] + a < 0) {
sum[i] = a + sum[i - 1];
} else if (sum[i - 1] < 0 && sum[i - 1] + a > 0) {
sum[i] = a + sum[i - 1];
} else if (sum[i - 1] > 0 && sum[i - 1] + a >= 0) {
ans += (sum[i - 1] + a + 1);
sum[i] = -1;
} else if (sum[i - 1] < 0 && sum[i - 1] + a <= 0) {
ans += (1 - (sum[i - 1] + a));
sum[i] = 1;
}
}
}
ans1 = ans;
ans = 0;
long long ans2 = 0;
for (long long i = (0); i < (long long)(n); i++) {
long long a = A[i];
if (i == 0) {
if (a >= 0) {
sum[i] = -1;
ans += abs(-1 - a);
} else {
sum[i] = a;
}
} else {
if (sum[i - 1] > 0 && sum[i - 1] + a < 0) {
sum[i] = a + sum[i - 1];
} else if (sum[i - 1] < 0 && sum[i - 1] + a > 0) {
sum[i] = a + sum[i - 1];
} else if (sum[i - 1] > 0 && sum[i - 1] + a >= 0) {
ans += (sum[i - 1] + a + 1);
sum[i] = -1;
} else if (sum[i - 1] < 0 && sum[i - 1] + a <= 0) {
ans += (1 - (sum[i - 1] + a));
sum[i] = 1;
}
}
}
ans2 = ans;
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 | import sys
input = sys.stdin.readline
N = int(input())
a = list(map(int, input().split()))
ans1, ans2 = 0, 0
f = a[0]
if f <= 0:
f = 1
ans1 += 1 - a[0]
for i in range(1, N):
if f * (f + a[i]) < 0:
f += a[i]
continue
ans1 += abs(f + a[i]) + 1
if f > 0:
f = -1
else:
f = 1
f = a[0]
if f >= 0:
f = -1
ans2 += 1 - a[i]
for i in range(1, N):
if f * (f + a[i]) < 0:
f += a[i]
continue
ans2 += abs(f + a[i]) + 1
if f > 0:
f = -1
else:
f = 1
print(min(ans1, 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 | java | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] a = new int[100100];
int[] s = new int[100100];
int n = sc.nextInt();
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
s[0] = a[0];
for (int i = 1; i < n; i++) {
s[i] = s[i-1] + a[i];
}
int count = 0;
// - + - + となる場合
while (s[0] >= 0) {
s[0]--;
count++; sum1++;
}
for (int i = 1; i < n; i++) {
s[i] -= count;
}
for (int i = 1; i < n; i++) {
count = 0;
// iが奇数の場合は正にする
if (i % 2 != 0) {
while (s[i-1]*s[i] >= 0) {
s[i]++;
count++; sum1++;
}
for (int j = i+1; j < n; j++) {
s[j] += count;
}
}
// iが偶数の場合は負にする
else {
while (s[i-1]*s[i] >= 0) {
s[i]--;
count++; sum1++;
}
for (int j = i+1; j < n; j++) {
s[j] -= count;
}
}
}
s[0] = a[0];
for (int i = 1; i < n; i++) {
s[i] = s[i-1] + a[i];
}
count = 0;
// + - + - となる場合
while (s[0] <= 0) {
s[0]++;
count++; sum2++;
}
for (int i = 1; i < n; i++) {
s[i] += count;
}
for (int i = 1; i < n; i++) {
count = 0;
if (i % 2 != 0) {
while (s[i-1]*s[i] >= 0) {
s[i]--;
count++; sum2++;
}
for (int j = i+1; j < n; j++) {
s[j] -= count;
}
}
else {
while (s[i-1]*s[i] >= 0) {
s[i]++;
count++; sum2++;
}
for (int j = i+1; j < n; j++) {
s[j] += count;
}
}
}
System.out.println(Math.min(sum1, sum2));
}
}
|
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;
const long long LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int, int>, int>;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
cout << fixed << setprecision(15);
long long N;
cin >> N;
vector<long long> A(N);
vector<long long> B(N);
long long start = 0;
bool first = true;
for (long long i = 0; i < (long long)(N); ++i) {
cin >> A[i];
if (first) {
if (A[i] != 0) {
start = i;
first = false;
}
}
if (i == 0) {
B[i] = A[i];
} else {
B[i] = A[i] + B[i - 1];
}
}
long long ans = 0;
long long total = 0;
if (A[start] > 0) {
total = -1;
if (start == 0) {
total = 0;
}
for (long long i = start; i < N; i++) {
if ((i - start) % 2 == 0) {
if (B[i] + total <= 0) {
ans += abs(B[i] + total) + 1;
total += abs(B[i] + total) + 1;
}
} else {
if (B[i] + total >= 0) {
ans += abs(B[i] + total) + 1;
total -= (abs(B[i] + total) + 1);
}
}
}
} else {
total = 1;
if (start == 0) {
total = 0;
}
for (long long i = start; i < N; i++) {
if ((i - start) % 2 == 0) {
if (B[i] + total >= 0) {
ans += abs(B[i] + total) + 1;
total -= (abs(B[i] + total) + 1);
}
} else {
if (B[i] + total <= 0) {
ans += abs(B[i] + total) + 1;
total += (abs(B[i] + total) + 1);
}
}
}
}
if (start != 0) {
ans += 2 * start - 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=list(map(int,input().split()))
sm=a[0]
ans=[0, 0]
for i in range(n-1):
sm1=sm+a[i+1]
if sm*sm1>=0:
ans[0]+=abs(sm1)+1
sm//=abs(sm)*(-1)
else:
sm=sm1
sm=-1
ans[1]+=abs(a[0])+1
for i in range(n-1):
sm1=sm+a[i+1]
if sm*sm1>=0:
ans[1]+=abs(sm1)+1
sm//=abs(sm)*(-1)
else:
sm=sm1
print(min(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 f(int a[], int N, bool positive) {
int cnt = 0;
int sum = a[0];
for (int i = 1; i < N; i++) {
int next = a[i];
int nextSum = sum + next;
if (positive) {
if (i % 2 == 0) {
if (nextSum <= 0) {
int des = abs(nextSum) + 1;
next += des;
cnt += des;
}
} else {
if (0 <= nextSum) {
int des = abs(nextSum) + 1;
next -= des;
cnt += des;
}
}
} else {
if (i % 2 == 0) {
if (0 <= nextSum) {
int des = abs(nextSum) + 1;
next -= des;
cnt += des;
}
} else {
if (nextSum <= 0) {
int des = abs(nextSum) + 1;
next += des;
cnt += des;
}
}
}
sum += next;
}
return cnt;
}
int main() {
int N;
cin >> N;
int a[N];
for (int i = 0; i < N; i++) cin >> a[i];
int cnt = min(f(a, N, 1), f(a, N, 0));
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>
long long power(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
long long mod(long long a, long long b) { return (a % b + b) % b; }
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, x;
cin >> n;
long long arr[n + 1], csum[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> x;
arr[i] = x;
}
long long ans = 0, sign;
for (long long i = 1; i <= n; i++) {
if (i == 1) {
if (arr[i] > 0)
sign = 1;
else if (arr[i] < 0)
sign = 2;
else {
if (arr[i + 1] < 0) {
arr[i] = 1;
sign = 1;
} else {
arr[i] = -1;
sign = 2;
}
ans++;
}
csum[1] = arr[1];
} else {
if (csum[i - 1] + arr[i] > 0 && sign == 1) {
x = -1 - (csum[i - 1] + arr[i]);
arr[i] = arr[i] + x;
ans += abs(x);
sign = 2;
csum[i] = -1;
continue;
} else if (csum[i - 1] + arr[i] < 0 && sign == 2) {
x = -1 + (csum[i - 1] + arr[i]);
arr[i] = arr[i] - x;
ans += abs(x);
sign = 1;
csum[i] = 1;
continue;
} else if (csum[i - 1] + arr[i] == 0) {
sign = 0;
if (i != n) {
if (arr[i + 1] > 0) {
csum[i] = -1;
arr[i]--;
ans++;
} else if (arr[i + 1] < 0) {
csum[i] = 1;
arr[i]++;
ans++;
} else {
csum[i] = 1;
arr[i]++;
ans++;
}
} else
ans++;
continue;
}
if (sign == 1)
sign = 2;
else if (sign == 2)
sign = 1;
csum[i] = csum[i - 1] + arr[i];
if (sign == 0) {
if (csum[i] > 0)
sign = 1;
else
sign = 2;
}
}
}
cout << ans << '\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 | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Hamza Hasbi
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
C_Sequence solver = new C_Sequence();
solver.solve(1, in, out);
out.close();
}
static class C_Sequence {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
long[] a = new long[n + 1];
long[] pre = new long[n + 1];
Arrays.fill(a, 0);
Arrays.fill(pre, 0);
long[] pro = new long[n + 1];
Arrays.fill(pro, 0);
long res = 0;
long ans = 0;
for (int i = 1; i <= n; i++) {
a[i] = in.nextLong();
pre[i] = pre[i - 1] + a[i];
if ((i & 1) == 1 && pre[i] <= 0) {
ans += Math.abs(1 - pre[i]);
pre[i] = 1;
continue;
}
if ((i & 1) == 0 && pre[i] > 0) {
ans += Math.abs(1 + pre[i]);
pre[i] = -1;
continue;
}
}
for (int i = 1; i <= n; i++) {
pro[i] = pro[i - 1] + a[i];
if ((i & 1) == 0 && pro[i] <= 0) {
res += Math.abs(1 - pro[i]);
pro[i] = 1;
continue;
}
if ((i & 1) == 1 && pro[i] > 0) {
res += Math.abs(1 + pro[i]);
pro[i] = -1;
continue;
}
}
out.printLine(Math.min(res, ans));
}
}
static class InputReader {
BufferedReader reader;
StringTokenizer st;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
st = null;
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String line = reader.readLine();
if (line == null) {
return null;
}
st = new StringTokenizer(line);
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void printLine(long i) {
writer.println(i);
}
public void close() {
writer.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()))
def test(total, res):
res = 0
hugou = total > 0
for i in a[1:]:
total += i
if hugou == (total>0):
res += abs(total)+1
if hugou:
total = -1
else:
total = 1
hugou = total>0
return res
res = 0
total = a[0]
if a[0]<=0:
total = 1
res += abs(a[0])+1
res1 = test(total, res)
res = 0
total = a[0]
if a[0]>=0:
total = -1
res += abs(a[0])+1
res2 = test(total, res)
print(min(res1, res2)) |
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(void) {
int n;
std::cin >> n;
std::vector<long long> a(n);
for (int i = 0; i < n; ++i) std::cin >> a[i];
int cost = 0;
std::vector<long long> s(n, 0);
s[0] = a[0];
for (int i = 1; i < n; ++i) {
s[i] = s[i - 1] + a[i];
if (s[i] * s[i - 1] < 0)
continue;
else {
if (s[i - 1] < 0) {
cost += std::abs(1 - s[i - 1] - a[i]);
a[i] = 1 - s[i - 1];
} else {
cost += std::abs(-1 - s[i - 1] - a[i]);
a[i] = -1 - s[i - 1];
}
}
s[i] = s[i - 1] + a[i];
}
std::cout << cost << 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;
const long long MOD = 1000000007LL;
const long long INF = 1LL << 60;
using vll = vector<long long>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pair<long long, long long> = pair<long long, long long>;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int nx[4] = {0, 1, -1, 0};
int ny[4] = {1, 0, 0, -1};
int main() {
long long n;
cin >> n;
vll a(n);
for (long long i = 0; i < (n); i++) cin >> a[i];
long long cu = 0;
long long k = 0;
long long ans = INF;
for (long long i = 0; i < (n); i++) {
if (i % 2 == 0) {
if (cu + a[i] < 0) {
k += abs(cu + a[i]) + 1;
cu = 1;
} else if (cu + a[i] == 0) {
cu = 1;
k++;
} else {
cu += a[i];
}
} else {
if (cu + a[i] > 0) {
k += cu + a[i] + 1;
cu = 0;
cu--;
} else if (cu + a[i] == 0) {
cu = 0;
cu--;
k++;
} else {
cu += a[i];
}
}
}
ans = min(ans, k);
k = 0;
for (long long i = 0; i < (n); i++) {
if (i % 2 == 1) {
if (cu + a[i] < 0) {
k += abs(cu + a[i]) + 1;
cu = 1;
} else if (cu + a[i] == 0) {
cu = 1;
k++;
} else {
cu += a[i];
}
} else {
if (cu + a[i] > 0) {
k += cu + a[i] + 1;
cu = 0;
cu--;
} else if (cu + a[i] == 0) {
cu = 0;
cu--;
k++;
} else {
cu += a[i];
}
}
}
ans = min(ans, k);
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 | n = gets.to_i
as = gets.split.map(&:to_i)
ans_p = 0
sum_p = as[0]
if as[0] <= 0
sum_p = 1 - as[0]
ans_p = sum_p
end
(1..n-1).each do |i|
if sum_p * (sum_p + as[i]) < 0
sum_p += as[i]
next
end
if sum_p > 0
ans_p += (-1 - (sum_p + as[i])).abs
sum_p = -1
else
ans_p += (1 - (sum_p + as[i])).abs
sum_p = 1
end
end
ans_n = 0
sum_n = as[0]
if as[0] >= 0
sum_n = 1 - as[0]
ans_n = sum_n
end
(1..n-1).each do |i|
if sum_n * (sum_n + as[i]) < 0
sum_n += as[i]
next
end
if sum_n > 0
ans_n += (-1 - (sum_n + as[i])).abs
sum_n = -1
else
ans_n += (1 - (sum_n + as[i])).abs
sum_n = 1
end
end
puts [ans_p, ans_n].min
|
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;
typedef long long ll;
template <class T>
using vec = std::vector<T>;
template <class T>
using vec2 = vec<vec<T>>;
template <class T>
using vec3 = vec<vec<vec<T>>>;
ll sub(ll n, vec<ll>& a) {
ll currentSum = a.at(0);
ll numOps = 0;
for (int i = 1; i < n; i++) {
ll nextSum = currentSum + a.at(i);
if (currentSum * nextSum < 0) {
} else {
nextSum = (currentSum > 0 ? -1 : 1);
numOps += abs(nextSum - (currentSum + a.at(i)));
}
currentSum = nextSum;
}
return numOps;
}
void solve(long long n, std::vector<long long> a) {
if (a.at(0) == 0) {
a.at(0) = 1;
ll pos = sub(n, a) + 1;
a.at(0) = -1;
ll neg = sub(n, a) + 1;
cout << min(pos, neg) << endl;
} else {
cout << sub(n, a) << endl;
}
}
int main() {
long long n;
scanf("%lld", &n);
std::vector<long long> a(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
solve(n, std::move(a));
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 = 0;
int sum = 0, ans = 0;
int hoge, foo;
int flag = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int tmp = 0;
scanf("%d", &tmp);
int foo = tmp;
if (ans + tmp < 0 && !flag) {
tmp = abs(sum) + 1;
ans += abs(sum) - abs(foo) + 1;
sum += tmp;
flag = 1;
} else if (ans + tmp > 0 && !flag) {
flag = 1;
sum += tmp;
} else if (ans + tmp < 0 && flag) {
sum += tmp;
flag = 1;
} else {
tmp = -1 * (abs(sum) + 1);
ans += abs(sum) + abs(foo) + 1;
sum += tmp;
flag = 0;
}
}
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 sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
b = a[:]
acc = 0
for i in range(n):
if i%2==0:
if acc+b[i]<=0:
b[i] += 1-(acc+b[i])
else:
if acc+b[i]>=0:
b[i] -= acc+b[i]+1
acc += b[i]
c = a[:]
acc = 0
for i in range(n):
if i%2==0:
if acc+c[i]>=0:
c[i] -= acc+c[i]+1
else:
if acc+b[i]<=0:
c[i] += 1-(acc+c[i])
acc += c[i]
ans = min(sum(abs(ai-bi) for ai, bi in zip(a, b)), sum(abs(ai-ci) for ai, ci in zip(a, c)))
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 | cpp | #include <bits/stdc++.h>
using namespace std;
static uint64_t calc_count(vector<long long> &vec, int64_t sign) {
unsigned long long count = 0;
long long total = vec[0];
if (total == 0) {
total = sign;
count++;
}
for (uint64_t i = 1; i < vec.size(); i++) {
sign *= -1;
total += vec[i];
if ((total == 0) || ((sign * total) < 0)) {
count += abs(sign - total);
total = sign;
}
}
return count;
}
int32_t main() {
uint64_t N;
cin >> N;
vector<long long> vec;
for (uint64_t i = 0; i < N; i++) {
long long val;
cin >> val;
vec.push_back(val);
}
cout << min(calc_count(vec, 1), calc_count(vec, -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 | java | import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
new Main().solve();
}
void solve() {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] a = new long[n];
long A = 0;
long ANS = 0;
long ans = 0;
long q = 1;
a[0] = sc.nextLong();
A = a[0];
for (int i = 1; i < n; i++) {
a[i] = sc.nextLong();
A += a[i];
q = q * -1;
if (A <= 0 && q == 1) {
ans += Math.abs(A - 1);
A = 1;
} else if (A >= 0 && q == -1) {
ans += Math.abs(A + 1);
A = -1;
}
}
ANS = ans;
A = 0;
ans = 0;
q = -1;
for (int i = 0; i < n; i++) {
A += a[i];
if (A <= 0 && q == 1) {
ans += Math.abs(A - 1);
A = 1;
} else if (A >= 0 && q == -1) {
ans += Math.abs(A + 1);
A = -1;
}
q = q * -1;
}
ANS = Math.min(ANS, ans);
System.out.println(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;
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 << str_sum << " " << flag << "\n";
}
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 | UNKNOWN | solve [] v acc = acc
solve as v acc
| v < 0 =
let w = v + (head as) in
if w <= 0
then solve (tail as) 1 (1 - w + acc)
else solve (tail as) w acc
| v > 0 =
let w = v + (head as) in
if w >= 0
then solve (tail as) (-1) (1 + w + acc)
else solve (tail as) w acc
-- a0は0ではないとした
main = do
n <- read <$> getLine :: IO Int
l <- getLine
let as = fmap read (words l) :: [Int] in
putStrLn (show (solve (tail as) (head as) 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;
long long a[100005], dp[100005];
cin >> n;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
dp[i] = sum;
}
long long diff = 0, ans = 0;
if (dp[0] == 0) {
if (dp[1] < 0)
diff++, ans++;
else
diff--, ans++;
}
for (int i = 1; i < n; i++) {
if (dp[i] + diff == 0) {
if (dp[i - 1] + diff < 0) diff++, ans++;
if (dp[i - 1] + diff > 0) diff--, ans++;
continue;
}
if ((dp[i - 1] + diff) / llabs(dp[i - 1] + diff) ==
(dp[i] + diff) / llabs(dp[i] + diff)) {
if (dp[i - 1] + diff < 0) {
ans += llabs(dp[i] + diff) + 1;
diff += llabs(dp[i] + diff) + 1;
} else {
ans += llabs(dp[i] + diff) + 1;
diff -= llabs(dp[i] + diff) + 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;
const long long INF = 1e9, MOD = 1e9 + 7;
const double EPS = 1e-9, PI = 3.141592653589793;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, a[100001], seq1, seq2, ans1 = 0, ans2 = 0, tmp1, tmp2;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
seq1 = a[0];
for (long long i = 1; i < n; i++) {
tmp1 = seq1;
if (seq1 > 0) {
seq1 += a[i];
if (seq1 >= 0) {
seq1 = -1;
ans1 += abs(-1 - tmp1 - a[i]);
}
} else {
tmp1 = seq1;
seq1 += a[i];
if (seq1 <= 0) {
seq1 = 1;
ans1 += (1 - tmp1 - a[i]);
}
}
}
if (a[0] > 0) a[0] = -1;
if (a[0] < 0) a[0] = 1;
seq2 = a[0];
for (long long i = 1; i < n; i++) {
tmp2 = seq2;
if (seq2 > 0) {
seq2 += a[i];
if (seq2 >= 0) {
seq2 = -1;
ans2 += abs(-1 - tmp2 - a[i]);
}
} else {
tmp2 = seq2;
seq2 += a[i];
if (seq2 <= 0) {
seq2 = 1;
ans2 += (1 - tmp2 - a[i]);
}
}
}
cout << min(ans1, ans2) << "\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 n;
vector<int> a;
vector<int> sum;
int abc059c(int sign) {
int i, ans = 0;
sum[0] = a[0];
if (sign > 0) {
for (i = 0; i < n; i++) {
if (i % 2 == 0 && sum[i] <= 0) {
ans += abs(sum[i]) + 1;
sum[i] = 1;
}
if (i % 2 == 1 && sum[i] >= 0) {
ans += abs(sum[i]) + 1;
sum[i] = -1;
}
if (i < n - 1) {
sum[i + 1] = sum[i] + a[i + 1];
}
}
} else if (sign < 0) {
for (i = 0; i < n; i++) {
if (i % 2 == 1 && sum[i] <= 0) {
ans += abs(sum[i]) + 1;
sum[i] = 1;
}
if (i % 2 == 0 && sum[i] >= 0) {
ans += abs(sum[i]) + 1;
sum[i] = -1;
}
if (i < n - 1) {
sum[i + 1] = sum[i] + a[i + 1];
}
}
} else {
exit(1);
}
return ans;
}
void solve() {
int ans = min(abc059c(1), abc059c(-1));
cout << ans << "\n";
return;
}
int main() {
int i, ans;
cin >> n;
a.resize(n);
sum.resize(n);
for (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;
cin >> n;
int count = 0;
bool plus;
int first;
cin >> first;
if (first > 0) {
plus = true;
} else if (first < 0) {
plus = false;
} else {
count++;
first++;
plus = true;
}
long sum = first;
for (int i = 0; i < n - 1; i++) {
plus = !plus;
int a;
cin >> a;
sum += a;
if (plus) {
if (sum > 0) {
continue;
} else {
count += 1 - sum;
sum = 1;
}
} else {
if (sum < 0) {
continue;
} else {
count += 1 + sum;
sum = -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 | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> List(n);
for (int i = 0; i < n; i++) {
cin >> List.at(i);
}
int cnt, Sign;
cnt = Sign = 0;
for (int i = 0; i < n; i++) {
if (Sign == 0) {
if (List.at(i) > 0) {
Sign = List.at(i);
} else if (List.at(i) < 0) {
Sign = List.at(i);
}
continue;
}
if (Sign > 0) {
while (Sign + List.at(i) >= 0) {
List.at(i)--;
cnt++;
}
Sign += List.at(i);
continue;
}
if (Sign < 0) {
while (List.at(i) + Sign <= 0) {
List.at(i)++;
cnt++;
}
Sign += List.at(i);
continue;
}
}
cout << cnt << 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 | java | import java.io.*;
import java.math.BigInteger;
public class Main implements Runnable {
static ContestScanner in;
static Writer out;
public static void main(String[] args) {
new Thread(null, new Main(), "", 16 * 1024 * 1024).start();
}
public void run() {
Main main = new Main();
try {
in = new ContestScanner();
out = new Writer();
main.solve();
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
void solve() throws IOException {
n = in.nextInt();
s = new long[n];
for (int i = 0; i < n; i++) {
s[i] = in.nextLong();
}
long left = Integer.MIN_VALUE;
long right = Integer.MAX_VALUE;
long ans = right;
while (left <= right) {
long m1 = (left * 2 + right) / 3;
long m2 = (left + right * 2) / 3;
long a1 = apply(m1);
long a2 = apply(m2);
if (a1 < a2) {
ans = Math.min(ans, a1);
right = m2 - 1;
} else {
ans = Math.min(ans, a2);
left = m1 + 1;
}
}
System.out.println(ans);
}
int n;
long[] s;
long apply(long diff) {
long ans = Math.abs(diff);
long sum = s[0] + diff;
for (int i = 1; i < n; i++) {
long a = s[i];
long target = -Long.signum(sum);
if ((a + sum) * target > 0) sum += a;
else {
ans += Math.abs(a + sum - target);
sum = target;
}
}
return ans;
}
}
class Writer extends PrintWriter{
public Writer(String filename)throws IOException
{super(new BufferedWriter(new FileWriter(filename)));}
public Writer()throws IOException {super(System.out);}
}
class ContestScanner implements Closeable {
private BufferedReader in;private int c=-2;
public ContestScanner()throws IOException
{in=new BufferedReader(new InputStreamReader(System.in));}
public ContestScanner(String filename)throws IOException
{in=new BufferedReader(new InputStreamReader(new FileInputStream(filename)));}
public String nextToken()throws IOException {
StringBuilder sb=new StringBuilder();
while((c=in.read())!=-1&&Character.isWhitespace(c));
while(c!=-1&&!Character.isWhitespace(c)){sb.append((char)c);c=in.read();}
return sb.toString();
}
public String readLine()throws IOException{
StringBuilder sb=new StringBuilder();if(c==-2)c=in.read();
while(c!=-1&&c!='\n'&&c!='\r'){sb.append((char)c);c=in.read();}
return sb.toString();
}
public long nextLong()throws IOException,NumberFormatException
{return Long.parseLong(nextToken());}
public int nextInt()throws NumberFormatException,IOException
{return(int)nextLong();}
public double nextDouble()throws NumberFormatException,IOException
{return Double.parseDouble(nextToken());}
public void close() throws IOException {in.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(int(i) for i in input().split())
b = []
for i in range(0,len(a)):
b.append(a[i])
def solve(cnt,A,N):
for i in range(1, N):
if sum(A[0:i])>0:
if sum(A[0:i+1])>=0:
r = A[i]
A[i]=-sum(A[0:i])-1
cnt+=abs(r-A[i])
else:
if sum(A[0:i+1])<=0:
r = A[i]
A[i]=-sum(A[0:i])+1
cnt+=abs(r-A[i])
return cnt
cnt1=0
if b[0]<=0:
ini=b[0]
b[0]=1
cnt1=abs(1-ini)
ans1=solve(cnt1,b,n)
cnt2=0
if a[0]>=0:
ini=a[0]
a[0]=-1
cnt2=abs(-1-ini)
ans2=solve(cnt2,a,n)
print(min(ans1,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 | python3 | def solve():
n = int(input())
a = list(map(int, input().split()))
b = [a[i] for i in range(n)]
# print(a)
# print(b)
i = 0
sum = 0
ans = 0
for i in range(n-1):
sum += a[i]
if sum > 0 and sum+a[i+1] > 0:
tmp = -1 - sum
ans += abs(tmp - a[i+1])
a[i+1] = tmp
elif sum < 0 and sum+a[i+1] < 0:
tmp = 1 - sum
ans += abs(tmp - a[i+1])
a[i+1] = tmp
# print(ans)
# print(a)
tmp_ans_1 = ans
ans = 0
sum = 0
i = 0
if b[0] > 0:
while b[0] >= 0:
b[0] -= 1
ans += 1
elif b[0] < 0:
while b[0] <= 0:
b[0] += 1
ans += 1
for i in range(n-1):
sum += b[i]
if sum > 0 and sum+b[i+1] > 0:
tmp = -1 - sum
ans += abs(tmp - b[i+1])
b[i+1] = tmp
elif sum < 0 and sum+b[i+1] < 0:
tmp = 1 - sum
ans += abs(tmp - b[i+1])
b[i+1] = tmp
# print(ans)
# print(b)
tmp_ans_2 = ans
if tmp_ans_1 <= tmp_ans_2:
ans = tmp_ans_1
elif tmp_ans_2 < tnp_ans_1:
ans = tmp_ans_2
print(ans)
if __name__ == "__main__":
solve()
|
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;
const long long LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int, int>, int>;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int main() {
cout << fixed << setprecision(15);
long long N;
cin >> N;
vector<long long> A(N);
for (long long i = 0; i < (long long)(N); ++i) {
cin >> A[i];
}
long long ans = INF;
for (long long check = 0; check < (long long)(2); ++check) {
long long temp = 0;
long long total = 0;
for (long long i = 0; i < (long long)(N); ++i) {
total += A[i];
if (i % 2 == check) {
if (total > 0)
continue;
else {
temp += abs(total - 1);
total = 1;
}
} else {
if (total < 0)
continue;
else {
temp += abs(total + 1);
total = -1;
}
}
}
ans = min(ans, temp);
}
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 = list(map(int, input().split()))
def sol(S):
ret = 0
for a in A[1:]:
b = a
if S * (S + b) > 0:
b = (abs(S) + 1) * (1 if S < 0 else -1)
if S + b == 0:
b = b - 1 if b < 0 else b + 1
ret += abs(b - a)
S += b
return ret
if A[0] == 0:
ans = min(sol(1), sol(-1)) + 1
else:
ans = min(sol(A[0]), sol(-A[0] // A[0]) + abs(A[0]) + 1)
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 | cpp | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
long long ans = INF;
for (long long i = 0; i < 2; ++i) {
long long sum = 0;
long long cnt = 0;
for (long long j = 0; j < n; ++j) {
sum += a[j];
if (j % 2 == i && sum <= 0) {
cnt += 1 - sum;
sum = 1;
} else if (j % 2 == 1 - i && sum >= 0) {
cnt += 1 + sum;
sum = -1;
}
}
ans = min(ans, cnt);
}
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;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++) cin >> a.at(i);
int t = 0, res1 = 0, res2 = 0;
for (int i = 0; i < N; i++) {
t += a.at(i);
if (i % 2 == 0) {
if (t <= 0) {
res1 += (1 - t);
t = 1;
}
} else {
if (t >= 0) {
res1 += abs(-1 - t);
t = -1;
}
}
}
t = 0;
for (int i = 0; i < N; i++) {
t += a.at(i);
if (i % 2 == 1) {
if (t <= 0) {
res2 += (1 - t);
t = 1;
}
} else {
if (t >= 0) {
res2 += abs(-1 - t);
t = -1;
}
}
}
int res = min(res1, res2);
cout << res << 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 | java | import java.util.Scanner;
public class Main {
@SuppressWarnings("resource")
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int a[]=new int[n];
for(int i=0;i<n;i++) {
a[i]=scanner.nextInt();
}
int r[]=new int[n];
r[0]=a[0];
int cnt1=0;
if(r[0]>=0) {
cnt1+=Math.abs(-1-r[0]);
r[0]=-1;
}
for(int i=1;i<n;i++) {
r[i]=r[i-1]+a[i];
if(i%2==1&&r[i]<=0) {
cnt1+=Math.abs(1-r[i]);
r[i]=1;
}
if(i%2==0&&r[i]>=0) {
cnt1+=Math.abs(-1-r[i]);
r[i]=-1;
}
}
r=new int[n];
r[0]=a[0];
int cnt2=0;
if(r[0]<=0) {
cnt2+=Math.abs(1-r[0]);
r[0]=1;
}
for(int i=1;i<n;i++) {
r[i]=r[i-1]+a[i];
if(i%2==1&&r[i]>=0) {
cnt2+=Math.abs(-1-r[i]);
r[i]=-1;
}
if(i%2==0&&r[i]<=0) {
cnt2+=Math.abs(1-r[i]);
r[i]=1;
}
}
System.out.println(Math.min(cnt1, cnt2));
}
} |
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;
static const int MOD = 10000007;
static const int MAX = 100005;
int N;
int A[MAX];
long long int S[MAX];
int change(bool pos) {
int k = -1;
long long int diff = 0, cnt = 0, counter;
if (pos) {
for (int i = (0); i < (N); i++) {
if (S[i] + diff > 0 && i % 2 == 0)
continue;
else if (S[i] + diff < 0 && i % 2 == 1)
continue;
else {
k = i;
if (k % 2 == 0) {
counter = abs(1 - (S[k] + diff));
diff += 1 - (S[k] + diff);
cnt += counter;
} else {
counter = abs((S[k] + diff) + 1);
diff += -1 - (S[k] + diff);
cnt += counter;
}
}
}
} else {
for (int i = (0); i < (N); i++) {
if (S[i] + diff > 0 && i % 2 == 1)
continue;
else if (S[i] + diff < 0 && i % 2 == 0)
continue;
else {
k = i;
if (k % 2 == 1) {
counter = abs(1 - (S[k] + diff));
diff += 1 - (S[k] + diff);
cnt += counter;
} else {
counter = abs(1 + (S[k] + diff));
diff += -1 - (S[k] + diff);
cnt += counter;
}
}
}
}
return cnt;
}
int main() {
cin >> N;
long long int sum = 0;
for (int i = (0); i < (N); i++) {
int a;
cin >> a;
A[i] = a;
sum += a;
S[i] = sum;
}
bool pos = true;
int plus, minus;
plus = change(pos);
pos = false;
minus = change(pos);
cout << min(plus, minus) << 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 n;
long long Num[111111];
long long Sum[111111];
long long Out1, Out2;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &Num[i]);
if (Num[1] == 0)
Sum[1] = 1, Out1++;
else
Sum[1] = Num[1];
for (int i = 2; i <= n; i++) {
Sum[i] = Sum[i - 1] + Num[i];
if (i % 2 == 0) {
if (Sum[i] >= 0) {
Out1 += (Sum[i] + 1);
Sum[i] = -1;
}
} else {
if (Sum[i] <= 0) {
Out1 += (1 - Sum[i]);
Sum[i] = 1;
}
}
}
memset(Sum, 0, sizeof(Sum));
if (Num[1] == 0)
Sum[1] = 1, Out2++;
else
Sum[1] = Num[1];
for (int i = 2; i <= n; i++) {
Sum[i] = Sum[i - 1] + Num[i];
if (i % 2 == 1) {
if (Sum[i] >= 0) {
Out2 += (Sum[i] + 1);
Sum[i] = -1;
}
} else {
if (Sum[i] <= 0) {
Out2 += (1 - Sum[i]);
Sum[i] = 1;
}
}
}
printf("%lld\n", min(Out1, Out2));
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()))
b = [0]*n
b[0]=a[0]
st = 0
pt = 0
m = 0
ans = 0
for i in range(1,n):
b[i]=b[i-1]+a[i]
for i in range(n):
if b[i]!=0:
st=i
break
if (st%2==0 and b[st]>0) or (st%2==1 and b[st]<0):
pt=0
else:
pt=1
if pt==0:
for i in range(n):
if i%2==0 and b[i]+m<=0:
ans+=1-b[i]-m
m+=1-b[i]-m
elif i%2==1 and b[i]+m>=0:
ans+=1+b[i]+m
m+=-1-b[i]-m
if pt==1:
for i in range(n):
if i%2==1 and b[i]+m<=0:
ans+=1-b[i]-m
m+=1-b[i]-m
elif i%2==0 and b[i]+m>=0:
ans+=1+b[i]+m
m+=-1-b[i]-m
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 | cpp | #include <bits/stdc++.h>
using namespace std;
const long long MOD = (1e+9) + 7;
const long long INF = 2e+9 + 10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
long long res = 0;
if (a[0] == 0) {
a[0]++;
res++;
}
long long sum = a[0];
bool sign = sum > 0;
for (int i = 1; i < n; i++) {
sum += a[i];
if (sign && sum >= 0) {
while (sum >= 0) {
sum--;
res++;
}
} else if (!sign && sum <= 0) {
while (sum <= 0) {
sum++;
res++;
}
}
sign = sum > 0;
}
cout << res << "\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 | UNKNOWN | #include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
long long a[n];
int i;
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
long long sum[n];
int j;
for (i = 0; i < n; i++) {
sum[i] = 0;
for (j = 0; j <= i; j++) sum[i] += a[j];
}
long long ans = 0;
for (i = 1; i < n; i++) {
if (sum[i] >= 0 && sum[i - 1] > 0) {
ans += (sum[i] + 1);
a[i] = -1 - sum[i - 1];
for (j = i + 1; j < n; j++) sum[j] -= (sum[i] + 1);
sum[i] = -1;
} else if (sum[i] <= 0 && sum[i - 1] < 0) {
ans += (-sum[i] + 1);
a[i] = (-sum[i - 1] + 1);
for (j = i + 1; j < n; j++) sum[j] += (-sum[i] + 1);
sum[i] = 1;
}
}
printf("%lld\n", 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 | python3 | n = int(input())
A = list(map(int, input().split()))
cnt = 0
chg = 0
w = A[0]
for i in range(n - 1):
nw = w + A[i + 1]
if w > 0:
if nw >= 0:
cnt += nw + 1
chg = -(nw + 1)
else:
if nw <= 0:
cnt += 1 - nw
chg = 1 - nw
w = nw + chg
chg = 0
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 = 1000000000;
const long INF64 = 1000000000000000ll;
const long long MOD = 1000000007ll;
int main() {
int n;
std::cin >> n;
std::vector<int> a(n);
for (int i = 0; i < (int)(n); i++) std::cin >> a[i];
int ans1 = 0, ans2 = 0;
int sum = 0;
int han = -1;
for (int i = 0; i < (int)(n); i++) {
han *= -1;
sum += a[i];
if (han < 0) {
ans1 += max(0, sum + 1);
sum += max(0, sum + 1);
} else {
ans1 -= min(0, sum - 1);
sum -= min(0, sum - 1);
}
}
han = 1;
sum = 0;
for (int i = 0; i < (int)(n); i++) {
han *= -1;
sum += a[i];
if (han < 0) {
ans2 += max(0, sum + 1);
sum += max(0, sum + 1);
} else {
ans2 -= min(0, sum - 1);
sum -= min(0, sum - 1);
}
}
std::cout << min(ans1, ans2) << 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;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (auto&& x : a) cin >> x;
int ans1 = 0, ans2 = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (i % 2 == 0 && sum <= 0) {
ans1 += -sum + 1;
sum = 1;
} else if (i % 2 == 1 && sum >= 0) {
ans1 += sum + 1;
sum = -1;
}
}
sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (i % 2 == 1 && sum <= 0) {
ans2 += -sum + 1;
sum = 1;
} else if (i % 2 == 0 && sum >= 0) {
ans2 += sum + 1;
sum = -1;
}
}
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())
al = list(map(int,input().split()))
import itertools
al_ac = list(itertools.accumulate(al))
ans = 0
if al_ac[0] > 0:
init = 1
else:
init = -1
fix = 0
for a in al_ac:
a += fix
if init == 1:
if a >= 1:
init *= -1
continue
else:
ans += abs(init - a)
fix += init - a
init *= -1
else:
if a <= -1:
init *= -1
continue
else:
ans += abs(init - a)
fix += init - a
init *= -1
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 | n = int(input())
a = [int(i) for i in input().split()]
b = a[:]
s1 = s2 = 0
for i in range(n):
c = sum(a[0:i+1])
if (i % 2 == 0 and c <= 0):
s1 += abs(c) + 1
a[i] += abs(c) + 1
elif(i % 2 == 1 and c >= 0):
s1 += abs(c) + 1
a[i] -= abs(c) + 1
for i in range(n):
c = sum(b[0:i+1])
if (i % 2 == 0 and c >= 0):
s2 += abs(c) + 1
b[i] -= abs(c) + 1
elif (i % 2 == 1 and c <= 0):
s2 += abs(c) + 1
b[i] += abs(c) + 1
print(min(s1,s2)) |
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 sign(x):
return (x > 0) - (x < 0)
def main():
n = int(input())
a = [int(an) for an in input().split()]
total = a[0]
if total == 0:
total -= a[1] + sign(a[1])
sign_total = sign(total)
ans = 0
for i in range(1, n):
total += a[i]
if a[i] == 0:
total += sign_total * -1
ans += 1
sign_tmp = sign(total)
if total == 0 or sign_total == sign_tmp:
val = total + sign_total
ans += val * sign_total
total -= val
sign_total *= -1
print(ans)
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() {
int N;
cin >> N;
std::vector<int> odd, even;
for (int i = 0; i < N; i++) {
int temp;
cin >> temp;
odd.push_back(temp);
}
even = odd;
int oddNum = 0, evenNum = 0;
while (odd[0] <= 0) odd[0]++, oddNum++;
int sum = odd[0];
for (int i = 1; i < N; i += 2) {
while (sum + odd[i] >= 0) odd[i]--, oddNum++;
sum += odd[i];
if (i != N - 1) {
while (sum + odd[i + 1] <= 0) odd[i + 1]++, oddNum++;
sum += odd[i + 1];
}
}
while (even[0] >= 0) even[0]--, evenNum++;
sum = even[0];
for (int i = 1; i < N; i += 2) {
while (sum + even[i] <= 0) even[i]++, evenNum++;
sum += even[i];
if (i != N - 1) {
while (sum + even[i + 1] >= 0) even[i + 1]--, evenNum++;
sum += even[i + 1];
}
}
printf("%d\n", oddNum < evenNum ? oddNum : evenNum);
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 Control.Monad
import Data.List
main=do
_<-getLine
(a:as)<-map read.words<$>getLine
print.sum.snd$ mapAccumL f a as
f a b
| a*(a+b) < 0 = (a+b,0)
| a < 0 = (1, 1-(a+b))
| otherwise = ((-1), 1+(a+b))
|
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.split.map(&:to_i)
x = A[0]
answer = 0
for i in 0..n-2
s = x + A[i+1]
if x * s >= 0
if x < 0
answer = answer - s + 1
A[i+1] = A[i+1] - s + 1
else
answer = answer + s + 1
A[i+1] = A[i+1] - s - 1
end
x = x + A[i+1]
end
end
puts answer |
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, count2;
vector<int> a, b;
cin >> n;
a.resize(n);
b.resize(n);
cin >> a[0];
for (i = 1; i < n; i++) {
cin >> a[i];
}
b = a;
count = 0;
count2 = 0;
if (a[0] == 0) {
a[0] = 1;
count = 1;
}
sum = 0;
for (int i = 0; i < n - 1; i++) {
sum += a[i];
if (sum + a[i + 1] == 0) {
count++;
if (sum > 0) {
a[i + 1]--;
} else {
a[i + 1]++;
}
}
if (sum * (sum + a[i + 1]) > 0) {
if (sum > 0) {
x = sum + 1;
s = x + a[i + 1];
a[i + 1] = -x;
count += abs(s);
} else {
x = sum - 1;
s = x + a[i + 1];
a[i + 1] = -x;
count += abs(s);
}
}
}
x = abs(b[0]) + 1;
if (b[0] >= 0) {
b[0] = -1;
} else {
b[0] = 1;
}
count2 = x;
sum = 0;
for (int i = 0; i < n - 1; i++) {
sum += b[i];
if (sum + b[i + 1] == 0) {
count2++;
if (sum > 0) {
b[i + 1]--;
} else {
b[i + 1]++;
}
}
if (sum * (sum + b[i + 1]) > 0) {
if (sum > 0) {
x = sum + 1;
s = x + b[i + 1];
b[i + 1] = -x;
count2 += abs(s);
} else {
x = sum - 1;
s = x + b[i + 1];
b[i + 1] = -x;
count2 += abs(s);
}
}
}
cout << min(count, count2);
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 ll = long long;
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);
ll ans = 0, sum = 0;
bool f = false;
for (int i = 0; i < (int)(n); i++) {
int now = a.at(i);
if (f == false) {
if (now == 0) {
if (i + 1 < n) {
if (a.at(i + 1) > 0)
sum--;
else if (a.at(i + 1) < 0)
sum++;
}
ans++;
} else {
f = true;
sum += now;
}
continue;
}
if ((sum < 0 && sum + now > 0) || (sum > 0 && sum + now < 0)) {
sum += now;
} else {
ll add = abs(sum + now) + 1;
if (sum < 0)
sum = 1;
else
sum = -1;
ans += add;
}
}
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 a[100050];
int sum[100050];
int main() {
int n;
scanf("%d", &n);
int cnt1 = 0, cnt2 = 0;
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
int lazy1 = 0, lazy2 = 0;
for (int i = 0; i < n; i++) {
int sum1 = sum[i];
sum1 += lazy1;
if (i % 2 == 0 && sum1 <= 0) {
lazy1 += 1 - sum1;
cnt1 += 1 - sum1;
}
if (i % 2 == 1 && sum1 >= 0) {
lazy1 -= 1 + sum1;
cnt1 += sum1 + 1;
}
}
for (int i = 0; i < n; i++) {
int sum2 = sum[i];
sum2 += lazy2;
if (i % 2 == 0 && sum2 >= 0) {
lazy2 -= 1 + sum2;
cnt2 += sum2 + 1;
}
if (i % 2 == 1 && sum2 <= 0) {
lazy2 += 1 - sum2;
cnt2 += 1 - sum2;
}
}
printf("%d\n", min(cnt1, cnt2));
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() {
bool ch = false;
int N;
long long ans = 0, a, count = 0;
cin >> N;
cin >> a;
ans += a;
if (ans > 0)
ch = true;
else
ch = false;
for (int i = 1; i < N; i++) {
cin >> a;
if (ch) {
if (ans + a >= 0) {
count += ans + a + 1;
ans = -1;
} else
ans += a;
ch = false;
} else {
if (ans + a <= 0) {
count += -(ans + a) + 1;
ans = 1;
} else
ans += a;
ch = true;
}
}
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;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v.at(i);
}
if (v.at(0) > 0) {
int s = 0;
int t = v.at(0);
for (int i = 1; i < n; i += 2) {
t += v.at(i);
while (t >= 0) {
t--;
s++;
}
if (i + 1 < n) {
t += v.at(i + 1);
while (t <= 0) {
t++;
s++;
}
}
}
cout << s << endl;
} else if (v.at(0) < 0) {
int s = 0;
int t = v.at(0);
for (int i = 1; i < n; i += 2) {
t += v.at(i);
while (t <= 0) {
t++;
s++;
}
if (i + 1 < n) {
t += v.at(i + 1);
while (t >= 0) {
t--;
s++;
}
}
}
cout << s << endl;
} else {
int s = 0;
int t = 1;
for (int i = 1; i < n; i += 2) {
t += v.at(i);
while (t >= 0) {
t--;
s++;
}
if (i + 1 < n) {
t += v.at(i + 1);
while (t <= 0) {
t++;
s++;
}
}
}
int u = 0;
int w = -1;
for (int i = 1; i < n; i += 2) {
w += v.at(i);
while (w <= 0) {
w++;
u++;
}
if (i + 1 < n) {
w += v.at(i + 1);
while (w >= 0) {
w--;
u++;
}
}
}
cout << min(s, u) << 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[100010];
int sign(int n) {
if (n > 0) return 1;
if (n < 0) return -1;
return 0;
}
int main(void) {
long long n;
long long res = 0;
long long si, d;
long long s = 0;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) {
if (a[i] != 0) {
si = sign(a[i]) * ((i % 2 == 0) ? 1 : -1);
break;
}
}
for (long long i = 0; i < n; i++) {
s += a[i];
if (sign(s) != si) {
d = si - s;
res += abs(d);
s += d;
}
si = -si;
}
cout << res << 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 dptemp[100010];
int s1[100010], dp[100010];
int mi = 0x3f3f3f3f, n, a, sum, pri1, pri2, all;
scanf("%d", &n);
dp[0] = 0;
for (a = 1; a <= n; a++) {
scanf("%d", &s1[a]);
dp[a] = s1[a] + dp[a - 1];
dptemp[a] = dp[a];
}
sum = 0;
all = 0;
if (dp[1] == 0) {
dp[1]++;
sum++;
all = 1;
for (a = 2; a <= n; a++) {
dp[a] += sum;
if (dp[a - 1] > 0) {
if (dp[a] >= 0) {
sum -= (dp[a] + 1);
all += (dp[a] + 1);
dp[a] = -1;
}
} else {
if (dp[a] <= 0) {
sum += (-dp[a] + 1);
all += (-dp[a] + 1);
dp[a] = 1;
}
}
}
if (all < mi) mi = all;
for (a = 1; a <= n; a++) dp[a] = dptemp[a];
dp[1]--;
sum--;
all = 1;
for (a = 2; a <= n; a++) {
dp[a] += sum;
if (dp[a - 1] > 0) {
if (dp[a] > 0) {
sum -= (dp[a] + 1);
all += (dp[a] + 1);
dp[a] = -1;
}
} else {
if (dp[a] <= 0) {
sum += (-dp[a] + 1);
all += (-dp[a] + 1);
dp[a] = 1;
}
}
}
if (all < mi) mi = all;
} else if (dp[1] > 0) {
sum = 0;
all = 0;
for (a = 1; a <= n; a++) dp[a] = dptemp[a];
for (a = 2; a <= n; a++) {
dp[a] += sum;
if (dp[a - 1] > 0) {
if (dp[a] >= 0) {
sum -= (dp[a] + 1);
all += (dp[a] + 1);
dp[a] = -1;
}
} else {
if (dp[a] <= 0) {
sum += (-dp[a] + 1);
all += (-dp[a] + 1);
dp[a] = 1;
}
}
}
if (all < mi) mi = all;
} else {
sum = 0;
all = 0;
for (a = 2; a <= n; a++) {
dp[a] += sum;
if (dp[a - 1] > 0) {
if (dp[a] > 0) {
sum -= (dp[a] + 1);
all += (dp[a] + 1);
dp[a] = -1;
}
} else {
if (dp[a] <= 0) {
sum += (-dp[a] + 1);
all += (-dp[a] + 1);
dp[a] = 1;
}
}
}
if (all < mi) mi = all;
}
printf("%d\n", mi);
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 copy
n = int(input())
a = list(map(int, input().split()))
def judge_pm(a,b):
if a*b<0:
return True
else:
return False
a1 = copy.deepcopy(a)
tmp_sum = a1[0]
operate_num1 = 0
for i in range(1, n):
if judge_pm(tmp_sum, tmp_sum+a1[i]):
pass
elif tmp_sum<0:
tmp_operate_num1 = - tmp_sum + 1 - a1[i]
operate_num1 += tmp_operate_num1
a1[i] += tmp_operate_num1
else:
tmp_operate_num1 = tmp_sum + 1 + a1[i]
operate_num1 += tmp_operate_num1
a1[i] -= tmp_operate_num1
tmp_sum += a1[i]
a2 = copy.deepcopy(a)
tmp_sum = a2[0]
operate_num2 = 0
for i in range(1, n):
if judge_pm(tmp_sum, tmp_sum+a2[i]):
pass
elif tmp_sum<0:
tmp_operate_num2 = - tmp_sum + 1 - a2[i]
operate_num2 += tmp_operate_num2
a2[i-1] -= tmp_operate_num2
tmp_sum -= tmp_operate_num2
else:
tmp_operate_num2 = tmp_sum + 1 + a2[i]
operate_num2 += tmp_operate_num2
a2[i-1] += tmp_operate_num2
tmp_sum += tmp_operate_num2
tmp_sum += a2[i]
print(min(operate_num1, operate_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 | UNKNOWN | using static System.Math;
using static System.Console;
using System.Collections.Generic;
using System.Linq;
using System;
class Program
{
#region Reader
static string ReadStr => Console.ReadLine();
static string[] ReadStrs => Console.ReadLine().Split(' ');
static int ReadInt => Convert.ToInt32(Console.ReadLine().Trim());
static int[] ReadInts => Console.ReadLine().Trim().Split(' ').Select(s => Convert.ToInt32(s)).ToArray();
static long ReadLong => Convert.ToInt64(Console.ReadLine().Trim());
static long[] ReadLongs => Console.ReadLine().Trim().Split(' ').Select(s => Convert.ToInt64(s)).ToArray();
static List<int[]> ReadPairs(int N)
{
List<int[]> ans = new List<int[]>();
for (int i = 0; i < N; i++) { ans.Add(ReadInts); }
return ans;
}
static List<long[]> ReadPairsLong(int N)
{
List<long[]> ans = new List<long[]>();
for (int i = 0; i < N; i++) { ans.Add(ReadLongs); }
return ans;
}
#endregion
#region Method
const int mod = 1000000007;
public static int Mod(int a, int mod) { return a % mod >= 0 ? a % mod : a % mod + mod; }
public static long Mod(long a, long mod = mod) { return a % mod >= 0 ? a % mod : a % mod + mod; }
bool eq<T, U>() => typeof(T).Equals(typeof(U));
T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
T cv<T>(string s) => eq<T, int>() ? ct<T, int>(int.Parse(s))
: eq<T, long>() ? ct<T, long>(long.Parse(s))
: eq<T, double>() ? ct<T, double>(double.Parse(s))
: eq<T, char>() ? ct<T, char>(s[0])
: ct<T, string>(s);
void Multi<T>(out T a) => a = cv<T>(ReadStr);
void Multi<T, U>(out (T,U) ans)
{
var ar = ReadStrs;
ans =(cv<T>(ar[0]), cv<U>(ar[1]));
}
void Multi<T, U, V>(out (T,U,V) ans)
{
var ar = ReadStrs;
ans =(cv<T>(ar[0]), cv<U>(ar[1]),cv<V>(ar[2]));
}
void Multi<T,U>(out T a,out U b)
{
var ar = ReadStrs;
a = cv<T>(ar[0]); b = cv<U>(ar[1]);
}
void Multi<T, U, V>(out T a,out U b,out V c)
{
var ar = ReadStrs;
a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
}
#endregion
public static Dictionary<int, int> PrimeFactors(int n)
{
int i = 2;
int tmp = n;
Dictionary<int, int> d = new Dictionary<int, int>();
while (i * i <= n) //※1
{
if (tmp % i == 0)
{
tmp /= i;
if (d.ContainsKey(i)) d[i]++;
else d.Add(i, 1);
}
else
{
i++;
}
}
if (tmp != 1)
{
if (d.ContainsKey(tmp)) d[tmp]++;
else d.Add(tmp, 1);
}
return d;
}
static List<long> Divisor(long N)
{
List<long> ans = new List<long>();
int max = (int)Math.Sqrt(N);
for (int i = 1; i < max; i++)
{
if (N % i == 0)
{
ans.Add(i);
ans.Add(N / i);
}
}
if (N % max == 0)
{
if (N / max == max) ans.Add(max);
else
{
ans.Add(max);
ans.Add(N / max);
}
}
return ans;
}
#region Mod
public static long GetInv(long a, long mod = 1000000007)
{
return PowerMod(a, mod - 2, mod);
}
public static long Combination(long a, long b, long mod = 1000000007)
{
if (b < 0 || b > a) return 0;
if (b > a / 2) b = a - b;
long numerator = Factorial(a, mod);
long denominator = (Factorial(b, mod) * Factorial(a - b, mod)) % mod;
return (numerator * GetInv(denominator, mod)) % mod;
}
public static long Factorial(long n, long mod = 1000000007)
{
if (n == 0) return 1;
if (n == 1) return 1;
long ans = n;
for (int i = 2; i < n; i++)
{
ans = (ans * i) % mod;
}
return ans;
}
private static long PowerMod(long a, long n, long mod = 1000000007)
{
if (n == 0) return 1;
if (n == 1) return a;
long p = PowerMod(a, n / 2, mod);
if (n % 2 == 1) return ((p * p) % mod * a) % mod;
else return (p * p) % mod;
}
#endregion
static HashSet<int> Primes(int limit)
{
bool[] done = new bool[limit+1];
var ans = new HashSet<int>();
for (int i = 2; i <= limit; i++)
{
if (done[i]) continue;
ans.Add(i);
int index = i;
while (index<=limit)
{
done[index] = true;
index += i;
}
}
return ans;
}
#region SegmentTree
/// <summary>
/// 行う演算は結合法則を満たす必要あり
/// </summary>
public class SegmentTree<T> where T : IComparable
{
/// <summary>
/// 完全二分木
/// </summary>
public T[] Data { get; }
/// <summary>
/// 完全二分木に含まれる葉の数
/// </summary>
private int LeavesCount { get; }
/// <summary>
/// 数列(問題などで与えられる)の要素数
/// </summary>
public int Count { get; }
/// <summary>
/// 葉のうち使われなかったもの、そしてQueryで引数として取得した範囲がDataのインデックスの外である場合に使う
/// </summary>
public T Default { get; }
public SegmentTree(T[] data, T def)
{
//初期値の設定
Count = data.Length;
Default = def;
LeavesCount = (int)Pow(2, Ceiling(Log(data.Length, 2)));
Data = new T[LeavesCount * 2];
//
//完全二分木の全要素を初期化
for (int i = 0; i < LeavesCount * 2; i++)
{
Data[i] = def;
}
//dataを用いて必要な要素をすべて埋める
for (int i = 0; i < data.Length; i++)
{
this[i] = data[i];
}
}
public T this[int index]
{
get
{
//取得したい要素の位置は、実際は LeavesCount-1+index となる
index = LeavesCount - 1 + index;
return Data[index];
}
set
{
//偏光したい要素の位置は、実際は LeavesCount-1+index となる
index = LeavesCount - 1 + index;
//子を変更
Data[index] = value;
//親たちも含めて、要素を変更
while (index > 0)
{
//indexを親のインデックスに更新
index = GetParentIndex(index);
//要素を更新
Data[index] = DecideNewElementFromTwoChildren(index);
}
}
}
/// <summary>
/// 唯一の親のインデックスを返す
/// </summary>
/// <param name="childIndex"></param>
/// <returns></returns>
private int GetParentIndex(int childIndex)
{
return (childIndex - 1) / 2;
}
/// <summary>
/// 二つの子のインデックスを返す
/// </summary>
/// <param name="parentIndex"></param>
/// <returns>小さいほうはl、大きいほうはr</returns>
private (int l, int r) GetChildIndexes(int parentIndex)
{
return (2 * parentIndex + 1, 2 * parentIndex + 2);
}
/// <summary>
/// 親の値を二つの子から決定する
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private T DecideNewElementFromTwoChildren(int index)
{
var children = GetChildIndexes(index);
return Select(Data[children.l], Data[children.r]);
}
/// <summary>
/// [a,b)の範囲で回答を探す
/// </summary>
/// <param name="a"></param>
/// <param name="halfOpen_b"></param>
/// <returns></returns>
public T Query(int a, int halfOpen_b)
{
return _Query(a, halfOpen_b, 0, LeavesCount, 0);
}
private T _Query(int a, int b, int l, int r, int current)
{
//Φ
if (a >= r || b <= l)
{
return Default;
}
//部分集合
else if (a <= l && b >= r)
{
return Data[current];
}
//一部
else
{
//(1) 範囲[l,r)を分割し、子lの回答と子rの回答を取得
//(2) 二つの回答を比べて、適切(Selectメソッド)な方を返す
//(1)
var children = GetChildIndexes(current);
T t1 = _Query(a, b, l, (l + r) / 2, children.l);
T t2 = _Query(a, b, (l + r) / 2, r, children.r);
//(2)
return Select(t1, t2);
}
}
/// <summary>
/// カスタマイズするところ。二つの子の値から、親の値を決定する方法を定める。
/// </summary>
/// <param name="t1">子の値1</param>
/// <param name="t2">子の値2</param>
/// <returns></returns>
private T Select(T t1, T t2)
{
return t1.CompareTo(t2) < 0 ? t2 : t1;
}
}
#endregion
static void Main()
{
int N = ReadInt;
int[] As = ReadInts;
if (As[0] != 0)
{
long sum = As[0];
long cost = 0;
for (int i = 1; i < N; i++)
{
if (sum * (sum + As[i]) < 0)
{
sum += As[i];
continue;
}
if (sum < 0)
{
cost += Abs(sum * -1 + 1 - As[i]);
sum = 1;
}
else
{
cost += Abs(sum * -1 - 1 - As[i]);
sum = -1;
}
}
WriteLine(cost);
}
else
{
long sum1 = 1;
long cost1 = 1;
for (int i = 1; i < N; i++)
{
if (sum1 * (sum1 + As[i]) < 0)
{
sum1 += As[i];
continue;
}
if (sum1 < 0)
{
cost1 += Abs(sum1 * -1 + 1 - As[i]);
sum1 = 1;
}
else
{
cost1 += Abs(sum1 * -1 - 1 - As[i]);
sum1 = -1;
}
}
long sum2 = -1;
long cost2 = 1;
for (int i = 1; i < N; i++)
{
if (sum2 * (sum2 + As[i]) < 0)
{
sum2 += As[i];
continue;
}
if (sum2 < 0)
{
cost2 += Abs(sum2 * -1 + 1 - As[i]);
sum2 = 1;
}
else
{
cost2 += Abs(sum2 * -1 - 1 - As[i]);
sum2 = -1;
}
}
WriteLine(Min(cost1,cost2));
}
}
}
|
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 | # vim: fileencoding=utf-8
def main():
n = int(input())
a = list(map(int, input().split()))
ans = 0
cursol = a[0]
for i in a[1:]:
t = cursol + i
if cursol > 0:
if t >= 0:
ans += t + 1
cursol = -1
else:
cursol = t
elif cursol < 0:
if t <= 0:
ans += abs(t) + 1
cursol = 1
else:
cursol = t
print(ans)
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], b[n];
cin >> a[0];
b[0] = a[0];
for (long long i = 1; i < n; i++) {
cin >> a[i];
b[i] = b[i - 1] + a[i];
}
if (count(a, a + n, 0) == n) {
cout << 2 * n - 1 << endl;
return 0;
}
long long sgn = 1;
long long ans = 0;
long long shift = 0;
for (long long i = 0; i < n; i++) {
if ((b[i] + shift) * sgn <= 0) {
ans += abs(b[i] + shift) + 1;
shift += -(b[i] + shift) + (b[i] + shift == 0 ? sgn : -b[i] / abs(b[i]));
}
sgn *= -1;
}
sgn = -1;
shift = 0;
long long ans2 = 0;
for (long long i = 0; i < n; i++) {
if ((b[i] + shift) * sgn <= 0) {
ans2 += abs(b[i] + shift) + 1;
shift += -(b[i] + shift) + (b[i] + shift == 0 ? sgn : -b[i] / abs(b[i]));
}
sgn *= -1;
}
cout << min(ans, 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;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long cnt = 0ll;
long long ans = 0ll;
long long p = -1ll;
if (a[0] > 0ll) p = 1ll;
for (int i = 0; i < n; ++i) {
cnt += a[i];
if (cnt * p <= 0ll) {
long long g = cnt * -1ll + p;
ans += (g * p);
cnt = cnt + g;
}
p *= -1ll;
}
cout << (ans) << "\n";
}
|
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 main() {
int n;
scanf("%d", &n);
int i;
int a[100005];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int ans[2];
int sb, sa;
if (a[0] <= 0) {
ans[0] = 1 - a[0];
sb = 1;
} else {
ans[0] = 0;
sb = a[0];
}
for (i = 1; i < n; i++) {
sa = sb + a[i];
if (i % 2 == 1) {
if (sa >= 0) {
ans[0] += sa + 1;
sa = -1;
}
} else {
if (sa <= 0) {
ans[0] += 1 - sa;
sa = 1;
}
}
sb = sa;
}
if (a[0] >= 0) {
ans[1] = a[0] + 1;
sb = -1;
} else {
ans[1] = 0;
sb = a[0];
}
for (i = 1; i < n; i++) {
sa = sb + a[i];
if (i % 2 == 0) {
if (sa >= 0) {
ans[1] += sa + 1;
sa = -1;
}
} else {
if (sa <= 0) {
ans[1] += 1 - sa;
sa = 1;
}
}
sb = sa;
}
if (ans[0] < ans[1])
printf("%d\n", ans[0]);
else
printf("%d\n", ans[1]);
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 | use std::io::*;
use std::str::FromStr;
use std::collections::HashMap;
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use std::collections::HashSet;
use std::cmp;
use std::f64::consts;
use std::cmp::Ordering;
use std::collections::VecDeque; //push_back, pop_front
fn main() {
let n: i64 = read();
let mut vec: Vec<i64> = (0..n).map(|_| read()).collect();
let mut count1 = 0;
// 偶数indexが+の場合
let mut sum = 0;
for (i, &e) in vec.iter().enumerate() {
sum += e;
if i % 2 == 0 {
if sum < 0 {
count1 += (1-sum).abs();
sum += (1-sum).abs();
}
} else {
if sum >= 0 {
count1 += (-1-sum).abs();
sum -= (-1-sum).abs();
}
}
}
if sum == 0 {
count1+=1;
}
let mut count2 = 0;
// 奇数indexが+の場合
let mut sum = 0;
for (i, &e) in vec.iter().enumerate() {
sum += e;
if i % 2 == 0 {
if sum >= 0 {
count2 += (-1-sum).abs();
sum -= (-1-sum).abs();
}
} else {
if sum < 0 {
count2 += (1-sum).abs();
sum += (1-sum).abs();
}
}
}
if sum == 0 {
count2+=1;
}
println!("{}", cmp::min(count1, count2));
}
fn calc_distance(xa: f64, ya: f64, xb: f64, yb: f64)->f64 {
(f64::powf(xb-xa, 2.0) + f64::powf(yb-ya, 2.0)).sqrt()
}
fn calc_triangle_area(x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64) -> f64 {
1.0/2.0 * ((x1-x3)*(y2-y3)-(x2-x3)*(y1-y3)).abs()
}
fn read<T: FromStr>() -> T {
let stdin = stdin();
let stdin = stdin.lock();
let token: String = stdin
.bytes()
.map(|c| c.expect("failed to read char") as char)
.skip_while(|c| c.is_whitespace())
.take_while(|c| !c.is_whitespace())
.collect();
token.parse().ok().expect("failed to parse token")
}
// 最大公約数
fn gcd(a: i64, b: i64) -> i64 {
match b {
0 => a,
_ => gcd(b, a % b)
}
}
// 最小公倍数
fn lcm(a: i64, b: i64) -> i64 {
let g = gcd(a ,b);
a / g * b
}
// 階乗-dp (overflow回避で1000000007の余りを使って計算)
fn kaijou_dp(n: i64) -> i64 {
let mut dp: Vec<i64> = vec![0; n as usize+1];
dp[0] = 1;
dp[1] = 1;
for i in 1..n {
dp[i as usize+1] = dp[i as usize] % 1000000007 * (i+1) % 1000000007;
}
return dp[n as usize];
}
// 階乗
fn kaijou(n: i64)->i64 {
if n == 1 {
return n;
}
return n * kaijou(n-1);
}
// 順列全列挙
pub trait LexicalPermutation {
/// Return `true` if the slice was permuted, `false` if it is already
/// at the last ordered permutation.
fn next_permutation(&mut self) -> bool;
}
impl<T> LexicalPermutation for [T] where T: Ord {
/// Original author in Rust: Thomas Backman <[email protected]>
/// let mut data = [1, 2, 3];
// let mut permutations = Vec::new();
//
// loop {
// permutations.push(data.to_vec());
// if !data.next_permutation() {
// break;
// }
// }
//
// println!("{:?}", permutations);
// // [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
fn next_permutation(&mut self) -> bool {
// These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; }
// Step 1: Identify the longest, rightmost weakly decreasing part of the vector
let mut i = self.len() - 1;
while i > 0 && self[i-1] >= self[i] {
i -= 1;
}
// If that is the entire vector, this is the last-ordered permutation.
if i == 0 {
return false;
}
// Step 2: Find the rightmost element larger than the pivot (i-1)
let mut j = self.len() - 1;
while j >= i && self[j] <= self[i-1] {
j -= 1;
}
// Step 3: Swap that element with the pivot
self.swap(j, i-1);
// Step 4: Reverse the (previously) weakly decreasing part
self[i..].reverse();
true
}
}
//iより小さい数字の数 = lower_bound(&a, i) as i64;
//iより大きい数字の数 = n - upper_bound(&c, i) as i64;
fn lower_bound<T: Ord>(vec: &Vec<T>, x: T) -> usize {
let (mut left, mut right): (i64, i64) = (-1, vec.len() as i64);
while (right - left) > 1 {
let mid = (right + left) / 2;
if x <= vec[mid as usize] {
right = mid;
} else {
left = mid;
}
}
return right as usize;
}
fn upper_bound<T: Ord>(vec: &Vec<T>, x: T) -> usize {
let (mut left, mut right): (i64, i64) = (-1, vec.len() as i64);
while (right - left) > 1 {
let mid = (right + left) / 2;
if x < vec[mid as usize] {
right = mid;
} else {
left = mid;
}
}
return right as usize;
}
|
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.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
public class Main implements Runnable { // クラス名はMain1
PrintWriter out = new PrintWriter(System.out);
InputReader sc = new InputReader(System.in);
public static void main(String[] args) {
Thread.setDefaultUncaughtExceptionHandler((t, e) -> System.exit(1));
new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); // 16MBスタックを確保して実行
}
public void run() {
try {
int N = sc.nextInt();
long[] A = new long[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextLong();
}
long[] wa = new long[N + 1];
for (int i = 1; i <= N; i++) {
wa[i] += wa[i - 1] + A[i - 1];
}
//out.println("A:" + Arrays.toString(A));
//out.println("W:" + Arrays.toString(wa));
boolean plus = wa[1] >= 0 ? true : false;
long cntp = 0;
long cntm = 0;
for (int i = 1; i <= N; i++) {
wa[i] += cntp - cntm;
if (plus && wa[i] >= 0) {
long p = Math.abs(wa[i]) + 1;
cntm += p;
wa[i] -= p;
A[i - 1] -= p;
} else if (!plus && wa[i] <= 0) {
long m = Math.abs(wa[i]) + 1;
cntp += m;
wa[i] += m;
A[i - 1] += m;
}
plus = !plus;
}
//out.println("A:" + Arrays.toString(A));
//out.println("W:" + Arrays.toString(wa));
out.println(cntp + cntm);
} catch (ArithmeticException ae) {
//ae.printStackTrace();
throw new RuntimeException();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException();
} finally {
out.flush();
out.close();
}
}
// 高速なScanner
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
|
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<long> an(n);
for (int i = 0; i < n; ++i) {
cin >> an[i];
}
auto get_sign = [](int x) { return x >= 0 ? 1 : -1; };
int cnt_min = INT_MAX;
for (int j = -1; j < 1; ++j) {
int sign = get_sign(j);
long accum = an[0];
int cnt = 0;
if (accum * sign <= 0) {
auto x = sign - accum;
accum += x;
cnt += abs(x);
}
for (int i = 1; i < n; ++i) {
auto new_accum = accum + an[i];
int new_sign = -sign;
if (new_accum * get_sign(accum) >= 0) {
int x = new_sign - new_accum;
new_accum += x;
cnt += abs(x);
}
accum = new_accum;
sign = new_sign;
}
if (cnt < cnt_min) {
cnt_min = cnt;
}
}
cout << cnt_min << 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
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
a = input().split()
a = list(map(lambda x: x.capitalize(), a))
a,b,c = a
print(a[0]+b[0]+c[0])
return
#B
def B():
a = II()
b = II()
if a > b:
print("GREATER")
if a < b:
print("LESS")
if a == b:
print("EQUAL")
return
#C
def C():
II()
a = LI()
def f(suma, b):
for i in a[1:]:
if suma * (suma + i) < 0:
suma += i
continue
b += abs(suma + i) + 1
suma = -1 * (suma > 0) or 1
return b
if a[0] == 0:
ans = min(f(1, 1), f(-1, 1))
else:
ans = min(f(a[0], 0), f(-a[0], 2 * abs(a[0])))
print(ans)
return
#D
def D():
s = S()
for i in range(len(s) - 1):
if s[i] == s[i+1]:
print(i + 1, i + 2)
return
for i in range(len(s) - 2):
if s[i] == s[i + 2]:
print(i + 1, i + 3)
return
print(-1, -1)
return
#Solve
if __name__ == '__main__':
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 | python3 | n = int(input())
A = [item for item in list(map(int, input().split()))]
S = [A[0]]
for i in range(1, n):
S.append(A[i]+S[i-1])
count = 0
if S[0] == 0:
A[0] += 1
for item in S:
item += 1
count += 1
#print(S)
for i in range(1, n):
#print(S[i-1], S[i])
if S[i] * S[i-1] >= 0:
dif = -1 * (S[i-1]//abs(S[i-1])) - S[i]
A[i] += dif
for j in range(i,n):
S[j] += dif
count += abs(dif)
#print(S)
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;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = (0); i < (n); i++) cin >> a[i];
ll ans = 0;
int sum_prev = a[0];
if (sum_prev == 0) {
if (a[1] >= 0)
sum_prev = -1;
else
sum_prev = 1;
ans = 1;
}
for (int i = (1); i < (n); i++) {
int sum_now = sum_prev + a[i];
if (sum_prev * sum_now >= 0) {
ans += abs(sum_now) + 1;
sum_now = -1 * int(sum_prev > 0);
}
sum_prev = sum_now;
}
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;
using vpii = vector<pair<int, int>>;
using vpll = vector<pair<ll, ll>>;
int main(void) {
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) cin >> A[i];
ll ans = 0;
ll cur = A[0];
if (cur == 0) {
ans++;
int i = 1;
while (A[i] == 0 && i < N) i++;
if (i == N)
cur++;
else if (A[i] > 0 && i % 2 == 0)
cur++;
else if (A[i] > 0 && i % 2 == 1)
cur--;
else if (A[i] < 0 && i % 2 == 0)
cur--;
else
cur++;
}
for (int i = 1; i < N; i++) {
if (cur > 0 && cur + A[i] >= 0) {
ans += abs(-1 - (cur + A[i]));
cur = -1;
} else if (cur < 0 && cur + A[i] <= 0) {
ans += abs(1 - (cur + A[i]));
cur = 1;
} else
cur += A[i];
}
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;
int main() {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long sum = 0;
long long res1 = 0;
long long res2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (sum + a[i] > 0) {
sum += a[i];
} else {
res1 = res1 + 1 - sum;
sum = 1;
}
} else {
if (sum + a[i] < 0) {
sum += a[i];
} else {
res1 = res1 + sum + 1;
sum = -1;
}
}
}
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (sum + a[i] < 0) {
} else {
res2 = res2 + 1 + sum;
sum = -1;
}
} else {
if (sum + a[i] > 0) {
sum += a[i];
} else {
res2 = res2 + 1 - sum;
sum = 1;
}
}
}
cout << min(res1, res2) << 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())
p=list(map(int,input().split()))
p2=[i for i in p]
stack=[0]*(n+1)
ans=0
if p[0]<=0:
ans+=1-p[0]
p[0]=1
stack[1]=1
else:
stack[1]=p[0]
for i in range(1,n):
if i%2==1:
if p[i]+p[i-1]+stack[i-1]>=0:
ans+=(p[i]+p[i-1]+stack[i-1])+1
p[i]-=(p[i]+p[i-1]+stack[i-1])+1
else:
if p[i]+p[i-1]+stack[i-1]<=0:
ans+=-(p[i]+p[i-1]+stack[i-1])+1
p[i]+=-(p[i]+p[i-1]+stack[i-1])+1
stack[i+1]=p[i]+p[i-1]+stack[i-1]
stack=[0]*(n+1)
ans2=0
if p2[0]>=0:
ans2+=p2[0]+1
p[0]=-1
stack[1]=-1
else:
stack[1]=p2[0]
for i in range(1,n):
if i%2==0:
if p2[i]+p2[i-1]+stack[i-1]>=0:
ans2+=(p2[i]+p2[i-1]+stack[i-1])+1
p2[i]-=(p2[i]+p2[i-1]+stack[i-1])+1
else:
if p2[i]+p2[i-1]+stack[i-1]<=0:
ans2+=-(p2[i]+p2[i-1]+stack[i-1])+1
p2[i]+=-(p2[i]+p2[i-1]+stack[i-1])+1
stack[i+1]=p2[i]+p2[i-1]+stack[i-1]
print(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 | python3 | N = int(input())
A = tuple(map(int, input().split(" ")))
m = 0
c = 0
for i in range(N):
if i%2 == 0:
m += A[i]
while m <= 0:
m += 1
c += 1
else:
m += A[i]
while m >= 0:
m -= 1
c += 1
o = 0
d = 0
for i in range(N):
if i%2 == 1:
o += A[i]
while o <= 0:
o += 1
d += 1
else:
o += A[i]
while o >= 0:
o -= 1
d += 1
print(min(c, d)) |
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;
signed main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < (long long)n; ++i) cin >> a[i];
long long ans1 = 0, ans2 = 0;
{
long long sum = 0;
vector<long long> b = a;
for (long long i = 0; i < (long long)n; ++i) {
if (sum <= 0 and sum + b[i] <= 0) {
ans1 += abs(b[i] - (1 - sum));
b[i] = 1 - sum;
} else if (sum > 0 and sum + b[i] >= 0) {
ans1 += abs(b[i] - (-sum - 1));
b[i] = -sum - 1;
}
sum += b[i];
}
}
if (a[0] == 0) {
return 1;
}
{
long long sum = 0;
vector<long long> b = a;
for (long long i = 0; i < (long long)n; ++i) {
if (sum < 0 and sum + b[i] <= 0) {
ans2 += abs(b[i] - (1 - sum));
b[i] = 1 - sum;
} else if (sum >= 0 and sum + b[i] >= 0) {
ans2 += abs(b[i] - (-sum - 1));
b[i] = -sum - 1;
}
sum += b[i];
}
}
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;
int main() {
int n;
scanf("%d", &n);
vector<int> a;
for (int i = 0; i < n; i++) {
int an;
scanf("%d", &an);
a.push_back(an);
}
int op_count = 0;
int now_sum = 0;
if (a[0] == 0) {
a[0] = 1;
op_count++;
}
int adding = a[0] > 0 ? -1 : 1;
for (int i = 0; i < n; i++) {
now_sum += a[i];
adding *= -1;
if (now_sum == 0) {
a[i] += adding;
now_sum += adding;
op_count++;
continue;
}
if (adding > 0) {
const int last = 1 - now_sum;
if (last > 1) {
a[i] += last;
now_sum += last;
op_count += abs(last);
}
} else {
const int last = -1 - now_sum;
if (last < -1) {
a[i] += last;
now_sum += last;
op_count += abs(last);
}
}
}
printf("%d\n", op_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 | cpp | #include <bits/stdc++.h>
using namespace std;
int n;
int a[100001];
int b[100001];
long long s[100001];
long long ans = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
s[0] = a[0];
if (s[0] == 0) {
a[0] = 1;
s[0] = 1;
ans = 1;
for (int i = 0; i < n - 1; i++) {
int m = s[i] + a[i + 1];
if (s[i] * m >= 0) {
if (s[i] < 0) {
s[i + 1] = 1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans += (a[i + 1] - t);
} else if (s[i] > 0) {
s[i + 1] = -1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans += (t - a[i + 1]);
}
}
}
long long ans2 = 1;
a[0] = -1;
s[0] = -1;
for (int i = 0; i < n - 1; i++) {
int m = s[i] + a[i + 1];
if (s[i] * m >= 0) {
if (s[i] < 0) {
s[i + 1] = 1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans2 += (a[i + 1] - t);
} else if (s[i] > 0) {
s[i + 1] = -1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans2 += (t - a[i + 1]);
}
}
}
cout << min(ans, ans2) << endl;
return 0;
} else {
for (int i = 0; i < n - 1; i++) {
int m = s[i] + a[i + 1];
if (s[i] * m >= 0) {
if (s[i] < 0) {
s[i + 1] = 1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans += (a[i + 1] - t);
} else if (s[i] > 0) {
s[i + 1] = -1;
int t = a[i + 1];
a[i + 1] = s[i + 1] - s[i];
ans += (t - a[i + 1]);
}
} else {
s[i + 1] = s[i] + a[i + 1];
}
}
}
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;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
long long sum1 = 0, num1 = 0;
for (int i = 0; i < n; i++) {
int tmp = a[i];
if (sum1 > 0 && sum1 + tmp >= 0) {
num1 += sum1 + tmp + 1;
tmp -= sum1 + tmp + 1;
} else if (sum1 < 0 && sum1 + tmp <= 0) {
num1 += abs(sum1 + tmp) + 1;
tmp += abs(sum1 + tmp) + 1;
}
sum1 += tmp;
}
long long sum2, num2 = 0;
if (a[0] > 0) {
sum2 = -1;
num2 += a[0] + 1;
} else {
sum2 = 1;
num2 += abs(a[0]) + 1;
}
for (int i = 1; i < n; i++) {
int tmp = a[i];
if (sum2 > 0 && sum2 + tmp >= 0) {
num2 += sum2 + tmp + 1;
tmp -= sum2 + tmp + 1;
} else if (sum2 < 0 && sum2 + tmp <= 0) {
num2 += abs(sum2 + tmp) + 1;
tmp += abs(sum2 + tmp) + 1;
}
sum2 += tmp;
}
cout << min(num1, num2) << 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 d[n];
for(int i=0;i<n;i++) cin >> d[i];
int count=0;
int sum=d[0];
int f =0;
if(d[0]>0){
f=-1;
}
if(d[0]<0){
f=1;
}
for(int i=1;i<n;i++){
sum+=d[i];
if(sum>0){
if(f==1) {
f=-1;
continue;
}
if(f==-1){
count+=sum+1;
sum=-1;
f=1;
continue;
}
if(sum<0){
if(f==-1){
f=1;
continue;
}
if(f==1){
count+=1-sum;
sum=1;
f=-1;
continue;
}
}
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 | java | import java.util.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
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 x = 0;
int Sx = 0;
for(int i=0; i<n; i++){
if(i%2==0){
if(Sx+a[i]<=0){
x += Math.abs(Sx + a[i]) + 1;
Sx = 1;
}
else{
Sx += a[i];
}
}
else{
if(Sx+a[i]>=0){
x += Math.abs(Sx + a[i]) + 1;
Sx = -1;
}
else{
Sx += a[i];
}
}
}
int y = 0;
int Sy = 0;
for(int i=0; i<n; i++){
if(i%2==0){
if(Sy+a[i]>=0){
y += Math.abs(Sy + a[i]) + 1;
Sy = -1;
}
else{
Sy += a[i];
}
}
else{
if(Sy+a[i]<=0){
y += Math.abs(Sy + a[i]) + 1;
Sy = 1;
}
else{
Sy += a[i];
}
}
}
System.out.println(Math.min(x, y));
}
} |
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;
vector<long long> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
long long ans1 = 0;
if (a[0] < 0) {
a[0] = 1;
ans1 += abs(a[0] - 1);
}
long long sum = a[0];
for (int i = 0; i < n - 1; i++) {
sum = sum + a[i + 1];
if (i % 2 == 0 && sum > 0) {
ans1 += abs(sum + 1);
sum = -1;
} else if (i % 2 != 0 && sum < 0) {
ans1 += abs(sum - 1);
sum = 1;
}
}
cout << ans1;
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()))
Cost = lambda a, Sum:0 if (Sum > 0) ^ (Sum + a > 0) else abs(Sum + a) + 1
Sum = lambda a, preSum:preSum+a if (preSum > 0) ^ (preSum + a > 0) else -preSum//abs(preSum)
pSum = Sum(A[0],0)
nSum = Sum(A[0],0)
pCost = 0
nCost = 0
for a in A[1:]:
pCost += Cost(a, pSum)
pSum = Sum(a, pSum)
nCost += Cost(a, nSum)
nSum = Sum(a, nSum)
print(min(pCost, nCost))
|
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;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long LLINF = 1LL << 60;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int i, n, sum = 0, ans = 0, minans;
cin >> n;
vector<int> v(n, 0), w(n, 0);
for (i = 0; i < n; i++) {
cin >> v[i];
}
sum = v[0];
w[0] = v[0];
for (i = 1; i < n; i++) {
if ((sum < 0 && sum + v[i] > 0) || (sum > 0 && sum + v[i] < 0)) {
w[i] = v[i];
sum += w[i];
continue;
}
if (sum < 0) {
ans += abs(-1 * sum + 1 - v[i]);
w[i] = -1 * sum + 1;
sum += w[i];
if (sum == 0) {
w[i]++;
sum++;
}
} else {
ans += abs(-1 * sum - 1 - v[i]);
w[i] = -1 * sum - 1;
sum += w[i];
if (sum == 0) {
w[i]--;
sum--;
}
}
}
minans = ans;
ans = 0;
w.clear();
sum = -1 * v[0];
w[0] = -1 * v[0];
for (i = 1; i < n; i++) {
if (sum < 0) {
ans += abs(-1 * sum + 1 - v[i]);
w[i] = -1 * sum + 1;
sum += w[i];
if (sum == 0) {
w[i]++;
sum++;
}
} else {
ans += abs(-1 * sum - 1 - v[i]);
w[i] = -1 * sum - 1;
sum += w[i];
if (sum == 0) {
w[i]--;
sum--;
}
}
}
minans = min(ans, minans);
cout << minans << 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<ll> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
ll sump = 0;
ll ansp = 0;
ll summ = 0;
ll ansm = 0;
for (int i = 0; i < N; i++) {
sump += A.at(i);
if (i % 2 == 0 && sump <= 0) {
ansp += -sump + 1;
sump = 1;
}
if (i % 2 == 1 && sump >= 0) {
ansp += sump + 1;
sump = -1;
}
}
for (int i = 0; i < N; i++) {
summ += A.at(i);
if (i % 2 == 1 && summ <= 0) {
ansm += -summ + 1;
summ = 1;
}
if (i % 2 == 0 && summ >= 0) {
ansm += summ + 1;
summ = -1;
}
}
cout << ansp << "-" << ansm << endl;
cout << min(ansp, ansm) << 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 | object Main {
def main(args: Array[String]): Unit = {
solve2
}
def solve2(): Unit = {
val sc = new java.util.Scanner(System.in)
val n = sc.nextInt
sc.nextLine
val a = sc.nextLine.split(" ").map(_.toInt).toList
var sum = 0L
var opeCount1 = 0L
// 正、負、正、負（偶数インデックスが正）とする
for (i <- 0 until n) {
sum = sum + a(i)
if (i % 2 == 0) {
if (sum <= 0) {
opeCount1 += -sum + 1
sum = 1
}
} else {
if (sum > 0) {
opeCount1 += sum + 1
sum = -1
}
}
}
sum = 0L
var opeCount2 = 0L
// 負、正、負、正（奇数インデックスが正）とする
for (i <- 0 until n) {
sum = sum + a(i)
if (i % 2 != 0) {
if (sum <= 0) {
opeCount2 += -sum + 1
sum = 1
}
} else {
if (sum > 0) {
opeCount2 += sum + 1
sum = -1
}
}
}
println(math.min(opeCount1, opeCount2))
}
def solve(): Unit = {
val sc = new java.util.Scanner(System.in)
val n = sc.nextInt
sc.nextLine
val a = sc.nextLine.split(" ").map(_.toInt).toList
var prevSum = a(0)
var opeCount = 0
for (i <- 1 until n) {
val currSum = prevSum + a(i)
if (prevSum < 0 && currSum < 0) {
opeCount += math.abs(currSum) + 1
prevSum = 1
} else if (prevSum > 0 && currSum > 0) {
opeCount += math.abs(currSum) + 1
prevSum = -1
} else {
if (currSum == 0) {
opeCount += 1
if (prevSum < 0) {
prevSum = 1
} else {
prevSum = -1
}
} else {
prevSum = prevSum + a(i)
}
}
}
println(opeCount)
}
}
|
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;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T1, class T2>
ostream& operator<<(ostream& s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T>
ostream& operator<<(ostream& s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T>
ostream& operator<<(ostream& s, vector<vector<T> > P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class T>
ostream& operator<<(ostream& s, set<T> P) {
for (__typeof__((P).begin()) it = (P).begin(); it != (P).end(); ++it) {
s << "<" << *it << "> ";
}
return s << endl;
}
template <class T1, class T2>
ostream& operator<<(ostream& s, map<T1, T2> P) {
for (__typeof__((P).begin()) it = (P).begin(); it != (P).end(); ++it) {
s << "<" << it->first << "->" << it->second << "> ";
}
return s << endl;
}
int main() {
long long n;
long long a[100010];
vector<long long> v;
vector<long long> w;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long sum = 0;
long long cnt = 0;
if (a[0] != 0) {
v.push_back(sum = a[0]);
for (int i = 1; i < n; i++) {
sum += a[i];
v.push_back(sum);
if (v[i] == 0 && v[i - 1] > 0) {
v[i] = -1;
sum = -1;
cnt++;
}
if (v[i] == 0 && v[i - 1] < 0) {
v[i] = +1;
sum = 1;
cnt++;
}
if (v[i - 1] > 0 && v[i] > 0) {
cnt += v[i] + 1;
v[i] = -1;
sum = -1;
}
if (v[i - 1] < 0 && v[i] < 0) {
cnt += 1 - v[i];
v[i] = 1;
sum = 1;
}
}
cout << cnt << endl;
} else {
long long cnt1 = 1, cnt2 = 1;
v.push_back(-1);
sum = 1;
for (int i = 1; i < n; i++) {
sum += a[i];
v.push_back(sum);
if (v[i] == 0 && v[i - 1] > 0) {
v[i] = -1;
sum = -1;
cnt1++;
}
if (v[i] == 0 && v[i - 1] < 0) {
v[i] = 1;
sum = 1;
cnt1++;
}
if (v[i - 1] > 0 && v[i] > 0) {
cnt1 += v[i] + 1;
v[i] = -1;
sum = -1;
}
if (v[i - 1] < 0 && v[i] < 0) {
cnt1 += 1 - v[i];
v[i] = 1;
sum = 1;
}
}
w.push_back(1);
sum = 1;
for (int i = 1; i < n; i++) {
sum += a[i];
w.push_back(sum);
if (w[i] == 0 && w[i - 1] > 0) {
w[i] = -1;
sum = -1;
cnt2++;
}
if (w[i] == 0 && w[i - 1] < 0) {
w[i] = 1;
sum = 1;
cnt2++;
}
if (w[i - 1] > 0 && w[i] > 0) {
cnt2 += w[i] + 1;
w[i] = -1;
sum = -1;
}
if (w[i - 1] < 0 && w[i] < 0) {
cnt2 += 1 - w[i];
w[i] = 1;
sum = 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 | python3 | import numpy as np
N = int(input())
a_s = input().split()
for i in range(N):
a_s[i] = int(a_s[i])
a_s = np.array(a_s)
def get_sign(x):
if x>0:
return +1
elif x<0:
return -1
else:
return 0
ans = 0
S0 = None
for i,a in enumerate(a_s):
if i==0:
S = a
if S == 0:
ans += 1
S = get_sign(a_s[i+1])*(-1)
else:
S = S0 + a
if get_sign(S0) == get_sign(S):
ans += abs(get_sign(S)*(-1) - S)
S = get_sign(S)*(-1)
elif get_sign(S)==0:
ans += 1
S = get_sign(S0)*(-1)
S0 = S
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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Hamza Hasbi
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
C_Sequence solver = new C_Sequence();
solver.solve(1, in, out);
out.close();
}
static class C_Sequence {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
long[] a = new long[n + 1];
long[] pre = new long[n + 1];
Arrays.fill(a, 0);
Arrays.fill(pre, 0);
boolean f = true;
long ans = 0;
for (int i = 1; i <= n; i++) {
a[i] = in.nextLong();
pre[i] = pre[i - 1] + a[i];
if (pre[i] == 0) {
if (pre[i - 1] > 0) pre[i]--;
else pre[i]++;
ans++;
continue;
}
if (pre[i - 1] > 0 && pre[i] > 0) {
pre[i] -= a[i];
long curr = -1 * pre[i - 1] - 1;
ans += Math.abs(a[i] - curr);
pre[i] = pre[i - 1] + curr;
continue;
}
if (pre[i - 1] < 0 && pre[i] < 0) {
pre[i] -= a[i];
long curr = pre[i - 1] + 1;
ans += Math.abs(a[i] - curr);
pre[i] = pre[i - 1] + curr;
}
}
out.printLine(ans);
}
}
static class InputReader {
BufferedReader reader;
StringTokenizer st;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
st = null;
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String line = reader.readLine();
if (line == null) {
return null;
}
st = new StringTokenizer(line);
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void printLine(long i) {
writer.println(i);
}
public void close() {
writer.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 | UNKNOWN | using System;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using static System.Console;
using static System.Math;
namespace AtCorder
{
public class Program
{
public static void Main(string[] args)
{
new Program().Solve(new ConsoleInput(Console.In, ' '));
}
public void Solve(ConsoleInput cin)
{
var n = cin.ReadInt;
var a = cin.ReadLongArray(n);
var ans = 0L;
for(int i = 1; i < n; i++)
{
var pre = (long)a.Take(i).Sum();
var now = (long)a.Take(i + 1).Sum();
if(pre * now < 0)
{
continue;
}
if(now > 0)
{
ans += a[i] + (pre + 1);
a[i] = -1 * (pre + 1);
}
else
{
ans += -1 * (pre - 1) - a[i];
a[i] = -1 * (pre - 1);
}
}
WriteLine(ans);
}
public long C(int X, int Y)
{
if (Y == 0 || Y == X)
{
return 1;
}
if (X < Y)
{
return 0;
}
var Pascal = new long[X + 1, X + 1];
for (int i = 0; i <= X; i++)
{
Pascal[i, 0] = 1L;
Pascal[i, i] = 1L;
}
for (int i = 2; i <= X; i++)
{
for (int j = 1; j < i; j++)
{
Pascal[i, j] = Pascal[i - 1, j] + Pascal[i - 1, j - 1];
}
}
return Pascal[X, Y];
}
public class ConsoleInput
{
private readonly System.IO.TextReader _stream;
private char _separator = ' ';
private Queue<string> inputStream;
public ConsoleInput(System.IO.TextReader stream, char separator = ' ')
{
this._separator = separator;
this._stream = stream;
inputStream = new Queue<string>();
}
public string Read
{
get
{
if (inputStream.Count != 0) return inputStream.Dequeue();
string[] tmp = _stream.ReadLine().Split(_separator);
for (int i = 0; i < tmp.Length; ++i)
inputStream.Enqueue(tmp[i]);
return inputStream.Dequeue();
}
}
public string ReadLine { get { return _stream.ReadLine(); } }
public int ReadInt { get { return int.Parse(Read); } }
public long ReadLong { get { return long.Parse(Read); } }
public double ReadDouble { get { return double.Parse(Read); } }
public string[] ReadStrArray(long N) { var ret = new string[N]; for (long i = 0; i < N; ++i) ret[i] = Read; return ret; }
public int[] ReadIntArray(long N) { var ret = new int[N]; for (long i = 0; i < N; ++i) ret[i] = ReadInt; return ret; }
public long[] ReadLongArray(long N) { var ret = new long[N]; for (long i = 0; i < N; ++i) ret[i] = ReadLong; return ret; }
}
}
}
|
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 int ans1, ans2, sum1, sum2;
int n, i;
long long int a[100005];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
if (a[1] >= 0) {
sum1 = a[1];
ans2 = a[1] + 1;
sum2 = -1;
} else {
sum1 = 1;
ans1 = abs(a[1]) + 1;
sum2 = a[1];
}
for (i = 2; i <= n; i++) {
if (sum1 > 0) {
if (a[i] + sum1 >= 0) {
ans1 += a[i] + sum1 + 1;
sum1 = -1;
} else {
sum1 += a[i];
}
} else {
if (a[i] + sum1 <= 0) {
ans1 += abs(sum1 + a[i]) + 1;
sum1 = 1;
} else {
sum1 += a[i];
}
}
}
if (sum1 == 0) {
ans1++;
}
for (i = 2; i <= n; i++) {
if (sum2 > 0) {
if (a[i] + sum2 >= 0) {
ans2 += a[i] + sum2 + 1;
sum2 = -1;
} else {
sum2 += a[i];
}
} else {
if (a[i] + sum2 <= 0) {
ans2 += abs(sum2 + a[i]) + 1;
sum2 = 1;
} else
sum2 += a[i];
}
}
if (sum2 == 0) {
ans2++;
}
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 | python3 | # https://atcoder.jp/contests/abc059/tasks/arc072_a
# C - Sequence
import copy
N = int(input().split()[0])
a_list = list(map(int, input().split()))
w_list_1 = copy.copy(a_list)
w_list_2 = copy.copy(a_list)
c_1, c_2 = 0, 0
c_list = []
for i in range(N): # 10 ** 5
# 偶数項を正にする場合
s_1 = sum(w_list_1[:i+1])
if i % 2 == 0 and s_1 < 0:
w_list_1[i] += abs(s_1)
c_1 += abs(s_1)
elif i % 2 != 0 and s_1 >= 0:
w_list_1[i] -= abs(s_1+1)
c_1 += abs(s_1+1)
s_1 = sum(w_list_1[:i+1])
if s_1 == 0:
a = w_list_1[i]
w_list_1[i] = a + 1 if a >= 0 else a - 1
c_1 += 1
# 偶数項を負にする場合
s_2 = sum(w_list_2[:i+1])
if i % 2 == 1 and s_2 < 0:
w_list_2[i] += abs(s_2)
c_2 += abs(s_2)
elif i % 2 != 1 and s_2 >= 0:
w_list_2[i] -= abs(s_2+1)
c_2 += abs(s_2+1)
s_2 = sum(w_list_2[:i+1])
if s_2 == 0:
a = w_list_2[i]
w_list_2[i] = a + 1 if a >= 0 else a - 1
c_2 += 1
ans = min([c_1, c_2])
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 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) cin >> A[i];
ll ret = A[0] > 0 ? 0 : abs(A[0]) + 1;
ll sum = A[0] > 0 ? A[0] : 1;
for (int i = 1; i < N; i++) {
ll after = sum + A[i];
if (after * sum < 0) {
sum = after;
} else {
ret += abs(after) + 1;
if (sum > 0)
sum = -1;
else
sum = 1;
}
}
ll ret2 = A[0] < 0 ? 0 : A[0] + 1;
ll sum2 = A[0] < 0 ? 0 : -1;
for (int i = 1; i < N; i++) {
ll after = sum + A[i];
if (after * sum < 0) {
sum = after;
} else {
ret += abs(after) + 1;
if (sum > 0)
sum = -1;
else
sum = 1;
}
}
cout << min(ret, ret2) << 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()))
k = 0
s = a[0]
for i in range(1, n):
if s < 0:
s += a[i]
if s <= 0:
k += 1 - s
s = 1
elif s > 0:
s += a[i]
if s >= 0:
k += 1 + s
s = -1
else:
print("okashi")
print(k) |
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 GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
long long n, cnt = 0;
long long A[100010];
long long solve(int i, bool target, long long prev) {
long long a = A[i] + prev;
long long diff = 0;
if ((a > 0) != target) {
if (target == 1) {
diff = 1 - a;
} else {
diff = -1 - a;
}
cnt += abs(diff);
}
return diff;
}
int main() {
GLL(n);
for (int i = 0; i < (int)(n); i++) GLL(A[i]);
for (int i = 0; i < (int)(n - 1); i++) A[i + 1] += A[i];
long long diff = 0;
bool sign = 1;
for (int i = 0; i < (int)(n); i++) {
diff += solve(i, sign, diff);
sign ^= 1;
}
long long ans1 = cnt;
cnt = 0;
diff = 0;
sign = 0;
for (int i = 0; i < (int)(n); i++) {
diff += solve(i, sign, diff);
sign ^= 1;
}
long long ans2 = cnt;
printf("%lld\n", min(ans1, ans2));
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.