id
stringlengths 22
25
| content
stringlengths 327
628k
| max_stars_repo_path
stringlengths 49
49
|
|---|---|---|
condefects-java_data_101 | import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
public class Main {
static class Element {
int value;
char source; // 'A' or 'B'
Element(int value, char source) {
this.value = value;
this.source = source;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
List<Element> numbers = new ArrayList<>();
for(int i = 0; i < a; i++) numbers.add(new Element(sc.nextInt(), 'A'));
for(int i = 0; i < b; i++) numbers.add(new Element(sc.nextInt(), 'B'));
numbers = numbers.stream().sorted(Comparator.comparingInt(e -> e.value)).toList();
boolean twoConsecutive = false;
int counter = 1;
while(!twoConsecutive && counter < numbers.size()){
if(numbers.get(counter - 1).source == numbers.get(counter).source) twoConsecutive = true;
counter++;
}
System.out.println(twoConsecutive ? "Yes" : "No");
}
}
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
public class Main {
static class Element {
int value;
char source; // 'A' or 'B'
Element(int value, char source) {
this.value = value;
this.source = source;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
List<Element> numbers = new ArrayList<>();
for(int i = 0; i < a; i++) numbers.add(new Element(sc.nextInt(), 'A'));
for(int i = 0; i < b; i++) numbers.add(new Element(sc.nextInt(), 'B'));
numbers = numbers.stream().sorted(Comparator.comparingInt(e -> e.value)).toList();
boolean twoConsecutive = false;
int counter = 1;
while(!twoConsecutive && counter < numbers.size()){
if(numbers.get(counter - 1).source == 'A' && numbers.get(counter).source == 'A') twoConsecutive = true;
counter++;
}
System.out.println(twoConsecutive ? "Yes" : "No");
}
}
| ConDefects/ConDefects/Code/abc355_b/Java/54222226 |
condefects-java_data_102 | import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<Integer> listA = new ArrayList<>();
ArrayList<Integer> listB = new ArrayList<>();
for (int i = 0; i < N; i++) {
listA.add(sc.nextInt());
}
for (int i = 0; i < M; i++) {
listB.add(sc.nextInt());
}
ArrayList<Integer> combinedList = new ArrayList<>(listA);
combinedList.addAll(listB);
Collections.sort(combinedList);
for (int i = 0; i < combinedList.size() - 1; i++) {
if (listA.contains(combinedList.get(i)) && listA.contains(combinedList.get(i + 1))) {
System.out.println("Yes");
break;
}
}
System.out.println("No");
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<Integer> listA = new ArrayList<>();
ArrayList<Integer> listB = new ArrayList<>();
for (int i = 0; i < N; i++) {
listA.add(sc.nextInt());
}
for (int i = 0; i < M; i++) {
listB.add(sc.nextInt());
}
ArrayList<Integer> combinedList = new ArrayList<>(listA);
combinedList.addAll(listB);
Collections.sort(combinedList);
for (int i = 0; i < combinedList.size() - 1; i++) {
if (listA.contains(combinedList.get(i)) && listA.contains(combinedList.get(i + 1))) {
System.out.println("Yes");
return;
}
}
System.out.println("No");
}
}
}
| ConDefects/ConDefects/Code/abc355_b/Java/54257485 |
condefects-java_data_103 | import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(final String[] args) {
try (final Scanner sc = new Scanner(System.in)) {
int N = Integer.parseInt(sc.next());
final int X = Integer.parseInt(sc.next());
final int[] A = new int[N];
final int[] B = new int[N];
for (int i = 0; i < N; i++) {
final int tempA = Integer.parseInt(sc.next());
if (tempA > X) {
N--;
continue;
}
A[i] = tempA;
B[i] = Integer.parseInt(sc.next());
}
final HashSet<Integer> makableAmountSet = new HashSet<>();
for (int i = 0; i < N; i++) {
@SuppressWarnings("unchecked")
final Set<Integer> tempMakableAmountSet = (Set<Integer>) makableAmountSet.clone();
for (final Integer makableAmount : tempMakableAmountSet) {
for (int j = 1; j <= B[i]; j++) {
makableAmountSet.add(makableAmount + A[i] * j);
if (makableAmountSet.contains(X)) {
System.out.println("Yes");
return;
}
}
}
for (int j = 1; j <= B[i]; j++) {
makableAmountSet.add(A[i] * j);
if (makableAmountSet.contains(X)) {
System.out.println("Yes");
return;
}
}
}
System.out.println("No");
}
}
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(final String[] args) {
try (final Scanner sc = new Scanner(System.in)) {
int N = Integer.parseInt(sc.next());
final int X = Integer.parseInt(sc.next());
final int[] A = new int[N];
final int[] B = new int[N];
for (int i = 0; i < N; i++) {
final int tempA = Integer.parseInt(sc.next());
if (tempA > X) {
N--;
sc.next();
continue;
}
A[i] = tempA;
B[i] = Integer.parseInt(sc.next());
}
final HashSet<Integer> makableAmountSet = new HashSet<>();
for (int i = 0; i < N; i++) {
@SuppressWarnings("unchecked")
final Set<Integer> tempMakableAmountSet = (Set<Integer>) makableAmountSet.clone();
for (final Integer makableAmount : tempMakableAmountSet) {
for (int j = 1; j <= B[i]; j++) {
makableAmountSet.add(makableAmount + A[i] * j);
if (makableAmountSet.contains(X)) {
System.out.println("Yes");
return;
}
}
}
for (int j = 1; j <= B[i]; j++) {
makableAmountSet.add(A[i] * j);
if (makableAmountSet.contains(X)) {
System.out.println("Yes");
return;
}
}
//System.out.println(makableAmountSet);
}
System.out.println("No");
}
}
}
| ConDefects/ConDefects/Code/abc286_d/Java/44680159 |
condefects-java_data_104 | import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt()+1; // TODO this is +1
int m = sc.nextInt();
ArrayList<int[]>[] neighbours = new ArrayList[n];
for(int i=1; i<n; i++) {
neighbours[i] = new ArrayList<>();
}
int[] starter = new int[3];
int smallestCurrent = Integer.MAX_VALUE;
for(int i=0; i<m; i++) {
int first = sc.nextInt();
int second = sc.nextInt();
int weight = sc.nextInt();
int[] edge3 = new int[]{first, second, weight}; // maybe double is goofy
neighbours[first].add(edge3);
neighbours[second].add(edge3);
if(weight<smallestCurrent) {
smallestCurrent = weight;
starter = edge3;
}
}
// we start with the smallest edge and then we greedily make it bigger
// therefore always adding the new edges and searching the one with smallest weight
// this is PriortiyHeap
PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
int[] colors = new int[n]; // this represents coloring 0 not colored -1 blue 1 red
long[] distance = new long[n]; // has the shortest distance to the next
int from[] = new int[n];
colors[starter[0]] = 1;
colors[starter[1]] = -1;
distance[starter[0]] = starter[2];
from[starter[0]] = starter[1];
distance[starter[1]] = starter[2];
from[starter[1]] = starter[0];
queue.addAll(neighbours[starter[0]]);
queue.addAll(neighbours[starter[1]]);
long result = Long.MAX_VALUE;
while(!queue.isEmpty()) {
int[] nextEdge = queue.poll();
int first = nextEdge[0];
int second = nextEdge[1];
int weight = nextEdge[2];
if(colors[first] == 0) {
colors[first] = -colors[second];
distance[first] = weight;
from[first] = second;
result = Long.min(result, weight+distance[second]);
if(weight < distance[second]) {
distance[second] = weight;
}
queue.addAll(neighbours[first]);
continue;
}
if(colors[second] == 0) {
colors[second] = -colors[first];
distance[second] = weight;
from[second] = first;
result = Long.min(result, weight+distance[first]);
if(weight < distance[first]) {
distance[first] = weight;
}
queue.addAll(neighbours[second]);
continue;
}
if(colors[second] != colors[first]) {
if(from[first] != second) {
result = Long.min(result, weight+distance[first]);
}
if(from[second] != first) {
result = Long.min(result, weight+distance[second]);
}
continue;
}
// now we have the problem
// so we have to paint them the same way
result = Long.min(result, weight);
}
System.out.println(result);
}
}
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt()+1; // TODO this is +1
int m = sc.nextInt();
ArrayList<int[]>[] neighbours = new ArrayList[n];
for(int i=1; i<n; i++) {
neighbours[i] = new ArrayList<>();
}
int[] starter = new int[3];
int smallestCurrent = Integer.MAX_VALUE;
for(int i=0; i<m; i++) {
int first = sc.nextInt();
int second = sc.nextInt();
int weight = sc.nextInt();
int[] edge3 = new int[]{first, second, weight}; // maybe double is goofy
neighbours[first].add(edge3);
neighbours[second].add(edge3);
if(weight<smallestCurrent) {
smallestCurrent = weight;
starter = edge3;
}
}
// we start with the smallest edge and then we greedily make it bigger
// therefore always adding the new edges and searching the one with smallest weight
// this is PriortiyHeap
PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
int[] colors = new int[n]; // this represents coloring 0 not colored -1 blue 1 red
long[] distance = new long[n]; // has the shortest distance to the next
int from[] = new int[n];
colors[starter[0]] = 1;
colors[starter[1]] = -1;
distance[starter[0]] = starter[2];
from[starter[0]] = starter[1];
distance[starter[1]] = starter[2];
from[starter[1]] = starter[0];
queue.addAll(neighbours[starter[0]]);
queue.addAll(neighbours[starter[1]]);
long result = Long.MAX_VALUE;
while(!queue.isEmpty()) {
int[] nextEdge = queue.poll();
int first = nextEdge[0];
int second = nextEdge[1];
int weight = nextEdge[2];
if(colors[first] == 0) {
colors[first] = -colors[second];
distance[first] = weight;
from[first] = second;
result = Long.min(result, weight+distance[second]);
if(weight < distance[second]) {
distance[second] = weight;
from[second] = first;
}
queue.addAll(neighbours[first]);
continue;
}
if(colors[second] == 0) {
colors[second] = -colors[first];
distance[second] = weight;
from[second] = first;
result = Long.min(result, weight+distance[first]);
if(weight < distance[first]) {
distance[first] = weight;
from[first] = second;
}
queue.addAll(neighbours[second]);
continue;
}
if(colors[second] != colors[first]) {
if(from[first] != second) {
result = Long.min(result, weight+distance[first]);
}
if(from[second] != first) {
result = Long.min(result, weight+distance[second]);
}
continue;
}
// now we have the problem
// so we have to paint them the same way
result = Long.min(result, weight);
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/arc165_c/Java/45681652 |
condefects-java_data_105 | import java.io.*;
import java.util.*;
public class Main {
private static final int INF = 1000000000;
public static void main(String[] args) {
InputReader reader = new InputReader(System.in);
PrintWriter writer = new PrintWriter(System.out, false);
int N = reader.nextInt();
int M = reader.nextInt();
int[][] dist = new int[N][N];
for (int i = 0; i < N; i++) {
Arrays.fill(dist[i], INF);
dist[i][i] = 0;
}
for (int i = 0; i < M; i++) {
int u = reader.nextInt() - 1;
int v = reader.nextInt() - 1;
int w = reader.nextInt();
dist[u][v] = w;
}
for (int k = 0; k < N; k++) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
int[][] dp = new int[(1 << N)][N];
for (int[] row : dp) Arrays.fill(row, INF);
for (int i = 0; i < N; i++) {
dp[(1 << i)][i] = 0;
}
for (int mask = 0; mask < (1 << N); mask++) {
for (int i = 0; i < N; i++) {
if ((mask & (1 << i)) != 0) {
for (int j = 0; j < N; j++) {
if ((mask & (1 << j)) != 0) {
dp[mask][i] = Math.min(dp[mask][i], dp[mask ^ (1 << i)][j] + dist[i][j]);
}
}
}
}
}
int result = INF;
for (int i = 0; i < N; i++) {
result = Math.min(result, dp[(1 << N) - 1][i]);
}
writer.println(result == INF ? "No" : result);
writer.close();
System.exit(0);
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
String str = "";
try {
str = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
import java.io.*;
import java.util.*;
public class Main {
private static final int INF = 1000000000;
public static void main(String[] args) {
InputReader reader = new InputReader(System.in);
PrintWriter writer = new PrintWriter(System.out, false);
int N = reader.nextInt();
int M = reader.nextInt();
int[][] dist = new int[N][N];
for (int i = 0; i < N; i++) {
Arrays.fill(dist[i], INF);
dist[i][i] = 0;
}
for (int i = 0; i < M; i++) {
int u = reader.nextInt() - 1;
int v = reader.nextInt() - 1;
int w = reader.nextInt();
dist[u][v] = w;
}
for (int k = 0; k < N; k++) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (dist[i][k] == INF || dist[k][j] == INF) continue;
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
int[][] dp = new int[(1 << N)][N];
for (int[] row : dp) Arrays.fill(row, INF);
for (int i = 0; i < N; i++) {
dp[(1 << i)][i] = 0;
}
for (int mask = 0; mask < (1 << N); mask++) {
for (int i = 0; i < N; i++) {
if ((mask & (1 << i)) != 0) {
for (int j = 0; j < N; j++) {
if ((mask & (1 << j)) != 0) {
if (dp[mask ^ (1 << i)][j] == INF || dist[i][j] == INF) continue;
dp[mask][i] = Math.min(dp[mask][i], dp[mask ^ (1 << i)][j] + dist[i][j]);
}
}
}
}
}
int result = INF;
for (int i = 0; i < N; i++) {
result = Math.min(result, dp[(1 << N) - 1][i]);
}
writer.println(result == INF ? "No" : result);
writer.close();
System.exit(0);
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
String str = "";
try {
str = reader.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} | ConDefects/ConDefects/Code/abc338_f/Java/49743455 |
condefects-java_data_106 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int m = Integer.parseInt(sa[1]);
int inf = 1000000000;
int[][] d = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
d[i][j] = inf;
}
}
}
for (int i = 0; i < m; i++) {
sa = br.readLine().split(" ");
int a = Integer.parseInt(sa[0]) - 1;
int b = Integer.parseInt(sa[1]) - 1;
int c = Integer.parseInt(sa[2]);
d[a][b] = c;
}
br.close();
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d[i][k] != inf && d[k][j] != inf) {
d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
long inf2 = 10000000000000000L;
int n2 = 1 << n;
long[][] dp = new long[n2][n];
for (int i = 0; i < n2; i++) {
Arrays.fill(dp[i], inf2);
}
for (int i = 0; i < n; i++) {
dp[1 << i][i] = 0;
}
for (int i = 1; i < n2; i++) {
for (int j = 0; j < n; j++) {
if ((i >> j & 1) == 1) {
for (int j2 = 0; j2 < n; j2++) {
int i2 = i | (1 << j2);
if (i2 != i && d[j][j2] != inf) {
dp[i2][j2] = Math.min(dp[i2][j2] , dp[i][j] + d[j][j2]);
}
}
}
}
}
long ans = inf2;
int n21 = n2 - 1;
for (int i = 0; i < n; i++) {
ans = Math.min(ans, dp[n21][i]);
}
if (ans == inf2) {
System.out.println("No");
} else {
System.out.println(ans);
}
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int m = Integer.parseInt(sa[1]);
int inf = 1000000000;
int[][] d = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
d[i][j] = inf;
}
}
}
for (int i = 0; i < m; i++) {
sa = br.readLine().split(" ");
int a = Integer.parseInt(sa[0]) - 1;
int b = Integer.parseInt(sa[1]) - 1;
int c = Integer.parseInt(sa[2]);
d[a][b] = c;
}
br.close();
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d[i][k] != inf && d[k][j] != inf) {
d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
long inf2 = 10000000000000000L;
int n2 = 1 << n;
long[][] dp = new long[n2][n];
for (int i = 0; i < n2; i++) {
Arrays.fill(dp[i], inf2);
}
for (int i = 0; i < n; i++) {
dp[1 << i][i] = 0;
}
for (int i = 1; i < n2; i++) {
for (int j = 0; j < n; j++) {
if ((i >> j & 1) == 1 && dp[i][j] != inf2) {
for (int j2 = 0; j2 < n; j2++) {
int i2 = i | (1 << j2);
if (i2 != i && d[j][j2] != inf) {
dp[i2][j2] = Math.min(dp[i2][j2] , dp[i][j] + d[j][j2]);
}
}
}
}
}
long ans = inf2;
int n21 = n2 - 1;
for (int i = 0; i < n; i++) {
ans = Math.min(ans, dp[n21][i]);
}
if (ans == inf2) {
System.out.println("No");
} else {
System.out.println(ans);
}
}
}
| ConDefects/ConDefects/Code/abc338_f/Java/49744782 |
condefects-java_data_107 | import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void main(String[] args) throws Exception {
new Solution().SOLVE();
}
}
class Solution {
Read sc = new Read();
public void SOLVE() throws IOException {
int T = 1;
while (T-- > 0) {
solve();
}
sc.bw.flush();
sc.bw.close();
}
void solve() throws IOException{
int n = sc.nextInt();
int m = sc.nextInt();
int inf = 0x3f3f3f3f;
long[][] e = new long[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(e[i], inf);
}
for (int i = 0; i < m; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
long w = sc.nextLong();
e[u][v] = Math.min(e[u][v], w);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
e[j][k] = Math.min(e[j][k], e[j][i] + e[i][k]);
}
}
}
long[][] dp = new long[n][1 << n];
for (int i = 0; i < n; i++) {
Arrays.fill(dp[i], inf);
dp[i][1 << i] = 0;
}
// for (int i = 0; i < 1 << n; i++) {
// for (int j = 0; j < n; j++) {
// if ((i >> j & 1) == 0) continue;
// for (int k = 0; k < n; k++) {
// dp[k][i | (1 << k)] = Math.min(dp[k][i | 1 << k], dp[j][i] + e[j][k]);
// }
// }
// }
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if ((i >> j & 1) == 0) continue;
for (int k = 0; k < n; k++) {
if (((i >> k) & 1) == 0 || k == j) continue;
dp[j][i] = Math.min(dp[j][i], dp[k][i ^ (1 << j)] + e[k][j]);
}
}
}
long ans = inf;
for (int i = 0; i < n; i++) {
ans = Math.min(ans, dp[i][(1 << n) - 1]);
}
sc.println((ans != inf) ? (ans + "") : "No");
}
private int gcd (int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
class Pair<P1, P2> {
P1 a; P2 b;
public Pair(P1 a, P2 b) {
this.a = a; this.b = b;
}
}
class Read{
BufferedReader bf;
StringTokenizer st;
BufferedWriter bw;
public Read(){
bf=new BufferedReader(new InputStreamReader(System.in));
st=new StringTokenizer("");
bw=new BufferedWriter(new OutputStreamWriter(System.out));
}
public String nextLine() throws IOException{
return bf.readLine();
}
public String next() throws IOException{
while(!st.hasMoreTokens()){
st=new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public char nextChar() throws IOException{
//确定下一个token只有一个字符的时候再用
return next().charAt(0);
}
public int nextInt() throws IOException{
return Integer.parseInt(next());
}
public long nextLong() throws IOException{
return Long.parseLong(next());
}
public double nextDouble() throws IOException{
return Double.parseDouble(next());
}
public float nextFloat() throws IOException{
return Float.parseFloat(next());
}
public byte nextByte() throws IOException{
return Byte.parseByte(next());
}
public short nextShort() throws IOException{
return Short.parseShort(next());
}
public BigInteger nextBigInteger() throws IOException{
return new BigInteger(next());
}
public void println() throws IOException {
bw.newLine();
}
public void println(int[] arr) throws IOException{
for (int value : arr) {
bw.write(value + " ");
}
println();
}
public void println(int l, int r, int[] arr) throws IOException{
for (int i = l; i <= r; i ++) {
bw.write(arr[i] + " ");
}
println();
}
public void println(int a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(int a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(String a) throws IOException{
bw.write(a);
bw.newLine();
}
public void print(String a) throws IOException{
bw.write(a);
}
public void println(long a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(long a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(double a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(double a) throws IOException{
bw.write(String.valueOf(a));
}
public void print(char a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(char a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
}
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void main(String[] args) throws Exception {
new Solution().SOLVE();
}
}
class Solution {
Read sc = new Read();
public void SOLVE() throws IOException {
int T = 1;
while (T-- > 0) {
solve();
}
sc.bw.flush();
sc.bw.close();
}
void solve() throws IOException{
int n = sc.nextInt();
int m = sc.nextInt();
int inf = 0x3f3f3f3f;
long[][] e = new long[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(e[i], inf);
}
for (int i = 0; i < m; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
long w = sc.nextLong();
e[u][v] = Math.min(e[u][v], w);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
e[j][k] = Math.min(e[j][k], e[j][i] + e[i][k]);
}
}
}
long[][] dp = new long[n][1 << n];
for (int i = 0; i < n; i++) {
Arrays.fill(dp[i], inf);
dp[i][1 << i] = 0;
}
// for (int i = 0; i < 1 << n; i++) {
// for (int j = 0; j < n; j++) {
// if ((i >> j & 1) == 0) continue;
// for (int k = 0; k < n; k++) {
// dp[k][i | (1 << k)] = Math.min(dp[k][i | 1 << k], dp[j][i] + e[j][k]);
// }
// }
// }
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if ((i >> j & 1) == 0) continue;
for (int k = 0; k < n; k++) {
if (((i >> k) & 1) == 0 || k == j) continue;
dp[j][i] = Math.min(dp[j][i], dp[k][i ^ (1 << j)] + e[k][j]);
}
}
}
long ans = inf;
for (int i = 0; i < n; i++) {
ans = Math.min(ans, dp[i][(1 << n) - 1]);
}
sc.println((ans < inf / 2) ? (ans + "") : "No");
}
private int gcd (int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
class Pair<P1, P2> {
P1 a; P2 b;
public Pair(P1 a, P2 b) {
this.a = a; this.b = b;
}
}
class Read{
BufferedReader bf;
StringTokenizer st;
BufferedWriter bw;
public Read(){
bf=new BufferedReader(new InputStreamReader(System.in));
st=new StringTokenizer("");
bw=new BufferedWriter(new OutputStreamWriter(System.out));
}
public String nextLine() throws IOException{
return bf.readLine();
}
public String next() throws IOException{
while(!st.hasMoreTokens()){
st=new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public char nextChar() throws IOException{
//确定下一个token只有一个字符的时候再用
return next().charAt(0);
}
public int nextInt() throws IOException{
return Integer.parseInt(next());
}
public long nextLong() throws IOException{
return Long.parseLong(next());
}
public double nextDouble() throws IOException{
return Double.parseDouble(next());
}
public float nextFloat() throws IOException{
return Float.parseFloat(next());
}
public byte nextByte() throws IOException{
return Byte.parseByte(next());
}
public short nextShort() throws IOException{
return Short.parseShort(next());
}
public BigInteger nextBigInteger() throws IOException{
return new BigInteger(next());
}
public void println() throws IOException {
bw.newLine();
}
public void println(int[] arr) throws IOException{
for (int value : arr) {
bw.write(value + " ");
}
println();
}
public void println(int l, int r, int[] arr) throws IOException{
for (int i = l; i <= r; i ++) {
bw.write(arr[i] + " ");
}
println();
}
public void println(int a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(int a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(String a) throws IOException{
bw.write(a);
bw.newLine();
}
public void print(String a) throws IOException{
bw.write(a);
}
public void println(long a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(long a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(double a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
public void print(double a) throws IOException{
bw.write(String.valueOf(a));
}
public void print(char a) throws IOException{
bw.write(String.valueOf(a));
}
public void println(char a) throws IOException{
bw.write(String.valueOf(a));
bw.newLine();
}
}
| ConDefects/ConDefects/Code/abc338_f/Java/49781267 |
condefects-java_data_108 | import java.util.*;
import java.io.*;
import java.math.*;
import java.util.stream.*;
import java.util.function.*;
class Main implements Runnable {
public void solve() {
int n = in.nextInt() , m = in.nextInt();
Floyd_Warshall fw = new Floyd_Warshall(n);
for(int i = 0 ; i < m ; i ++) {
int u = in.nextInt() , v = in.nextInt() ;
long w = in.nextLong();
--u;--v;
fw.addEdge(u, v, w);
}
fw.run();
int [][] dp = new int[1 << n][n];
for(int i = 0 ; i < (1 << n) ; i ++) for(int j = 0 ; j < n ; j ++) dp[i][j] = inf ;
for(int i = 0 ; i < n ; i ++) dp[1 << i][i] = 0 ;
for(int i = 0 ; i < (1 << n) ; i ++) {
for(int j = 0 ; j < n ; j ++) if(((i >> j) & 1) == 1) {
if(dp[i][j] == lnf) continue;
for(int k = 0 ; k < n ; k ++) if(((i >> k) & 1) == 0 && fw.dist(j , k) != -1) {
dp[i | (1 << k)][k] = Math.min(dp[i | (1 << k)][k] , dp[i][j] + (int) fw.dist(j , k));
}
}
}
int min = inf ;
for(int i = 0 ; i < n ; i ++) min = Math.min(min , dp[(1 << n) - 1][i]);
out.println(min == inf ? no : min);
}
// ===============================================================================================================
class Floyd_Warshall {
private long [][] dist ;
private int N ;
private boolean cycle ;
Floyd_Warshall(int N)
{
this.N = N ;
this.cycle = false;
this.dist = new long[N][N];
for(long [] v : dist) Arrays.fill(v , inf);
for(int i = 0 ; i < N ; i ++ ) dist[i][i] = 0 ;
}
public void addEdge(int u , int v , long w) { this.dist[u][v] = w ; }
public void run()
{
for(int mid = 0 ; mid < N ; mid ++ )
{
for(int begin = 0 ; begin < N ; begin ++ )
{
for(int end = 0 ; end < N ; end ++ )
{
long u = dist[begin][mid] , v = dist[mid][end] , g = dist[begin][end] ;
if(u == inf || v == inf) continue;
if((u + v) < g) // 最短経路の上書き.
{
dist[begin][end] = u + v ;
}
else if(((u + v) == g)) // 最短経路の内のある処理.
{
}
}
if(dist[begin][begin] < 0) cycle = true ;
}
}
}
public boolean isCycle() { return cycle; }
public long dist(int u , int v) { return dist[u][v] == inf ? -1 : dist[u][v] ; }
}
// ===============================================================================================================
public PrintWriter out = new PrintWriter(System.out);
public In in = new In() ;
public static final int inf = (1 << 30);
public static final long lnf = (1L << 60);
public static final String yes = "Yes" , no = "No" ;
public static final int mod7 = 1000000007 , mod9 = 998244353;
public static final int [] dy4 = {-1,0,1,0} , dx4 = {0,1,0,-1};
public static final int [] dy8 = {-1,-1,-1,0,1,1,1,0} , dx8 = {-1,0,1,1,1,0,-1,-1};
// ===============================================================================================================
public static void main(String ... args) { new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start(); }
public void run() { solve(); out.flush(); }
// ===============================================================================================================
// ===============================================================================================================
public Integer [] parseInt(int [] array) { return IntStream.of(array).boxed().toArray(Integer[]::new); }
public Long [] parseLong(long [] array) { return LongStream.of(array).boxed().toArray(Long[]::new); }
// ===============================================================================================================
}
class In {
private final InputStream in = System.in;
private final Scanner sc = new Scanner(System.in);
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
return next().charAt(0);
}
public BigInteger nextBigInteger() {
return sc.nextBigInteger();
}
public int [] nextInt(int n) {
int [] array = new int[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt();
}
return array ;
}
public int [][] nextInt(int n , int m) {
int [][] array = new int[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt(m);
}
return array ;
}
public long [] nextLong(int n) {
long [] array = new long[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong();
}
return array ;
}
public long [][] nextLong(int n , int m) {
long [][] array = new long[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong(m);
}
return array ;
}
public double [] nextDouble(int n) {
double [] array = new double[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextDouble();
}
return array ;
}
public String [] next(int n) {
String [] array = new String[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = next();
}
return array ;
}
public String [][] next(int n , int m) {
String [][] array = new String[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = next(m);
}
return array ;
}
public char [] nextChar(int n) {
char [] array = new char[n];
String string = next() ;
for(int i = 0 ; i < n ; i ++) {
array[i] = string.charAt(i);
}
return array ;
}
public char [][] nextChar(int n , int m) {
char [][] array = new char[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextChar(m);
}
return array ;
}
}
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.stream.*;
import java.util.function.*;
class Main implements Runnable {
public void solve() {
int n = in.nextInt() , m = in.nextInt();
Floyd_Warshall fw = new Floyd_Warshall(n);
for(int i = 0 ; i < m ; i ++) {
int u = in.nextInt() , v = in.nextInt() ;
long w = in.nextLong();
--u;--v;
fw.addEdge(u, v, w);
}
fw.run();
int [][] dp = new int[1 << n][n];
for(int i = 0 ; i < (1 << n) ; i ++) for(int j = 0 ; j < n ; j ++) dp[i][j] = inf ;
for(int i = 0 ; i < n ; i ++) dp[1 << i][i] = 0 ;
for(int i = 0 ; i < (1 << n) ; i ++) {
for(int j = 0 ; j < n ; j ++) if(((i >> j) & 1) == 1) {
if(dp[i][j] == inf) continue;
for(int k = 0 ; k < n ; k ++) if(((i >> k) & 1) == 0 && fw.dist(j , k) != -1) {
dp[i | (1 << k)][k] = Math.min(dp[i | (1 << k)][k] , dp[i][j] + (int) fw.dist(j , k));
}
}
}
int min = inf ;
for(int i = 0 ; i < n ; i ++) min = Math.min(min , dp[(1 << n) - 1][i]);
out.println(min == inf ? no : min);
}
// ===============================================================================================================
class Floyd_Warshall {
private long [][] dist ;
private int N ;
private boolean cycle ;
Floyd_Warshall(int N)
{
this.N = N ;
this.cycle = false;
this.dist = new long[N][N];
for(long [] v : dist) Arrays.fill(v , inf);
for(int i = 0 ; i < N ; i ++ ) dist[i][i] = 0 ;
}
public void addEdge(int u , int v , long w) { this.dist[u][v] = w ; }
public void run()
{
for(int mid = 0 ; mid < N ; mid ++ )
{
for(int begin = 0 ; begin < N ; begin ++ )
{
for(int end = 0 ; end < N ; end ++ )
{
long u = dist[begin][mid] , v = dist[mid][end] , g = dist[begin][end] ;
if(u == inf || v == inf) continue;
if((u + v) < g) // 最短経路の上書き.
{
dist[begin][end] = u + v ;
}
else if(((u + v) == g)) // 最短経路の内のある処理.
{
}
}
if(dist[begin][begin] < 0) cycle = true ;
}
}
}
public boolean isCycle() { return cycle; }
public long dist(int u , int v) { return dist[u][v] == inf ? -1 : dist[u][v] ; }
}
// ===============================================================================================================
public PrintWriter out = new PrintWriter(System.out);
public In in = new In() ;
public static final int inf = (1 << 30);
public static final long lnf = (1L << 60);
public static final String yes = "Yes" , no = "No" ;
public static final int mod7 = 1000000007 , mod9 = 998244353;
public static final int [] dy4 = {-1,0,1,0} , dx4 = {0,1,0,-1};
public static final int [] dy8 = {-1,-1,-1,0,1,1,1,0} , dx8 = {-1,0,1,1,1,0,-1,-1};
// ===============================================================================================================
public static void main(String ... args) { new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start(); }
public void run() { solve(); out.flush(); }
// ===============================================================================================================
// ===============================================================================================================
public Integer [] parseInt(int [] array) { return IntStream.of(array).boxed().toArray(Integer[]::new); }
public Long [] parseLong(long [] array) { return LongStream.of(array).boxed().toArray(Long[]::new); }
// ===============================================================================================================
}
class In {
private final InputStream in = System.in;
private final Scanner sc = new Scanner(System.in);
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
return next().charAt(0);
}
public BigInteger nextBigInteger() {
return sc.nextBigInteger();
}
public int [] nextInt(int n) {
int [] array = new int[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt();
}
return array ;
}
public int [][] nextInt(int n , int m) {
int [][] array = new int[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextInt(m);
}
return array ;
}
public long [] nextLong(int n) {
long [] array = new long[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong();
}
return array ;
}
public long [][] nextLong(int n , int m) {
long [][] array = new long[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextLong(m);
}
return array ;
}
public double [] nextDouble(int n) {
double [] array = new double[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextDouble();
}
return array ;
}
public String [] next(int n) {
String [] array = new String[n];
for(int i = 0 ; i < n ; i ++) {
array[i] = next();
}
return array ;
}
public String [][] next(int n , int m) {
String [][] array = new String[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = next(m);
}
return array ;
}
public char [] nextChar(int n) {
char [] array = new char[n];
String string = next() ;
for(int i = 0 ; i < n ; i ++) {
array[i] = string.charAt(i);
}
return array ;
}
public char [][] nextChar(int n , int m) {
char [][] array = new char[n][m];
for(int i = 0 ; i < n ; i ++) {
array[i] = nextChar(m);
}
return array ;
}
}
| ConDefects/ConDefects/Code/abc338_f/Java/49743913 |
condefects-java_data_109 | import java.io.*;
import java.math.*;
import java.time.*;
import java.util.*;
import java.util.Map.Entry;
class Main implements Runnable {
public static void solve () {
int N = nextInt();
int[] a = nextIntArray(N);
long mod = 998244353L;
long ans = 0;
for (int x=1; x<=N; x++) {
//数列からk個選ぶ場合を独立で考える
//dp[i][j][k] = [i番目まで見て][j個選らんだときの][kで割った余り]
long[][][] dp = new long[N+1][x+1][x];
dp[0][0][0] = 1;
for (int i=0; i<N; i++) {
for (int j=0; j<=x; j++) {
for (int k=0; k<x; k++) {
dp[i+1][j][k] += dp[i][j][k];
if (j != x) {
dp[i+1][j+1][(k+a[i])%x] += dp[i][j][k];
}
}
}
}
ans += dp[N][x][0];
ans %= mod;
}
println(ans);
}
/*
* ############################################################################################
* # useful fields, useful methods, useful class
* ##############################################################################################
*/
// fields
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
// public static int[] dy = {-1, 0, 1, 0};
// public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
// methods
public static int min (int... a) {Arrays.sort(a); return a[0];}
public static int max (int... a) {Arrays.sort(a); return a[a.length-1];}
public static long min (long... a) {Arrays.sort(a); return a[0];}
public static long max (long... a) {Arrays.sort(a); return a[a.length-1];}
public static long pow (long c, long b) {
long res = 1;
for (int i=0; i<b; i++) {
res *= c;
}
return res;
}
// class
public static class Edge implements Comparable<Edge> {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
@Override public int compareTo (Edge e) {
return this.cost - e.cost;
}
}
public static class Point implements Comparable<Point> {
int x, y;
Point (int x, int y) {
this.x = x;
this.y = y;
}
@Override public int compareTo (Point p) {
return this.y - p.y;
}
@Override public boolean equals (Object o) {
Point p = (Point)o;
if (this.x == p.x && this.y == p.y) return true;
return false;
}
@Override public int hashCode () {
return y*(infi+1) + x;
}
}
/*
* ##############################################################################################
* # input
* ##############################################################################################
*/
// input - fields
public static final InputStream in = System.in;
public static final byte[] buffer = new byte[1024];
public static int ptr = 0;
public static int bufferLength = 0;
// input - basic methods
public static boolean hasNextByte() {
if (ptr < bufferLength) {
return true;
}
else {
ptr = 0;
try {
bufferLength = in.read(buffer);
}
catch (IOException e) {
e.printStackTrace();
}
if (bufferLength <= 0) {
return false;
}
}
return true;
}
public static int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
public static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public static void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public static boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
// input - single
public static String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public static int nextInt() {
return (int) nextLong();
}
public static long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public static double nextDouble() {
return Double.parseDouble(next());
}
// input - array
public static String[] nextStringArray(int n) {
String[] array = new String[n];
for (int i = 0; i < n; i++) array[i] = next();
return array;
}
public static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) array[i] = nextInt();
return array;
}
public static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) array[i] = nextLong();
return array;
}
public static double[] nextDoubleArray(int n) {
double[] array = new double[n];
for (int i = 0; i < n; i++) {
array[i] = nextDouble();
}
return array;
}
// input - table
public static char[][] nextCharTable(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) array[i] = next().toCharArray();
return array;
}
public static int[][] nextIntTable(int h, int w) {
int[][] a = new int[h][];
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) a[i][j] = nextInt();
}
return a;
}
/*
* ##############################################################################################
* # output
* ##############################################################################################
*/
// output - fields
static PrintWriter out = new PrintWriter(System.out);
//output - single
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void debug(Object... o) {
for (int i=0; i<o.length; i++) {
System.out.print(o[i] + " ");
}
System.out.println("");
}
//output - array
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
/*
* ##############################################################################################
* # main
* ##############################################################################################
*/
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
}
import java.io.*;
import java.math.*;
import java.time.*;
import java.util.*;
import java.util.Map.Entry;
class Main implements Runnable {
public static void solve () {
int N = nextInt();
int[] a = nextIntArray(N);
long mod = 998244353L;
long ans = 0;
for (int x=1; x<=N; x++) {
//数列からk個選ぶ場合を独立で考える
//dp[i][j][k] = [i番目まで見て][j個選らんだときの][kで割った余り]
long[][][] dp = new long[N+1][x+1][x];
dp[0][0][0] = 1;
for (int i=0; i<N; i++) {
for (int j=0; j<=x; j++) {
for (int k=0; k<x; k++) {
dp[i+1][j][k] += dp[i][j][k];
dp[i+1][j][k] %= mod;
if (j != x) {
dp[i+1][j+1][(k+a[i])%x] += dp[i][j][k];
dp[i+1][j+1][(k+a[i])%x] %= mod;
}
}
}
}
ans += dp[N][x][0];
ans %= mod;
}
println(ans);
}
/*
* ############################################################################################
* # useful fields, useful methods, useful class
* ##############################################################################################
*/
// fields
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
// public static int[] dy = {-1, 0, 1, 0};
// public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
// methods
public static int min (int... a) {Arrays.sort(a); return a[0];}
public static int max (int... a) {Arrays.sort(a); return a[a.length-1];}
public static long min (long... a) {Arrays.sort(a); return a[0];}
public static long max (long... a) {Arrays.sort(a); return a[a.length-1];}
public static long pow (long c, long b) {
long res = 1;
for (int i=0; i<b; i++) {
res *= c;
}
return res;
}
// class
public static class Edge implements Comparable<Edge> {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
@Override public int compareTo (Edge e) {
return this.cost - e.cost;
}
}
public static class Point implements Comparable<Point> {
int x, y;
Point (int x, int y) {
this.x = x;
this.y = y;
}
@Override public int compareTo (Point p) {
return this.y - p.y;
}
@Override public boolean equals (Object o) {
Point p = (Point)o;
if (this.x == p.x && this.y == p.y) return true;
return false;
}
@Override public int hashCode () {
return y*(infi+1) + x;
}
}
/*
* ##############################################################################################
* # input
* ##############################################################################################
*/
// input - fields
public static final InputStream in = System.in;
public static final byte[] buffer = new byte[1024];
public static int ptr = 0;
public static int bufferLength = 0;
// input - basic methods
public static boolean hasNextByte() {
if (ptr < bufferLength) {
return true;
}
else {
ptr = 0;
try {
bufferLength = in.read(buffer);
}
catch (IOException e) {
e.printStackTrace();
}
if (bufferLength <= 0) {
return false;
}
}
return true;
}
public static int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
public static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public static void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public static boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
// input - single
public static String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public static int nextInt() {
return (int) nextLong();
}
public static long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public static double nextDouble() {
return Double.parseDouble(next());
}
// input - array
public static String[] nextStringArray(int n) {
String[] array = new String[n];
for (int i = 0; i < n; i++) array[i] = next();
return array;
}
public static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) array[i] = nextInt();
return array;
}
public static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) array[i] = nextLong();
return array;
}
public static double[] nextDoubleArray(int n) {
double[] array = new double[n];
for (int i = 0; i < n; i++) {
array[i] = nextDouble();
}
return array;
}
// input - table
public static char[][] nextCharTable(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) array[i] = next().toCharArray();
return array;
}
public static int[][] nextIntTable(int h, int w) {
int[][] a = new int[h][];
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) a[i][j] = nextInt();
}
return a;
}
/*
* ##############################################################################################
* # output
* ##############################################################################################
*/
// output - fields
static PrintWriter out = new PrintWriter(System.out);
//output - single
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void debug(Object... o) {
for (int i=0; i<o.length; i++) {
System.out.print(o[i] + " ");
}
System.out.println("");
}
//output - array
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
/*
* ##############################################################################################
* # main
* ##############################################################################################
*/
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc262_d/Java/40494895 |
condefects-java_data_110 | import java.io.*;
import java.util.*;
public class Main {
public static Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static int mod = 998244353;
public static int inv100 = 828542813;
public static void main(String args[]) {
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = sc.nextInt();
}
int f[][] = new int[n + 1][];
//f[0][0] = 1;
int ans = 0;
for(int m = 1; m <= n; ++m) {
for(int i = 0; i <= n; ++i) {
f[i] = new int[m];
}
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = m; j > 0; --j) {
for (int k = 0; k < m; ++k) {
f[j][(k + arr[i - 1]) % m] = (f[j][(k + arr[i - 1]) % m] + f[j - 1][k]) % mod;
}
}
}
ans += f[m][0];
}
out.println(ans % mod);
out.close();
}
}
import java.io.*;
import java.util.*;
public class Main {
public static Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static int mod = 998244353;
public static int inv100 = 828542813;
public static void main(String args[]) {
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = sc.nextInt();
}
int f[][] = new int[n + 1][];
//f[0][0] = 1;
int ans = 0;
for(int m = 1; m <= n; ++m) {
for(int i = 0; i <= n; ++i) {
f[i] = new int[m];
}
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = m; j > 0; --j) {
for (int k = 0; k < m; ++k) {
f[j][(k + arr[i - 1]) % m] = (f[j][(k + arr[i - 1]) % m] + f[j - 1][k]) % mod;
}
}
}
ans = (ans + f[m][0]) % mod;
}
out.println(ans % mod);
out.close();
}
} | ConDefects/ConDefects/Code/abc262_d/Java/44376368 |
condefects-java_data_111 | import java.util.Scanner;
public class Main{
public static int mod(int[] arr) {
int mod = 998244353;
int n = arr.length;
int ans = 0;
for (int m = 1; m <= n; ++m) {
int[][] f = new int[m + 1][m]; // n + 1 = mod m = 余数
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = m; j > 0; --j) {
for (int k = 0; k < m; ++k) {
f[j][(k + arr[i - 1]) % m] = (f[j][(k + arr[i - 1]) % m] + f[j - 1][k]) % mod;
}
}
}
ans = (ans + f[m][0]) % mod;
}
return ans;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
mod(arr);
}
}
import java.util.Scanner;
public class Main{
public static int mod(int[] arr) {
int mod = 998244353;
int n = arr.length;
int ans = 0;
for (int m = 1; m <= n; ++m) {
int[][] f = new int[m + 1][m]; // n + 1 = mod m = 余数
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = m; j > 0; --j) {
for (int k = 0; k < m; ++k) {
f[j][(k + arr[i - 1]) % m] = (f[j][(k + arr[i - 1]) % m] + f[j - 1][k]) % mod;
}
}
}
ans = (ans + f[m][0]) % mod;
}
return ans;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
System.out.println(mod(arr));
}
} | ConDefects/ConDefects/Code/abc262_d/Java/44386829 |
condefects-java_data_112 |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long a[] = new long[n + 1];
int mod = 998244353;
for(int i = 1; i <= n; i++) {
a[i] = sc.nextLong();
}
//dp[i][j][k] : i番目の数字まで使ってmod j = kのパターン数
// long dp[][][] = new long[n + 1][n + 1][n];
long result = 0;
for(int i = 1; i <= n; i++) {
//dp[j][k][l] : j番目の数字までの中からk個使ってmod i = lのパターン数
long dp[][][] = new long[n + 1][n + 1][n];
for(int j = 0; j <= n; j++) {
for(int k = 0; k <= j; k++) {
if(k == 0) {
dp[j][0][0] = 1;
continue;
}
for(int l = 0; l < i; l++) {
int tmp = (int)((a[j] + l)%i);
dp[j][k][l] += dp[j - 1][k][l];
dp[j][k][tmp] += dp[j - 1][k - 1][l];
}
}
}
result += dp[n][i][0];
// System.out.println(dp[n][i][0]);
result %= mod;
}
System.out.println(result);
// for(int i = 1; i <= n; i++) {
// System.out.print(dp[n][i][0] + " ");
// }
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long a[] = new long[n + 1];
int mod = 998244353;
for(int i = 1; i <= n; i++) {
a[i] = sc.nextLong();
}
//dp[i][j][k] : i番目の数字まで使ってmod j = kのパターン数
// long dp[][][] = new long[n + 1][n + 1][n];
long result = 0;
for(int i = 1; i <= n; i++) {
//dp[j][k][l] : j番目の数字までの中からk個使ってmod i = lのパターン数
long dp[][][] = new long[n + 1][n + 1][n];
for(int j = 0; j <= n; j++) {
for(int k = 0; k <= j; k++) {
if(k == 0) {
dp[j][0][0] = 1;
continue;
}
for(int l = 0; l < i; l++) {
int tmp = (int)((a[j] + l)%i);
dp[j][k][l] += dp[j - 1][k][l];
dp[j][k][tmp] += dp[j - 1][k - 1][l];
dp[j][k][l] %= mod;
dp[j][k][tmp] %= mod;
}
}
}
result += dp[n][i][0];
// System.out.println(dp[n][i][0]);
result %= mod;
}
System.out.println(result);
// for(int i = 1; i <= n; i++) {
// System.out.print(dp[n][i][0] + " ");
// }
}
} | ConDefects/ConDefects/Code/abc262_d/Java/38921282 |
condefects-java_data_113 | import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
class ArrayUtils {
static int[] toIntArray(Collection<Integer> l) {
return l.stream().mapToInt(Integer::intValue).toArray();
}
static long[] toLongArray(Collection<Long> l) {
return l.stream().mapToLong(Long::longValue).toArray();
}
static double[] toDoubleArray(Collection<Double> l) {
return l.stream().mapToDouble(Double::doubleValue).toArray();
}
static List<Integer> toList(int[] a) {
return Arrays.stream(a).mapToObj(Integer::valueOf).collect(Collectors.toList());
}
static List<Long> toList(long[] a) {
return Arrays.stream(a).mapToObj(Long::valueOf).collect(Collectors.toList());
}
static List<Double> toList(double[] a) {
return Arrays.stream(a).mapToObj(Double::valueOf).collect(Collectors.toList());
}
static void fills(int[][] a, int value) {
for(int[] a2 : a) {
Arrays.fill(a2, value);
}
}
static void fills(long[][] a, long value) {
for(long[] a2 : a) {
Arrays.fill(a2, value);
}
}
static char[] reverse(char[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
char temp = a[j];
a[j] = a[i];
a[i] = temp;
}
return a;
}
static void reverse(int[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
static void reverse(long[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
long temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
class FastScaner {
InputStream in;
FastScaner(InputStream in) {
this.in = in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter(PrintStream out) {
this.out = out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner(System.in);
static FastWriter out = new FastWriter(System.out);
static FastWriter tr = new FastWriter(System.err);
void solve() {
int T = in.nextInt();
for(int i=1; i<=T; i++) {
out.pr(doTestCase()?"Yes":"No").ln();
}
}
boolean doTestCase() {
int N = in.nextInt();
long K = in.nextLong();
var S = in.next();
var Sr = rev(S);
K %= 2*N;
String Sdash;
if(K <= N) {
Sdash = Sr.substring(0,(int)K);
} else {
int l = (int)(2*N - K);
Sdash = Sr.substring(0,(int)(N-l)) + Sr;
}
var s1 = S+Sdash;
if(!s1.equals(rev(s1))) {
return false;
}
var s2 = S+Sdash;
if(!s2.equals(rev(s2))) {
return false;
}
return true;
}
String rev(String s) {
return new StringBuilder(s).reverse().toString();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
tr.flush();
}
}
}
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
class ArrayUtils {
static int[] toIntArray(Collection<Integer> l) {
return l.stream().mapToInt(Integer::intValue).toArray();
}
static long[] toLongArray(Collection<Long> l) {
return l.stream().mapToLong(Long::longValue).toArray();
}
static double[] toDoubleArray(Collection<Double> l) {
return l.stream().mapToDouble(Double::doubleValue).toArray();
}
static List<Integer> toList(int[] a) {
return Arrays.stream(a).mapToObj(Integer::valueOf).collect(Collectors.toList());
}
static List<Long> toList(long[] a) {
return Arrays.stream(a).mapToObj(Long::valueOf).collect(Collectors.toList());
}
static List<Double> toList(double[] a) {
return Arrays.stream(a).mapToObj(Double::valueOf).collect(Collectors.toList());
}
static void fills(int[][] a, int value) {
for(int[] a2 : a) {
Arrays.fill(a2, value);
}
}
static void fills(long[][] a, long value) {
for(long[] a2 : a) {
Arrays.fill(a2, value);
}
}
static char[] reverse(char[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
char temp = a[j];
a[j] = a[i];
a[i] = temp;
}
return a;
}
static void reverse(int[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
static void reverse(long[] a) {
for (int i = 0, j = a.length - 1; j > i; i++, j--) {
long temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
class FastScaner {
InputStream in;
FastScaner(InputStream in) {
this.in = in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter(PrintStream out) {
this.out = out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner(System.in);
static FastWriter out = new FastWriter(System.out);
static FastWriter tr = new FastWriter(System.err);
void solve() {
int T = in.nextInt();
for(int i=1; i<=T; i++) {
out.pr(doTestCase()?"Yes":"No").ln();
}
}
boolean doTestCase() {
int N = in.nextInt();
long K = in.nextLong();
var S = in.next();
var Sr = rev(S);
K %= 2*N;
String Sdash;
if(K <= N) {
Sdash = Sr.substring(0,(int)K);
} else {
int l = (int)(2*N - K);
Sdash = Sr.substring(0,(int)(N-l)) + Sr;
}
var s1 = S+Sdash;
if(!s1.equals(rev(s1))) {
return false;
}
var s2 = Sdash+S;
if(!s2.equals(rev(s2))) {
return false;
}
return true;
}
String rev(String s) {
return new StringBuilder(s).reverse().toString();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
tr.flush();
}
}
}
| ConDefects/ConDefects/Code/arc155_a/Java/41303893 |
condefects-java_data_114 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
final int t = Integer.parseInt(br.readLine());
final PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < t; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
long n = Long.parseLong(st.nextToken());
long k = Long.parseLong(st.nextToken());
String s = br.readLine();
pw.println(solve(n, k, s) ? "Yes" : "No");
}
pw.close();
br.close();
}
private static boolean solve(long n, long k, String s) {
long x = k % (2 * n);
StringBuilder rev_s = new StringBuilder(s).reverse();
StringBuilder sd = new StringBuilder();
if (x > n) {
sd.append(s.substring(0, (int) (x - n)));
}
sd.append(rev_s.substring(Math.max((int) (n - x), 0)));
return isPalindrome(s + sd) && isPalindrome(sd + s);
}
private static boolean isPalindrome(String s) {
boolean isOK = true;
int l = 0, r = s.length() - 1;
while (l < r) {
if (s.charAt(l) == s.charAt(r)) {
l++;
r--;
} else {
isOK = false;
break;
}
}
return isOK;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
final int t = Integer.parseInt(br.readLine());
final PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < t; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
long n = Long.parseLong(st.nextToken());
long k = Long.parseLong(st.nextToken());
String s = br.readLine();
pw.println(solve(n, k, s) ? "Yes" : "No");
}
pw.close();
br.close();
}
private static boolean solve(long n, long k, String s) {
long x = k % (2 * n);
StringBuilder rev_s = new StringBuilder(s).reverse();
StringBuilder sd = new StringBuilder();
if (x > n) {
sd.append(rev_s.substring(0, (int) (x - n)));
}
sd.append(rev_s.substring(Math.max((int) (n - x), 0)));
return isPalindrome(s + sd) && isPalindrome(sd + s);
}
private static boolean isPalindrome(String s) {
boolean isOK = true;
int l = 0, r = s.length() - 1;
while (l < r) {
if (s.charAt(l) == s.charAt(r)) {
l++;
r--;
} else {
isOK = false;
break;
}
}
return isOK;
}
}
| ConDefects/ConDefects/Code/arc155_a/Java/39516160 |
condefects-java_data_115 | import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
long n,A,B,p,q,r,s;
n=scanner.nextLong();
A=scanner.nextLong();
B=scanner.nextLong();
p=scanner.nextLong();
q=scanner.nextLong();
r=scanner.nextLong();
s=scanner.nextLong();
long lowerbound1=Math.max(1-A,1-B);
long upperbound1=Math.min(n-A,n-B);
long lowerbound2=Math.max(1-A,B-n);
long upperbound2=Math.min(n-A,B-1);
for(long i=p;i<=q;i++){
for(long j=r;j<=s;j++){
if(j-i==B-A||j+i==A+B){
if(j-i==B-A){
if((i-A)>=lowerbound1&&(i-A)<=upperbound1) {
System.out.print("#");
}
else
System.out.print(".");
}
else if(j+i==A+B){
if((i-A)>=lowerbound1&&(i-A)<=upperbound2) {
System.out.print("#");
}
else
System.out.print(".");
}
}
else{
System.out.print(".");
}
}
System.out.println();
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
long n,A,B,p,q,r,s;
n=scanner.nextLong();
A=scanner.nextLong();
B=scanner.nextLong();
p=scanner.nextLong();
q=scanner.nextLong();
r=scanner.nextLong();
s=scanner.nextLong();
long lowerbound1=Math.max(1-A,1-B);
long upperbound1=Math.min(n-A,n-B);
long lowerbound2=Math.max(1-A,B-n);
long upperbound2=Math.min(n-A,B-1);
for(long i=p;i<=q;i++){
for(long j=r;j<=s;j++){
if(j-i==B-A||j+i==A+B){
if(j-i==B-A){
if((i-A)>=lowerbound1&&(i-A)<=upperbound1) {
System.out.print("#");
}
else
System.out.print(".");
}
else if(j+i==A+B){
if((i-A)>=lowerbound2&&(i-A)<=upperbound2) {
System.out.print("#");
}
else
System.out.print(".");
}
}
else{
System.out.print(".");
}
}
System.out.println();
}
}
} | ConDefects/ConDefects/Code/abc230_c/Java/29564060 |
condefects-java_data_116 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Long> A = new ArrayList<>();
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
A.add(sc.nextLong());
}
sc.close();
List<Long> up = new ArrayList<>();
List<Long> down = new ArrayList<>();
Long pre = 0L;
for (int i = 0; i < n; i++) {
if (A.get(i) > pre) {
++pre;
up.add(pre);
} else {
pre = A.get(i);
up.add(pre);
}
}
pre = 0L;
for (int i = n - 1; i >= 0; i--) {
if (A.get(i) > pre) {
++pre;
down.add(pre);
} else {
pre = A.get(i);
down.add(pre);
}
}
long ans = 0L;
for (int i = 0; i < n; i++) {
long min = (up.get(i) - down.get(n - i - 1)) >= 0 ? down.get(i) : up.get(n - i - 1);
if (ans < min) {
ans = min;
}
}
System.out.print(ans);
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Long> A = new ArrayList<>();
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
A.add(sc.nextLong());
}
sc.close();
List<Long> up = new ArrayList<>();
List<Long> down = new ArrayList<>();
Long pre = 0L;
for (int i = 0; i < n; i++) {
if (A.get(i) > pre) {
++pre;
up.add(pre);
} else {
pre = A.get(i);
up.add(pre);
}
}
pre = 0L;
for (int i = n - 1; i >= 0; i--) {
if (A.get(i) > pre) {
++pre;
down.add(pre);
} else {
pre = A.get(i);
down.add(pre);
}
}
long ans = 0L;
for (int i = 0; i < n; i++) {
long min = (up.get(i) - down.get(n - i - 1)) >= 0 ? down.get(n - i - 1) : up.get(i);
if (ans < min) {
ans = min;
}
}
System.out.print(ans);
}
} | ConDefects/ConDefects/Code/abc336_d/Java/49689012 |
condefects-java_data_117 | // 18:02:11 14-01-2024
// D - Pyramid
// https://atcoder.jp/contests/abc336/tasks/abc336_d
// 2000 ms
import java.io.*;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
int n = inp();
int[] arr = in.nextIntArray(n);
if(n==1){
out.println(1);
return;
}
/*
int l = 0 , r = ((n+1)/2) + 1;
while(r - l > 1){
int m = (l + r) / 2;
if(isPos(n,arr,m)) l = m;
else r=m;
}
*/
isPos(n , arr , -1);
}
boolean isPos(int n , int[] arr , int m){
if(m == 1) return true;
int[] dp = new int[n];
int fnd = 1;
for(int i = 0 ; i < n ; i++){
if(arr[i] < fnd){
dp[i] = arr[i];
}
else{
dp[i] = (i-1<0?0:dp[i-1]) + 1;
fnd++;
}
}
int[] dp2 = new int[n];
fnd = 1;
for(int i = n-1 ; i >= 0 ; i--){
if(arr[i] < fnd){
dp2[i] = arr[i];
}
else{
dp2[i] = (i+1>=n?0:dp2[i+1]) + 1;
fnd++;
}
}
int max = 0;
for(int i = 0 ; i + 1 < n ; i++){
if(dp[i] <= dp2[i+1]+1){
max = Math.max(max , dp[i]);
}
else{
max = Math.max(max , dp2[i+1]+1);
}
}
out.println(max);
return true;
}
public static void main(String... args) {
int ntc = 1;
// ntc = in.nextInt();
for(int i = 1 ; i <= ntc ; i++)
new Main().solve();
out.flush();
}
int inp(){
return in.nextInt();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
// template - Yu_212
// 18:02:11 14-01-2024
// D - Pyramid
// https://atcoder.jp/contests/abc336/tasks/abc336_d
// 2000 ms
import java.io.*;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
int n = inp();
int[] arr = in.nextIntArray(n);
if(n==1){
out.println(1);
return;
}
/*
int l = 0 , r = ((n+1)/2) + 1;
while(r - l > 1){
int m = (l + r) / 2;
if(isPos(n,arr,m)) l = m;
else r=m;
}
*/
isPos(n , arr , -1);
}
boolean isPos(int n , int[] arr , int m){
if(m == 1) return true;
int[] dp = new int[n];
int fnd = 1;
for(int i = 0 ; i < n ; i++){
if(arr[i] < fnd){
dp[i] = arr[i];
fnd = arr[i]+1;
}
else{
dp[i] = (i-1<0?0:dp[i-1]) + 1;
fnd++;
}
}
int[] dp2 = new int[n];
fnd = 1;
for(int i = n-1 ; i >= 0 ; i--){
if(arr[i] < fnd){
dp2[i] = arr[i];
fnd = arr[i]+1;
}
else{
dp2[i] = (i+1>=n?0:dp2[i+1]) + 1;
fnd++;
}
}
int max = 0;
for(int i = 0 ; i + 1 < n ; i++){
if(dp[i] <= dp2[i+1]+1){
max = Math.max(max , dp[i]);
}
else{
max = Math.max(max , dp2[i+1]+1);
}
}
out.println(max);
return true;
}
public static void main(String... args) {
int ntc = 1;
// ntc = in.nextInt();
for(int i = 1 ; i <= ntc ; i++)
new Main().solve();
out.flush();
}
int inp(){
return in.nextInt();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
// template - Yu_212 | ConDefects/ConDefects/Code/abc336_d/Java/49323303 |
condefects-java_data_118 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int[] a = new int[n];
for(int i = 0; i < n; i++) a[i] = Integer.parseInt(sc.next());
int[] l = new int[n];
int[] r = new int[n];
l[0] = Math.min(a[0], 1);
for(int i = 1; i < n; i++) l[i] = Math.min(a[i], l[i - 1] + 1);
r[n - 1] = Math.min(a[n - 1], 1);
for(int i = n - 2; i >= 0; i--) r[i] = Math.min(a[i], r[i + 1] + 1);
int ans = 0;
for(int i = 0; i < n; i++) ans = Math.max(ans, Math.min(r[i], r[i]));
System.out.println(ans);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int[] a = new int[n];
for(int i = 0; i < n; i++) a[i] = Integer.parseInt(sc.next());
int[] l = new int[n];
int[] r = new int[n];
l[0] = Math.min(a[0], 1);
for(int i = 1; i < n; i++) l[i] = Math.min(a[i], l[i - 1] + 1);
r[n - 1] = Math.min(a[n - 1], 1);
for(int i = n - 2; i >= 0; i--) r[i] = Math.min(a[i], r[i + 1] + 1);
int ans = 0;
for(int i = 0; i < n; i++) ans = Math.max(ans, Math.min(l[i], r[i]));
System.out.println(ans);
}
}
}
| ConDefects/ConDefects/Code/abc336_d/Java/49318515 |
condefects-java_data_119 | import static java.lang.Math.*;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.TreeMap;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoublePredicate;
import java.util.function.IntPredicate;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongPredicate;
import java.util.function.LongUnaryOperator;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
final class Main {
public static void main(final String[] args) {
final long begin = System.currentTimeMillis(), end;
IntStream.range(0, VvyLw.MULTI ? VvyLw.io.ni() : 1).forEach(i -> VvyLw.solve());
end = System.currentTimeMillis();
VvyLw.io.dump(end - begin + "ms");
VvyLw.io.close();
}
}
final class VvyLw extends Utility {
static final IO io = new IO(System.in, System.out, System.err, false);
static final Random rd = new Random();
static final boolean MULTI = false;
static final int INF = 1 << 30;
static final long LINF = (1L << 61) - 1;
static final double EPS = 1e-18;
static final int MOD = 998244353;
static final int M0D = (int) 1e9 + 7;
static final int[] dx = {0, -1, 1, 0, 0, -1, -1, 1, 1};
static final int[] dy = {0, 0, 0, -1, 1, -1, 1, -1, 1};
static final void solve() {
final int n = io.ni();
final var s = io.ns();
final var c = io.ni(n);
final long[] ne = new long[n + 1], no = new long[n + 1], re = new long[n + 1], ro = new long[n + 1];
for(int i = 0; i < n; ++i) {
ne[i + 1] = ne[i];
no[i + 1] = no[i];
if(i % 2 == 0) {
if(s.charAt(i) == '0') {
no[i + 1] += c[i];
} else {
ne[i + 1] += c[i];
}
} else {
if(s.charAt(i) == '0') {
ne[i + 1] += c[i];
} else {
no[i + 1] += c[i];
}
}
}
for(int i = n; --i >= 0;) {
re[i] = re[i + 1];
ro[i] = ro[i + 1];
if(i % 2 == 0) {
if(s.charAt(i) == '0') {
re[i] += c[i];
} else {
ro[i] += c[i];
}
} else {
if(s.charAt(i) == '0') {
ro[i] += c[i];
} else {
re[i] += c[i];
}
}
}
long ans = LINF;
for(int i = 0; i <= n; ++i) {
ans = min(ans, ne[i] + re[i]);
ans = min(ans, no[i] + ro[i]);
}
io.out(ans);
}
}
class Utility {
protected static final String yes(final boolean ok){ return ok ? "Yes" : "No"; }
protected static final String no(final boolean ok){ return yes(!ok); }
protected static final long sqr(final long x){ return x * x; }
protected static final long cub(final long x){ return x * x * x; }
protected static final int mod(long n, final int m) {
n %= m;
return (int) (n < 0 ? n + m : n);
}
protected static final long mod(long n, final long m) {
n %= m;
return n < 0 ? n + m : n;
}
protected static final double log(final double x, final long base){ return Math.log(x) / Math.log(base); }
protected static final long intCeil(final long a, final long b){ return a == 0 ? 0 : (a - 1) / b + 1; }
protected static final double intRound(final double a, final long b, final int c) {
final long d = intPow(10, c);
return rint((a * d) / b) / d;
}
protected static final long intPow(long a, int b) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
protected static final long intPow(long a, long b, final long m) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
res = mod(res, m);
}
a *= a;
a = mod(a, m);
b >>= 1;
}
return res;
}
protected static final long inv(long a, final long m) {
long b = m, u = 1, v = 0;
while(b > 0) {
final long t = a / b;
a -= t * b;
a ^= b;
b ^= a;
a ^= b;
u -= t * v;
u ^= v;
v ^= u;
u ^= v;
}
return mod(u, m);
}
protected static final long lcm(final long a, final long b){ return a / gcd(a, b) * b; }
protected static final long lcm(final int... a){ return Arrays.stream(a).asLongStream().reduce(1, (x, y) -> lcm(x, y)); }
protected static final long lcm(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> lcm(x, y)); }
protected static final long gcd(final long a, final long b){ return b > 0 ? gcd(b, a % b) : a; }
protected static final int gcd(final int... a){ return Arrays.stream(a).reduce(0, (x, y) -> (int) gcd(x, y)); }
protected static final long gcd(final long... a){ return Arrays.stream(a).reduce(0, (x, y) -> gcd(x, y)); }
protected static final int min(final int... a){ return Arrays.stream(a).min().getAsInt(); }
protected static final long min(final long... a){ return Arrays.stream(a).min().getAsLong(); }
protected static final double min(final double... a){ return Arrays.stream(a).min().getAsDouble(); }
protected static final int max(final int... a){ return Arrays.stream(a).max().getAsInt(); }
protected static final long max(final long... a){ return Arrays.stream(a).max().getAsLong(); }
protected static final double max(final double... a){ return Arrays.stream(a).max().getAsDouble(); }
protected static final long sum(final int... a){ return Arrays.stream(a).asLongStream().sum(); }
protected static final long sum(final long... a){ return Arrays.stream(a).sum(); }
protected static final double sum(final double... a){ return Arrays.stream(a).sum(); }
protected static final long prod(final int... a){ return Arrays.stream(a).asLongStream().reduce(1, (x, y) -> x * y); }
protected static final long prod(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> x * y); }
protected static final double prod(final double... a){ return Arrays.stream(a).reduce(1, (x, y) -> x * y); }
protected static final double ave(final int... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double ave(final long... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double ave(final double... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double median(final int[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2.0;
}
protected static final double median(final long[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2.0;
}
protected static final double median(final double[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2;
}
protected static final long[] div(final long n) {
final ArrayList<Long> d = new ArrayList<>();
for(long i = 1; i * i <= n; ++i) {
if(n % i == 0) {
d.add(i);
if(i * i != n) {
d.add(n / i);
}
}
}
return d.stream().mapToLong(i -> i).sorted().toArray();
}
protected static final IntPair[] primeFactor(long n) {
final ArrayList<IntPair> pf = new ArrayList<>();
for(long i = 2; i * i <= n; ++i) {
if(n % i != 0) {
continue;
}
int cnt = 0;
while(n % i == 0) {
cnt++;
n /= i;
}
pf.add(IntPair.of(i, cnt));
}
if(n != 1) {
pf.add(IntPair.of(n, 1));
}
return pf.toArray(IntPair[]::new);
}
protected static final long eulerPhi(long n) {
long res = n;
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) {
res -= res / i;
while(n % i == 0) {
n /= i;
}
}
}
if(n > 1) {
res -= res / n;
}
return res;
}
protected static final long sigma(final long n){ return n * (n + 1) / 2; }
protected static final long sigma(final long a, final long b) {
assert a <= b;
return sigma(b) - sigma(a - 1);
}
protected static final long fact(int n) {
long res = 1;
while(n > 0) {
res *= n--;
}
return res;
}
protected static final long fact(int n, final long mod) {
long res = 1;
while(n > 0) {
res *= n--;
res %= mod;
}
return res;
}
protected static final long perm(final int n, final int r) {
int m = n;
long res = 1;
while(m > n - r) {
res *= m--;
}
return res;
}
protected static final long perm(final int n, final int r, final long mod) {
int m = n;
long res = 1;
while(m > n - r) {
res *= m--;
res %= mod;
}
return res;
}
protected static final long binom(final int n, final int r) {
if(r < 0 || n < r) {
return 0;
}
int tmp = n;
long res = 1;
for(int i = 1; i <= min(n - r, r); ++i) {
res *= tmp--;
res /= i;
}
return res;
}
protected static final long binom(final int n, final int r, final long mod) {
if(r < 0 || n < r) {
return 0;
}
int tmp = n;
long res = 1;
for(int i = 1; i <= min(n - r, r); ++i) {
res *= tmp--;
res = mod;
res /= i;
res %= mod;
}
return res;
}
protected static final boolean isInt(final double n){ return n == (long) floor(n); }
protected static final boolean isSqr(final long n){ return isInt(sqrt(n)); }
protected static final boolean isPrime(final long n) {
if(n == 1) {
return false;
}
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) {
return false;
}
}
return true;
}
protected static final boolean scope(final int l, final int x, final int r){ return l <= x && x <= r; }
protected static final boolean scope(final long l, final long x, final long r){ return l <= x && x <= r; }
protected static final boolean scope(final double l, final double x, final double r){ return l <= x && x <= r; }
protected static final int clamp(final int l, final int x, final int r){ return x < l ? l : x > r ? r : x; }
protected static final long clamp(final long l, final long x, final long r){ return x < l ? l : x > r ? r : x; }
protected static final double clamp(final double l, final double x, final double r){ return x < l ? l : x > r ? r : x; }
protected static final boolean isBit(final long i, final long j){ return (i >> j & 1) == 1; }
protected static final boolean nextPerm(final int[] a) {
try {
final int[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final long[] a) {
try {
final long[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final double[] a) {
try {
final double[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final char[] a) {
try {
final char[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean prevPerm(final int[] a) {
try {
final int[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final int[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final long[] a) {
try {
final long[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final long[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final double[] a) {
try {
final double[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final double[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final char[] a) {
try {
final char[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final char[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
private static final int[] nextPermutation(final int[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final long[] nextPermutation(final long[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final double[] nextPermutation(final double[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final char[] nextPermutation(final char[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final int[] prevPermutation(final int[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final long[] prevPermutation(final long[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final double[] prevPermutation(final double[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final char[] prevPermutation(final char[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final int find(final int dest, final int[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final long dest, final long[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final double dest, final double[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final char dest, final char[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int findRev(final int dest, final int[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final long dest, final long[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final double dest, final double[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final char dest, final char[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static void reverse(final int[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final long[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final double[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final char[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
protected static final int find(final int[] a, final int x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final long[] a, final long x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final double[] a, final double x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final char[] s, final char c) {
for(int i = 0; i < s.length; ++i) {
if(s[i] == c) {
return i;
}
}
return -1;
}
protected static final int find(final Object[] a, final Object x) {
for(int i = 0; i < a.length; ++i) {
if(a[i].equals(x)) {
return i;
}
}
return -1;
}
protected static final int findRev(final int[] a, final int x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final long[] a, final long x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final double[] a, final double x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final char[] s, final char c) {
for(int i = s.length; --i >= 0;) {
if(s[i] == c) {
return i;
}
}
return -1;
}
protected static final int findRev(final Object[] a, final Object x) {
for(int i = a.length; --i >= 0;) {
if(a[i].equals(x)) {
return i;
}
}
return -1;
}
protected static final boolean binarySearch(final int[] a, final int x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final boolean binarySearch(final long[] a, final long x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final <T extends Comparable<? super T>> boolean binarySearch(final T[] a, final T x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final <T extends Comparable<? super T>> boolean binarySearch(final List<T> a, final T x){ return Collections.binarySearch(a, x, null) >= 0; }
protected static final int lowerBound(final int[] a, final int x){ return bins(a.length, -1, (IntPredicate) y -> a[y] >= x); }
protected static final int lowerBound(final long[] a, final long x){ return bins(a.length, -1, (IntPredicate) y -> a[y] >= x); }
protected static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T x){ return lowerBound(Arrays.asList(a), x); }
protected static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T x){ return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) >= 0 ? 1 : -1); }
protected static final int upperBound(final int[] a, final int x){ return bins(a.length, -1, (IntPredicate) y -> a[y] > x); }
protected static final int upperBound(final long[] a, final long x){ return bins(a.length, -1, (IntPredicate) y -> a[y] > x); }
protected static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T x){ return upperBound(Arrays.asList(a), x); }
protected static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T x){ return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) > 0 ? 1 : -1); }
protected static final String sorted(final String s){ return s.chars().sorted().mapToObj(Character::toString).collect(Collectors.joining()); }
protected static final int[] sorted(final int[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final long[] sorted(final long[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final double[] sorted(final double[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final char[] sorted(final char[] a){ return sorted(new String(a)).toCharArray(); }
protected static final <T extends Comparable<? super T>> T[] sorted(final T[] a){ return Arrays.stream(a).sorted().toArray(n -> Arrays.copyOf(a, n)); }
protected static final boolean isSorted(final String s){ return s.equals(sorted(s)); }
protected static final boolean isSorted(final int[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final long[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final double[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final char[] a){ return Arrays.equals(a, sorted(a)); }
protected static final <T extends Comparable<? super T>> boolean isSorted(final T[] a){ return Arrays.equals(a, sorted(a)); }
protected static final String reverse(final String s){ return new StringBuilder(s).reverse().toString(); }
protected static final int[] reverse(final int[] a) {
final int n = a.length;
final int[] b = new int[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final long[] reverse(final long[] a) {
final int n = a.length;
final long[] b = new long[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final double[] reverse(final double[] a) {
final int n = a.length;
final double[] b = new double[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final char[] reverse(final char[] a) {
final int n = a.length;
final char[] b = new char[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final Object[] reverse(final Object[] a) {
final int n = a.length;
final Object[] b = new Object[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final int[] rotate(final int[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final int[] res = new int[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final long[] rotate(final long[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final long[] res = new long[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final double[] rotate(final double[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final double[] res = new double[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final char[] rotate(final char[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final char[] res = new char[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final boolean[] rotate(final boolean[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final boolean[] res = new boolean[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final Object[] rotate(final Object[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final Object[] res = new Object[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final String rotate(final String s, final int id) {
final List<Character> t = s.chars().mapToObj(i -> (char) i).collect(Collectors.toList());
Collections.rotate(t, -id);
return t.stream().map(String::valueOf).collect(Collectors.joining());
}
protected static final int[][] rotateR(final int[][] a) {
final int h = a.length, w = a[0].length;
final int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final long[][] rotateR(final long[][] a) {
final int h = a.length, w = a[0].length;
final long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final double[][] rotateR(final double[][] a) {
final int h = a.length, w = a[0].length;
final double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final char[][] rotateR(final char[][] a) {
final int h = a.length, w = a[0].length;
final char[][] b = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final int[][] rotateL(final int[][] a) {
final int h = a.length, w = a[0].length;
final int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final long[][] rotateL(final long[][] a) {
final int h = a.length, w = a[0].length;
final long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final double[][] rotateL(final double[][] a) {
final int h = a.length, w = a[0].length;
final double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final char[][] rotateL(final char[][] a) {
final int h = a.length, w = a[0].length;
final char[][] b = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[w - j - 1][i] = a[i][j]);
});
return b;
}
protected static final void swap(final int[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final long[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final double[] a, final int i, final int j) {
final double tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
protected static final void swap(final char[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final boolean[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final Object[] a, final int i, final int j) {
final Object tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
protected static final void swap(final int[] a, final int[] b) {
assert a.length == b.length;
final int n = a.length;
final int[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final long[] a, final long[] b) {
assert a.length == b.length;
final int n = a.length;
final long[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final double[] a, final double[] b) {
assert a.length == b.length;
final int n = a.length;
final double[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final char[] a, final char[] b) {
assert a.length == b.length;
final int n = a.length;
final char[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final boolean[] a, final boolean[] b) {
assert a.length == b.length;
final int n = a.length;
final boolean[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final Object[] a, final Object[] b) {
assert a.length == b.length;
final int n = a.length;
final Object[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> Pair<S, F>[] swap(final Pair<F, S>[] p) {
@SuppressWarnings("unchecked")
final Pair<S, F>[] q = new Pair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
protected static final IntPair[] swap(final IntPair[] p) {
final IntPair[] q = new IntPair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
protected static final FloatPair[] swap(final FloatPair[] p) {
final FloatPair[] q = new FloatPair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
@SuppressWarnings("unchecked")
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> F[] first(final Pair<F, S>[] p){ return (F[]) Arrays.stream(p).map(i -> i.first).toArray(); }
protected static final long[] first(final IntPair[] p){ return Arrays.stream(p).mapToLong(i -> i.first).toArray(); }
protected static final double[] first(final FloatPair[] p){ return Arrays.stream(p).mapToDouble(i -> i.first).toArray(); }
@SuppressWarnings("unchecked")
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> S[] second(final Pair<F, S>[] p){ return (S[]) Arrays.stream(p).map(i -> i.second).toArray(); }
protected static final long[] second(final IntPair[] p){ return Arrays.stream(p).mapToLong(i -> i.second).toArray(); }
protected static final double[] second(final FloatPair[] p){ return Arrays.stream(p).mapToDouble(i -> i.second).toArray(); }
protected static final IntStream iota(final int n){ return IntStream.range(0, n); }
protected static final IntStream iota(final int n, final int init){ return IntStream.range(0 + init, n + init); }
protected static final int bins(int ok, int ng, final IntPredicate fn) {
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final long bins(long ok, long ng, final LongPredicate fn) {
while(abs(ok - ng) > 1) {
final long mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final double bins(double ok, double ng, final DoublePredicate fn) {
while(abs(ok - ng) > VvyLw.EPS) {
final double mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final Map<Integer, Integer> counter(final int[] a) {
final Map<Integer, Integer> res = new HashMap<>();
for(final int i: a) {
res.merge(i, 1, (x, y) -> x + y);
}
return res;
}
protected static final Map<Long, Integer> counter(final long[] a) {
final Map<Long, Integer> res = new HashMap<>();
for(final long i: a) {
res.merge(i, 1, (x, y) -> x + y);
}
return res;
}
protected static final long innerProd(final IntPair... p){ return iota(p.length).mapToLong(i -> p[i].first.longValue() * p[i].second.longValue()).sum(); }
protected static final double innerProd(final FloatPair... p){ return iota(p.length).mapToDouble(i -> p[i].first.doubleValue() * p[i].second.doubleValue()).sum(); }
protected static final FloatPair intersection(final IntPair a, final long sec1, final IntPair b, final long sec2) {
double m1, m2, b1, b2;
if(a.second.longValue() == 0 && b.second.longValue() == 0) {
return null;
} else if(a.second.longValue() == 0) {
m2 = -b.first.doubleValue() / b.second.longValue();
b2 = -sec2 / b.second.doubleValue();
final double x = -sec1 / a.first.doubleValue(), y = b2 + m2 * x;
return FloatPair.of(x, y);
} else if(b.second.longValue() == 0) {
m1 = -a.first.doubleValue() / a.second.longValue();
b1 = -sec1 / a.second.doubleValue();
final double x = -sec2 / b.first.doubleValue(), y = b1 + m1 * x;
return FloatPair.of(x, y);
}
m1 = -a.first.doubleValue() / a.second.longValue();
m2 = -b.first.doubleValue() / b.second.longValue();
b1 = -sec1 / a.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
assert m1 != m2;
final double x = (b1 - b2) / (m2 - m1), y = m1 * x + b1;
return FloatPair.of(x, y);
}
protected static final FloatPair intersection(final FloatPair a, final double sec1, final FloatPair b, final double sec2) {
double m1, m2, b1, b2;
if(a.second.doubleValue() == 0 && b.second.doubleValue() == 0) {
return null;
} else if(a.second.doubleValue() == 0) {
m2 = -b.first.doubleValue() / b.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
final double x = -sec1 / a.first.doubleValue(), y = b2 + m2 * x;
return FloatPair.of(x, y);
} else if(b.second.doubleValue() == 0) {
m1 = -a.first.doubleValue() / a.second.doubleValue();
b1 = -sec1 / a.second.doubleValue();
final double x = -sec2 / b.first.doubleValue(), y = b1 + m1 * x;
return FloatPair.of(x, y);
}
m1 = -a.first.doubleValue() / a.second.doubleValue();
m2 = -b.first.doubleValue() / b.second.doubleValue();
b1 = -sec1 / a.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
assert m1 != m2;
final double x = (b1 - b2) / (m2 - m1), y = m1 * x + b1;
return FloatPair.of(x, y);
}
protected static final int[] corPress(final int[] a) {
final int[] res = new int[a.length];
final int[] x = Arrays.stream(a).sorted().distinct().toArray();
Arrays.setAll(res, i -> lowerBound(x, a[i]));
return res;
}
protected static final int[] corPress(final long[] a) {
final int[] res = new int[a.length];
final long[] x = Arrays.stream(a).sorted().distinct().toArray();
Arrays.setAll(res, i -> lowerBound(x, a[i]));
return res;
}
protected static final String runLenPress(final String s) {
final int n = s.length();
final StringBuilder sb = new StringBuilder();
for(int l = 0; l < n;) {
int r = l + 1;
for(; r < n && s.charAt(l) == s.charAt(r); ++r){}
sb.append(s.charAt(l));
sb.append(r - l);
l = r;
}
return sb.toString();
}
protected static final String runLenRev(final String s) {
final int n = s.length();
final StringBuilder sb = new StringBuilder();
for(int l = 0; l < n;) {
int r = l + 1;
for(; r < n && scope('0', s.charAt(r), '9'); ++r){}
sb.append(String.valueOf(s.charAt(l)).repeat(Integer.parseInt(s.substring(l + 1, r))));
l = r;
}
return sb.toString();
}
protected static final int[] zAlgorithm(final String s) {
final int n = s.length();
int j = 0;
final int[] pre = new int[n];
for(int i = 0; ++i < n;) {
if(i + pre[i - j] < j + pre[j]) {
pre[i] = pre[i - j];
}
else {
int k = max(0, j + pre[j] - i);
while(i + k < n && s.charAt(k) == s.charAt(i + k)) {
++k;
}
pre[i] = k;
j = i;
}
}
pre[0] = n;
return pre;
}
protected static final int[] manacher(final String s_, final boolean calcEven) {
int n = s_.length();
final char[] s;
if(calcEven) {
s = new char[2 * n - 1];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
for(int i = n; --i >= 0;) {
s[2 * i] = s_.charAt(i);
}
final char d = Collections.min(s_.chars().mapToObj(c -> (char) c).collect(Collectors.toList()));
for(int i = 0; i < n - 1; ++i) {
s[2 * i + 1] = d;
}
} else {
s = new char[n];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
}
n = s.length;
final int[] rad = new int[n];
for(int i = 0, j = 0; i < n;) {
while(i - j >= 0 && i + j < n && s[i - j] == s[i + j]) {
++j;
}
rad[i] = j;
int k = 1;
while(i - k >= 0 && i + k < n && k + rad[i - k] < j) {
rad[i + k] = rad[i - k];
++k;
}
i += k;
j -= k;
}
if(calcEven) {
for(int i = 0; i < n; ++i) {
if(((i ^ rad[i]) & 1) == 0) {
rad[i]--;
}
}
} else {
for(int x: rad) {
x = 2 * x - 1;
}
}
return rad;
}
protected static final long kthRoot(final long n, final int k) {
if(k == 1) {
return n;
}
final LongPredicate chk = x -> {
long mul = 1;
for(int j = 0; j < k; ++j) {
try {
mul = multiplyExact(mul, x);
} catch(final ArithmeticException e) {
return false;
}
}
return mul <= n;
};
long ret = 0;
for(int i = 32; --i >= 0;) {
if(chk.test(ret | (1L << i))) {
ret |= 1L << i;
}
}
return ret;
}
protected static final long tetration(final long a, final long b, final long m) {
if(m == 1) {
return 0;
}
if(a == 0) {
return (b & 1) == 0 ? 1 : 0;
}
if(b == 0) {
return 1;
}
if(b == 1) {
return a % m;
}
if(b == 2) {
return intPow(a, a, m);
}
final long phi = eulerPhi(m);
long tmp = tetration(a, b - 1, phi);
if(tmp == 0) {
tmp += phi;
}
return intPow(a, tmp, m);
}
protected static final long floorSum(final long n, final long m, long a, long b) {
long ans = 0;
if(a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if(b >= m) {
ans += n * (b / m);
b %= m;
}
final long ym = (a * n + b) / m, xm = (ym * m - b);
if(ym == 0) {
return ans;
}
ans += (n - (xm + a - 1) / a) * ym;
ans += floorSum(ym, a, m, (a - xm % a) % a);
return ans;
}
}
interface TriFunction<T, U, V, R> {
R apply(final T a, final U b, final V c);
}
interface QuadFunction<A, B, C, D, R> {
R apply(final A a, final B b, final C c, final D d);
}
interface TriConsumer<T, U, V> {
void accept(final T a, final U b, final V c);
}
interface TriPredicate<T, U, V> {
boolean test(final T a, final U b, final V c);
}
interface RecursiveFunction<T, R> {
R apply(final RecursiveFunction<T, R> rec, final T n);
}
interface RecursiveBiFunction<T, U, R> {
R apply(final RecursiveBiFunction<T, U, R> rec, final T n, final U m);
}
interface RecursiveTriFunction<T, U, V, R> {
R apply(final RecursiveTriFunction<T, U, V, R> rec, final T p, final U q, final V r);
}
interface RecursiveUnaryOperator<T> {
T apply(final RecursiveUnaryOperator<T> rec, final T n);
}
interface RecursiveBinaryOperator<T> {
T apply(final RecursiveBinaryOperator<T> rec, final T a, final T b);
}
interface RecursiveConsumer<T> {
void accept(final RecursiveConsumer<T> rec, final T x);
}
interface RecursiveBiConsumer<T, U> {
void accept(final RecursiveBiConsumer<T, U> rec, final T x, final U y);
}
interface RecursiveTriConsumer<T, U, V> {
void accept(final RecursiveTriConsumer<T, U, V> rec, final T x, final U y, final V z);
}
interface RecursivePredicate<T> {
boolean test(final RecursivePredicate<T> rec, final T n);
}
interface RecursiveBiPredicate<T, U> {
boolean test(final RecursiveBiPredicate<T, U> rec, final T x, final U y);
}
interface RecursiveTriPredicate<T, U, V> {
boolean test(final RecursiveTriPredicate<T, U, V> rec, final T x, final U y, final V z);
}
interface RecursiveIntFunction<R> {
R apply(final RecursiveIntFunction<R> rec, final int n);
}
interface RecursiveLongFunction<R> {
R apply(final RecursiveLongFunction<R> rec, final long n);
}
interface RecursiveDoubleFunction<R> {
R apply(final RecursiveDoubleFunction<R> rec, final double n);
}
interface RecursiveIntUnaryOperator {
int apply(final RecursiveIntUnaryOperator rec, final int n);
}
interface RecursiveLongUnaryOperator {
long apply(final RecursiveLongUnaryOperator rec, final long n);
}
interface RecursiveDoubleUnaryOperator {
double apply(final RecursiveDoubleUnaryOperator rec, final double n);
}
interface RecursiveIntBinaryOperator {
int apply(final RecursiveIntBinaryOperator rec, final int a, final int b);
}
interface RecursiveLongBinaryOperator {
long apply(final RecursiveLongBinaryOperator rec, final long a, final long b);
}
interface RecursiveDoubleBinaryOperator {
double apply(final RecursiveDoubleBinaryOperator rec, final double a, final double b);
}
interface RecursiveIntConsumer {
void accept(final RecursiveIntConsumer rec, final int n);
}
interface RecursiveLongConsumer {
void accept(final RecursiveLongConsumer rec, final long n);
}
interface RecursiveDoubleConsumer {
void accept(final RecursiveDoubleConsumer rec, final double n);
}
interface RecursiveIntPredicate {
boolean test(final RecursiveIntPredicate rec, final int n);
}
interface RecursiveLongPredicate {
boolean test(final RecursiveLongPredicate rec, final long n);
}
interface RecursiveDoublePredicate {
boolean test(final RecursiveDoublePredicate rec, final double n);
}
final class IO implements Closeable, AutoCloseable {
private final MyScanner in;
private final MyPrinter out, err;
private final boolean autoFlush;
IO(final InputStream in, final OutputStream out, final OutputStream err, final boolean autoFlush) {
this.in = new MyScanner(in);
this.out = new MyPrinter(out, this.autoFlush = autoFlush);
this.err = new MyPrinter(err, true);
}
final int ni(){ return in.ni(); }
final long nl(){ return in.nl(); }
final double nd(){ return in.nd(); }
final char nc(){ return in.nc(); }
final String ns(){ return in.ns(); }
final char[] nt(){ return in.nt(); }
final BigInteger nb(){ return in.nb(); }
final IntPair pi(){ return in.pi(); }
final FloatPair pf(){ return in.pf(); }
final int[] ni(final int n) {
final int[] a = new int[n];
Arrays.setAll(a, i -> ni());
return a;
}
final int[] ni(final int n, final IntUnaryOperator f){ return Arrays.stream(ni(n)).map(f).toArray(); }
final long[] nl(final int n) {
final long[] a = new long[n];
Arrays.setAll(a, i -> nl());
return a;
}
final long[] nl(final int n, final LongUnaryOperator f){ return Arrays.stream(nl(n)).map(f).toArray(); }
final double[] nd(final int n) {
final double[] a = new double[n];
Arrays.setAll(a, i -> nd());
return a;
}
final char[] nc(final int n) {
final char[] a = new char[n];
IntStream.range(0, n).forEach(i -> a[i] = nc());
return a;
}
final String[] ns(final int n) {
final String[] a = new String[n];
Arrays.setAll(a, i -> ns());
return a;
}
final char[][] nt(final int n) {
final char[][] a = new char[n][];
Arrays.setAll(a, i -> nt());
return a;
}
final BigInteger[] nb(final int n) {
final BigInteger[] a = new BigInteger[n];
Arrays.setAll(a, i -> nb());
return a;
}
final IntPair[] pi(final int n) {
final IntPair[] a = new IntPair[n];
Arrays.setAll(a, i -> pi());
return a;
}
final IntPair[] pi(final int n, final UnaryOperator<IntPair> f){ return Arrays.stream(pi(n)).map(f).toArray(IntPair[]::new); }
final FloatPair[] pf(final int n) {
final FloatPair[] a = new FloatPair[n];
Arrays.setAll(a, i -> pf());
return a;
}
final int[][] ni(final int h, final int w) {
final int[][] a = new int[h][w];
Arrays.setAll(a, i -> ni(w));
return a;
}
final long[][] nl(final int h, final int w) {
final long[][] a = new long[h][w];
Arrays.setAll(a, i -> nl(w));
return a;
}
final double[][] nd(final int h, final int w) {
final double[][] a = new double[h][w];
Arrays.setAll(a, i -> nd(w));
return a;
}
final char[][] nc(final int h, final int w) {
final char[][] a = new char[h][w];
Arrays.setAll(a, i -> nc(w));
return a;
}
final String[][] ns(final int h, final int w) {
final String[][] a = new String[h][w];
Arrays.setAll(a, i -> ns(w));
return a;
}
final BigInteger[][] nb(final int h, final int w) {
final BigInteger[][] a = new BigInteger[h][w];
Arrays.setAll(a, i -> nb(w));
return a;
}
final String line(){ return in.line(); }
final void print(final Object arg){ out.print(arg); }
final void printf(final String fmt, final Object... args){ out.printf(fmt, args); }
final void out(){ out.out(); }
final void out(final Object head, final Object... tail){ out.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S> p){ out.out(p); }
final <E> void out(final Collection<E> a){ out.out(a); }
final void out(final int[] head, final int[]...tail){ out.out(head, tail); }
final void out(final long[] head, final long[]...tail){ out.out(head, tail); }
final void out(final double[] head, final double[]...tail){ out.out(head, tail); }
final void out(final boolean[] head, final boolean[]...tail){ out.out(head, tail); }
final void out(final char[] head, final char[]...tail){ out.out(head, tail); }
final void out(final Object[] head, final Object[]...tail){ out.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S>[] args){ Arrays.stream(args).forEach(this::out); }
final void out(final int[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final long[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final double[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final char[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final Object[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final Object head, final Object... tail) {
out(head);
Arrays.stream(tail).forEach(this::out);
}
final void fin(final Object head, final Object... tail) {
out(head, tail);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void fin(final Pair<F, S> arg) {
out(arg);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <E> void fin(final Collection<E> args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final int[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final long[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final double[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final boolean[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final char[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final Object[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void fin(final Pair<F, S>[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final int[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final long[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final double[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final boolean[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final char[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final Object[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void ende(final Object head, final Object... tail) {
outl(head, tail);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void dump(final Object head, final Object... tail){ err.out(head, tail); }
final void dump(final int[] head, final int[]...tail){ err.out(head, tail); }
final void dump(final long[] head, final long[]...tail){ err.out(head, tail); }
final void dump(final double[] head, final double[]...tail){ err.out(head, tail); }
final void dump(final boolean[] head, final boolean[]...tail){ err.out(head, tail); }
final void dump(final char[] head, final char[]...tail){ err.out(head, tail); }
final void dump(final Object[] head, final Object[]...tail){ err.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void dump(final Pair<F, S>[] args){ Arrays.stream(args).forEach(this::dump); }
final void dump(final int[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final long[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final double[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final char[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final Object[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
@Override
public final void close() {
out.flush();
in.close();
out.close();
err.close();
}
private final class MyScanner implements Closeable, AutoCloseable {
private int pos, lim;
private final byte[] buf;
private final InputStream is;
private boolean check;
MyScanner(final InputStream is) {
this.is = is;
pos = lim = 0;
buf = new byte[1 << 17];
check = false;
}
private final boolean isPunct(final byte bt){ return !Utility.scope(33, bt, 126); }
private final boolean isNum(final byte bt){ return Utility.scope('0', bt, '9'); }
private final byte read() {
if(pos == lim && lim != -1) {
try {
lim = is.read(buf);
pos = 0;
} catch(final IOException e) {
e.printStackTrace();
}
}
return buf[pos++];
}
private final byte next() {
byte bt;
if(check) {
check = false;
bt = buf[pos - 1];
if(!isPunct(bt)) {
return bt;
}
}
while(isPunct(bt = read())){}
return bt;
}
final int ni(){ return toIntExact(nl()); }
final long nl() {
byte c = next();
final boolean neg = c == '-';
if(neg) {
c = next();
}
assert isNum(c);
long res = c - '0';
while(isNum(c = read())) {
res = 10 * res + c - '0';
}
check = !isNum(c);
return neg ? -res : res;
}
final double nd() {
byte c = next();
final boolean neg = c == '-';
if(neg) {
c = next();
}
assert isNum(c);
double res = c - '0';
while(isNum(c = read())) {
res = 10 * res + c - '0';
}
if(c != '.') {
check = true;
return res;
}
int i;
for(i = 0; isNum(c = read()); ++i) {
res = res * 10 + c - '0';
}
res /= pow(10, i);
check = true;
return neg ? -res : res;
}
final char nc(){ return (char) next(); }
final String ns() {
final StringBuilder sb = new StringBuilder();
byte c = next();
while(!isPunct(c)) {
sb.append((char) c);
c = read();
}
return sb.toString();
}
final char[] nt(){ return ns().toCharArray(); }
final BigInteger nb(){ return new BigInteger(ns()); }
final IntPair pi(){ return IntPair.of(nl(), nl()); }
final FloatPair pf(){ return FloatPair.of(nd(), nd()); }
final String line() {
final StringBuilder sb = new StringBuilder();
byte c;
while((c = read()) != '\n') {
sb.append((char) c);
}
return sb.toString();
}
@Override
public final void close() {
try {
is.close();
} catch(final IOException e) {
e.printStackTrace();
}
}
}
private final class MyPrinter implements Closeable, Flushable, AutoCloseable {
private OutputStream os;
private final boolean autoFlush;
private final byte[] buf;
private int pos;
private final boolean debug;
MyPrinter(final OutputStream os, final boolean autoFlush){
this.os = os;
this.autoFlush = autoFlush;
buf = new byte[1 << 17];
pos = 0;
debug = os == System.err;
}
private final void write(final byte bt) {
buf[pos++] = bt;
if(pos == buf.length) {
flush();
}
}
private final void newLine() {
write((byte) '\n');
if(autoFlush) {
flush();
}
}
final void print(final Object arg) {
if(arg instanceof final String s) {
for(final char c: s.toCharArray()) {
write((byte) c);
}
} else {
print(String.valueOf(arg));
}
if(autoFlush) {
flush();
}
}
final void printf(final String fmt, final Object... args) {
print(new Formatter().format(fmt, args));
if(autoFlush) {
flush();
}
}
final void out(){ newLine(); }
final void out(final Object head, final Object... tail) {
print(head);
for(final var el: tail) {
print(" " + el);
}
newLine();
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S> arg) {
if(debug) {
print(arg.toString());
} else {
print(arg.first + " " + arg.second);
}
newLine();
}
final <E> void out(final Collection<E> args) {
if(debug) {
print(args.toString());
} else {
int i = 0;
for(final var el: args) {
print(el);
if(++i != args.size()) {
print(" ");
}
}
}
newLine();
}
private final void out(final int[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final int[] head, final int[]... tail) {
out(head);
for(final int[] a: tail) {
out(a);
}
}
private final void out(final long[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final long[] head, final long[]... tail) {
out(head);
for(final long[] a: tail) {
out(a);
}
}
private final void out(final double[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final double[] head, final double[]... tail) {
out(head);
for(final double[] a: tail) {
out(a);
}
}
private final void out(final boolean[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final boolean[] head, final boolean[]... tail) {
out(head);
for(final boolean[] a: tail) {
out(a);
}
}
private final void out(final char[] args) {
if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final char[] head, final char[]... tail) {
out(head);
for(final char[] a: tail) {
out(a);
}
}
private final void out(final Object[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final Object[] head, final Object[]... tail) {
out(head);
for(final Object[] a: tail) {
out(a);
}
}
@Override
public final void flush() {
try {
os.write(buf, 0, pos);
pos = 0;
} catch(final IOException e) {
e.printStackTrace();
}
}
@Override
public final void close() {
if(os == null) {
return;
}
try {
os.close();
os = null;
} catch(final IOException e) {
e.printStackTrace();
}
}
}
}
class Pair<F extends Comparable<? super F>, S extends Comparable<? super S>> implements Comparable<Pair<F, S>>, Cloneable {
public F first;
public S second;
protected Pair(final F first, final S second) {
this.first = first;
this.second = second;
}
static final <F extends Comparable<? super F>, S extends Comparable<? super S>> Pair<F, S> of(final F a, final S b){ return new Pair<>(a, b); }
Pair<S, F> swap(){ return Pair.of(second, first); }
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> p = (Pair<?, ?>) o;
return first.equals(p.first) && second.equals(p.second);
}
@Override
public final int hashCode(){ return Objects.hash(first, second); }
@Override
public final String toString(){ return "(" + first + ", " + second + ")"; }
@SuppressWarnings("unchecked")
@Override
public final Pair<F, S> clone() {
try {
return (Pair<F, S>) super.clone();
} catch(final CloneNotSupportedException e){
e.printStackTrace();
}
throw new Error();
}
@Override
public final int compareTo(final Pair<F, S> p) {
if(first.compareTo(p.first) == 0) {
return second.compareTo(p.second);
}
return first.compareTo(p.first);
}
}
final class IntPair extends Pair<Long, Long> {
private IntPair(final long first, final long second){ super(first, second); }
static final IntPair ZERO = new IntPair(0, 0);
static final IntPair ONE = new IntPair(1, 1);
static final IntPair of(final long a, final long b){ return new IntPair(a, b); }
@Override
final IntPair swap(){ return new IntPair(second, first); }
final IntPair add(final IntPair p){ return new IntPair(first + p.first, second + p.second); }
final IntPair sub(final IntPair p){ return new IntPair(first - p.first, second - p.second); }
final IntPair mul(final IntPair p){ return new IntPair(first * p.first, second * p.second); }
final IntPair div(final IntPair p){ return new IntPair(first / p.first, second / p.second); }
final IntPair mod(final IntPair p){ return new IntPair(first % p.first, second % p.second); }
final IntPair rotate(){ return new IntPair(-second, first); }
final FloatPair rotate(final int ang) {
final double rad = toRadians(Utility.mod(ang, 360));
return FloatPair.of(first * cos(rad) - second * sin(rad), first * sin(rad) + second * cos(rad));
}
final long dot(final IntPair p){ return first * p.first + second * p.second; }
final long cross(final IntPair p){ return rotate().dot(p); }
final long sqr(){ return dot(this); }
final double grad() {
try {
return 1.0 * second / first;
} catch(final ArithmeticException e) {
e.printStackTrace();
}
throw new Error();
}
final double abs(){ return hypot(first, second); }
final long lcm(){ return Utility.lcm(first, second); }
final long gcd(){ return Utility.gcd(first, second); }
final IntPair extgcd() {
long x = 1, y = 0, t1 = 0, t2 = 0, t3 = 1, a = first, b = second;
while(b > 0) {
t1 = a / b;
a -= t1 * b;
a ^= b;
b ^= a;
a ^= b;
x -= t1 * t2;
x ^= t2;
t2 ^= x;
x ^= t2;
y -= t1 * t3;
y ^= t3;
t3 ^= y;
y ^= t3;
}
return new IntPair(x, y);
}
}
final class FloatPair extends Pair<Double, Double> {
private FloatPair(final double first, final double second){ super(first, second); }
static final FloatPair of(final double a, final double b){ return new FloatPair(a, b); }
@Override
final FloatPair swap(){ return new FloatPair(second, first); }
final FloatPair add(final FloatPair p){ return new FloatPair(first + p.first, second + p.second); }
final FloatPair sub(final FloatPair p){ return new FloatPair(first - p.first, second - p.second); }
final FloatPair mul(final FloatPair p){ return new FloatPair(first * p.first, second * p.second); }
final FloatPair div(final FloatPair p){ return new FloatPair(first / p.first, second / p.second); }
final FloatPair rotate(){ return new FloatPair(-second, first); }
final FloatPair rotate(final int ang) {
final double rad = toRadians(Utility.mod(ang, 360));
return FloatPair.of(first * cos(rad) - second * sin(rad), first * sin(rad) + second * cos(rad));
}
final double dot(final FloatPair p){ return first * p.first + second * p.second; }
final double cross(final FloatPair p){ return rotate().dot(p); }
final double sqr(){ return dot(this); }
final double grad() {
try {
return second / first;
} catch(final ArithmeticException e) {
e.printStackTrace();
}
throw new Error();
}
final double abs(){ return hypot(first, second); }
}
final class Why {
static final boolean isBipartite(final UnionFind uf) {
assert uf.size() % 2 == 0;
final int n = uf.size() / 2;
boolean ok = true;
for(int i = 0; i < n; ++i) {
ok &= !uf.same(i, i + n);
}
return ok;
}
static final long invNum(final int[] a) {
final int[] b = Utility.sorted(a);
final Map<Integer, Integer> id = new HashMap<>();
for(int i = 0; i < a.length; ++i) {
id.put(b[i], i);
}
final FenwickTree bit = new FenwickTree(a.length);
long res = 0;
for(int i = 0; i < a.length; ++i) {
res += i - bit.sum(id.get(a[i]));
bit.add(id.get(a[i]), 1);
}
return res;
}
static final long invNum(final long[] a) {
final long[] b = Utility.sorted(a);
final Map<Long, Integer> id = new HashMap<>();
for(int i = 0; i < a.length; ++i) {
id.put(b[i], i);
}
final FenwickTree bit = new FenwickTree(a.length);
long res = 0;
for(int i = 0; i < a.length; ++i) {
res += i - bit.sum(id.get(a[i]));
bit.add(id.get(a[i]), 1);
}
return res;
}
}
final class Edge {
public int src, to, id;
public long cost;
Edge(final int src, final int to, final int id) {
this.src = src;
this.to = to;
this.id = id;
}
Edge(final int src, final int to, final long cost, final int id) {
this.src = src;
this.to = to;
this.cost = cost;
this.id = id;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Edge e = (Edge) o;
return src == e.src && to == e.to && cost == e.cost;
}
@Override
public final int hashCode(){ return Objects.hash(src, to, cost, id); }
@Override
public final String toString(){ return String.valueOf(to); }
}
class Graph extends ArrayList<ArrayList<Edge>> {
protected final boolean undirected;
protected final int n, indexed;
protected int id;
protected final ArrayList<Edge> edge;
Graph(final int n, final boolean undirected){ this(n, 1, undirected); }
Graph(final int n, final int indexed, final boolean undirected) {
this.n = n;
this.indexed = indexed;
this.undirected = undirected;
id = 0;
edge = new ArrayList<>();
IntStream.range(0, n).forEach(i -> add(new ArrayList<>()));
}
static Graph of(final List<ArrayList<Edge>> g, final boolean undirected) {
int max = 0, min = Integer.MAX_VALUE;
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
max = max(e.src, e.to);
min = min(e.src, e.to);
}
}
final Graph gp = new Graph(max, min, undirected);
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
gp.addEdge(e.src, e.to);
}
}
return gp;
}
final void addEdge(int a, int b) {
a -= indexed;
b -= indexed;
this.get(a).add(new Edge(a, b, id));
edge.add(new Edge(a, b, id++));
if(undirected) {
this.get(b).add(new Edge(b, a, --id));
edge.add(new Edge(b, a, id++));
}
}
void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni())); }
protected final ArrayList<Edge> getEdge(){ return edge; }
protected final int[] allDist(final int v) {
final int[] d = new int[n];
Arrays.fill(d, -1);
final Queue<Integer> q = new ArrayDeque<>();
d[v] = 0;
q.add(v);
while(!q.isEmpty()) {
final int tmp = q.poll();
for(final Edge el: this.get(tmp)) {
if(d[el.to] != -1) {
continue;
}
d[el.to] = d[tmp] + 1;
q.add(el.to);
}
}
return d;
}
protected final int dist(final int u, final int v){ return allDist(u)[v]; }
protected final ArrayList<Integer> topologicalSort() {
final int[] deg = new int[n];
for(int i = 0; i < n; ++i) {
for(final Edge ed: this.get(i)) {
deg[ed.to]++;
}
}
final Stack<Integer> sk = new Stack<>();
for(int i = 0; i < n; ++i) {
if(deg[i] == 0) {
sk.add(i);
}
}
final ArrayList<Integer> ord = new ArrayList<>();
while(!sk.isEmpty()) {
final int tmp = sk.pop();
ord.add(tmp);
for(final Edge ed: this.get(tmp)) {
if(--deg[ed.to] == 0) {
sk.add(ed.to);
}
}
}
return n == ord.size() ? ord : null;
}
protected final int[] cycleDetector() {
final int[] used = new int[n];
final Edge[] pre = new Edge[n];
final ArrayList<Edge> cycle = new ArrayList<>();
final RecursiveIntPredicate dfs = (rec, i) -> {
used[i] = 1;
for(final Edge e: get(i)) {
if(used[e.to] == 0) {
pre[e.to] = e;
if(rec.test(rec, e.to)) {
return true;
}
} else if(used[e.to] == 1) {
int now = i;
while(now != e.to) {
cycle.add(pre[now]);
now = pre[now].src;
}
cycle.add(e);
return true;
}
}
used[i] = 2;
return false;
};
for(int i = 0; i < n; ++i) {
if(used[i] == 0 && dfs.test(dfs, i)) {
Collections.reverse(cycle);
return cycle.stream().mapToInt(e -> e.to).toArray();
}
}
return null;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; ++i) {
final int m = get(i).size();
sb.append(i + ": [");
for(int j = 0; j < m; ++j) {
sb.append(get(i).get(j).to);
if(j + 1 < m) {
sb.append(", ");
}
}
sb.append(']');
if(i + 1 < n) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class ShortestPath {
private final long[] cost;
private final int[] src;
ShortestPath(final long[] cost, final int[] src) {
this.cost = cost;
this.src = src;
}
final boolean isThru(final int i){ return src[i] != -1; }
final int[] path(int i) {
final List<Integer> res = new ArrayList<>();
for(; i != -1; i = src[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(k -> k).toArray();
}
final long[] get(){ return cost; }
}
final class MST {
public final ArrayList<Edge> tree;
public final long cost;
MST(final ArrayList<Edge> tree, final long cost) {
this.tree = tree;
this.cost = cost;
}
}
final class WeightedGraph extends Graph {
WeightedGraph(final int n, final boolean undirected){ super(n, undirected); }
WeightedGraph(final int n, final int indexed, final boolean undirected){ super(n, indexed, undirected); }
static final WeightedGraph of(final List<ArrayList<Edge>> g, final boolean undirected) {
int max = 0, min = Integer.MAX_VALUE;
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
max = max(e.src, e.to);
min = min(e.src, e.to);
}
}
final WeightedGraph gp = new WeightedGraph(max, min, undirected);
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
gp.addEdge(e.src, e.to, e.cost);
}
}
return gp;
}
final void addEdge(int a, int b, final long cost) {
a -= indexed;
b -= indexed;
this.get(a).add(new Edge(a, b, cost, id));
edge.add(new Edge(a, b, cost, id++));
if(undirected) {
this.get(b).add(new Edge(b, a, cost, --id));
edge.add(new Edge(b, a, cost, id++));
}
}
final void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni(), VvyLw.io.nl())); }
final ShortestPath dijkstra(final int v) {
final long[] cost = new long[n];
final int[] src = new int[n];
Arrays.fill(cost, Long.MAX_VALUE);
Arrays.fill(src, -1);
final Queue<IntPair> dj = new PriorityQueue<>();
cost[v] = 0;
dj.add(IntPair.of(cost[v], v));
while(!dj.isEmpty()) {
final IntPair tmp = dj.poll();
if(cost[tmp.second.intValue()] < tmp.first.longValue()) {
continue;
}
for(final Edge ed: this.get(tmp.second.intValue())) {
final long next = tmp.first.longValue() + ed.cost;
if(cost[ed.to] <= next) {
continue;
}
cost[ed.to] = next;
src[ed.to] = tmp.second.intValue();
dj.add(IntPair.of(cost[ed.to], ed.to));
}
}
return new ShortestPath(cost, src);
}
final long[] spfa(final int v) {
final long[] cost = new long[n];
Arrays.fill(cost, Long.MAX_VALUE);
final boolean[] pend = new boolean[n];
final int[] cnt = new int[n];
final Queue<Integer> q = new ArrayDeque<>();
q.add(v);
pend[v] = true;
cnt[v]++;
cost[v] = 0;
while(!q.isEmpty()) {
final int p = q.poll();
pend[p] = false;
for(final Edge e: this.get(p)) {
final long next = cost[p] + e.cost;
if(next >= cost[e.to]) {
continue;
}
cost[e.to] = next;
if(!pend[e.to]) {
if(++cnt[e.to] >= n) {
return null;
}
pend[e.to] = true;
q.add(e.to);
}
}
}
return cost;
}
final long[][] floydWarshall() {
final long[][] cost = new long[n][n];
IntStream.range(0, n).forEach(i -> Arrays.fill(cost[i], VvyLw.LINF));
IntStream.range(0, n).forEach(i -> cost[i][i] = 0);
for(int i = 0; i < n; ++i) {
for(final Edge j: this.get(i)) {
cost[i][j.to] = j.cost;
}
}
for(int k = 0; k < n; ++k) {
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
if(cost[i][k] == VvyLw.LINF || cost[k][j] == VvyLw.LINF) {
continue;
}
if(cost[i][j] > cost[i][k] + cost[k][j]) {
cost[i][j] = cost[i][k] + cost[k][j];
}
}
}
}
return cost;
}
final MST kruskal() {
final UnionFind uf = new UnionFind(n);
final ArrayList<Edge> e = new ArrayList<>();
long res = 0;
for(final Edge ed: edge.stream().sorted(Comparator.comparing(ed -> ed.cost)).collect(Collectors.toList())) {
if(uf.unite(ed.src, ed.to)) {
e.add(ed);
res += ed.cost;
}
}
return new MST(e, res);
}
final MST directed(final int v) {
@SuppressWarnings("unchecked")
final ArrayList<Edge> ed = (ArrayList<Edge>) edge.clone();
for(int i = 0; i < n; ++i) {
if(i != v) {
ed.add(new Edge(i, v, 0));
}
}
int x = 0;
final int[] par = new int[2 * n], vis = new int[2 * n], link = new int[2 * n];
Arrays.fill(par, -1);
Arrays.fill(vis, -1);
Arrays.fill(link, -1);
final SkewHeap heap = new SkewHeap(true);
final SkewHeap.Node[] ins = new SkewHeap.Node[2 * n];
Arrays.fill(ins, null);
for(int i = 0; i < ed.size(); i++) {
final Edge e = ed.get(i);
ins[e.to] = heap.push(ins[e.to], e.cost, i);
}
final ArrayList<Integer> st = new ArrayList<>();
final IntUnaryOperator go = z -> {
z = ed.get(ins[z].idx).src;
while(link[z] != -1) {
st.add(z);
z = link[z];
}
for(final int p: st) {
link[p] = z;
}
st.clear();
return z;
};
for(int i = n; ins[x] != null; ++i) {
while(vis[x] == -1) {
vis[x] = 0;
x = go.applyAsInt(x);
}
while(x != i) {
final long w = ins[x].key;
SkewHeap.Node z = heap.pop(ins[x]);
z = heap.add(z, -w);
ins[i] = heap.meld(ins[i], z);
par[x] = i;
link[x] = i;
x = go.applyAsInt(x);
}
while(ins[x] != null && go.applyAsInt(x) == x) {
ins[x] = heap.pop(ins[x]);
}
}
for(int i = v; i != -1; i = par[i]) {
vis[i] = 1;
}
long cost = 0;
final ArrayList<Edge> e = new ArrayList<>();
for(int i = x; i >= 0; i--) {
if(vis[i] == 1) {
continue;
}
cost += ed.get(ins[i].idx).cost;
e.add(ed.get(ins[i].idx));
for(int j = ed.get(ins[i].idx).to; j != -1 && vis[j] == 0; j = par[j]) {
vis[j] = 1;
}
}
return new MST(e, cost);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; ++i) {
final int m = get(i).size();
sb.append(i + ": [");
for(int j = 0; j < m; ++j) {
sb.append("(to: " + get(i).get(j).to + ", cost: " + get(i).get(j).cost + ')');
if(j + 1 < m) {
sb.append(", ");
}
}
sb.append(']');
if(i + 1 < n) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class SkewHeap {
static final class Node {
long key, lazy;
Node l, r;
final int idx;
Node(final long key, final int idx) {
this.key = key;
this.idx = idx;
lazy = 0;
l = null;
r = null;
}
}
private final boolean isMin;
SkewHeap(final boolean isMin){ this.isMin = isMin; }
private final Node alloc(final long key, final int idx){ return new Node(key, idx); }
private final Node propagate(final Node t) {
if(t != null && t.lazy != 0) {
if(t.l != null) {
t.l.lazy += t.lazy;
}
if(t.r != null) {
t.r.lazy += t.lazy;
}
t.key += t.lazy;
t.lazy = 0;
}
return t;
}
final Node meld(Node x, Node y) {
propagate(x);
propagate(y);
if(x == null || y == null) {
return x != null ? x : y;
}
if((x.key < y.key) ^ isMin) {
final Node tmp = x;
x = y;
y = tmp;
}
x.r = meld(y, x.r);
final Node tmp = x.l;
x.l = x.r;
x.r = tmp;
return x;
}
final Node push(final Node t, final long key, final int idx){ return meld(t, alloc(key, idx)); }
final Node pop(final Node t) {
if(t == null) {
throw new NullPointerException();
}
return meld(t.l, t.r);
}
final Node add(final Node t, final long lazy) {
if(t != null) {
t.lazy += lazy;
propagate(t);
}
return t;
}
}
final class SCC {
private final int n, indexed;
private int m;
private final ArrayList<Edge> edge;
private final int[] start, ids;
private int[][] groups;
private boolean notBuilt;
SCC(final int n){ this(n, 1); }
SCC(final int n, final int indexed) {
this.n = n;
this.indexed = indexed;
edge = new ArrayList<>();
start = new int[n + 1];
ids = new int[n];
m = 0;
notBuilt = true;
}
final void addEdge(int from, int to) {
from -= indexed;
to -= indexed;
rangeCheck(from);
rangeCheck(to);
edge.add(new Edge(from, to, m++));
start[from + 1]++;
}
final void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni())); }
final int id(final int i) {
if(notBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
rangeCheck(i);
return ids[i];
}
final void build() {
for(int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
final Edge[] ed = new Edge[m];
final int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for(final Edge e: edge) {
ed[count[e.src]++] = e;
}
int nowOrd = 0, groupNum = 0, k = 0, ptr = 0;
final int[] par = new int[n], vis = new int[n], low = new int[n], ord = new int[n];
Arrays.fill(ord, -1);
final long[] stack = new long[n];
for(int i = 0; i < n; i++) {
if(ord[i] >= 0) {
continue;
}
par[i] = -1;
stack[ptr++] = 0L << 32 | i;
while(ptr > 0) {
long p = stack[--ptr];
int u = (int) (p & 0xffff_ffffl);
int j = (int) (p >>> 32);
if(j == 0) {
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if(start[u] + j < count[u]) {
int to = ed[start[u] + j].to;
stack[ptr++] += 1l << 32;
if(ord[to] == -1) {
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else {
low[u] = min(low[u], ord[to]);
}
} else {
while(j --> 0) {
final int to = ed[start[u] + j].to;
if(par[to] == u) {
low[u] = min(low[u], low[to]);
}
}
if(low[u] == ord[u]) {
while(true) {
final int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if(v == u) {
break;
}
}
groupNum++;
}
}
}
}
for(int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
final int[] counts = new int[groupNum];
for(final int x: ids) {
counts[x]++;
}
groups = new int[groupNum][];
for(int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for(int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
notBuilt = false;
}
final int[][] groups() {
if(notBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
return groups;
}
private final void rangeCheck(final int i) {
if(!Utility.scope(0, i, n - 1)) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
final class LowestCommonAncestor {
private final int log;
private final int[] dep, sum;
private final Graph g;
private final int[][] table;
LowestCommonAncestor(final Graph g) {
this.g = g;
final int n = g.size();
dep = new int[n];
sum = new int[n];
log = Integer.toBinaryString(n).length();
table = new int[log][n];
IntStream.range(0, log).forEach(i -> Arrays.fill(table[i], -1));
build();
}
private final void dfs(final int idx, final int par, final int d) {
table[0][idx] = par;
dep[idx] = d;
for(final Edge el: g.get(idx)) {
if(el.to != par) {
sum[el.to] = (int) (sum[idx] + el.cost);
dfs(el.to, idx, d + 1);
}
}
}
private final void build() {
dfs(0, -1, 0);
for(int k = 0; k < log - 1; ++k) {
for(int i = 0; i < table[k].length; ++i) {
if(table[k][i] == -1) {
table[k + 1][i] = -1;
} else {
table[k + 1][i] = table[k][table[k][i]];
}
}
}
}
final int query(int u, int v) {
if(dep[u] > dep[v]) {
u ^= v;
v ^= u;
u ^= v;
}
v = climb(v, dep[v] - dep[u]);
if(u == v) {
return u;
}
for(int i = log; --i >= 0;) {
if(table[i][u] != table[i][v]) {
u = table[i][u];
v = table[i][v];
}
}
return table[0][u];
}
final int climb(int u, final int k) {
if(dep[u] < k) {
return -1;
}
for(int i = log; --i >= 0;) {
if(((k >> i) % 2) == 1) {
u = table[i][u];
}
}
return u;
}
final int dist(final int u, final int v){ return sum[u] + sum[v] - 2 * sum[query(u, v)]; }
}
interface DSU {
int root(final int i);
int size(final int i);
int size();
default boolean same(final int i, final int j){ return root(i) == root(j); }
boolean unite(int i, int j);
ArrayList<ArrayList<Integer>> groups();
}
class UnionFind implements DSU {
protected final int[] par;
UnionFind(final int n) {
par = new int[n];
Arrays.fill(par, -1);
}
@Override
public final int root(final int i){ return par[i] >= 0 ? par[i] = root(par[i]) : i; }
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public boolean unite(int i, int j) {
i = root(i);
j = root(j);
if(i == j) {
return false;
}
if(i > j) {
i ^= j;
j ^= i;
i ^= j;
}
par[i] += par[j];
par[j] = i;
return true;
}
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>(n);
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
}
abstract class MergeUnionFind<T> extends UnionFind {
MergeUnionFind(final int n){ super(n); }
abstract void merge(final int i, final int j);
abstract T get(final int i);
@Override
public final boolean unite(int i, int j) {
i = root(i);
j = root(j);
if(i == j) {
return false;
}
if(i > j) {
i ^= j;
j ^= i;
i ^= j;
}
par[i] += par[j];
par[j] = i;
merge(i, j);
return true;
}
}
final class WeightedUnionFind implements DSU {
private final int[] par;
private final long[] weight;
WeightedUnionFind(final int n) {
par = new int[n];
weight = new long[n];
Arrays.fill(par, -1);
}
@Override
public final int root(final int i) {
if(par[i] < 0) {
return i;
}
final int r = root(par[i]);
weight[i] += weight[par[i]];
return par[i] = r;
}
final long get(final int i) {
root(i);
return weight[i];
}
final long diff(final int x, final int y){ return get(y) - get(x); }
final int unite(int x, int y, long w) {
w += diff(y, x);
x = root(x);
y = root(y);
if(x == y) {
return w == 0 ? 0 : -1;
}
if(par[x] > par[y]) {
x ^= y;
y ^= x;
x ^= y;
w = -w;
}
par[x] += par[y];
par[y] = x;
weight[y] = w;
return 1;
}
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>();
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
// deprecated
@Override
public final boolean unite(final int i, final int j){ return unite(i, j, 0) > 0; }
}
final class UndoUnionFind implements DSU {
private final int[] par;
private final Stack<Pair<Integer, Integer>> his;
UndoUnionFind(final int n) {
par = new int[n];
Arrays.fill(par, -1);
his = new Stack<>();
}
@Override
public final boolean unite(int x, int y) {
x = root(x);
y = root(y);
his.add(Pair.of(x, par[x]));
his.add(Pair.of(y, par[y]));
if(x == y) {
return false;
}
if(par[x] > par[y]) {
x ^= y;
y ^= x;
x ^= y;
}
par[x] += par[y];
par[y] = x;
return true;
}
@Override
public final int root(final int i) {
if(par[i] < 0) {
return i;
}
return root(par[i]);
}
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>();
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
final void undo() {
final Pair<Integer, Integer> pop1 = his.pop(), pop2 = his.pop();
par[pop1.first] = pop1.second;
par[pop2.first] = pop2.second;
}
final void snapshot() {
while(!his.empty()) {
his.pop();
}
}
final void rollback() {
while(!his.empty()) {
undo();
}
}
}
final class PrimeTable {
private final int[] p;
private final boolean[] sieve;
PrimeTable(final int n) {
sieve = new boolean[n + 1];
Arrays.fill(sieve, true);
sieve[0] = sieve[1] = false;
for(int i = 2; i <= n; ++i) {
if(!sieve[i]) {
continue;
}
for(long j = (long) i * i; j <= n; j += i) {
sieve[(int) j] = false;
}
}
final int size = (int) IntStream.rangeClosed(0, n).filter(i -> sieve[i]).count();
int j = 0;
p = new int[size];
for(int i = 2; i <= n; ++i) {
if(sieve[i]) {
p[j++] = i;
}
}
}
final boolean[] table(){ return sieve; }
final int[] get(){ return p; }
}
final class PrimeFactor {
private final int[] spf;
PrimeFactor(final int n) {
spf = Utility.iota(n + 1).toArray();
for(int i = 2; i * i <= n; ++i) {
if(spf[i] != i) {
continue;
}
for(int j = i * i; j <= n; j += i) {
if(spf[j] == j) {
spf[j] = i;
}
}
}
}
final TreeMap<Integer, Integer> get(int n) {
final TreeMap<Integer, Integer> m = new TreeMap<>();
while(n != 1) {
m.merge(spf[n], 1, (a, b) -> (a + b));
n /= spf[n];
}
return m;
}
}
final class PrimeCounter {
private final int sq;
private final boolean[] p;
private final int[] psum;
private final ArrayList<Integer> ps;
PrimeCounter(final long n) {
sq = (int) kthRooti(n, 2);
psum = new int[sq + 1];
p = new PrimeTable(sq).table();
for(int i = 1; i <= sq; ++i) {
psum[i] = psum[i - 1] + (p[i] ? 1 : 0);
}
ps = new ArrayList<>();
for(int i = 1; i <= sq; ++i) {
if(p[i]) {
ps.add(i);
}
}
}
private final long kthRooti(final long n, final int k){ return Utility.kthRoot(n, k); }
private final long p2(final long x, final long y) {
if(x < 4) {
return 0;
}
final long a = pi(y);
final long b = pi(kthRooti(x, 2));
if(a >= b) {
return 0;
}
long sum = (long) (a - 2) * (a + 1) / 2 - (b - 2) * (b + 1) / 2;
for(long i = a; i < b; ++i) {
sum += pi(x / ps.get((int) i));
}
return sum;
}
private final long phi(final long m, final long a) {
if(m < 1) {
return 0;
}
if(a > m) {
return 1;
}
if(a < 1) {
return m;
}
if(m <= (long) ps.get((int) (a - 1)) * ps.get((int) (a - 1))) {
return pi(m) - a + 1;
}
if(m <= (long) ps.get((int) (a - 1)) * ps.get((int) (a - 1)) * ps.get((int) (a - 1)) && m <= sq) {
final long sx = pi(kthRooti(m, 2));
long ans = pi(m) - (long) (sx + a - 2) * (sx - a + 1) / 2;
for(long i = a; i < sx; ++i) {
ans += pi(m / ps.get((int) i));
}
return ans;
}
return phi(m, a - 1) - phi(m / ps.get((int) (a - 1)), a - 1);
}
final long pi(final long n) {
if(n <= sq) {
return psum[(int) n];
}
final long m = kthRooti(n, 3);
final long a = pi(m);
return phi(n, a) + a - 1 - p2(n, m);
}
}
// N <= 1e18;
final class LongPrime {
private static final int bsf(final long x){ return Long.numberOfTrailingZeros(x); }
private static final long gcd(long a, long b) {
a = abs(a);
b = abs(b);
if(a == 0) {
return b;
}
if(b == 0) {
return a;
}
final int shift = bsf(a|b);
a >>= bsf(a);
do {
b >>= bsf(b);
if(a > b) {
a ^= b;
b ^= a;
a ^= b;
}
b -= a;
} while(b > 0);
return a << shift;
}
static final boolean isPrime(final long n) {
if(n <= 1) {
return false;
}
if(n == 2) {
return true;
}
if(n % 2 == 0) {
return false;
}
long d = n - 1;
while(d % 2 == 0) {
d /= 2;
}
final long[] sample = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
for(final long a: sample) {
if(n <= a) {
break;
}
long t = d;
BigInteger y = BigInteger.valueOf(a).modPow(BigInteger.valueOf(t), BigInteger.valueOf(n));
while(t != n - 1 && !y.equals(BigInteger.ONE) && !y.equals(BigInteger.valueOf(n).subtract(BigInteger.ONE))) {
y = y.multiply(y).mod(BigInteger.valueOf(n));
t <<= 1;
}
if(!y.equals(BigInteger.valueOf(n).subtract(BigInteger.ONE)) && t % 2 == 0) {
return false;
}
}
return true;
}
private static final long find(final long n) {
if(isPrime(n)) {
return n;
}
if(n % 2 == 0) {
return 2;
}
long st = 0;
final LongBinaryOperator f = (x, y) -> { return BigInteger.valueOf(x).multiply(BigInteger.valueOf(x)).add(BigInteger.valueOf(y)).mod(BigInteger.valueOf(n)).longValue(); };
while(true) {
st++;
long x = st, y = f.applyAsLong(x, st);
while(true) {
final long p = gcd(y - x + n, n);
if(p == 0 || p == n) {
break;
}
if(p != 1) {
return p;
}
x = f.applyAsLong(x, st);
y = f.applyAsLong(f.applyAsLong(y, st), st);
}
}
}
static final ArrayList<Long> primeFactor(final long n) {
if(n == 1) return new ArrayList<>();
final long x = find(n);
if(x == n) return new ArrayList<>(Arrays.asList(x));
final ArrayList<Long> l = primeFactor(x), r = primeFactor(n / x);
l.addAll(r);
Collections.sort(l);
return l;
}
}
// N > 1e18
final class BigPrime {
private static final int bsf(final long x){ return Long.numberOfTrailingZeros(x); }
private static final BigInteger gcd(BigInteger a, BigInteger b) {
a = a.abs();
b = b.abs();
if(a.equals(BigInteger.ZERO)) {
return b;
}
if(b.equals(BigInteger.ZERO)) {
return a;
}
final int shift = bsf(a.or(b).longValue());
a = a.shiftRight(bsf(a.longValue()));
do {
b = b.shiftRight(bsf(b.longValue()));
if(a.compareTo(b) > 0) {
final BigInteger tmp = b;
b = a;
a = tmp;
}
b = b.subtract(a);
} while(b.compareTo(BigInteger.ZERO) > 0);
return a.shiftLeft(shift);
}
static final boolean isPrime(final BigInteger n) {
if(n.compareTo(BigInteger.ONE) <= 0) {
return false;
}
if(n.equals(BigInteger.TWO)) {
return true;
}
if(n.and(BigInteger.ONE).equals(BigInteger.valueOf(0))) {
return false;
}
BigInteger d = n.subtract(BigInteger.ONE);
while(d.and(BigInteger.ONE).equals(BigInteger.valueOf(0))) {
d = d.shiftRight(1);
}
final long[] sample = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
for(final long a: sample) {
if(n.compareTo(BigInteger.valueOf(a)) <= 0) {
break;
}
BigInteger t = d;
BigInteger y = BigInteger.valueOf(a).modPow(t, n);
while(!t.equals(n.subtract(BigInteger.ONE)) && !y.equals(BigInteger.ONE) && !y.equals(n.subtract(BigInteger.ONE))) {
y = y.multiply(y).mod(n);
t = t.shiftLeft(1);
}
if(!y.equals(n.subtract(BigInteger.ONE)) && t.and(BigInteger.ONE).equals(BigInteger.ZERO)) {
return false;
}
}
return true;
}
private static final BigInteger find(final BigInteger n) {
if(isPrime(n)) {
return n;
}
if(n.and(BigInteger.ONE).equals(BigInteger.ZERO)) {
return BigInteger.TWO;
}
int st = 0;
final BiFunction<BigInteger, Integer, BigInteger> f = (x, y) -> { return x.multiply(x).add(BigInteger.valueOf(y)).mod(n); };
while(true) {
st++;
BigInteger x = BigInteger.valueOf(st), y = f.apply(x, st);
while(true) {
final BigInteger p = gcd(y.subtract(x).add(n), n);
if(p.equals(BigInteger.ZERO) || p.equals(n)) {
break;
}
if(!p.equals(BigInteger.ONE)) {
return p;
}
x = f.apply(x, st);
y = f.apply(f.apply(y, st), st);
}
}
}
static final ArrayList<BigInteger> primeFactor(final BigInteger n) {
if(n.equals(BigInteger.ONE)) {
return new ArrayList<>();
}
final BigInteger x = find(n);
if(x.equals(n)) {
return new ArrayList<>(Arrays.asList(x));
}
final ArrayList<BigInteger> l = primeFactor(x), r = primeFactor(n.divide(x));
l.addAll(r);
Collections.sort(l);
return l;
}
}
final class ModPrime {
private final int len, mod;
private final long[] f, rf;
ModPrime(final int mod, final int sz) {
this.mod = mod;
len = min(sz + 1, mod);
f = new long[len];
rf = new long[len];
init();
}
private final long inv(long x) {
long res = 1, k = mod - 2;
while(k > 0) {
if(k % 2 == 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
k >>= 1;
}
return res;
}
private final void init() {
f[0] = 1;
for(int i = 0; ++i < len;) {
f[i] = (f[i - 1] * i) % mod;
}
rf[len - 1] = inv(f[len - 1]);
for(int i = len; --i > 0;) {
rf[i - 1] = (rf[i] * i) % mod;
}
}
final long C(final int n, final int k) {
if(k < 0 || n < k) {
return 0;
}
final long a = f[n], b = rf[n - k], c = rf[k], bc = (b * c) % mod;
return (a * bc) % mod;
}
final long P(final int n, final int k) {
if (k < 0 || n < k) {
return 0;
}
final long a = f[n], b = rf[n - k];
return (a * b) % mod;
}
final long H(final int n, final int k) {
if (n == 0 && k == 0) {
return 1;
}
return C(n + k - 1, k);
}
final long fact(final int n){ return f[n]; }
}
final class EulerPhiTable {
private final int[] euler;
EulerPhiTable(final int n) {
euler = Utility.iota(n + 1).toArray();
for(int i = 2; i <= n; ++i) {
if(euler[i] == i) {
for(int j = i; j <= n; j += i) {
euler[j] = euler[j] / i * (i - 1);
}
}
}
}
final int[] get(){ return euler; }
}
final class DP {
static final long knapsack01(final int[] a, final long[] v, final int w) {
final int n = a.length;
final long[] dp = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = w; j >= a[i]; j--) {
if(dp[j - a[i]] != Long.MIN_VALUE) {
if(dp[j - a[i]] + v[i] > dp[j]) {
dp[j] = dp[j - a[i]] + v[i];
}
}
}
}
return Utility.max(dp);
}
static final int knapsack01(final long[] a, final int[] v, final long w) {
final int n = a.length;
final int s = (int) Utility.sum(v);
final long[] dp = new long[s + 1];
Arrays.fill(dp, w + 1);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = s; j >= v[i]; j--) {
dp[j] = Math.min(dp[j], dp[j - v[i]] + a[i]);
}
}
int res = 0;
for(int i = 0; i <= s; i++) {
if(dp[i] <= w) {
res = i;
}
}
return res;
}
private static final long[] knapsack(final int[] a, final long[] v, final int[] m, final int w, final boolean less) {
final int n = a.length;
final long[] dp = new long[w + 1], deqv = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
final int[] deq = new int[w + 1];
for(int i = 0; i < n; ++i) {
if(a[i] == 0) {
for(int j = 0; j <= w; ++j) {
if(dp[j] != Long.MIN_VALUE && (less ? dp[j] + v[i] * m[i] < dp[j] : dp[j] + v[i] * m[i] > dp[j])) {
dp[j] = dp[j] + v[i] * m[i];
}
}
} else {
for(int k = 0; k < a[i]; ++k) {
int s = 0, t = 0;
for(int j = 0; a[i] * j + k <= w; ++j) {
if(dp[a[i] * j + k] != Long.MIN_VALUE) {
final long val = dp[a[i] * j + k] - j * v[i];
while(s < t && (less ? val < deqv[t - 1] : val > deqv[t - 1])) {
t--;
}
deq[t] = j;
deqv[t++] = val;
}
if(s < t) {
dp[j * a[i] + k] = deqv[s] + j * v[i];
if(deq[s] == j - m[i]) {
s++;
}
}
}
}
}
}
return dp;
}
static final long knapsack(final int[] a, final long[] v, final int[] m, final int w){ return Utility.max(knapsack(a, v, m, w, false)); }
static final long knapsack(final long[] a, final int[] v, final long[] m, final long w) {
final int n = a.length;
final int max = Utility.max(v);
if(max == 0) {
return 0;
}
final int[] ma = new int[n];
final long[] mb = new long[n];
for(int i = 0; i < n; i++) {
ma[i] = (int) Math.min(m[i], max - 1);
mb[i] = m[i] - ma[i];
}
int sum = 0;
for(int i = 0; i < n; ++i) {
sum += ma[i] * v[i];
}
final long[] dp = knapsack(v, a, ma, sum, true);
final int[] id = Utility.iota(n).boxed().sorted((i, j) -> -Long.compare(v[i] * a[j], v[j] * a[i])).mapToInt(i -> i).toArray();
long res = 0;
for(int i = 0; i < dp.length; ++i) {
if(dp[i] > w || dp[i] == Long.MIN_VALUE) {
continue;
}
long rest = w - dp[i], cost = i;
for(final int j: id) {
final long get = Math.min(mb[j], rest / a[j]);
if(get <= 0) {
continue;
}
cost += get * v[j];
rest -= get * a[j];
}
res = Math.max(res, cost);
}
return res;
}
static final long knapsack(final int[] a, final long[] v, final int w) {
final int n = a.length;
final long[] dp = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = a[i]; j <= w; j++) {
if(dp[j - a[i]] != Long.MIN_VALUE) {
if(dp[j - a[i]] + v[i] > dp[j]) {
dp[j] = dp[j - a[i]] + v[i];
}
}
}
}
return Utility.max(dp);
}
static final long maxRectangle(final int[] a) {
final Stack<Integer> sk = new Stack<>();
final long[] h = new long[a.length + 1];
for(int i = 0; i < a.length; ++i) {
h[i] = a[i];
}
final int[] l = new int[h.length];
long res = 0;
for(int i = 0; i < h.length; i++) {
while(!sk.isEmpty() && h[sk.peek()] >= h[i]) {
res = max(res, (i - l[sk.peek()] - 1) * h[sk.pop()]);
}
l[i] = sk.isEmpty() ? -1 : sk.peek();
sk.add(i);
}
return res;
}
static final long maxRectangle(final long[] a) {
final Stack<Integer> sk = new Stack<>();
final long[] h = Arrays.copyOf(a, a.length + 1);
final int[] l = new int[h.length];
long res = 0;
for(int i = 0; i < h.length; i++) {
while(!sk.isEmpty() && h[sk.peek()] >= h[i]) {
res = max(res, (i - l[sk.peek()] - 1) * h[sk.pop()]);
}
l[i] = sk.isEmpty() ? -1 : sk.peek();
sk.add(i);
}
return res;
}
static final int lcs(final String s, final String t) {
final int n = s.length();
final int[] dp = new int[n + 1], ndp = new int[n + 1];
for(int i = 0; i < t.length(); ++i) {
for(int j = 0; j < n; ++j) {
if(s.charAt(j) == t.charAt(i)) {
ndp[j + 1] = dp[j] + 1;
} else {
ndp[j + 1] = max(ndp[j], dp[j + 1]);
}
}
Utility.swap(dp, ndp);
}
return dp[n];
}
static final int[] lis(final int[] a) {
final int n = a.length;
List<IntPair> dp = new ArrayList<IntPair>();
final int[] p = new int[n];
Arrays.fill(p, -1);
for(int i = 0; i < n; ++i) {
final int id = Utility.lowerBound(dp, IntPair.of(a[i], -i));
if(id != 0) {
p[i] = -dp.get(id - 1).second.intValue();
}
if(id == dp.size()) {
dp.add(IntPair.of(a[i], -i));
} else {
dp.set(id, IntPair.of(a[i], -i));
}
}
final List<Integer> res = new ArrayList<Integer>();
for(int i = -dp.get(dp.size() - 1).second.intValue(); i != -1; i = p[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(i -> i).toArray();
}
static final int[] lis(final long[] a) {
final int n = a.length;
List<IntPair> dp = new ArrayList<IntPair>();
final int[] p = new int[n];
Arrays.fill(p, -1);
for(int i = 0; i < n; ++i) {
final int id = Utility.lowerBound(dp, IntPair.of(a[i], -i));
if(id != 0) {
p[i] = -dp.get(id - 1).second.intValue();
}
if(id == n) {
dp.add(IntPair.of(a[i], -i));
} else {
dp.set(id, IntPair.of(a[i], -i));
}
}
final List<Integer> res = new ArrayList<Integer>();
for(int i = -dp.get(dp.size() - 1).second.intValue(); i != -1; i = p[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(i -> i).toArray();
}
}
final class Matrix implements Cloneable {
private final int h, w;
private final long[][] mat;
Matrix(final int n){ this(n, n); }
Matrix(final int h, final int w) {
this.h = h;
this.w = w;
mat = new long[h][w];
}
Matrix(final int[][] m) {
this(m.length, m[0].length);
IntStream.range(0, h).forEach(i -> Arrays.setAll(mat[i], j -> m[i][j]));
}
Matrix(final long[][] m) {
this(m.length, m[0].length);
IntStream.range(0, h).forEach(i -> Arrays.setAll(mat[i], j -> m[i][j]));
}
static final Matrix E(final int n) {
final Matrix m = new Matrix(n);
IntStream.range(0, n).forEach(i -> m.set(i, i, 1));
return m;
}
final long[] getH(final int i){ return mat[i]; }
final long[] getW(final int i){ return IntStream.range(0, h).mapToLong(j -> mat[j][i]).toArray(); }
final long[][] get(){ return mat; }
final long get(final int i, final int j){ return mat[i][j]; }
final void set(final int i, final int j, final long x){ mat[i][j] = x; }
final Matrix add(final Matrix m) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, mat[i][j] + m.get(i, j));
}
}
return mt;
}
final Matrix add(final Matrix m, final long mod) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, Utility.mod(mat[i][j] + m.get(i, j), mod));
}
}
return mt;
}
final Matrix sub(final Matrix m) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, mat[i][j] - m.get(i, j));
}
}
return mt;
}
final Matrix sub(final Matrix m, final long mod) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, Utility.mod(mat[i][j] - m.get(i, j), mod));
}
}
return mt;
}
final Matrix mul(final Matrix m) {
assert w == m.h;
final Matrix mt = new Matrix(h, m.w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < m.w; ++j) {
for(int k = 0; k < w; ++k) {
mt.set(i, j, mt.get(i, j) + mat[i][k] * m.get(k, j));
}
}
}
return mt;
}
final Matrix mul(final Matrix m, final long mod) {
assert w == m.h;
final Matrix mt = new Matrix(h, m.w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < m.w; ++j) {
for(int k = 0; k < w; ++k) {
mt.set(i, j, Utility.mod(mt.get(i, j) + mat[i][k] * m.get(k, j), mod));
}
}
}
return mt;
}
final Matrix pow(int k) {
Matrix n = clone();
Matrix m = Matrix.E(h);
while(k > 0) {
if(k % 2 == 1) {
m = m.mul(n);
}
n = n.mul(n);
k >>= 1;
}
return m;
}
final Matrix pow(long k, final long mod) {
Matrix n = clone();
Matrix m = Matrix.E(h);
while(k > 0) {
if(k % 2 == 1) {
m = m.mul(n, mod);
}
n = n.mul(n, mod);
k >>= 1L;
}
return m;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Matrix m = (Matrix) o;
if(h != m.h || w != m.w) {
return false;
}
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
if(mat[i][j] != m.get(i, j)) {
return false;
}
}
}
return true;
}
@Override
public final Matrix clone() {
final Matrix m = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
m.mat[i] = Arrays.copyOf(mat[i], w);
}
return m;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
final int interval = String.valueOf(IntStream.range(0, h).mapToLong(i -> IntStream.range(0, w).mapToLong(j -> mat[i][j]).max().getAsLong()).max().getAsLong()).length() + 1;
for(int i = 0; i < h; ++i) {
sb.append("[");
for(int j = 0; j < w; ++j) {
sb.append(String.format("%" + interval + "d", mat[i][j]));
if(j + 1 == w) {
sb.append("]");
}
}
if(i + 1 != h) {
sb.append("\n");
}
}
return sb.toString();
}
}
class InclusiveScan {
protected final int n;
protected long[] s;
protected InclusiveScan(final int n) {
this.n = n;
s = new long[n + 1];
}
InclusiveScan(final int[] a, final LongBinaryOperator op) {
n = a.length;
s = Arrays.stream(a).asLongStream().toArray();
Arrays.parallelPrefix(s, op);
}
InclusiveScan(final long[] a, final LongBinaryOperator op) {
n = a.length;
s = a.clone();
Arrays.parallelPrefix(s, op);
}
protected final long[] get(){ return s; }
}
final class PrefixSum extends InclusiveScan {
private boolean built;
PrefixSum(final int n) {
super(n);
built = false;
}
PrefixSum(final int[] a) {
super(a, Long::sum);
s = Utility.rotate(Arrays.copyOf(s, n + 1), -1);
}
PrefixSum(final long[] a) {
super(a, Long::sum);
s = Utility.rotate(Arrays.copyOf(s, n + 1), -1);
}
final long sum(final int l, final int r){ return s[r] - s[l]; }
final void add(final int l, final int r, final long x) {
if(built) {
throw new UnsupportedOperationException("Prefix Sum has been built.");
}
s[l] += x;
s[r] -= x;
}
final long[] build() {
assert !built;
Arrays.parallelPrefix(s, Long::sum);
built = true;
return Arrays.copyOf(s, n);
}
}
final class PrefixSum2D {
private final int h, w;
private final long[][] data;
private boolean built;
PrefixSum2D(final int h, final int w) {
this.h = h + 3;
this.w = w + 3;
data = new long[this.h][this.w];
built = false;
}
PrefixSum2D(final int[][] a) {
this(a.length, a[0].length);
for(int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j) {
add(i, j, a[i][j]);
}
}
}
PrefixSum2D(final long[][] a) {
this(a.length, a[0].length);
for(int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j) {
add(i, j, a[i][j]);
}
}
}
final void add(int i, int j, final long x) {
if(built) {
throw new UnsupportedOperationException("Prefix Sum 2D has been built.");
}
i++;
j++;
if(i >= h || j >= w) {
return;
}
data[i][j] += x;
}
final void add(final int i1, final int j1, final int i2, final int j2, final long x) {
add(i1, j1, x);
add(i1, j2, -x);
add(i2, j1, -x);
add(i2, j2, x);
}
final void build() {
assert !built;
for(int i = 0; ++i < h;) {
for(int j = 0; ++j < w;) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
built = true;
}
final long get(final int i1, final int j1, final int i2, final int j2) {
if(!built) {
throw new UnsupportedOperationException("Prefix Sum 2D hasn't been built.");
}
return data[i2][j2] - data[i1][j2] - data[i2][j1] + data[i1][j1];
}
final long get(final int i, final int j) {
if(!built) {
throw new UnsupportedOperationException("Prefix Sum 2D hasn't been built.");
}
return data[i + 1][j + 1];
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < h - 3; ++i) {
sb.append(get(i, 0));
for(int j = 0; ++j < w - 3;) {
sb.append(" " + get(i, j));
}
if(i + 1 < h) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class SuffixArray extends ArrayList<Integer> {
private final String vs;
SuffixArray(final String vs, final boolean compress) {
this.vs = vs;
final int[] newVS = new int[vs.length() + 1];
if(compress) {
final List<Integer> xs = vs.chars().sorted().distinct().boxed().collect(Collectors.toList());
for(int i = 0; i < vs.length(); ++i) {
newVS[i] = Utility.lowerBound(xs, (int) vs.charAt(i)) + 1;
}
} else {
final int d = vs.chars().min().getAsInt();
for(int i = 0; i < vs.length(); ++i) {
newVS[i] = vs.charAt(i) - d + 1;
}
}
this.addAll(Arrays.stream(SAIS(newVS)).boxed().collect(Collectors.toList()));
}
private final int[] SAIS(final int[] s) {
final int n = s.length;
final int[] ret = new int[n];
final boolean[] isS = new boolean[n], isLMS = new boolean[n];
int m = 0;
for(int i = n - 2; i >= 0; i--) {
isS[i] = (s[i] > s[i + 1]) || (s[i] == s[i + 1] && isS[i + 1]);
m += (isLMS[i + 1] = isS[i] && !isS[i + 1]) ? 1 : 0;
}
final Consumer<ArrayList<Integer>> inducedSort = (lms) -> {
final int upper = Arrays.stream(s).max().getAsInt();
final int[] l = new int[upper + 2], r = new int[upper + 2];
for(final int v: s) {
++l[v + 1];
++r[v];
}
Arrays.parallelPrefix(l, (x, y) -> x + y);
Arrays.parallelPrefix(r, (x, y) -> x + y);
Arrays.fill(ret, -1);
for(int i = lms.size(); --i >= 0;) {
ret[--r[s[lms.get(i)]]] = lms.get(i);
}
for(final int v: ret) {
if(v >= 1 && isS[v - 1]) {
ret[l[s[v - 1]]++] = v - 1;
}
}
Arrays.fill(r, 0);
for(final int v: s) {
++r[v];
}
Arrays.parallelPrefix(r, (x, y) -> x + y);
for(int k = ret.length - 1, i = ret[k]; k >= 1; i = ret[--k]) {
if(i >= 1 && !isS[i - 1]) {
ret[--r[s[i - 1]]] = i - 1;
}
}
};
final ArrayList<Integer> lms = new ArrayList<>(), newLMS = new ArrayList<>();
for(int i = 0; ++i < n;) {
if(isLMS[i]) {
lms.add(i);
}
}
inducedSort.accept(lms);
for(int i = 0; i < n; ++i) {
if(!isS[ret[i]] && ret[i] > 0 && isS[ret[i] - 1]) {
newLMS.add(ret[i]);
}
}
final BiPredicate<Integer, Integer> same = (a, b) -> {
if(s[a++] != s[b++]) {
return false;
}
while(true) {
if(s[a] != s[b]) {
return false;
}
if(isLMS[a] || isLMS[b]) {
return isLMS[a] && isLMS[b];
}
a++;
b++;
}
};
int rank = 0;
ret[n - 1] = 0;
for(int i = 0; ++i < m;) {
if(!same.test(newLMS.get(i - 1), newLMS.get(i))) {
++rank;
}
ret[newLMS.get(i)] = rank;
}
if(rank + 1 < m) {
final int[] newS = new int[m];
for(int i = 0; i < m; ++i) {
newS[i] = ret[lms.get(i)];
}
final var lmsSA = SAIS(newS);
IntStream.range(0, m).forEach(i -> newLMS.set(i, lms.get(lmsSA[i])));
}
inducedSort.accept(newLMS);
return ret;
}
private final boolean ltSubstr(final String t, int si, int ti) {
final int sn = vs.length(), tn = t.length();
while(si < sn && ti < tn) {
if(vs.charAt(si) < t.charAt(ti)) {
return true;
}
if(vs.charAt(si) > t.charAt(ti)) {
return false;
}
++si;
++ti;
}
return si >= sn && ti < tn;
}
final int lowerBound(final String t) {
int ok = this.size(), ng = 0;
while(ok - ng > 1) {
final int mid = (ok + ng) / 2;
if(ltSubstr(t, this.get(mid), 0)) {
ng = mid;
} else {
ok = mid;
}
}
return ok;
}
final Pair<Integer, Integer> equalRange(final String t) {
final int low = lowerBound(t);
int ng = low - 1, ok = this.size();
final StringBuilder sb = new StringBuilder(t);
sb.setCharAt(t.length() - 1, (char)(sb.charAt(sb.length() - 1) - 1));
final String u = sb.toString();
while(ok - ng > 1) {
final int mid = (ok + ng) / 2;
if(ltSubstr(u, this.get(mid), 0)) {
ng = mid;
} else {
ok = mid;
}
}
final int end = this.size() - 1;
this.add(end, this.get(end) - 1);
return Pair.of(low, ok);
}
final int[] lcpArray() {
final int n = this.size() - 1;
final int[] lcp = new int[n + 1], rank = new int[n + 1];
for(int i = 0; i <= n; ++i) {
rank[this.get(i)] = i;
}
int h = 0;
for(int i = 0; i <= n; ++i) {
if(rank[i] < n) {
final int j = this.get(rank[i] + 1);
for(; j + h < n && i + h < n; ++h) {
if(vs.charAt(j + h) != vs.charAt(i + h)) {
break;
}
}
lcp[rank[i] + 1] = h;
if(h > 0) {
h--;
}
}
}
return lcp;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < this.size(); ++i) {
sb.append(i + ":[" + this.get(i) + "]");
for(int j = this.get(i); j < vs.length(); ++j) {
sb.append(" " + vs.charAt(j));
}
if(i + 1 != this.size()) {
sb.append("\n");
}
}
return sb.toString();
}
}
final class Deque<T> implements Iterable<T> {
private int n, head, tail;
private Object[] buf;
Deque(){ this(1 << 17); }
private Deque(final int n) {
this.n = n;
head = tail = 0;
buf = new Object[n];
}
Deque(final T[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
private final int next(final int index) {
final int next = index + 1;
return next == n ? 0 : next;
}
private final int prev(final int index) {
final int prev = index - 1;
return prev == -1 ? n - 1 : prev;
}
private final int index(final int i) {
final int size = size();
assert i < size;
final int id = head + i;
return n <= id ? id - n : id;
}
private final void arraycopy(final int fromId, final T[] a, final int from, final int len) {
assert fromId + len <= size();
final int h = index(fromId);
if(h + len < n) {
System.arraycopy(buf, h, a, from, len);
} else {
final int back = n - h;
System.arraycopy(buf, h, a, from, back);
System.arraycopy(buf, 0, a, from + back, len - back);
}
}
@SuppressWarnings("unchecked")
private final void extend() {
final Object[] tmp = new Object[n << 1];
arraycopy(0, (T[]) tmp, 0, size());
buf = tmp;
n = buf.length;
}
final boolean isEmpty(){ return size() == 0; }
final int size() {
final int size = tail - head;
return size < 0 ? size + n : size;
}
final void addFirst(final T x) {
if(prev(head) == tail) {
extend();
}
head = prev(head);
buf[head] = x;
}
final void addLast(final T x) {
if(next(tail) == head) {
extend();
}
buf[tail] = x;
tail = next(tail);
}
final void removeFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
head = next(head);
}
final void removeLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
}
@SuppressWarnings("unchecked")
final T pollFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
final T ans = (T) buf[head];
head = next(head);
return ans;
}
@SuppressWarnings("unchecked")
final T pollLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
return (T) buf[tail];
}
final T peekFirst(){ return get(0); }
final T peekLast(){ return get(n - 1); }
@SuppressWarnings("unchecked")
final T get(final int i){ return (T) buf[index(i)]; }
final void set(final int i, final T x){ buf[index(i)] = x; }
final void add(final T x){ addLast(x); }
final T poll(){ return pollFirst(); }
final T peek(){ return peekFirst(); }
@SuppressWarnings("unchecked")
final void swap(final int a, final int b) {
final int i = index(a), j = index(b);
final T num = (T) buf[i];
buf[i] = buf[j];
buf[j] = num;
}
final void clear(){ head = tail = 0; }
@SuppressWarnings("unchecked")
final T[] toArray() {
final Object[] array = new Object[size()];
arraycopy(0, (T[]) array, 0, size());
return (T[]) array;
}
@Override
public final String toString(){ return Arrays.toString(toArray()); }
@Override
public final Iterator<T> iterator(){ return new DequeIterator(); }
private class DequeIterator implements Iterator<T> {
private int now = head;
private int rem = size();
@Override
public boolean hasNext(){ return rem > 0; }
@Override
public final T next() {
if(!hasNext()) {
throw new NoSuchElementException();
}
@SuppressWarnings("unchecked")
final T res = (T) buf[now];
now = (now + 1) % n;
rem--;
return res;
}
@Override
public final void remove() {
if(isEmpty()) {
throw new IllegalStateException();
}
now = (now - 1 + n) % n;
buf[now] = null;
head = (head + 1) % n;
rem++;
}
}
}
final class IntDeque {
private int n, head, tail;
private long[] buf;
IntDeque(){ this(1 << 17); }
private IntDeque(final int n) {
this.n = n;
head = tail = 0;
buf = new long[n];
}
IntDeque(final int[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
IntDeque(final long[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
private final int next(final int index) {
final int next = index + 1;
return next == n ? 0 : next;
}
private final int prev(final int index) {
final int prev = index - 1;
return prev == -1 ? n - 1 : prev;
}
private final int index(final int i) {
final int size = size();
assert i < size;
final int id = head + i;
return n <= id ? id - n : id;
}
private final void arraycopy(final int fromId, final long[] a, final int from, final int len) {
assert fromId + len <= size();
final int h = index(fromId);
if(h + len < n) {
System.arraycopy(buf, h, a, from, len);
} else {
final int back = n - h;
System.arraycopy(buf, h, a, from, back);
System.arraycopy(buf, 0, a, from + back, len - back);
}
}
private final void extend() {
final long[] tmp = new long[n << 1];
arraycopy(0, tmp, 0, size());
buf = tmp;
n = buf.length;
}
final boolean isEmpty(){ return size() == 0; }
final int size() {
final int size = tail - head;
return size < 0 ? size + n : size;
}
final void addFirst(final long x) {
head = prev(head);
if(head == tail) {
extend();
}
buf[head] = x;
}
final void addLast(final long x) {
if(next(tail) == head) {
extend();
}
buf[tail] = x;
tail = next(tail);
}
final void removeFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
head = next(head);
}
final void removeLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
}
final long pollFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
final long ans = buf[head];
head = next(head);
return ans;
}
final long pollLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
return buf[tail];
}
final long peekFirst(){ return get(0); }
final long peekLast(){ return get(n - 1); }
final long get(final int i){ return buf[index(i)]; }
final void set(final int i, final long x){ buf[index(i)] = x; }
final void add(final long x){ addLast(x); }
final long poll(){ return pollFirst(); }
final long peek(){ return peekFirst(); }
final void swap(final int a, final int b) {
final int i = index(a);
final int j = index(b);
final long num = buf[i];
buf[i] = buf[j];
buf[j] = num;
}
final void clear(){ head = tail = 0; }
final long[] toArray(){ return Arrays.copyOf(buf, size()); }
@Override
public final String toString(){ return Arrays.toString(toArray()); }
}
final class AVLTree<T extends Comparable<? super T>> {
static final class Node<T extends Comparable<? super T>> {
T val;
@SuppressWarnings("unchecked")
Node<T>[] ch = new Node[2];
int dep, size;
Node(final T val, final Node<T> l, final Node<T> r) {
this.val = val;
dep = size = 1;
ch[0] = l;
ch[1] = r;
}
}
private Node<T> root;
private final int depth(final Node<T> t){ return t == null ? 0 : t.dep; }
private final int count(final Node<T> t){ return t == null ? 0 : t.size; }
private final Node<T> update(final Node<T> t) {
t.dep = max(depth(t.ch[0]), depth(t.ch[1])) + 1;
t.size = count(t.ch[0]) + count(t.ch[1]) + 1;
return t;
}
private final Node<T> rotate(Node<T> t, final int b) {
Node<T> s = t.ch[1 - b];
t.ch[1 - b] = s.ch[b];
s.ch[b] = t;
t = update(t);
s = update(s);
return s;
}
private final Node<T> fetch(Node<T> t) {
if(t == null) {
return t;
}
if(depth(t.ch[0]) - depth(t.ch[1]) == 2) {
if(depth(t.ch[0].ch[1]) > depth(t.ch[0].ch[0])) {
t.ch[0] = rotate(t.ch[0], 0);
}
t = rotate(t, 1);
}
else if(depth(t.ch[0]) - depth(t.ch[1]) == -2) {
if (depth(t.ch[1].ch[0]) > depth(t.ch[1].ch[1])) {
t.ch[1] = rotate(t.ch[1], 1);
}
t = rotate(t, 0);
}
return t;
}
private final Node<T> insert(final Node<T> t, final int k, final T v) {
if(t == null) {
return new Node<T>(v, null, null);
}
final int c = count(t.ch[0]), b = (k > c) ? 1 : 0;
t.ch[b] = insert(t.ch[b], k - (b == 1 ? (c + 1) : 0), v);
update(t);
return fetch(t);
}
private final Node<T> erase(final Node<T> t) {
if(t == null || t.ch[0] == null && t.ch[1] == null) {
return null;
}
if(t.ch[0] == null || t.ch[1] == null) {
return t.ch[t.ch[0] == null ? 1 : 0];
}
return fetch(update(new Node<T>(find(t.ch[1], 0).val, t.ch[0], erase(t.ch[1], 0))));
}
private final Node<T> erase(Node<T> t, final int k) {
if(t == null) {
return null;
}
final int c = count(t.ch[0]);
if(k < c) {
t.ch[0] = erase(t.ch[0], k);
t = update(t);
}
else if(k > c) {
t.ch[1] = erase(t.ch[1], k - (c + 1));
t = update(t);
}
else {
t = erase(t);
}
return fetch(t);
}
private final Node<T> find(final Node<T> t, final int k) {
if(t == null) {
return t;
}
final int c = count(t.ch[0]);
return k < c ? find(t.ch[0], k) : k == c ? t : find(t.ch[1], k - (c + 1));
}
private final int cnt(final Node<T> t, final T v) {
if(t == null) {
return 0;
}
if(t.val.compareTo(v) < 0) {
return count(t.ch[0]) + 1 + cnt(t.ch[1], v);
}
if(t.val.equals(v)) {
return count(t.ch[0]);
}
return cnt(t.ch[0], v);
}
AVLTree(){ root = null; }
final void add(final T val){ root = insert(root, cnt(root, val), val); }
final void remove(final int k){ root = erase(root, k); }
final T get(final int k){ return find(root, k).val; }
final int count(final T val){ return cnt(root, val); }
final int size(){ return root.size; }
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < root.size;) {
sb.append(" ");
sb.append(get(i));
}
return "[" + sb.toString() + "]";
}
}
final class DoubleEndedPriorityQueue<T extends Number> {
private final ArrayList<T> d;
DoubleEndedPriorityQueue(final ArrayList<T> d) {
this.d = d;
makeHeap();
}
private final void makeHeap() {
for(int i = d.size(); i-- > 0;) {
if (i % 2 == 1 && d.get(i - 1).longValue() < d.get(i).longValue()) {
Collections.swap(d, i - 1, i);
}
up(down(i), i);
}
}
private final int down(int k) {
final int n = d.size();
if(k % 2 == 1) {
while(2 * k + 1 < n) {
int c = 2 * k + 3;
if(n <= c || d.get(c - 2).longValue() < d.get(c).longValue()) {
c -= 2;
}
if(c < n && d.get(c).longValue() < d.get(k).longValue()) {
Collections.swap(d, k, c);
k = c;
}
else {
break;
}
}
} else {
while(2 * k + 2 < n) {
int c = 2 * k + 4;
if(n <= c || d.get(c).longValue() < d.get(c - 2).longValue()) {
c -= 2;
}
if(c < n && d.get(k).longValue() < d.get(c).longValue()) {
Collections.swap(d, k, c);
k = c;
}
else {
break;
}
}
}
return k;
}
private final int up(int k, final int root) {
if((k | 1) < d.size() && d.get(k & ~1).longValue() < d.get(k | 1).longValue()) {
Collections.swap(d, k & ~1, k | 1);
k ^= 1;
}
int p;
while(root < k && d.get(p = parent(k)).longValue() < d.get(k).longValue()) {
Collections.swap(d, p, k);
k = p;
}
while(root < k && d.get(k).longValue() < d.get(p = parent(k) | 1).longValue()) {
Collections.swap(d, p, k);
k = p;
}
return k;
}
private final int parent(final int k){ return ((k >> 1) - 1) & ~1; }
private final void popBack(final ArrayList<T> d){ d.remove(d.size() - 1); }
final void push(final T x) {
final int k = d.size();
d.add(x);
up(k, 1);
}
final T popMin() {
final T res = getMin();
if(d.size() < 3) {
popBack(d);
} else {
Collections.swap(d, 1, d.size() - 1);
popBack(d);
up(down(1), 1);
}
return res;
}
final T popMax() {
final T res = getMax();
if(d.size() < 2) {
popBack(d);
} else {
Collections.swap(d, 0, d.size() - 1);
popBack(d);
up(down(0), 1);
}
return res;
}
final T getMin(){ return d.size() < 2 ? d.get(0) : d.get(1); }
final T getMax(){ return d.get(0); }
final int size(){ return d.size(); }
final boolean isEmpty(){ return d.isEmpty(); }
}
final class FenwickTree {
private final int n;
private final long[] data;
FenwickTree(final int n) {
this.n = n + 2;
data = new long[this.n + 1];
}
FenwickTree(final int[] a) {
this(a.length);
IntStream.range(0, a.length).forEach(i -> add(i, a[i]));
}
FenwickTree(final long[] a) {
this(a.length);
IntStream.range(0, a.length).forEach(i -> add(i, a[i]));
}
final long sum(int k) {
if(k < 0) {
return 0;
}
long ret = 0;
for(++k; k > 0; k -= k & -k) {
ret += data[k];
}
return ret;
}
final long sum(final int l, final int r){ return sum(r) - sum(l - 1); }
final long get(final int k){ return sum(k) - sum(k - 1); }
final void add(int k, final long x) {
for(++k; k < n; k += k & -k) {
data[k] += x;
}
}
final void add(final int l, final int r, final long x) {
add(l, x);
add(r + 1, -x);
}
private final int lg(final int n){ return 31 - Integer.numberOfLeadingZeros(n); }
final int lowerBound(long w) {
if(w <= 0) {
return 0;
}
int x = 0;
for(int k = 1 << lg(n); k > 0; k >>= 1) {
if(x + k <= n - 1 && data[x + k] < w) {
w -= data[x + k];
x += k;
}
}
return x;
}
final int upperBound(long w) {
if(w < 0) {
return 0;
}
int x = 0;
for(int k = 1 << lg(n); k > 0; k >>= 1) {
if(x + k <= n - 1 && data[x + k] <= w) {
w -= data[x + k];
x += k;
}
}
return x;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(sum(0));
for(int i = 0; ++i < n - 2;) {
sb.append(" " + sum(i));
}
return sb.toString();
}
}
final class RangeBIT {
private final int n;
private final FenwickTree a, b;
RangeBIT(final int n) {
this.n = n;
a = new FenwickTree(n + 1);
b = new FenwickTree(n + 1);
}
RangeBIT(final int[] arr) {
this(arr.length);
for(int i = 0; i < arr.length; ++i) {
add(i, i, arr[i]);
}
}
RangeBIT(final long[] arr) {
this(arr.length);
for(int i = 0; i < arr.length; ++i) {
add(i, i, arr[i]);
}
}
final void add(final int l, final int r, final long x) {
a.add(l, x);
a.add(r, -x);
b.add(l, x * (1 - l));
b.add(r, x * (r - 1));
}
final long get(final int i){ return sum(i, i + 1); }
final long sum(int l, int r) {
l--;
r--;
return a.sum(r) * r + b.sum(r) - a.sum(l) * l - b.sum(l);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class SegmentTree<T> {
private int n = 1, rank = 0;
private final int fini;
private final BinaryOperator<T> op;
private final T e;
private final Object[] dat;
SegmentTree(final int fini, final BinaryOperator<T> op, final T e) {
this.fini = fini;
this.op = op;
this.e = e;
while(this.fini > n) {
n <<= 1;
rank++;
}
dat = new Object[2 * n];
Arrays.fill(dat, e);
}
SegmentTree(final T[] a, final BinaryOperator<T> op, final T e) {
this(a.length, op, e);
IntStream.range(0, a.length).forEach(i -> update(i, a[i]));
}
@SuppressWarnings("unchecked")
final void update(int i, final T x) {
i += n;
dat[i] = x;
do {
i >>= 1;
dat[i] = op.apply((T) dat[2 * i], (T) dat[2 * i + 1]);
} while(i > 0);
}
final T get(final int i){ return query(i, i + 1); }
@SuppressWarnings("unchecked")
final T query(int a, int b) {
T l = e, r = e;
for(a += n, b += n; a < b; a >>= 1, b >>= 1) {
if(a % 2 == 1) {
l = op.apply(l, (T) dat[a++]);
}
if(b % 2 == 1) {
r = op.apply((T) dat[--b], r);
}
}
return op.apply(l, r);
}
@SuppressWarnings("unchecked")
final T all(){ return (T) dat[1]; }
@SuppressWarnings("unchecked")
final int findLeft(final int r, final Predicate<T> fn) {
if(r == 0) {
return 0;
}
int h = 0, i = r + n;
T val = e;
for(; h <= rank; h++) {
if(i >> (h & 1) > 0) {
final T val2 = op.apply(val, (T) dat[i >> (h ^ 1)]);
if(fn.test(val2)){
i -= 1 << h;
if(i == n) {
return 0;
}
val = val2;
}
else {
break;
}
}
}
for(; h-- > 0;) {
final T val2 = op.apply(val, (T) dat[(i >> h) - 1]);
if(fn.test(val2)){
i -= 1 << h;
if(i == n) {
return 0;
}
val = val2;
}
}
return i - n;
}
@SuppressWarnings("unchecked")
final int findRight(final int l, final Predicate<T> fn) {
if(l == fini) {
return fini;
}
int h = 0, i = l + n;
T val = e;
for(; h <= rank; h++) {
if(i >> (h & 1) > 0){
final T val2 = op.apply(val, (T) dat[i >> h]);
if(fn.test(val2)){
i += 1 << h;
if(i == n * 2) {
return fini;
}
val = val2;
}
else {
break;
}
}
}
for(; h-- > 0;) {
final T val2 = op.apply(val, (T) dat[i >> h]);
if(fn.test(val2)) {
i += 1 << h;
if(i == n * 2) {
return fini;
}
val = val2;
}
}
return min(i - n, fini);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < fini;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
class LazySegmentTree<T, U extends Comparable<? super U>> {
private final int n;
private int sz, h;
private final Object[] data, lazy;
private final BinaryOperator<T> f;
private final BiFunction<T, U, T> map;
private final BinaryOperator<U> comp;
private final T e;
private final U id;
@SuppressWarnings("unchecked")
private final void update(final int k){ data[k] = f.apply((T) data[2 * k], (T) data[2 * k + 1]); }
@SuppressWarnings("unchecked")
private final void allApply(final int k, final U x) {
data[k] = map.apply((T) data[k], x);
if(k < sz) {
lazy[k] = comp.apply((U) lazy[k], x);
}
}
@SuppressWarnings("unchecked")
private final void propagate(final int k) {
if(!lazy[k].equals(id)) {
allApply(2 * k, (U) lazy[k]);
allApply(2 * k + 1, (U) lazy[k]);
lazy[k] = id;
}
}
LazySegmentTree(final int n, final BinaryOperator<T> f, final BiFunction<T, U, T> map, final BinaryOperator<U> comp, final T e, final U id) {
this.n = n;
this.f = f;
this.map = map;
this.comp = comp;
this.e = e;
this.id = id;
sz = 1;
h = 0;
while(sz < n) {
sz <<= 1;
h++;
}
data = new Object[2 * sz];
Arrays.fill(data, e);
lazy = new Object[2 * sz];
Arrays.fill(lazy, id);
}
LazySegmentTree(final T[] a, final BinaryOperator<T> f, final BiFunction<T, U, T> map, final BinaryOperator<U> comp, final T e, final U id) {
this(a.length, f, map, comp, e, id);
build(a);
}
final void build(final T[] a) {
assert n == a.length;
for(int k = 0; k < n; ++k) {
data[k + sz] = a[k];
}
for(int k = sz; --k > 0;) {
update(k);
}
}
final void set(int k, final T x) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
data[k] = x;
for(int i = 0; ++i <= h;) {
update(k >> i);
}
}
@SuppressWarnings("unchecked")
final T get(int k) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
return (T) data[k];
}
@SuppressWarnings("unchecked")
final T query(int l, int r) {
if(l >= r) {
return e;
}
l += sz;
r += sz;
for(int i = h; i > 0; i--) {
if(((l >> i) << i) != l) {
propagate(l >> i);
}
if(((r >> i) << i) != r) {
propagate((r - 1) >> i);
}
}
T l2 = e, r2 = e;
for(; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
l2 = f.apply(l2, (T) data[l++]);
}
if(r % 2 == 1) {
r2 = f.apply((T) data[--r], r2);
}
}
return f.apply(l2, r2);
}
@SuppressWarnings("unchecked")
final T all(){ return (T) data[1]; }
@SuppressWarnings("unchecked")
final void apply(int k, final U x) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
data[k] = map.apply((T) data[k], x);
for(int i = 0; ++i <= h;) {
update(k >> i);
}
}
final void apply(int l, int r, final U x) {
if(l >= r) {
return;
}
l += sz;
r += sz;
for(int i = h; i > 0; i--) {
if(((l >> i) << i) != l) {
propagate(l >> i);
}
if(((r >> i) << i) != r) {
propagate((r - 1) >> i);
}
}
int l2 = l, r2 = r;
for(; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
allApply(l++, x);
}
if(r % 2 == 1) {
allApply(--r, x);
}
}
l = l2;
r = r2;
for(int i = 0; ++i <= h;) {
if(((l >> i) << i) != l) {
update(l >> i);
}
if(((r >> i) << i) != r) {
update((r - 1) >> i);
}
}
}
@SuppressWarnings("unchecked")
final int findFirst(int l, final Predicate<T> fn) {
if(l >= n) {
return n;
}
l += sz;
for(int i = h; i > 0; i--) {
propagate(l >> i);
}
T sum = e;
do {
while((l & 1) == 0) {
l >>= 1;
}
if(fn.test(f.apply(sum, (T) data[l]))) {
while(l < sz) {
propagate(l);
l <<= 1;
final T nxt = f.apply(sum, (T) data[l]);
if(!fn.test(nxt)) {
sum = nxt;
l++;
}
}
return l + 1 - sz;
}
sum = f.apply(sum, (T) data[l++]);
} while((l & -l) != l);
return n;
}
@SuppressWarnings("unchecked")
final int findLast(int r, final Predicate<T> fn) {
if(r <= 0) {
return -1;
}
r += sz;
for(int i = h; i > 0; i--) {
propagate((r - 1) >> i);
}
T sum = e;
do {
r--;
while(r > 1 && r % 2 == 1) {
r >>= 1;
}
if(fn.test(f.apply((T) data[r], sum))) {
while(r < sz) {
propagate(r);
r = (r << 1) + 1;
final T nxt = f.apply((T) data[r], sum);
if(!fn.test(nxt)) {
sum = nxt;
r--;
}
}
return r - sz;
}
sum = f.apply((T) data[r], sum);
} while((r & -r) != r);
return -1;
}
final void clear(){ Arrays.fill(data, e); }
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class Zwei<T> implements Cloneable {
public T first, second;
private Zwei(final T first, final T second) {
this.first = first;
this.second = second;
}
static final <T> Zwei<T> of(final T f, final T s){ return new Zwei<>(f, s); }
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Zwei<?> z = (Zwei<?>) o;
return first.equals(z.first) && second.equals(z.second);
}
@Override
public final int hashCode(){ return Objects.hash(first, second); }
@Override
public final String toString(){ return String.valueOf(first); }
@SuppressWarnings("unchecked")
@Override
public final Zwei<T> clone() {
try {
return (Zwei<T>) super.clone();
} catch(final CloneNotSupportedException e){
e.printStackTrace();
}
throw new Error();
}
}
final class RAMX extends LazySegmentTree<Long, Long> {
RAMX(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, Long::sum, Long::sum, Long.valueOf(Long.MIN_VALUE), Long.valueOf(0)); }
RAMX(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, Long::sum, Long::sum, Long.valueOf(Long.MIN_VALUE), Long.valueOf(0)); }
}
final class RAMN extends LazySegmentTree<Long, Long> {
RAMN(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, Long::sum, Long::sum, Long.valueOf(Long.MAX_VALUE), Long.valueOf(0)); }
RAMN(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, Long::sum, Long::sum, Long.valueOf(Long.MAX_VALUE), Long.valueOf(0)); }
}
final class RASM extends LazySegmentTree<Zwei<Long>, Long> {
private final int n;
private final Zwei<Long>[] b;
@SuppressWarnings("unchecked")
RASM(final int[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.first.longValue() + x.second.longValue() * y.longValue(), x.second.longValue()), Long::sum, Zwei.of(0L, 0L), Long.valueOf(0));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of((long) a[i], 1L);
}
build(b);
}
@SuppressWarnings("unchecked")
RASM(final long[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.first.longValue() + x.second.longValue() * y.longValue(), x.second.longValue()), Long::sum, Zwei.of(0L, 0L), Long.valueOf(0));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of(a[i], 1L);
}
build(b);
}
}
final class RUMX extends LazySegmentTree<Long, Long> {
RUMX(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE)); }
RUMX(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE)); }
}
final class RUMN extends LazySegmentTree<Long, Long> {
RUMN(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE)); }
RUMN(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE)); }
}
final class RUSM extends LazySegmentTree<Zwei<Long>, Long> {
private final int n;
private final Zwei<Long>[] b;
@SuppressWarnings("unchecked")
RUSM(final int[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.second.longValue() * y.longValue(), x.second.longValue()), (x, y) -> y, Zwei.of(0L, 0L), Long.valueOf(Long.MIN_VALUE));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of((long) a[i], 1L);
}
build(b);
}
@SuppressWarnings("unchecked")
RUSM(final long[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.second.longValue() * y.longValue(), x.second.longValue()), (x, y) -> y, Zwei.of(0L, 0L), Long.valueOf(Long.MIN_VALUE));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of(a[i], 1L);
}
build(b);
}
}
final class DualSegmentTree<T> {
private final int n;
private int sz, h;
private final Object[] lazy;
private final T id;
private final BinaryOperator<T> ap;
@SuppressWarnings("unchecked")
private final void propagate(final int k) {
if(lazy[k] != id) {
lazy[2 * k] = ap.apply((T) lazy[2 * k], (T) lazy[k]);
lazy[2 * k + 1] = ap.apply((T) lazy[2 * k + 1], (T) lazy[k]);
lazy[k] = id;
}
}
private final void thrust(final int k) {
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
}
DualSegmentTree(final int n, final BinaryOperator<T> ap, final T id) {
this.n = n;
this.ap = ap;
this.id = id;
sz = 1;
h = 0;
while(sz < n) {
sz <<= 1;
h++;
}
lazy = new Object[2 * sz];
Arrays.fill(lazy, id);
}
@SuppressWarnings("unchecked")
final void apply(int a, int b, final T x) {
thrust(a += sz);
thrust(b += sz - 1);
for(int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
lazy[l] = ap.apply((T) lazy[l], x);
l++;
}
if(r % 2 == 1) {
r--;
lazy[r] = ap.apply((T) lazy[r], x);
}
}
}
@SuppressWarnings("unchecked")
final T get(int k) {
thrust(k += sz);
return (T) lazy[k];
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class SparseTable {
private final long[][] st;
private final int[] lookup;
private final LongBinaryOperator op;
SparseTable(final int[] a, final LongBinaryOperator op) {
this.op = op;
int b = 0;
while((1 << b) <= a.length) {
++b;
}
st = new long[b][1 << b];
for(int i = 0; i < a.length; i++) {
st[0][i] = a[i];
}
for(int i = 1; i < b; i++) {
for(int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = op.applyAsLong(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
lookup = new int[a.length + 1];
for(int i = 2; i < lookup.length; i++) {
lookup[i] = lookup[i >> 1] + 1;
}
}
SparseTable(final long[] a, final LongBinaryOperator op) {
this.op = op;
int b = 0;
while((1 << b) <= a.length) {
++b;
}
st = new long[b][1 << b];
for(int i = 0; i < a.length; i++) {
st[0][i] = a[i];
}
for(int i = 1; i < b; i++) {
for(int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = op.applyAsLong(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
lookup = new int[a.length + 1];
for(int i = 2; i < lookup.length; i++) {
lookup[i] = lookup[i >> 1] + 1;
}
}
final long query(final int l, final int r) {
final int b = lookup[r - l];
return op.applyAsLong(st[b][l], st[b][r - (1 << b)]);
}
final int minLeft(final int x, final LongPredicate fn) {
if(x == 0) {
return 0;
}
int ok = x, ng = -1;
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(query(mid, x) - 1)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
final int maxRight(final int x, final LongPredicate fn) {
if(x == lookup.length - 1) {
return lookup.length - 1;
}
int ok = x, ng = lookup.length;
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(query(x, mid))) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
}
final class WaveletMatrix {
private final WaveletMatrixBeta mat;
private final long[] ys;
WaveletMatrix(final int[] arr){ this(arr, 20); }
WaveletMatrix(final long[] arr){ this(arr, 20); }
WaveletMatrix(final int[] arr, final int log) {
ys = Arrays.stream(arr).asLongStream().sorted().distinct().toArray();
final long[] t = new long[arr.length];
Arrays.setAll(t, i -> index(arr[i]));
mat = new WaveletMatrixBeta(t, log);
}
WaveletMatrix(final long[] arr, final int log) {
ys = Arrays.stream(arr).sorted().distinct().toArray();
final long[] t = new long[arr.length];
Arrays.setAll(t, i -> index(arr[i]));
mat = new WaveletMatrixBeta(t, log);
}
private final int index(final long x){ return Utility.lowerBound(ys, x); }
final long get(final int k){ return ys[(int) mat.access(k)]; }
final int rank(final int r, final long x) {
final int pos = index(x);
if(pos == ys.length || ys[pos] != x) {
return 0;
}
return mat.rank(pos, r);
}
final int rank(final int l, final int r, final long x){ return rank(r, x) - rank(l, x); }
final long kthMin(final int l, final int r, final int k){ return ys[(int) mat.kthMin(l, r, k)]; }
final long kthMax(final int l, final int r, final int k){ return ys[(int) mat.kthMax(l, r, k)]; }
final int rangeFreq(final int l, final int r, final long upper){ return mat.rangeFreq(l, r, index(upper)); }
final int rangeFreq(final int l, final int r, final long lower, final long upper){ return mat.rangeFreq(l, r, index(lower), index(upper)); }
final long prev(final int l, final int r, final long upper) {
final long ret = mat.prev(l, r, index(upper));
return ret == -1 ? -1 : ys[(int) ret];
}
final long next(final int l, final int r, final long lower) {
final long ret = mat.next(l, r, index(lower));
return ret == -1 ? -1 : ys[(int) ret];
}
private final class WaveletMatrixBeta {
private final int log;
private final SuccinctIndexableDictionary[] matrix;
private final int[] mid;
WaveletMatrixBeta(final long[] arr, final int log) {
final int len = arr.length;
this.log = log;
matrix = new SuccinctIndexableDictionary[log];
mid = new int[log];
final long[] l = new long[len], r = new long[len];
for(int level = log; --level >= 0;) {
matrix[level] = new SuccinctIndexableDictionary(len + 1);
int left = 0, right = 0;
for(int i = 0; i < len; ++i) {
if(((arr[i] >> level) & 1) == 1) {
matrix[level].set(i);
r[right++] = arr[i];
} else {
l[left++] = arr[i];
}
}
mid[level] = left;
matrix[level].build();
final long[] tmp = new long[len];
System.arraycopy(arr, 0, tmp, 0, len);
System.arraycopy(l, 0, arr, 0, len);
System.arraycopy(tmp, 0, l, 0, len);
for(int i = 0; i < right; ++i) {
arr[left + i] = r[i];
}
}
}
private final IntPair succ(final boolean f, final int l, final int r, final int level){ return IntPair.of(matrix[level].rank(f, l) + mid[level] * (f ? 1 : 0), matrix[level].rank(f, r) + mid[level] * (f ? 1 : 0)); }
final long access(int k) {
long ret = 0;
for(int level = log; --level >= 0;) {
final boolean f = matrix[level].get(k);
if(f) {
ret |= 1L << level;
}
k = matrix[level].rank(f, k) + mid[level] * (f ? 1 : 0);
}
return ret;
}
final int rank(final long x, int r) {
int l = 0;
for(int level = log; --level >= 0;) {
final IntPair p = succ(((x >> level) & 1) == 1, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return r - l;
}
final long kthMin(int l, int r, int k) {
if(!Utility.scope(0, k, r - l - 1)) {
throw new IndexOutOfBoundsException();
}
long ret = 0;
for(int level = log; --level >= 0;) {
final int cnt = matrix[level].rank(false, r) - matrix[level].rank(false, l);
final boolean f = cnt <= k;
if(f) {
ret |= 1 << level;
k -= cnt;
}
final IntPair p = succ(f, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return ret;
}
final long kthMax(final int l, final int r, final int k){ return kthMin(l, r, r - l - k - 1); }
final int rangeFreq(int l, int r, final long upper) {
int ret = 0;
for(int level = log; --level >= 0;) {
final boolean f = ((upper >> level) & 1) == 1;
if(f) {
ret += matrix[level].rank(false, r) - matrix[level].rank(false, l);
}
final IntPair p = succ(f, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return ret;
}
final int rangeFreq(final int l, final int r, final long lower, final long upper){ return rangeFreq(l, r, upper) - rangeFreq(l, r, lower); }
final long prev(final int l, final int r, final long upper) {
final int cnt = rangeFreq(l, r, upper);
return cnt == 0 ? -1 : kthMin(l, r, cnt - 1);
}
final long next(final int l, final int r, final long lower) {
final int cnt = rangeFreq(l, r, lower);
return cnt == r - l ? -1 : kthMin(l, r, cnt);
}
private final class SuccinctIndexableDictionary {
private final int blk;
private final int[] bit, sum;
SuccinctIndexableDictionary(final int len) {
blk = (len + 31) >> 5;
bit = new int[blk];
sum = new int[blk];
}
final void set(final int k){ bit[k >> 5] |= 1 << (k & 31); }
final void build() {
sum[0] = 0;
for(int i = 0; i + 1 < blk; ++i) {
sum[i + 1] = sum[i] + Integer.bitCount(bit[i]);
}
}
final boolean get(final int k){ return ((bit[k >> 5] >> (k & 31)) & 1) == 1; }
final int rank(final int k){ return (sum[k >> 5] + Integer.bitCount(bit[k >> 5] & ((1 << (k & 31)) - 1))); }
final int rank(final boolean val, final int k){ return val ? rank(k) : k - rank(k); }
}
}
}
import static java.lang.Math.*;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.TreeMap;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoublePredicate;
import java.util.function.IntPredicate;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongPredicate;
import java.util.function.LongUnaryOperator;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
final class Main {
public static void main(final String[] args) {
final long begin = System.currentTimeMillis(), end;
IntStream.range(0, VvyLw.MULTI ? VvyLw.io.ni() : 1).forEach(i -> VvyLw.solve());
end = System.currentTimeMillis();
VvyLw.io.dump(end - begin + "ms");
VvyLw.io.close();
}
}
final class VvyLw extends Utility {
static final IO io = new IO(System.in, System.out, System.err, false);
static final Random rd = new Random();
static final boolean MULTI = false;
static final int INF = 1 << 30;
static final long LINF = (1L << 61) - 1;
static final double EPS = 1e-18;
static final int MOD = 998244353;
static final int M0D = (int) 1e9 + 7;
static final int[] dx = {0, -1, 1, 0, 0, -1, -1, 1, 1};
static final int[] dy = {0, 0, 0, -1, 1, -1, 1, -1, 1};
static final void solve() {
final int n = io.ni();
final var s = io.ns();
final var c = io.ni(n);
final long[] ne = new long[n + 1], no = new long[n + 1], re = new long[n + 1], ro = new long[n + 1];
for(int i = 0; i < n; ++i) {
ne[i + 1] = ne[i];
no[i + 1] = no[i];
if(i % 2 == 0) {
if(s.charAt(i) == '0') {
no[i + 1] += c[i];
} else {
ne[i + 1] += c[i];
}
} else {
if(s.charAt(i) == '0') {
ne[i + 1] += c[i];
} else {
no[i + 1] += c[i];
}
}
}
for(int i = n; --i >= 0;) {
re[i] = re[i + 1];
ro[i] = ro[i + 1];
if(i % 2 == 0) {
if(s.charAt(i) == '0') {
re[i] += c[i];
} else {
ro[i] += c[i];
}
} else {
if(s.charAt(i) == '0') {
ro[i] += c[i];
} else {
re[i] += c[i];
}
}
}
long ans = LINF;
for(int i = 0; ++i < n;) {
ans = min(ans, ne[i] + re[i]);
ans = min(ans, no[i] + ro[i]);
}
io.out(ans);
}
}
class Utility {
protected static final String yes(final boolean ok){ return ok ? "Yes" : "No"; }
protected static final String no(final boolean ok){ return yes(!ok); }
protected static final long sqr(final long x){ return x * x; }
protected static final long cub(final long x){ return x * x * x; }
protected static final int mod(long n, final int m) {
n %= m;
return (int) (n < 0 ? n + m : n);
}
protected static final long mod(long n, final long m) {
n %= m;
return n < 0 ? n + m : n;
}
protected static final double log(final double x, final long base){ return Math.log(x) / Math.log(base); }
protected static final long intCeil(final long a, final long b){ return a == 0 ? 0 : (a - 1) / b + 1; }
protected static final double intRound(final double a, final long b, final int c) {
final long d = intPow(10, c);
return rint((a * d) / b) / d;
}
protected static final long intPow(long a, int b) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
protected static final long intPow(long a, long b, final long m) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
res = mod(res, m);
}
a *= a;
a = mod(a, m);
b >>= 1;
}
return res;
}
protected static final long inv(long a, final long m) {
long b = m, u = 1, v = 0;
while(b > 0) {
final long t = a / b;
a -= t * b;
a ^= b;
b ^= a;
a ^= b;
u -= t * v;
u ^= v;
v ^= u;
u ^= v;
}
return mod(u, m);
}
protected static final long lcm(final long a, final long b){ return a / gcd(a, b) * b; }
protected static final long lcm(final int... a){ return Arrays.stream(a).asLongStream().reduce(1, (x, y) -> lcm(x, y)); }
protected static final long lcm(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> lcm(x, y)); }
protected static final long gcd(final long a, final long b){ return b > 0 ? gcd(b, a % b) : a; }
protected static final int gcd(final int... a){ return Arrays.stream(a).reduce(0, (x, y) -> (int) gcd(x, y)); }
protected static final long gcd(final long... a){ return Arrays.stream(a).reduce(0, (x, y) -> gcd(x, y)); }
protected static final int min(final int... a){ return Arrays.stream(a).min().getAsInt(); }
protected static final long min(final long... a){ return Arrays.stream(a).min().getAsLong(); }
protected static final double min(final double... a){ return Arrays.stream(a).min().getAsDouble(); }
protected static final int max(final int... a){ return Arrays.stream(a).max().getAsInt(); }
protected static final long max(final long... a){ return Arrays.stream(a).max().getAsLong(); }
protected static final double max(final double... a){ return Arrays.stream(a).max().getAsDouble(); }
protected static final long sum(final int... a){ return Arrays.stream(a).asLongStream().sum(); }
protected static final long sum(final long... a){ return Arrays.stream(a).sum(); }
protected static final double sum(final double... a){ return Arrays.stream(a).sum(); }
protected static final long prod(final int... a){ return Arrays.stream(a).asLongStream().reduce(1, (x, y) -> x * y); }
protected static final long prod(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> x * y); }
protected static final double prod(final double... a){ return Arrays.stream(a).reduce(1, (x, y) -> x * y); }
protected static final double ave(final int... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double ave(final long... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double ave(final double... a){ return Arrays.stream(a).average().getAsDouble(); }
protected static final double median(final int[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2.0;
}
protected static final double median(final long[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2.0;
}
protected static final double median(final double[] a) {
assert isSorted(a);
final int m = a.length / 2;
return a.length % 2 != 0 ? a[m] : (a[m - 1] + a[m]) / 2;
}
protected static final long[] div(final long n) {
final ArrayList<Long> d = new ArrayList<>();
for(long i = 1; i * i <= n; ++i) {
if(n % i == 0) {
d.add(i);
if(i * i != n) {
d.add(n / i);
}
}
}
return d.stream().mapToLong(i -> i).sorted().toArray();
}
protected static final IntPair[] primeFactor(long n) {
final ArrayList<IntPair> pf = new ArrayList<>();
for(long i = 2; i * i <= n; ++i) {
if(n % i != 0) {
continue;
}
int cnt = 0;
while(n % i == 0) {
cnt++;
n /= i;
}
pf.add(IntPair.of(i, cnt));
}
if(n != 1) {
pf.add(IntPair.of(n, 1));
}
return pf.toArray(IntPair[]::new);
}
protected static final long eulerPhi(long n) {
long res = n;
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) {
res -= res / i;
while(n % i == 0) {
n /= i;
}
}
}
if(n > 1) {
res -= res / n;
}
return res;
}
protected static final long sigma(final long n){ return n * (n + 1) / 2; }
protected static final long sigma(final long a, final long b) {
assert a <= b;
return sigma(b) - sigma(a - 1);
}
protected static final long fact(int n) {
long res = 1;
while(n > 0) {
res *= n--;
}
return res;
}
protected static final long fact(int n, final long mod) {
long res = 1;
while(n > 0) {
res *= n--;
res %= mod;
}
return res;
}
protected static final long perm(final int n, final int r) {
int m = n;
long res = 1;
while(m > n - r) {
res *= m--;
}
return res;
}
protected static final long perm(final int n, final int r, final long mod) {
int m = n;
long res = 1;
while(m > n - r) {
res *= m--;
res %= mod;
}
return res;
}
protected static final long binom(final int n, final int r) {
if(r < 0 || n < r) {
return 0;
}
int tmp = n;
long res = 1;
for(int i = 1; i <= min(n - r, r); ++i) {
res *= tmp--;
res /= i;
}
return res;
}
protected static final long binom(final int n, final int r, final long mod) {
if(r < 0 || n < r) {
return 0;
}
int tmp = n;
long res = 1;
for(int i = 1; i <= min(n - r, r); ++i) {
res *= tmp--;
res = mod;
res /= i;
res %= mod;
}
return res;
}
protected static final boolean isInt(final double n){ return n == (long) floor(n); }
protected static final boolean isSqr(final long n){ return isInt(sqrt(n)); }
protected static final boolean isPrime(final long n) {
if(n == 1) {
return false;
}
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) {
return false;
}
}
return true;
}
protected static final boolean scope(final int l, final int x, final int r){ return l <= x && x <= r; }
protected static final boolean scope(final long l, final long x, final long r){ return l <= x && x <= r; }
protected static final boolean scope(final double l, final double x, final double r){ return l <= x && x <= r; }
protected static final int clamp(final int l, final int x, final int r){ return x < l ? l : x > r ? r : x; }
protected static final long clamp(final long l, final long x, final long r){ return x < l ? l : x > r ? r : x; }
protected static final double clamp(final double l, final double x, final double r){ return x < l ? l : x > r ? r : x; }
protected static final boolean isBit(final long i, final long j){ return (i >> j & 1) == 1; }
protected static final boolean nextPerm(final int[] a) {
try {
final int[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final long[] a) {
try {
final long[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final double[] a) {
try {
final double[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean nextPerm(final char[] a) {
try {
final char[] res = nextPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
Arrays.sort(a);
return false;
}
}
protected static final boolean prevPerm(final int[] a) {
try {
final int[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final int[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final long[] a) {
try {
final long[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final long[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final double[] a) {
try {
final double[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final double[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
protected static final boolean prevPerm(final char[] a) {
try {
final char[] res = prevPermutation(a);
System.arraycopy(res, 0, a, 0, a.length);
return true;
} catch(final NullPointerException e) {
final char[] res = reverse(sorted(a));
System.arraycopy(res, 0, a, 0, a.length);
return false;
}
}
private static final int[] nextPermutation(final int[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final long[] nextPermutation(final long[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final double[] nextPermutation(final double[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final char[] nextPermutation(final char[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] < a[i]) {
final int j = find(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
return a;
}
}
return null;
}
private static final int[] prevPermutation(final int[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final long[] prevPermutation(final long[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final double[] prevPermutation(final double[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final char[] prevPermutation(final char[] a) {
for(int i = a.length; --i > 0;) {
if(a[i - 1] > a[i]) {
final int j = findRev(a[i - 1], a, i, a.length - 1);
swap(a, i - 1, j);
Arrays.sort(a, i, a.length);
reverse(a, i, a.length - 1);
return a;
}
}
return null;
}
private static final int find(final int dest, final int[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final long dest, final long[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final double dest, final double[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final char dest, final char[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int findRev(final int dest, final int[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final long dest, final long[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final double dest, final double[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final char dest, final char[] a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a[m] > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static void reverse(final int[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final long[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final double[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
private static void reverse(final char[] arr, int start, int end) {
while(start < end) {
swap(arr, start, end);
start++;
end--;
}
}
protected static final int find(final int[] a, final int x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final long[] a, final long x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final double[] a, final double x) {
for(int i = 0; i < a.length; ++i) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int find(final char[] s, final char c) {
for(int i = 0; i < s.length; ++i) {
if(s[i] == c) {
return i;
}
}
return -1;
}
protected static final int find(final Object[] a, final Object x) {
for(int i = 0; i < a.length; ++i) {
if(a[i].equals(x)) {
return i;
}
}
return -1;
}
protected static final int findRev(final int[] a, final int x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final long[] a, final long x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final double[] a, final double x) {
for(int i = a.length; --i >= 0;) {
if(a[i] == x) {
return i;
}
}
return -1;
}
protected static final int findRev(final char[] s, final char c) {
for(int i = s.length; --i >= 0;) {
if(s[i] == c) {
return i;
}
}
return -1;
}
protected static final int findRev(final Object[] a, final Object x) {
for(int i = a.length; --i >= 0;) {
if(a[i].equals(x)) {
return i;
}
}
return -1;
}
protected static final boolean binarySearch(final int[] a, final int x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final boolean binarySearch(final long[] a, final long x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final <T extends Comparable<? super T>> boolean binarySearch(final T[] a, final T x){ return Arrays.binarySearch(a, x) >= 0; }
protected static final <T extends Comparable<? super T>> boolean binarySearch(final List<T> a, final T x){ return Collections.binarySearch(a, x, null) >= 0; }
protected static final int lowerBound(final int[] a, final int x){ return bins(a.length, -1, (IntPredicate) y -> a[y] >= x); }
protected static final int lowerBound(final long[] a, final long x){ return bins(a.length, -1, (IntPredicate) y -> a[y] >= x); }
protected static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T x){ return lowerBound(Arrays.asList(a), x); }
protected static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T x){ return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) >= 0 ? 1 : -1); }
protected static final int upperBound(final int[] a, final int x){ return bins(a.length, -1, (IntPredicate) y -> a[y] > x); }
protected static final int upperBound(final long[] a, final long x){ return bins(a.length, -1, (IntPredicate) y -> a[y] > x); }
protected static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T x){ return upperBound(Arrays.asList(a), x); }
protected static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T x){ return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) > 0 ? 1 : -1); }
protected static final String sorted(final String s){ return s.chars().sorted().mapToObj(Character::toString).collect(Collectors.joining()); }
protected static final int[] sorted(final int[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final long[] sorted(final long[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final double[] sorted(final double[] a){ return Arrays.stream(a).sorted().toArray(); }
protected static final char[] sorted(final char[] a){ return sorted(new String(a)).toCharArray(); }
protected static final <T extends Comparable<? super T>> T[] sorted(final T[] a){ return Arrays.stream(a).sorted().toArray(n -> Arrays.copyOf(a, n)); }
protected static final boolean isSorted(final String s){ return s.equals(sorted(s)); }
protected static final boolean isSorted(final int[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final long[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final double[] a){ return Arrays.equals(a, sorted(a)); }
protected static final boolean isSorted(final char[] a){ return Arrays.equals(a, sorted(a)); }
protected static final <T extends Comparable<? super T>> boolean isSorted(final T[] a){ return Arrays.equals(a, sorted(a)); }
protected static final String reverse(final String s){ return new StringBuilder(s).reverse().toString(); }
protected static final int[] reverse(final int[] a) {
final int n = a.length;
final int[] b = new int[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final long[] reverse(final long[] a) {
final int n = a.length;
final long[] b = new long[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final double[] reverse(final double[] a) {
final int n = a.length;
final double[] b = new double[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final char[] reverse(final char[] a) {
final int n = a.length;
final char[] b = new char[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final Object[] reverse(final Object[] a) {
final int n = a.length;
final Object[] b = new Object[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final int[] rotate(final int[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final int[] res = new int[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final long[] rotate(final long[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final long[] res = new long[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final double[] rotate(final double[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final double[] res = new double[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final char[] rotate(final char[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final char[] res = new char[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final boolean[] rotate(final boolean[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final boolean[] res = new boolean[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final Object[] rotate(final Object[] a, final int id) {
final int n = a.length, k = (int) mod(id, n);
final Object[] res = new Object[n];
System.arraycopy(a, k, res, 0, n - k);
System.arraycopy(a, 0, res, n - k, k);
return res;
}
protected static final String rotate(final String s, final int id) {
final List<Character> t = s.chars().mapToObj(i -> (char) i).collect(Collectors.toList());
Collections.rotate(t, -id);
return t.stream().map(String::valueOf).collect(Collectors.joining());
}
protected static final int[][] rotateR(final int[][] a) {
final int h = a.length, w = a[0].length;
final int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final long[][] rotateR(final long[][] a) {
final int h = a.length, w = a[0].length;
final long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final double[][] rotateR(final double[][] a) {
final int h = a.length, w = a[0].length;
final double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][i]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final char[][] rotateR(final char[][] a) {
final int h = a.length, w = a[0].length;
final char[][] b = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final int[][] rotateL(final int[][] a) {
final int h = a.length, w = a[0].length;
final int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final long[][] rotateL(final long[][] a) {
final int h = a.length, w = a[0].length;
final long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final double[][] rotateL(final double[][] a) {
final int h = a.length, w = a[0].length;
final double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
Arrays.setAll(b[i], j -> a[j][w - i - 1]);
});
return b;
}
protected static final char[][] rotateL(final char[][] a) {
final int h = a.length, w = a[0].length;
final char[][] b = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[w - j - 1][i] = a[i][j]);
});
return b;
}
protected static final void swap(final int[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final long[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final double[] a, final int i, final int j) {
final double tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
protected static final void swap(final char[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final boolean[] a, final int i, final int j) {
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
protected static final void swap(final Object[] a, final int i, final int j) {
final Object tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
protected static final void swap(final int[] a, final int[] b) {
assert a.length == b.length;
final int n = a.length;
final int[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final long[] a, final long[] b) {
assert a.length == b.length;
final int n = a.length;
final long[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final double[] a, final double[] b) {
assert a.length == b.length;
final int n = a.length;
final double[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final char[] a, final char[] b) {
assert a.length == b.length;
final int n = a.length;
final char[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final boolean[] a, final boolean[] b) {
assert a.length == b.length;
final int n = a.length;
final boolean[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final void swap(final Object[] a, final Object[] b) {
assert a.length == b.length;
final int n = a.length;
final Object[] c = a.clone();
System.arraycopy(b, 0, a, 0, n);
System.arraycopy(c, 0, b, 0, n);
}
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> Pair<S, F>[] swap(final Pair<F, S>[] p) {
@SuppressWarnings("unchecked")
final Pair<S, F>[] q = new Pair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
protected static final IntPair[] swap(final IntPair[] p) {
final IntPair[] q = new IntPair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
protected static final FloatPair[] swap(final FloatPair[] p) {
final FloatPair[] q = new FloatPair[p.length];
Arrays.setAll(q, i -> p[i].swap());
return q;
}
@SuppressWarnings("unchecked")
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> F[] first(final Pair<F, S>[] p){ return (F[]) Arrays.stream(p).map(i -> i.first).toArray(); }
protected static final long[] first(final IntPair[] p){ return Arrays.stream(p).mapToLong(i -> i.first).toArray(); }
protected static final double[] first(final FloatPair[] p){ return Arrays.stream(p).mapToDouble(i -> i.first).toArray(); }
@SuppressWarnings("unchecked")
protected static final <F extends Comparable<? super F>, S extends Comparable<? super S>> S[] second(final Pair<F, S>[] p){ return (S[]) Arrays.stream(p).map(i -> i.second).toArray(); }
protected static final long[] second(final IntPair[] p){ return Arrays.stream(p).mapToLong(i -> i.second).toArray(); }
protected static final double[] second(final FloatPair[] p){ return Arrays.stream(p).mapToDouble(i -> i.second).toArray(); }
protected static final IntStream iota(final int n){ return IntStream.range(0, n); }
protected static final IntStream iota(final int n, final int init){ return IntStream.range(0 + init, n + init); }
protected static final int bins(int ok, int ng, final IntPredicate fn) {
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final long bins(long ok, long ng, final LongPredicate fn) {
while(abs(ok - ng) > 1) {
final long mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final double bins(double ok, double ng, final DoublePredicate fn) {
while(abs(ok - ng) > VvyLw.EPS) {
final double mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final Map<Integer, Integer> counter(final int[] a) {
final Map<Integer, Integer> res = new HashMap<>();
for(final int i: a) {
res.merge(i, 1, (x, y) -> x + y);
}
return res;
}
protected static final Map<Long, Integer> counter(final long[] a) {
final Map<Long, Integer> res = new HashMap<>();
for(final long i: a) {
res.merge(i, 1, (x, y) -> x + y);
}
return res;
}
protected static final long innerProd(final IntPair... p){ return iota(p.length).mapToLong(i -> p[i].first.longValue() * p[i].second.longValue()).sum(); }
protected static final double innerProd(final FloatPair... p){ return iota(p.length).mapToDouble(i -> p[i].first.doubleValue() * p[i].second.doubleValue()).sum(); }
protected static final FloatPair intersection(final IntPair a, final long sec1, final IntPair b, final long sec2) {
double m1, m2, b1, b2;
if(a.second.longValue() == 0 && b.second.longValue() == 0) {
return null;
} else if(a.second.longValue() == 0) {
m2 = -b.first.doubleValue() / b.second.longValue();
b2 = -sec2 / b.second.doubleValue();
final double x = -sec1 / a.first.doubleValue(), y = b2 + m2 * x;
return FloatPair.of(x, y);
} else if(b.second.longValue() == 0) {
m1 = -a.first.doubleValue() / a.second.longValue();
b1 = -sec1 / a.second.doubleValue();
final double x = -sec2 / b.first.doubleValue(), y = b1 + m1 * x;
return FloatPair.of(x, y);
}
m1 = -a.first.doubleValue() / a.second.longValue();
m2 = -b.first.doubleValue() / b.second.longValue();
b1 = -sec1 / a.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
assert m1 != m2;
final double x = (b1 - b2) / (m2 - m1), y = m1 * x + b1;
return FloatPair.of(x, y);
}
protected static final FloatPair intersection(final FloatPair a, final double sec1, final FloatPair b, final double sec2) {
double m1, m2, b1, b2;
if(a.second.doubleValue() == 0 && b.second.doubleValue() == 0) {
return null;
} else if(a.second.doubleValue() == 0) {
m2 = -b.first.doubleValue() / b.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
final double x = -sec1 / a.first.doubleValue(), y = b2 + m2 * x;
return FloatPair.of(x, y);
} else if(b.second.doubleValue() == 0) {
m1 = -a.first.doubleValue() / a.second.doubleValue();
b1 = -sec1 / a.second.doubleValue();
final double x = -sec2 / b.first.doubleValue(), y = b1 + m1 * x;
return FloatPair.of(x, y);
}
m1 = -a.first.doubleValue() / a.second.doubleValue();
m2 = -b.first.doubleValue() / b.second.doubleValue();
b1 = -sec1 / a.second.doubleValue();
b2 = -sec2 / b.second.doubleValue();
assert m1 != m2;
final double x = (b1 - b2) / (m2 - m1), y = m1 * x + b1;
return FloatPair.of(x, y);
}
protected static final int[] corPress(final int[] a) {
final int[] res = new int[a.length];
final int[] x = Arrays.stream(a).sorted().distinct().toArray();
Arrays.setAll(res, i -> lowerBound(x, a[i]));
return res;
}
protected static final int[] corPress(final long[] a) {
final int[] res = new int[a.length];
final long[] x = Arrays.stream(a).sorted().distinct().toArray();
Arrays.setAll(res, i -> lowerBound(x, a[i]));
return res;
}
protected static final String runLenPress(final String s) {
final int n = s.length();
final StringBuilder sb = new StringBuilder();
for(int l = 0; l < n;) {
int r = l + 1;
for(; r < n && s.charAt(l) == s.charAt(r); ++r){}
sb.append(s.charAt(l));
sb.append(r - l);
l = r;
}
return sb.toString();
}
protected static final String runLenRev(final String s) {
final int n = s.length();
final StringBuilder sb = new StringBuilder();
for(int l = 0; l < n;) {
int r = l + 1;
for(; r < n && scope('0', s.charAt(r), '9'); ++r){}
sb.append(String.valueOf(s.charAt(l)).repeat(Integer.parseInt(s.substring(l + 1, r))));
l = r;
}
return sb.toString();
}
protected static final int[] zAlgorithm(final String s) {
final int n = s.length();
int j = 0;
final int[] pre = new int[n];
for(int i = 0; ++i < n;) {
if(i + pre[i - j] < j + pre[j]) {
pre[i] = pre[i - j];
}
else {
int k = max(0, j + pre[j] - i);
while(i + k < n && s.charAt(k) == s.charAt(i + k)) {
++k;
}
pre[i] = k;
j = i;
}
}
pre[0] = n;
return pre;
}
protected static final int[] manacher(final String s_, final boolean calcEven) {
int n = s_.length();
final char[] s;
if(calcEven) {
s = new char[2 * n - 1];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
for(int i = n; --i >= 0;) {
s[2 * i] = s_.charAt(i);
}
final char d = Collections.min(s_.chars().mapToObj(c -> (char) c).collect(Collectors.toList()));
for(int i = 0; i < n - 1; ++i) {
s[2 * i + 1] = d;
}
} else {
s = new char[n];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
}
n = s.length;
final int[] rad = new int[n];
for(int i = 0, j = 0; i < n;) {
while(i - j >= 0 && i + j < n && s[i - j] == s[i + j]) {
++j;
}
rad[i] = j;
int k = 1;
while(i - k >= 0 && i + k < n && k + rad[i - k] < j) {
rad[i + k] = rad[i - k];
++k;
}
i += k;
j -= k;
}
if(calcEven) {
for(int i = 0; i < n; ++i) {
if(((i ^ rad[i]) & 1) == 0) {
rad[i]--;
}
}
} else {
for(int x: rad) {
x = 2 * x - 1;
}
}
return rad;
}
protected static final long kthRoot(final long n, final int k) {
if(k == 1) {
return n;
}
final LongPredicate chk = x -> {
long mul = 1;
for(int j = 0; j < k; ++j) {
try {
mul = multiplyExact(mul, x);
} catch(final ArithmeticException e) {
return false;
}
}
return mul <= n;
};
long ret = 0;
for(int i = 32; --i >= 0;) {
if(chk.test(ret | (1L << i))) {
ret |= 1L << i;
}
}
return ret;
}
protected static final long tetration(final long a, final long b, final long m) {
if(m == 1) {
return 0;
}
if(a == 0) {
return (b & 1) == 0 ? 1 : 0;
}
if(b == 0) {
return 1;
}
if(b == 1) {
return a % m;
}
if(b == 2) {
return intPow(a, a, m);
}
final long phi = eulerPhi(m);
long tmp = tetration(a, b - 1, phi);
if(tmp == 0) {
tmp += phi;
}
return intPow(a, tmp, m);
}
protected static final long floorSum(final long n, final long m, long a, long b) {
long ans = 0;
if(a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if(b >= m) {
ans += n * (b / m);
b %= m;
}
final long ym = (a * n + b) / m, xm = (ym * m - b);
if(ym == 0) {
return ans;
}
ans += (n - (xm + a - 1) / a) * ym;
ans += floorSum(ym, a, m, (a - xm % a) % a);
return ans;
}
}
interface TriFunction<T, U, V, R> {
R apply(final T a, final U b, final V c);
}
interface QuadFunction<A, B, C, D, R> {
R apply(final A a, final B b, final C c, final D d);
}
interface TriConsumer<T, U, V> {
void accept(final T a, final U b, final V c);
}
interface TriPredicate<T, U, V> {
boolean test(final T a, final U b, final V c);
}
interface RecursiveFunction<T, R> {
R apply(final RecursiveFunction<T, R> rec, final T n);
}
interface RecursiveBiFunction<T, U, R> {
R apply(final RecursiveBiFunction<T, U, R> rec, final T n, final U m);
}
interface RecursiveTriFunction<T, U, V, R> {
R apply(final RecursiveTriFunction<T, U, V, R> rec, final T p, final U q, final V r);
}
interface RecursiveUnaryOperator<T> {
T apply(final RecursiveUnaryOperator<T> rec, final T n);
}
interface RecursiveBinaryOperator<T> {
T apply(final RecursiveBinaryOperator<T> rec, final T a, final T b);
}
interface RecursiveConsumer<T> {
void accept(final RecursiveConsumer<T> rec, final T x);
}
interface RecursiveBiConsumer<T, U> {
void accept(final RecursiveBiConsumer<T, U> rec, final T x, final U y);
}
interface RecursiveTriConsumer<T, U, V> {
void accept(final RecursiveTriConsumer<T, U, V> rec, final T x, final U y, final V z);
}
interface RecursivePredicate<T> {
boolean test(final RecursivePredicate<T> rec, final T n);
}
interface RecursiveBiPredicate<T, U> {
boolean test(final RecursiveBiPredicate<T, U> rec, final T x, final U y);
}
interface RecursiveTriPredicate<T, U, V> {
boolean test(final RecursiveTriPredicate<T, U, V> rec, final T x, final U y, final V z);
}
interface RecursiveIntFunction<R> {
R apply(final RecursiveIntFunction<R> rec, final int n);
}
interface RecursiveLongFunction<R> {
R apply(final RecursiveLongFunction<R> rec, final long n);
}
interface RecursiveDoubleFunction<R> {
R apply(final RecursiveDoubleFunction<R> rec, final double n);
}
interface RecursiveIntUnaryOperator {
int apply(final RecursiveIntUnaryOperator rec, final int n);
}
interface RecursiveLongUnaryOperator {
long apply(final RecursiveLongUnaryOperator rec, final long n);
}
interface RecursiveDoubleUnaryOperator {
double apply(final RecursiveDoubleUnaryOperator rec, final double n);
}
interface RecursiveIntBinaryOperator {
int apply(final RecursiveIntBinaryOperator rec, final int a, final int b);
}
interface RecursiveLongBinaryOperator {
long apply(final RecursiveLongBinaryOperator rec, final long a, final long b);
}
interface RecursiveDoubleBinaryOperator {
double apply(final RecursiveDoubleBinaryOperator rec, final double a, final double b);
}
interface RecursiveIntConsumer {
void accept(final RecursiveIntConsumer rec, final int n);
}
interface RecursiveLongConsumer {
void accept(final RecursiveLongConsumer rec, final long n);
}
interface RecursiveDoubleConsumer {
void accept(final RecursiveDoubleConsumer rec, final double n);
}
interface RecursiveIntPredicate {
boolean test(final RecursiveIntPredicate rec, final int n);
}
interface RecursiveLongPredicate {
boolean test(final RecursiveLongPredicate rec, final long n);
}
interface RecursiveDoublePredicate {
boolean test(final RecursiveDoublePredicate rec, final double n);
}
final class IO implements Closeable, AutoCloseable {
private final MyScanner in;
private final MyPrinter out, err;
private final boolean autoFlush;
IO(final InputStream in, final OutputStream out, final OutputStream err, final boolean autoFlush) {
this.in = new MyScanner(in);
this.out = new MyPrinter(out, this.autoFlush = autoFlush);
this.err = new MyPrinter(err, true);
}
final int ni(){ return in.ni(); }
final long nl(){ return in.nl(); }
final double nd(){ return in.nd(); }
final char nc(){ return in.nc(); }
final String ns(){ return in.ns(); }
final char[] nt(){ return in.nt(); }
final BigInteger nb(){ return in.nb(); }
final IntPair pi(){ return in.pi(); }
final FloatPair pf(){ return in.pf(); }
final int[] ni(final int n) {
final int[] a = new int[n];
Arrays.setAll(a, i -> ni());
return a;
}
final int[] ni(final int n, final IntUnaryOperator f){ return Arrays.stream(ni(n)).map(f).toArray(); }
final long[] nl(final int n) {
final long[] a = new long[n];
Arrays.setAll(a, i -> nl());
return a;
}
final long[] nl(final int n, final LongUnaryOperator f){ return Arrays.stream(nl(n)).map(f).toArray(); }
final double[] nd(final int n) {
final double[] a = new double[n];
Arrays.setAll(a, i -> nd());
return a;
}
final char[] nc(final int n) {
final char[] a = new char[n];
IntStream.range(0, n).forEach(i -> a[i] = nc());
return a;
}
final String[] ns(final int n) {
final String[] a = new String[n];
Arrays.setAll(a, i -> ns());
return a;
}
final char[][] nt(final int n) {
final char[][] a = new char[n][];
Arrays.setAll(a, i -> nt());
return a;
}
final BigInteger[] nb(final int n) {
final BigInteger[] a = new BigInteger[n];
Arrays.setAll(a, i -> nb());
return a;
}
final IntPair[] pi(final int n) {
final IntPair[] a = new IntPair[n];
Arrays.setAll(a, i -> pi());
return a;
}
final IntPair[] pi(final int n, final UnaryOperator<IntPair> f){ return Arrays.stream(pi(n)).map(f).toArray(IntPair[]::new); }
final FloatPair[] pf(final int n) {
final FloatPair[] a = new FloatPair[n];
Arrays.setAll(a, i -> pf());
return a;
}
final int[][] ni(final int h, final int w) {
final int[][] a = new int[h][w];
Arrays.setAll(a, i -> ni(w));
return a;
}
final long[][] nl(final int h, final int w) {
final long[][] a = new long[h][w];
Arrays.setAll(a, i -> nl(w));
return a;
}
final double[][] nd(final int h, final int w) {
final double[][] a = new double[h][w];
Arrays.setAll(a, i -> nd(w));
return a;
}
final char[][] nc(final int h, final int w) {
final char[][] a = new char[h][w];
Arrays.setAll(a, i -> nc(w));
return a;
}
final String[][] ns(final int h, final int w) {
final String[][] a = new String[h][w];
Arrays.setAll(a, i -> ns(w));
return a;
}
final BigInteger[][] nb(final int h, final int w) {
final BigInteger[][] a = new BigInteger[h][w];
Arrays.setAll(a, i -> nb(w));
return a;
}
final String line(){ return in.line(); }
final void print(final Object arg){ out.print(arg); }
final void printf(final String fmt, final Object... args){ out.printf(fmt, args); }
final void out(){ out.out(); }
final void out(final Object head, final Object... tail){ out.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S> p){ out.out(p); }
final <E> void out(final Collection<E> a){ out.out(a); }
final void out(final int[] head, final int[]...tail){ out.out(head, tail); }
final void out(final long[] head, final long[]...tail){ out.out(head, tail); }
final void out(final double[] head, final double[]...tail){ out.out(head, tail); }
final void out(final boolean[] head, final boolean[]...tail){ out.out(head, tail); }
final void out(final char[] head, final char[]...tail){ out.out(head, tail); }
final void out(final Object[] head, final Object[]...tail){ out.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S>[] args){ Arrays.stream(args).forEach(this::out); }
final void out(final int[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final long[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final double[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final char[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void out(final Object[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final Object head, final Object... tail) {
out(head);
Arrays.stream(tail).forEach(this::out);
}
final void fin(final Object head, final Object... tail) {
out(head, tail);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void fin(final Pair<F, S> arg) {
out(arg);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <E> void fin(final Collection<E> args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final int[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final long[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final double[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final boolean[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final char[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final Object[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void fin(final Pair<F, S>[] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final int[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final long[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final double[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final boolean[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final char[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void fin(final Object[][] args) {
out(args);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void ende(final Object head, final Object... tail) {
outl(head, tail);
if(!autoFlush) {
out.flush();
}
System.exit(0);
}
final void dump(final Object head, final Object... tail){ err.out(head, tail); }
final void dump(final int[] head, final int[]...tail){ err.out(head, tail); }
final void dump(final long[] head, final long[]...tail){ err.out(head, tail); }
final void dump(final double[] head, final double[]...tail){ err.out(head, tail); }
final void dump(final boolean[] head, final boolean[]...tail){ err.out(head, tail); }
final void dump(final char[] head, final char[]...tail){ err.out(head, tail); }
final void dump(final Object[] head, final Object[]...tail){ err.out(head, tail); }
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void dump(final Pair<F, S>[] args){ Arrays.stream(args).forEach(this::dump); }
final void dump(final int[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final long[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final double[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final char[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
final void dump(final Object[][] args){ IntStream.range(0, args.length).forEach(i -> dump(args[i])); }
@Override
public final void close() {
out.flush();
in.close();
out.close();
err.close();
}
private final class MyScanner implements Closeable, AutoCloseable {
private int pos, lim;
private final byte[] buf;
private final InputStream is;
private boolean check;
MyScanner(final InputStream is) {
this.is = is;
pos = lim = 0;
buf = new byte[1 << 17];
check = false;
}
private final boolean isPunct(final byte bt){ return !Utility.scope(33, bt, 126); }
private final boolean isNum(final byte bt){ return Utility.scope('0', bt, '9'); }
private final byte read() {
if(pos == lim && lim != -1) {
try {
lim = is.read(buf);
pos = 0;
} catch(final IOException e) {
e.printStackTrace();
}
}
return buf[pos++];
}
private final byte next() {
byte bt;
if(check) {
check = false;
bt = buf[pos - 1];
if(!isPunct(bt)) {
return bt;
}
}
while(isPunct(bt = read())){}
return bt;
}
final int ni(){ return toIntExact(nl()); }
final long nl() {
byte c = next();
final boolean neg = c == '-';
if(neg) {
c = next();
}
assert isNum(c);
long res = c - '0';
while(isNum(c = read())) {
res = 10 * res + c - '0';
}
check = !isNum(c);
return neg ? -res : res;
}
final double nd() {
byte c = next();
final boolean neg = c == '-';
if(neg) {
c = next();
}
assert isNum(c);
double res = c - '0';
while(isNum(c = read())) {
res = 10 * res + c - '0';
}
if(c != '.') {
check = true;
return res;
}
int i;
for(i = 0; isNum(c = read()); ++i) {
res = res * 10 + c - '0';
}
res /= pow(10, i);
check = true;
return neg ? -res : res;
}
final char nc(){ return (char) next(); }
final String ns() {
final StringBuilder sb = new StringBuilder();
byte c = next();
while(!isPunct(c)) {
sb.append((char) c);
c = read();
}
return sb.toString();
}
final char[] nt(){ return ns().toCharArray(); }
final BigInteger nb(){ return new BigInteger(ns()); }
final IntPair pi(){ return IntPair.of(nl(), nl()); }
final FloatPair pf(){ return FloatPair.of(nd(), nd()); }
final String line() {
final StringBuilder sb = new StringBuilder();
byte c;
while((c = read()) != '\n') {
sb.append((char) c);
}
return sb.toString();
}
@Override
public final void close() {
try {
is.close();
} catch(final IOException e) {
e.printStackTrace();
}
}
}
private final class MyPrinter implements Closeable, Flushable, AutoCloseable {
private OutputStream os;
private final boolean autoFlush;
private final byte[] buf;
private int pos;
private final boolean debug;
MyPrinter(final OutputStream os, final boolean autoFlush){
this.os = os;
this.autoFlush = autoFlush;
buf = new byte[1 << 17];
pos = 0;
debug = os == System.err;
}
private final void write(final byte bt) {
buf[pos++] = bt;
if(pos == buf.length) {
flush();
}
}
private final void newLine() {
write((byte) '\n');
if(autoFlush) {
flush();
}
}
final void print(final Object arg) {
if(arg instanceof final String s) {
for(final char c: s.toCharArray()) {
write((byte) c);
}
} else {
print(String.valueOf(arg));
}
if(autoFlush) {
flush();
}
}
final void printf(final String fmt, final Object... args) {
print(new Formatter().format(fmt, args));
if(autoFlush) {
flush();
}
}
final void out(){ newLine(); }
final void out(final Object head, final Object... tail) {
print(head);
for(final var el: tail) {
print(" " + el);
}
newLine();
}
final <F extends Comparable<? super F>, S extends Comparable<? super S>> void out(final Pair<F, S> arg) {
if(debug) {
print(arg.toString());
} else {
print(arg.first + " " + arg.second);
}
newLine();
}
final <E> void out(final Collection<E> args) {
if(debug) {
print(args.toString());
} else {
int i = 0;
for(final var el: args) {
print(el);
if(++i != args.size()) {
print(" ");
}
}
}
newLine();
}
private final void out(final int[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final int[] head, final int[]... tail) {
out(head);
for(final int[] a: tail) {
out(a);
}
}
private final void out(final long[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final long[] head, final long[]... tail) {
out(head);
for(final long[] a: tail) {
out(a);
}
}
private final void out(final double[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final double[] head, final double[]... tail) {
out(head);
for(final double[] a: tail) {
out(a);
}
}
private final void out(final boolean[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final boolean[] head, final boolean[]... tail) {
out(head);
for(final boolean[] a: tail) {
out(a);
}
}
private final void out(final char[] args) {
if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final char[] head, final char[]... tail) {
out(head);
for(final char[] a: tail) {
out(a);
}
}
private final void out(final Object[] args) {
if(debug) {
print(Arrays.toString(args));
} else if(args.length > 0) {
print(args[0]);
for(int i = 0; ++i < args.length;) {
print(" " + args[i]);
}
}
newLine();
}
final void out(final Object[] head, final Object[]... tail) {
out(head);
for(final Object[] a: tail) {
out(a);
}
}
@Override
public final void flush() {
try {
os.write(buf, 0, pos);
pos = 0;
} catch(final IOException e) {
e.printStackTrace();
}
}
@Override
public final void close() {
if(os == null) {
return;
}
try {
os.close();
os = null;
} catch(final IOException e) {
e.printStackTrace();
}
}
}
}
class Pair<F extends Comparable<? super F>, S extends Comparable<? super S>> implements Comparable<Pair<F, S>>, Cloneable {
public F first;
public S second;
protected Pair(final F first, final S second) {
this.first = first;
this.second = second;
}
static final <F extends Comparable<? super F>, S extends Comparable<? super S>> Pair<F, S> of(final F a, final S b){ return new Pair<>(a, b); }
Pair<S, F> swap(){ return Pair.of(second, first); }
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> p = (Pair<?, ?>) o;
return first.equals(p.first) && second.equals(p.second);
}
@Override
public final int hashCode(){ return Objects.hash(first, second); }
@Override
public final String toString(){ return "(" + first + ", " + second + ")"; }
@SuppressWarnings("unchecked")
@Override
public final Pair<F, S> clone() {
try {
return (Pair<F, S>) super.clone();
} catch(final CloneNotSupportedException e){
e.printStackTrace();
}
throw new Error();
}
@Override
public final int compareTo(final Pair<F, S> p) {
if(first.compareTo(p.first) == 0) {
return second.compareTo(p.second);
}
return first.compareTo(p.first);
}
}
final class IntPair extends Pair<Long, Long> {
private IntPair(final long first, final long second){ super(first, second); }
static final IntPair ZERO = new IntPair(0, 0);
static final IntPair ONE = new IntPair(1, 1);
static final IntPair of(final long a, final long b){ return new IntPair(a, b); }
@Override
final IntPair swap(){ return new IntPair(second, first); }
final IntPair add(final IntPair p){ return new IntPair(first + p.first, second + p.second); }
final IntPair sub(final IntPair p){ return new IntPair(first - p.first, second - p.second); }
final IntPair mul(final IntPair p){ return new IntPair(first * p.first, second * p.second); }
final IntPair div(final IntPair p){ return new IntPair(first / p.first, second / p.second); }
final IntPair mod(final IntPair p){ return new IntPair(first % p.first, second % p.second); }
final IntPair rotate(){ return new IntPair(-second, first); }
final FloatPair rotate(final int ang) {
final double rad = toRadians(Utility.mod(ang, 360));
return FloatPair.of(first * cos(rad) - second * sin(rad), first * sin(rad) + second * cos(rad));
}
final long dot(final IntPair p){ return first * p.first + second * p.second; }
final long cross(final IntPair p){ return rotate().dot(p); }
final long sqr(){ return dot(this); }
final double grad() {
try {
return 1.0 * second / first;
} catch(final ArithmeticException e) {
e.printStackTrace();
}
throw new Error();
}
final double abs(){ return hypot(first, second); }
final long lcm(){ return Utility.lcm(first, second); }
final long gcd(){ return Utility.gcd(first, second); }
final IntPair extgcd() {
long x = 1, y = 0, t1 = 0, t2 = 0, t3 = 1, a = first, b = second;
while(b > 0) {
t1 = a / b;
a -= t1 * b;
a ^= b;
b ^= a;
a ^= b;
x -= t1 * t2;
x ^= t2;
t2 ^= x;
x ^= t2;
y -= t1 * t3;
y ^= t3;
t3 ^= y;
y ^= t3;
}
return new IntPair(x, y);
}
}
final class FloatPair extends Pair<Double, Double> {
private FloatPair(final double first, final double second){ super(first, second); }
static final FloatPair of(final double a, final double b){ return new FloatPair(a, b); }
@Override
final FloatPair swap(){ return new FloatPair(second, first); }
final FloatPair add(final FloatPair p){ return new FloatPair(first + p.first, second + p.second); }
final FloatPair sub(final FloatPair p){ return new FloatPair(first - p.first, second - p.second); }
final FloatPair mul(final FloatPair p){ return new FloatPair(first * p.first, second * p.second); }
final FloatPair div(final FloatPair p){ return new FloatPair(first / p.first, second / p.second); }
final FloatPair rotate(){ return new FloatPair(-second, first); }
final FloatPair rotate(final int ang) {
final double rad = toRadians(Utility.mod(ang, 360));
return FloatPair.of(first * cos(rad) - second * sin(rad), first * sin(rad) + second * cos(rad));
}
final double dot(final FloatPair p){ return first * p.first + second * p.second; }
final double cross(final FloatPair p){ return rotate().dot(p); }
final double sqr(){ return dot(this); }
final double grad() {
try {
return second / first;
} catch(final ArithmeticException e) {
e.printStackTrace();
}
throw new Error();
}
final double abs(){ return hypot(first, second); }
}
final class Why {
static final boolean isBipartite(final UnionFind uf) {
assert uf.size() % 2 == 0;
final int n = uf.size() / 2;
boolean ok = true;
for(int i = 0; i < n; ++i) {
ok &= !uf.same(i, i + n);
}
return ok;
}
static final long invNum(final int[] a) {
final int[] b = Utility.sorted(a);
final Map<Integer, Integer> id = new HashMap<>();
for(int i = 0; i < a.length; ++i) {
id.put(b[i], i);
}
final FenwickTree bit = new FenwickTree(a.length);
long res = 0;
for(int i = 0; i < a.length; ++i) {
res += i - bit.sum(id.get(a[i]));
bit.add(id.get(a[i]), 1);
}
return res;
}
static final long invNum(final long[] a) {
final long[] b = Utility.sorted(a);
final Map<Long, Integer> id = new HashMap<>();
for(int i = 0; i < a.length; ++i) {
id.put(b[i], i);
}
final FenwickTree bit = new FenwickTree(a.length);
long res = 0;
for(int i = 0; i < a.length; ++i) {
res += i - bit.sum(id.get(a[i]));
bit.add(id.get(a[i]), 1);
}
return res;
}
}
final class Edge {
public int src, to, id;
public long cost;
Edge(final int src, final int to, final int id) {
this.src = src;
this.to = to;
this.id = id;
}
Edge(final int src, final int to, final long cost, final int id) {
this.src = src;
this.to = to;
this.cost = cost;
this.id = id;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Edge e = (Edge) o;
return src == e.src && to == e.to && cost == e.cost;
}
@Override
public final int hashCode(){ return Objects.hash(src, to, cost, id); }
@Override
public final String toString(){ return String.valueOf(to); }
}
class Graph extends ArrayList<ArrayList<Edge>> {
protected final boolean undirected;
protected final int n, indexed;
protected int id;
protected final ArrayList<Edge> edge;
Graph(final int n, final boolean undirected){ this(n, 1, undirected); }
Graph(final int n, final int indexed, final boolean undirected) {
this.n = n;
this.indexed = indexed;
this.undirected = undirected;
id = 0;
edge = new ArrayList<>();
IntStream.range(0, n).forEach(i -> add(new ArrayList<>()));
}
static Graph of(final List<ArrayList<Edge>> g, final boolean undirected) {
int max = 0, min = Integer.MAX_VALUE;
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
max = max(e.src, e.to);
min = min(e.src, e.to);
}
}
final Graph gp = new Graph(max, min, undirected);
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
gp.addEdge(e.src, e.to);
}
}
return gp;
}
final void addEdge(int a, int b) {
a -= indexed;
b -= indexed;
this.get(a).add(new Edge(a, b, id));
edge.add(new Edge(a, b, id++));
if(undirected) {
this.get(b).add(new Edge(b, a, --id));
edge.add(new Edge(b, a, id++));
}
}
void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni())); }
protected final ArrayList<Edge> getEdge(){ return edge; }
protected final int[] allDist(final int v) {
final int[] d = new int[n];
Arrays.fill(d, -1);
final Queue<Integer> q = new ArrayDeque<>();
d[v] = 0;
q.add(v);
while(!q.isEmpty()) {
final int tmp = q.poll();
for(final Edge el: this.get(tmp)) {
if(d[el.to] != -1) {
continue;
}
d[el.to] = d[tmp] + 1;
q.add(el.to);
}
}
return d;
}
protected final int dist(final int u, final int v){ return allDist(u)[v]; }
protected final ArrayList<Integer> topologicalSort() {
final int[] deg = new int[n];
for(int i = 0; i < n; ++i) {
for(final Edge ed: this.get(i)) {
deg[ed.to]++;
}
}
final Stack<Integer> sk = new Stack<>();
for(int i = 0; i < n; ++i) {
if(deg[i] == 0) {
sk.add(i);
}
}
final ArrayList<Integer> ord = new ArrayList<>();
while(!sk.isEmpty()) {
final int tmp = sk.pop();
ord.add(tmp);
for(final Edge ed: this.get(tmp)) {
if(--deg[ed.to] == 0) {
sk.add(ed.to);
}
}
}
return n == ord.size() ? ord : null;
}
protected final int[] cycleDetector() {
final int[] used = new int[n];
final Edge[] pre = new Edge[n];
final ArrayList<Edge> cycle = new ArrayList<>();
final RecursiveIntPredicate dfs = (rec, i) -> {
used[i] = 1;
for(final Edge e: get(i)) {
if(used[e.to] == 0) {
pre[e.to] = e;
if(rec.test(rec, e.to)) {
return true;
}
} else if(used[e.to] == 1) {
int now = i;
while(now != e.to) {
cycle.add(pre[now]);
now = pre[now].src;
}
cycle.add(e);
return true;
}
}
used[i] = 2;
return false;
};
for(int i = 0; i < n; ++i) {
if(used[i] == 0 && dfs.test(dfs, i)) {
Collections.reverse(cycle);
return cycle.stream().mapToInt(e -> e.to).toArray();
}
}
return null;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; ++i) {
final int m = get(i).size();
sb.append(i + ": [");
for(int j = 0; j < m; ++j) {
sb.append(get(i).get(j).to);
if(j + 1 < m) {
sb.append(", ");
}
}
sb.append(']');
if(i + 1 < n) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class ShortestPath {
private final long[] cost;
private final int[] src;
ShortestPath(final long[] cost, final int[] src) {
this.cost = cost;
this.src = src;
}
final boolean isThru(final int i){ return src[i] != -1; }
final int[] path(int i) {
final List<Integer> res = new ArrayList<>();
for(; i != -1; i = src[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(k -> k).toArray();
}
final long[] get(){ return cost; }
}
final class MST {
public final ArrayList<Edge> tree;
public final long cost;
MST(final ArrayList<Edge> tree, final long cost) {
this.tree = tree;
this.cost = cost;
}
}
final class WeightedGraph extends Graph {
WeightedGraph(final int n, final boolean undirected){ super(n, undirected); }
WeightedGraph(final int n, final int indexed, final boolean undirected){ super(n, indexed, undirected); }
static final WeightedGraph of(final List<ArrayList<Edge>> g, final boolean undirected) {
int max = 0, min = Integer.MAX_VALUE;
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
max = max(e.src, e.to);
min = min(e.src, e.to);
}
}
final WeightedGraph gp = new WeightedGraph(max, min, undirected);
for(int i = 0; i < g.size(); ++i) {
for(final Edge e: g.get(i)) {
gp.addEdge(e.src, e.to, e.cost);
}
}
return gp;
}
final void addEdge(int a, int b, final long cost) {
a -= indexed;
b -= indexed;
this.get(a).add(new Edge(a, b, cost, id));
edge.add(new Edge(a, b, cost, id++));
if(undirected) {
this.get(b).add(new Edge(b, a, cost, --id));
edge.add(new Edge(b, a, cost, id++));
}
}
final void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni(), VvyLw.io.nl())); }
final ShortestPath dijkstra(final int v) {
final long[] cost = new long[n];
final int[] src = new int[n];
Arrays.fill(cost, Long.MAX_VALUE);
Arrays.fill(src, -1);
final Queue<IntPair> dj = new PriorityQueue<>();
cost[v] = 0;
dj.add(IntPair.of(cost[v], v));
while(!dj.isEmpty()) {
final IntPair tmp = dj.poll();
if(cost[tmp.second.intValue()] < tmp.first.longValue()) {
continue;
}
for(final Edge ed: this.get(tmp.second.intValue())) {
final long next = tmp.first.longValue() + ed.cost;
if(cost[ed.to] <= next) {
continue;
}
cost[ed.to] = next;
src[ed.to] = tmp.second.intValue();
dj.add(IntPair.of(cost[ed.to], ed.to));
}
}
return new ShortestPath(cost, src);
}
final long[] spfa(final int v) {
final long[] cost = new long[n];
Arrays.fill(cost, Long.MAX_VALUE);
final boolean[] pend = new boolean[n];
final int[] cnt = new int[n];
final Queue<Integer> q = new ArrayDeque<>();
q.add(v);
pend[v] = true;
cnt[v]++;
cost[v] = 0;
while(!q.isEmpty()) {
final int p = q.poll();
pend[p] = false;
for(final Edge e: this.get(p)) {
final long next = cost[p] + e.cost;
if(next >= cost[e.to]) {
continue;
}
cost[e.to] = next;
if(!pend[e.to]) {
if(++cnt[e.to] >= n) {
return null;
}
pend[e.to] = true;
q.add(e.to);
}
}
}
return cost;
}
final long[][] floydWarshall() {
final long[][] cost = new long[n][n];
IntStream.range(0, n).forEach(i -> Arrays.fill(cost[i], VvyLw.LINF));
IntStream.range(0, n).forEach(i -> cost[i][i] = 0);
for(int i = 0; i < n; ++i) {
for(final Edge j: this.get(i)) {
cost[i][j.to] = j.cost;
}
}
for(int k = 0; k < n; ++k) {
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
if(cost[i][k] == VvyLw.LINF || cost[k][j] == VvyLw.LINF) {
continue;
}
if(cost[i][j] > cost[i][k] + cost[k][j]) {
cost[i][j] = cost[i][k] + cost[k][j];
}
}
}
}
return cost;
}
final MST kruskal() {
final UnionFind uf = new UnionFind(n);
final ArrayList<Edge> e = new ArrayList<>();
long res = 0;
for(final Edge ed: edge.stream().sorted(Comparator.comparing(ed -> ed.cost)).collect(Collectors.toList())) {
if(uf.unite(ed.src, ed.to)) {
e.add(ed);
res += ed.cost;
}
}
return new MST(e, res);
}
final MST directed(final int v) {
@SuppressWarnings("unchecked")
final ArrayList<Edge> ed = (ArrayList<Edge>) edge.clone();
for(int i = 0; i < n; ++i) {
if(i != v) {
ed.add(new Edge(i, v, 0));
}
}
int x = 0;
final int[] par = new int[2 * n], vis = new int[2 * n], link = new int[2 * n];
Arrays.fill(par, -1);
Arrays.fill(vis, -1);
Arrays.fill(link, -1);
final SkewHeap heap = new SkewHeap(true);
final SkewHeap.Node[] ins = new SkewHeap.Node[2 * n];
Arrays.fill(ins, null);
for(int i = 0; i < ed.size(); i++) {
final Edge e = ed.get(i);
ins[e.to] = heap.push(ins[e.to], e.cost, i);
}
final ArrayList<Integer> st = new ArrayList<>();
final IntUnaryOperator go = z -> {
z = ed.get(ins[z].idx).src;
while(link[z] != -1) {
st.add(z);
z = link[z];
}
for(final int p: st) {
link[p] = z;
}
st.clear();
return z;
};
for(int i = n; ins[x] != null; ++i) {
while(vis[x] == -1) {
vis[x] = 0;
x = go.applyAsInt(x);
}
while(x != i) {
final long w = ins[x].key;
SkewHeap.Node z = heap.pop(ins[x]);
z = heap.add(z, -w);
ins[i] = heap.meld(ins[i], z);
par[x] = i;
link[x] = i;
x = go.applyAsInt(x);
}
while(ins[x] != null && go.applyAsInt(x) == x) {
ins[x] = heap.pop(ins[x]);
}
}
for(int i = v; i != -1; i = par[i]) {
vis[i] = 1;
}
long cost = 0;
final ArrayList<Edge> e = new ArrayList<>();
for(int i = x; i >= 0; i--) {
if(vis[i] == 1) {
continue;
}
cost += ed.get(ins[i].idx).cost;
e.add(ed.get(ins[i].idx));
for(int j = ed.get(ins[i].idx).to; j != -1 && vis[j] == 0; j = par[j]) {
vis[j] = 1;
}
}
return new MST(e, cost);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; ++i) {
final int m = get(i).size();
sb.append(i + ": [");
for(int j = 0; j < m; ++j) {
sb.append("(to: " + get(i).get(j).to + ", cost: " + get(i).get(j).cost + ')');
if(j + 1 < m) {
sb.append(", ");
}
}
sb.append(']');
if(i + 1 < n) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class SkewHeap {
static final class Node {
long key, lazy;
Node l, r;
final int idx;
Node(final long key, final int idx) {
this.key = key;
this.idx = idx;
lazy = 0;
l = null;
r = null;
}
}
private final boolean isMin;
SkewHeap(final boolean isMin){ this.isMin = isMin; }
private final Node alloc(final long key, final int idx){ return new Node(key, idx); }
private final Node propagate(final Node t) {
if(t != null && t.lazy != 0) {
if(t.l != null) {
t.l.lazy += t.lazy;
}
if(t.r != null) {
t.r.lazy += t.lazy;
}
t.key += t.lazy;
t.lazy = 0;
}
return t;
}
final Node meld(Node x, Node y) {
propagate(x);
propagate(y);
if(x == null || y == null) {
return x != null ? x : y;
}
if((x.key < y.key) ^ isMin) {
final Node tmp = x;
x = y;
y = tmp;
}
x.r = meld(y, x.r);
final Node tmp = x.l;
x.l = x.r;
x.r = tmp;
return x;
}
final Node push(final Node t, final long key, final int idx){ return meld(t, alloc(key, idx)); }
final Node pop(final Node t) {
if(t == null) {
throw new NullPointerException();
}
return meld(t.l, t.r);
}
final Node add(final Node t, final long lazy) {
if(t != null) {
t.lazy += lazy;
propagate(t);
}
return t;
}
}
final class SCC {
private final int n, indexed;
private int m;
private final ArrayList<Edge> edge;
private final int[] start, ids;
private int[][] groups;
private boolean notBuilt;
SCC(final int n){ this(n, 1); }
SCC(final int n, final int indexed) {
this.n = n;
this.indexed = indexed;
edge = new ArrayList<>();
start = new int[n + 1];
ids = new int[n];
m = 0;
notBuilt = true;
}
final void addEdge(int from, int to) {
from -= indexed;
to -= indexed;
rangeCheck(from);
rangeCheck(to);
edge.add(new Edge(from, to, m++));
start[from + 1]++;
}
final void input(final int m){ IntStream.range(0, m).forEach(i -> addEdge(VvyLw.io.ni(), VvyLw.io.ni())); }
final int id(final int i) {
if(notBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
rangeCheck(i);
return ids[i];
}
final void build() {
for(int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
final Edge[] ed = new Edge[m];
final int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for(final Edge e: edge) {
ed[count[e.src]++] = e;
}
int nowOrd = 0, groupNum = 0, k = 0, ptr = 0;
final int[] par = new int[n], vis = new int[n], low = new int[n], ord = new int[n];
Arrays.fill(ord, -1);
final long[] stack = new long[n];
for(int i = 0; i < n; i++) {
if(ord[i] >= 0) {
continue;
}
par[i] = -1;
stack[ptr++] = 0L << 32 | i;
while(ptr > 0) {
long p = stack[--ptr];
int u = (int) (p & 0xffff_ffffl);
int j = (int) (p >>> 32);
if(j == 0) {
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if(start[u] + j < count[u]) {
int to = ed[start[u] + j].to;
stack[ptr++] += 1l << 32;
if(ord[to] == -1) {
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else {
low[u] = min(low[u], ord[to]);
}
} else {
while(j --> 0) {
final int to = ed[start[u] + j].to;
if(par[to] == u) {
low[u] = min(low[u], low[to]);
}
}
if(low[u] == ord[u]) {
while(true) {
final int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if(v == u) {
break;
}
}
groupNum++;
}
}
}
}
for(int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
final int[] counts = new int[groupNum];
for(final int x: ids) {
counts[x]++;
}
groups = new int[groupNum][];
for(int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for(int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
notBuilt = false;
}
final int[][] groups() {
if(notBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
return groups;
}
private final void rangeCheck(final int i) {
if(!Utility.scope(0, i, n - 1)) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
final class LowestCommonAncestor {
private final int log;
private final int[] dep, sum;
private final Graph g;
private final int[][] table;
LowestCommonAncestor(final Graph g) {
this.g = g;
final int n = g.size();
dep = new int[n];
sum = new int[n];
log = Integer.toBinaryString(n).length();
table = new int[log][n];
IntStream.range(0, log).forEach(i -> Arrays.fill(table[i], -1));
build();
}
private final void dfs(final int idx, final int par, final int d) {
table[0][idx] = par;
dep[idx] = d;
for(final Edge el: g.get(idx)) {
if(el.to != par) {
sum[el.to] = (int) (sum[idx] + el.cost);
dfs(el.to, idx, d + 1);
}
}
}
private final void build() {
dfs(0, -1, 0);
for(int k = 0; k < log - 1; ++k) {
for(int i = 0; i < table[k].length; ++i) {
if(table[k][i] == -1) {
table[k + 1][i] = -1;
} else {
table[k + 1][i] = table[k][table[k][i]];
}
}
}
}
final int query(int u, int v) {
if(dep[u] > dep[v]) {
u ^= v;
v ^= u;
u ^= v;
}
v = climb(v, dep[v] - dep[u]);
if(u == v) {
return u;
}
for(int i = log; --i >= 0;) {
if(table[i][u] != table[i][v]) {
u = table[i][u];
v = table[i][v];
}
}
return table[0][u];
}
final int climb(int u, final int k) {
if(dep[u] < k) {
return -1;
}
for(int i = log; --i >= 0;) {
if(((k >> i) % 2) == 1) {
u = table[i][u];
}
}
return u;
}
final int dist(final int u, final int v){ return sum[u] + sum[v] - 2 * sum[query(u, v)]; }
}
interface DSU {
int root(final int i);
int size(final int i);
int size();
default boolean same(final int i, final int j){ return root(i) == root(j); }
boolean unite(int i, int j);
ArrayList<ArrayList<Integer>> groups();
}
class UnionFind implements DSU {
protected final int[] par;
UnionFind(final int n) {
par = new int[n];
Arrays.fill(par, -1);
}
@Override
public final int root(final int i){ return par[i] >= 0 ? par[i] = root(par[i]) : i; }
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public boolean unite(int i, int j) {
i = root(i);
j = root(j);
if(i == j) {
return false;
}
if(i > j) {
i ^= j;
j ^= i;
i ^= j;
}
par[i] += par[j];
par[j] = i;
return true;
}
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>(n);
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
}
abstract class MergeUnionFind<T> extends UnionFind {
MergeUnionFind(final int n){ super(n); }
abstract void merge(final int i, final int j);
abstract T get(final int i);
@Override
public final boolean unite(int i, int j) {
i = root(i);
j = root(j);
if(i == j) {
return false;
}
if(i > j) {
i ^= j;
j ^= i;
i ^= j;
}
par[i] += par[j];
par[j] = i;
merge(i, j);
return true;
}
}
final class WeightedUnionFind implements DSU {
private final int[] par;
private final long[] weight;
WeightedUnionFind(final int n) {
par = new int[n];
weight = new long[n];
Arrays.fill(par, -1);
}
@Override
public final int root(final int i) {
if(par[i] < 0) {
return i;
}
final int r = root(par[i]);
weight[i] += weight[par[i]];
return par[i] = r;
}
final long get(final int i) {
root(i);
return weight[i];
}
final long diff(final int x, final int y){ return get(y) - get(x); }
final int unite(int x, int y, long w) {
w += diff(y, x);
x = root(x);
y = root(y);
if(x == y) {
return w == 0 ? 0 : -1;
}
if(par[x] > par[y]) {
x ^= y;
y ^= x;
x ^= y;
w = -w;
}
par[x] += par[y];
par[y] = x;
weight[y] = w;
return 1;
}
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>();
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
// deprecated
@Override
public final boolean unite(final int i, final int j){ return unite(i, j, 0) > 0; }
}
final class UndoUnionFind implements DSU {
private final int[] par;
private final Stack<Pair<Integer, Integer>> his;
UndoUnionFind(final int n) {
par = new int[n];
Arrays.fill(par, -1);
his = new Stack<>();
}
@Override
public final boolean unite(int x, int y) {
x = root(x);
y = root(y);
his.add(Pair.of(x, par[x]));
his.add(Pair.of(y, par[y]));
if(x == y) {
return false;
}
if(par[x] > par[y]) {
x ^= y;
y ^= x;
x ^= y;
}
par[x] += par[y];
par[y] = x;
return true;
}
@Override
public final int root(final int i) {
if(par[i] < 0) {
return i;
}
return root(par[i]);
}
@Override
public final int size(final int i){ return -par[root(i)]; }
@Override
public final int size(){ return par.length; }
@Override
public final ArrayList<ArrayList<Integer>> groups() {
final int n = par.length;
final ArrayList<ArrayList<Integer>> res = new ArrayList<>();
IntStream.range(0, n).forEach(i -> res.add(new ArrayList<>()));
IntStream.range(0, n).forEach(i -> res.get(root(i)).add(i));
res.removeIf(ArrayList::isEmpty);
return res;
}
final void undo() {
final Pair<Integer, Integer> pop1 = his.pop(), pop2 = his.pop();
par[pop1.first] = pop1.second;
par[pop2.first] = pop2.second;
}
final void snapshot() {
while(!his.empty()) {
his.pop();
}
}
final void rollback() {
while(!his.empty()) {
undo();
}
}
}
final class PrimeTable {
private final int[] p;
private final boolean[] sieve;
PrimeTable(final int n) {
sieve = new boolean[n + 1];
Arrays.fill(sieve, true);
sieve[0] = sieve[1] = false;
for(int i = 2; i <= n; ++i) {
if(!sieve[i]) {
continue;
}
for(long j = (long) i * i; j <= n; j += i) {
sieve[(int) j] = false;
}
}
final int size = (int) IntStream.rangeClosed(0, n).filter(i -> sieve[i]).count();
int j = 0;
p = new int[size];
for(int i = 2; i <= n; ++i) {
if(sieve[i]) {
p[j++] = i;
}
}
}
final boolean[] table(){ return sieve; }
final int[] get(){ return p; }
}
final class PrimeFactor {
private final int[] spf;
PrimeFactor(final int n) {
spf = Utility.iota(n + 1).toArray();
for(int i = 2; i * i <= n; ++i) {
if(spf[i] != i) {
continue;
}
for(int j = i * i; j <= n; j += i) {
if(spf[j] == j) {
spf[j] = i;
}
}
}
}
final TreeMap<Integer, Integer> get(int n) {
final TreeMap<Integer, Integer> m = new TreeMap<>();
while(n != 1) {
m.merge(spf[n], 1, (a, b) -> (a + b));
n /= spf[n];
}
return m;
}
}
final class PrimeCounter {
private final int sq;
private final boolean[] p;
private final int[] psum;
private final ArrayList<Integer> ps;
PrimeCounter(final long n) {
sq = (int) kthRooti(n, 2);
psum = new int[sq + 1];
p = new PrimeTable(sq).table();
for(int i = 1; i <= sq; ++i) {
psum[i] = psum[i - 1] + (p[i] ? 1 : 0);
}
ps = new ArrayList<>();
for(int i = 1; i <= sq; ++i) {
if(p[i]) {
ps.add(i);
}
}
}
private final long kthRooti(final long n, final int k){ return Utility.kthRoot(n, k); }
private final long p2(final long x, final long y) {
if(x < 4) {
return 0;
}
final long a = pi(y);
final long b = pi(kthRooti(x, 2));
if(a >= b) {
return 0;
}
long sum = (long) (a - 2) * (a + 1) / 2 - (b - 2) * (b + 1) / 2;
for(long i = a; i < b; ++i) {
sum += pi(x / ps.get((int) i));
}
return sum;
}
private final long phi(final long m, final long a) {
if(m < 1) {
return 0;
}
if(a > m) {
return 1;
}
if(a < 1) {
return m;
}
if(m <= (long) ps.get((int) (a - 1)) * ps.get((int) (a - 1))) {
return pi(m) - a + 1;
}
if(m <= (long) ps.get((int) (a - 1)) * ps.get((int) (a - 1)) * ps.get((int) (a - 1)) && m <= sq) {
final long sx = pi(kthRooti(m, 2));
long ans = pi(m) - (long) (sx + a - 2) * (sx - a + 1) / 2;
for(long i = a; i < sx; ++i) {
ans += pi(m / ps.get((int) i));
}
return ans;
}
return phi(m, a - 1) - phi(m / ps.get((int) (a - 1)), a - 1);
}
final long pi(final long n) {
if(n <= sq) {
return psum[(int) n];
}
final long m = kthRooti(n, 3);
final long a = pi(m);
return phi(n, a) + a - 1 - p2(n, m);
}
}
// N <= 1e18;
final class LongPrime {
private static final int bsf(final long x){ return Long.numberOfTrailingZeros(x); }
private static final long gcd(long a, long b) {
a = abs(a);
b = abs(b);
if(a == 0) {
return b;
}
if(b == 0) {
return a;
}
final int shift = bsf(a|b);
a >>= bsf(a);
do {
b >>= bsf(b);
if(a > b) {
a ^= b;
b ^= a;
a ^= b;
}
b -= a;
} while(b > 0);
return a << shift;
}
static final boolean isPrime(final long n) {
if(n <= 1) {
return false;
}
if(n == 2) {
return true;
}
if(n % 2 == 0) {
return false;
}
long d = n - 1;
while(d % 2 == 0) {
d /= 2;
}
final long[] sample = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
for(final long a: sample) {
if(n <= a) {
break;
}
long t = d;
BigInteger y = BigInteger.valueOf(a).modPow(BigInteger.valueOf(t), BigInteger.valueOf(n));
while(t != n - 1 && !y.equals(BigInteger.ONE) && !y.equals(BigInteger.valueOf(n).subtract(BigInteger.ONE))) {
y = y.multiply(y).mod(BigInteger.valueOf(n));
t <<= 1;
}
if(!y.equals(BigInteger.valueOf(n).subtract(BigInteger.ONE)) && t % 2 == 0) {
return false;
}
}
return true;
}
private static final long find(final long n) {
if(isPrime(n)) {
return n;
}
if(n % 2 == 0) {
return 2;
}
long st = 0;
final LongBinaryOperator f = (x, y) -> { return BigInteger.valueOf(x).multiply(BigInteger.valueOf(x)).add(BigInteger.valueOf(y)).mod(BigInteger.valueOf(n)).longValue(); };
while(true) {
st++;
long x = st, y = f.applyAsLong(x, st);
while(true) {
final long p = gcd(y - x + n, n);
if(p == 0 || p == n) {
break;
}
if(p != 1) {
return p;
}
x = f.applyAsLong(x, st);
y = f.applyAsLong(f.applyAsLong(y, st), st);
}
}
}
static final ArrayList<Long> primeFactor(final long n) {
if(n == 1) return new ArrayList<>();
final long x = find(n);
if(x == n) return new ArrayList<>(Arrays.asList(x));
final ArrayList<Long> l = primeFactor(x), r = primeFactor(n / x);
l.addAll(r);
Collections.sort(l);
return l;
}
}
// N > 1e18
final class BigPrime {
private static final int bsf(final long x){ return Long.numberOfTrailingZeros(x); }
private static final BigInteger gcd(BigInteger a, BigInteger b) {
a = a.abs();
b = b.abs();
if(a.equals(BigInteger.ZERO)) {
return b;
}
if(b.equals(BigInteger.ZERO)) {
return a;
}
final int shift = bsf(a.or(b).longValue());
a = a.shiftRight(bsf(a.longValue()));
do {
b = b.shiftRight(bsf(b.longValue()));
if(a.compareTo(b) > 0) {
final BigInteger tmp = b;
b = a;
a = tmp;
}
b = b.subtract(a);
} while(b.compareTo(BigInteger.ZERO) > 0);
return a.shiftLeft(shift);
}
static final boolean isPrime(final BigInteger n) {
if(n.compareTo(BigInteger.ONE) <= 0) {
return false;
}
if(n.equals(BigInteger.TWO)) {
return true;
}
if(n.and(BigInteger.ONE).equals(BigInteger.valueOf(0))) {
return false;
}
BigInteger d = n.subtract(BigInteger.ONE);
while(d.and(BigInteger.ONE).equals(BigInteger.valueOf(0))) {
d = d.shiftRight(1);
}
final long[] sample = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
for(final long a: sample) {
if(n.compareTo(BigInteger.valueOf(a)) <= 0) {
break;
}
BigInteger t = d;
BigInteger y = BigInteger.valueOf(a).modPow(t, n);
while(!t.equals(n.subtract(BigInteger.ONE)) && !y.equals(BigInteger.ONE) && !y.equals(n.subtract(BigInteger.ONE))) {
y = y.multiply(y).mod(n);
t = t.shiftLeft(1);
}
if(!y.equals(n.subtract(BigInteger.ONE)) && t.and(BigInteger.ONE).equals(BigInteger.ZERO)) {
return false;
}
}
return true;
}
private static final BigInteger find(final BigInteger n) {
if(isPrime(n)) {
return n;
}
if(n.and(BigInteger.ONE).equals(BigInteger.ZERO)) {
return BigInteger.TWO;
}
int st = 0;
final BiFunction<BigInteger, Integer, BigInteger> f = (x, y) -> { return x.multiply(x).add(BigInteger.valueOf(y)).mod(n); };
while(true) {
st++;
BigInteger x = BigInteger.valueOf(st), y = f.apply(x, st);
while(true) {
final BigInteger p = gcd(y.subtract(x).add(n), n);
if(p.equals(BigInteger.ZERO) || p.equals(n)) {
break;
}
if(!p.equals(BigInteger.ONE)) {
return p;
}
x = f.apply(x, st);
y = f.apply(f.apply(y, st), st);
}
}
}
static final ArrayList<BigInteger> primeFactor(final BigInteger n) {
if(n.equals(BigInteger.ONE)) {
return new ArrayList<>();
}
final BigInteger x = find(n);
if(x.equals(n)) {
return new ArrayList<>(Arrays.asList(x));
}
final ArrayList<BigInteger> l = primeFactor(x), r = primeFactor(n.divide(x));
l.addAll(r);
Collections.sort(l);
return l;
}
}
final class ModPrime {
private final int len, mod;
private final long[] f, rf;
ModPrime(final int mod, final int sz) {
this.mod = mod;
len = min(sz + 1, mod);
f = new long[len];
rf = new long[len];
init();
}
private final long inv(long x) {
long res = 1, k = mod - 2;
while(k > 0) {
if(k % 2 == 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
k >>= 1;
}
return res;
}
private final void init() {
f[0] = 1;
for(int i = 0; ++i < len;) {
f[i] = (f[i - 1] * i) % mod;
}
rf[len - 1] = inv(f[len - 1]);
for(int i = len; --i > 0;) {
rf[i - 1] = (rf[i] * i) % mod;
}
}
final long C(final int n, final int k) {
if(k < 0 || n < k) {
return 0;
}
final long a = f[n], b = rf[n - k], c = rf[k], bc = (b * c) % mod;
return (a * bc) % mod;
}
final long P(final int n, final int k) {
if (k < 0 || n < k) {
return 0;
}
final long a = f[n], b = rf[n - k];
return (a * b) % mod;
}
final long H(final int n, final int k) {
if (n == 0 && k == 0) {
return 1;
}
return C(n + k - 1, k);
}
final long fact(final int n){ return f[n]; }
}
final class EulerPhiTable {
private final int[] euler;
EulerPhiTable(final int n) {
euler = Utility.iota(n + 1).toArray();
for(int i = 2; i <= n; ++i) {
if(euler[i] == i) {
for(int j = i; j <= n; j += i) {
euler[j] = euler[j] / i * (i - 1);
}
}
}
}
final int[] get(){ return euler; }
}
final class DP {
static final long knapsack01(final int[] a, final long[] v, final int w) {
final int n = a.length;
final long[] dp = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = w; j >= a[i]; j--) {
if(dp[j - a[i]] != Long.MIN_VALUE) {
if(dp[j - a[i]] + v[i] > dp[j]) {
dp[j] = dp[j - a[i]] + v[i];
}
}
}
}
return Utility.max(dp);
}
static final int knapsack01(final long[] a, final int[] v, final long w) {
final int n = a.length;
final int s = (int) Utility.sum(v);
final long[] dp = new long[s + 1];
Arrays.fill(dp, w + 1);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = s; j >= v[i]; j--) {
dp[j] = Math.min(dp[j], dp[j - v[i]] + a[i]);
}
}
int res = 0;
for(int i = 0; i <= s; i++) {
if(dp[i] <= w) {
res = i;
}
}
return res;
}
private static final long[] knapsack(final int[] a, final long[] v, final int[] m, final int w, final boolean less) {
final int n = a.length;
final long[] dp = new long[w + 1], deqv = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
final int[] deq = new int[w + 1];
for(int i = 0; i < n; ++i) {
if(a[i] == 0) {
for(int j = 0; j <= w; ++j) {
if(dp[j] != Long.MIN_VALUE && (less ? dp[j] + v[i] * m[i] < dp[j] : dp[j] + v[i] * m[i] > dp[j])) {
dp[j] = dp[j] + v[i] * m[i];
}
}
} else {
for(int k = 0; k < a[i]; ++k) {
int s = 0, t = 0;
for(int j = 0; a[i] * j + k <= w; ++j) {
if(dp[a[i] * j + k] != Long.MIN_VALUE) {
final long val = dp[a[i] * j + k] - j * v[i];
while(s < t && (less ? val < deqv[t - 1] : val > deqv[t - 1])) {
t--;
}
deq[t] = j;
deqv[t++] = val;
}
if(s < t) {
dp[j * a[i] + k] = deqv[s] + j * v[i];
if(deq[s] == j - m[i]) {
s++;
}
}
}
}
}
}
return dp;
}
static final long knapsack(final int[] a, final long[] v, final int[] m, final int w){ return Utility.max(knapsack(a, v, m, w, false)); }
static final long knapsack(final long[] a, final int[] v, final long[] m, final long w) {
final int n = a.length;
final int max = Utility.max(v);
if(max == 0) {
return 0;
}
final int[] ma = new int[n];
final long[] mb = new long[n];
for(int i = 0; i < n; i++) {
ma[i] = (int) Math.min(m[i], max - 1);
mb[i] = m[i] - ma[i];
}
int sum = 0;
for(int i = 0; i < n; ++i) {
sum += ma[i] * v[i];
}
final long[] dp = knapsack(v, a, ma, sum, true);
final int[] id = Utility.iota(n).boxed().sorted((i, j) -> -Long.compare(v[i] * a[j], v[j] * a[i])).mapToInt(i -> i).toArray();
long res = 0;
for(int i = 0; i < dp.length; ++i) {
if(dp[i] > w || dp[i] == Long.MIN_VALUE) {
continue;
}
long rest = w - dp[i], cost = i;
for(final int j: id) {
final long get = Math.min(mb[j], rest / a[j]);
if(get <= 0) {
continue;
}
cost += get * v[j];
rest -= get * a[j];
}
res = Math.max(res, cost);
}
return res;
}
static final long knapsack(final int[] a, final long[] v, final int w) {
final int n = a.length;
final long[] dp = new long[w + 1];
Arrays.fill(dp, Long.MIN_VALUE);
dp[0] = 0;
for(int i = 0; i < n; i++) {
for(int j = a[i]; j <= w; j++) {
if(dp[j - a[i]] != Long.MIN_VALUE) {
if(dp[j - a[i]] + v[i] > dp[j]) {
dp[j] = dp[j - a[i]] + v[i];
}
}
}
}
return Utility.max(dp);
}
static final long maxRectangle(final int[] a) {
final Stack<Integer> sk = new Stack<>();
final long[] h = new long[a.length + 1];
for(int i = 0; i < a.length; ++i) {
h[i] = a[i];
}
final int[] l = new int[h.length];
long res = 0;
for(int i = 0; i < h.length; i++) {
while(!sk.isEmpty() && h[sk.peek()] >= h[i]) {
res = max(res, (i - l[sk.peek()] - 1) * h[sk.pop()]);
}
l[i] = sk.isEmpty() ? -1 : sk.peek();
sk.add(i);
}
return res;
}
static final long maxRectangle(final long[] a) {
final Stack<Integer> sk = new Stack<>();
final long[] h = Arrays.copyOf(a, a.length + 1);
final int[] l = new int[h.length];
long res = 0;
for(int i = 0; i < h.length; i++) {
while(!sk.isEmpty() && h[sk.peek()] >= h[i]) {
res = max(res, (i - l[sk.peek()] - 1) * h[sk.pop()]);
}
l[i] = sk.isEmpty() ? -1 : sk.peek();
sk.add(i);
}
return res;
}
static final int lcs(final String s, final String t) {
final int n = s.length();
final int[] dp = new int[n + 1], ndp = new int[n + 1];
for(int i = 0; i < t.length(); ++i) {
for(int j = 0; j < n; ++j) {
if(s.charAt(j) == t.charAt(i)) {
ndp[j + 1] = dp[j] + 1;
} else {
ndp[j + 1] = max(ndp[j], dp[j + 1]);
}
}
Utility.swap(dp, ndp);
}
return dp[n];
}
static final int[] lis(final int[] a) {
final int n = a.length;
List<IntPair> dp = new ArrayList<IntPair>();
final int[] p = new int[n];
Arrays.fill(p, -1);
for(int i = 0; i < n; ++i) {
final int id = Utility.lowerBound(dp, IntPair.of(a[i], -i));
if(id != 0) {
p[i] = -dp.get(id - 1).second.intValue();
}
if(id == dp.size()) {
dp.add(IntPair.of(a[i], -i));
} else {
dp.set(id, IntPair.of(a[i], -i));
}
}
final List<Integer> res = new ArrayList<Integer>();
for(int i = -dp.get(dp.size() - 1).second.intValue(); i != -1; i = p[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(i -> i).toArray();
}
static final int[] lis(final long[] a) {
final int n = a.length;
List<IntPair> dp = new ArrayList<IntPair>();
final int[] p = new int[n];
Arrays.fill(p, -1);
for(int i = 0; i < n; ++i) {
final int id = Utility.lowerBound(dp, IntPair.of(a[i], -i));
if(id != 0) {
p[i] = -dp.get(id - 1).second.intValue();
}
if(id == n) {
dp.add(IntPair.of(a[i], -i));
} else {
dp.set(id, IntPair.of(a[i], -i));
}
}
final List<Integer> res = new ArrayList<Integer>();
for(int i = -dp.get(dp.size() - 1).second.intValue(); i != -1; i = p[i]) {
res.add(i);
}
Collections.reverse(res);
return res.stream().mapToInt(i -> i).toArray();
}
}
final class Matrix implements Cloneable {
private final int h, w;
private final long[][] mat;
Matrix(final int n){ this(n, n); }
Matrix(final int h, final int w) {
this.h = h;
this.w = w;
mat = new long[h][w];
}
Matrix(final int[][] m) {
this(m.length, m[0].length);
IntStream.range(0, h).forEach(i -> Arrays.setAll(mat[i], j -> m[i][j]));
}
Matrix(final long[][] m) {
this(m.length, m[0].length);
IntStream.range(0, h).forEach(i -> Arrays.setAll(mat[i], j -> m[i][j]));
}
static final Matrix E(final int n) {
final Matrix m = new Matrix(n);
IntStream.range(0, n).forEach(i -> m.set(i, i, 1));
return m;
}
final long[] getH(final int i){ return mat[i]; }
final long[] getW(final int i){ return IntStream.range(0, h).mapToLong(j -> mat[j][i]).toArray(); }
final long[][] get(){ return mat; }
final long get(final int i, final int j){ return mat[i][j]; }
final void set(final int i, final int j, final long x){ mat[i][j] = x; }
final Matrix add(final Matrix m) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, mat[i][j] + m.get(i, j));
}
}
return mt;
}
final Matrix add(final Matrix m, final long mod) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, Utility.mod(mat[i][j] + m.get(i, j), mod));
}
}
return mt;
}
final Matrix sub(final Matrix m) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, mat[i][j] - m.get(i, j));
}
}
return mt;
}
final Matrix sub(final Matrix m, final long mod) {
assert h == m.h && w == m.w;
final Matrix mt = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
mt.set(i, j, Utility.mod(mat[i][j] - m.get(i, j), mod));
}
}
return mt;
}
final Matrix mul(final Matrix m) {
assert w == m.h;
final Matrix mt = new Matrix(h, m.w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < m.w; ++j) {
for(int k = 0; k < w; ++k) {
mt.set(i, j, mt.get(i, j) + mat[i][k] * m.get(k, j));
}
}
}
return mt;
}
final Matrix mul(final Matrix m, final long mod) {
assert w == m.h;
final Matrix mt = new Matrix(h, m.w);
for(int i = 0; i < h; ++i) {
for(int j = 0; j < m.w; ++j) {
for(int k = 0; k < w; ++k) {
mt.set(i, j, Utility.mod(mt.get(i, j) + mat[i][k] * m.get(k, j), mod));
}
}
}
return mt;
}
final Matrix pow(int k) {
Matrix n = clone();
Matrix m = Matrix.E(h);
while(k > 0) {
if(k % 2 == 1) {
m = m.mul(n);
}
n = n.mul(n);
k >>= 1;
}
return m;
}
final Matrix pow(long k, final long mod) {
Matrix n = clone();
Matrix m = Matrix.E(h);
while(k > 0) {
if(k % 2 == 1) {
m = m.mul(n, mod);
}
n = n.mul(n, mod);
k >>= 1L;
}
return m;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Matrix m = (Matrix) o;
if(h != m.h || w != m.w) {
return false;
}
for(int i = 0; i < h; ++i) {
for(int j = 0; j < w; ++j) {
if(mat[i][j] != m.get(i, j)) {
return false;
}
}
}
return true;
}
@Override
public final Matrix clone() {
final Matrix m = new Matrix(h, w);
for(int i = 0; i < h; ++i) {
m.mat[i] = Arrays.copyOf(mat[i], w);
}
return m;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
final int interval = String.valueOf(IntStream.range(0, h).mapToLong(i -> IntStream.range(0, w).mapToLong(j -> mat[i][j]).max().getAsLong()).max().getAsLong()).length() + 1;
for(int i = 0; i < h; ++i) {
sb.append("[");
for(int j = 0; j < w; ++j) {
sb.append(String.format("%" + interval + "d", mat[i][j]));
if(j + 1 == w) {
sb.append("]");
}
}
if(i + 1 != h) {
sb.append("\n");
}
}
return sb.toString();
}
}
class InclusiveScan {
protected final int n;
protected long[] s;
protected InclusiveScan(final int n) {
this.n = n;
s = new long[n + 1];
}
InclusiveScan(final int[] a, final LongBinaryOperator op) {
n = a.length;
s = Arrays.stream(a).asLongStream().toArray();
Arrays.parallelPrefix(s, op);
}
InclusiveScan(final long[] a, final LongBinaryOperator op) {
n = a.length;
s = a.clone();
Arrays.parallelPrefix(s, op);
}
protected final long[] get(){ return s; }
}
final class PrefixSum extends InclusiveScan {
private boolean built;
PrefixSum(final int n) {
super(n);
built = false;
}
PrefixSum(final int[] a) {
super(a, Long::sum);
s = Utility.rotate(Arrays.copyOf(s, n + 1), -1);
}
PrefixSum(final long[] a) {
super(a, Long::sum);
s = Utility.rotate(Arrays.copyOf(s, n + 1), -1);
}
final long sum(final int l, final int r){ return s[r] - s[l]; }
final void add(final int l, final int r, final long x) {
if(built) {
throw new UnsupportedOperationException("Prefix Sum has been built.");
}
s[l] += x;
s[r] -= x;
}
final long[] build() {
assert !built;
Arrays.parallelPrefix(s, Long::sum);
built = true;
return Arrays.copyOf(s, n);
}
}
final class PrefixSum2D {
private final int h, w;
private final long[][] data;
private boolean built;
PrefixSum2D(final int h, final int w) {
this.h = h + 3;
this.w = w + 3;
data = new long[this.h][this.w];
built = false;
}
PrefixSum2D(final int[][] a) {
this(a.length, a[0].length);
for(int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j) {
add(i, j, a[i][j]);
}
}
}
PrefixSum2D(final long[][] a) {
this(a.length, a[0].length);
for(int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j) {
add(i, j, a[i][j]);
}
}
}
final void add(int i, int j, final long x) {
if(built) {
throw new UnsupportedOperationException("Prefix Sum 2D has been built.");
}
i++;
j++;
if(i >= h || j >= w) {
return;
}
data[i][j] += x;
}
final void add(final int i1, final int j1, final int i2, final int j2, final long x) {
add(i1, j1, x);
add(i1, j2, -x);
add(i2, j1, -x);
add(i2, j2, x);
}
final void build() {
assert !built;
for(int i = 0; ++i < h;) {
for(int j = 0; ++j < w;) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
built = true;
}
final long get(final int i1, final int j1, final int i2, final int j2) {
if(!built) {
throw new UnsupportedOperationException("Prefix Sum 2D hasn't been built.");
}
return data[i2][j2] - data[i1][j2] - data[i2][j1] + data[i1][j1];
}
final long get(final int i, final int j) {
if(!built) {
throw new UnsupportedOperationException("Prefix Sum 2D hasn't been built.");
}
return data[i + 1][j + 1];
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < h - 3; ++i) {
sb.append(get(i, 0));
for(int j = 0; ++j < w - 3;) {
sb.append(" " + get(i, j));
}
if(i + 1 < h) {
sb.append('\n');
}
}
return sb.toString();
}
}
final class SuffixArray extends ArrayList<Integer> {
private final String vs;
SuffixArray(final String vs, final boolean compress) {
this.vs = vs;
final int[] newVS = new int[vs.length() + 1];
if(compress) {
final List<Integer> xs = vs.chars().sorted().distinct().boxed().collect(Collectors.toList());
for(int i = 0; i < vs.length(); ++i) {
newVS[i] = Utility.lowerBound(xs, (int) vs.charAt(i)) + 1;
}
} else {
final int d = vs.chars().min().getAsInt();
for(int i = 0; i < vs.length(); ++i) {
newVS[i] = vs.charAt(i) - d + 1;
}
}
this.addAll(Arrays.stream(SAIS(newVS)).boxed().collect(Collectors.toList()));
}
private final int[] SAIS(final int[] s) {
final int n = s.length;
final int[] ret = new int[n];
final boolean[] isS = new boolean[n], isLMS = new boolean[n];
int m = 0;
for(int i = n - 2; i >= 0; i--) {
isS[i] = (s[i] > s[i + 1]) || (s[i] == s[i + 1] && isS[i + 1]);
m += (isLMS[i + 1] = isS[i] && !isS[i + 1]) ? 1 : 0;
}
final Consumer<ArrayList<Integer>> inducedSort = (lms) -> {
final int upper = Arrays.stream(s).max().getAsInt();
final int[] l = new int[upper + 2], r = new int[upper + 2];
for(final int v: s) {
++l[v + 1];
++r[v];
}
Arrays.parallelPrefix(l, (x, y) -> x + y);
Arrays.parallelPrefix(r, (x, y) -> x + y);
Arrays.fill(ret, -1);
for(int i = lms.size(); --i >= 0;) {
ret[--r[s[lms.get(i)]]] = lms.get(i);
}
for(final int v: ret) {
if(v >= 1 && isS[v - 1]) {
ret[l[s[v - 1]]++] = v - 1;
}
}
Arrays.fill(r, 0);
for(final int v: s) {
++r[v];
}
Arrays.parallelPrefix(r, (x, y) -> x + y);
for(int k = ret.length - 1, i = ret[k]; k >= 1; i = ret[--k]) {
if(i >= 1 && !isS[i - 1]) {
ret[--r[s[i - 1]]] = i - 1;
}
}
};
final ArrayList<Integer> lms = new ArrayList<>(), newLMS = new ArrayList<>();
for(int i = 0; ++i < n;) {
if(isLMS[i]) {
lms.add(i);
}
}
inducedSort.accept(lms);
for(int i = 0; i < n; ++i) {
if(!isS[ret[i]] && ret[i] > 0 && isS[ret[i] - 1]) {
newLMS.add(ret[i]);
}
}
final BiPredicate<Integer, Integer> same = (a, b) -> {
if(s[a++] != s[b++]) {
return false;
}
while(true) {
if(s[a] != s[b]) {
return false;
}
if(isLMS[a] || isLMS[b]) {
return isLMS[a] && isLMS[b];
}
a++;
b++;
}
};
int rank = 0;
ret[n - 1] = 0;
for(int i = 0; ++i < m;) {
if(!same.test(newLMS.get(i - 1), newLMS.get(i))) {
++rank;
}
ret[newLMS.get(i)] = rank;
}
if(rank + 1 < m) {
final int[] newS = new int[m];
for(int i = 0; i < m; ++i) {
newS[i] = ret[lms.get(i)];
}
final var lmsSA = SAIS(newS);
IntStream.range(0, m).forEach(i -> newLMS.set(i, lms.get(lmsSA[i])));
}
inducedSort.accept(newLMS);
return ret;
}
private final boolean ltSubstr(final String t, int si, int ti) {
final int sn = vs.length(), tn = t.length();
while(si < sn && ti < tn) {
if(vs.charAt(si) < t.charAt(ti)) {
return true;
}
if(vs.charAt(si) > t.charAt(ti)) {
return false;
}
++si;
++ti;
}
return si >= sn && ti < tn;
}
final int lowerBound(final String t) {
int ok = this.size(), ng = 0;
while(ok - ng > 1) {
final int mid = (ok + ng) / 2;
if(ltSubstr(t, this.get(mid), 0)) {
ng = mid;
} else {
ok = mid;
}
}
return ok;
}
final Pair<Integer, Integer> equalRange(final String t) {
final int low = lowerBound(t);
int ng = low - 1, ok = this.size();
final StringBuilder sb = new StringBuilder(t);
sb.setCharAt(t.length() - 1, (char)(sb.charAt(sb.length() - 1) - 1));
final String u = sb.toString();
while(ok - ng > 1) {
final int mid = (ok + ng) / 2;
if(ltSubstr(u, this.get(mid), 0)) {
ng = mid;
} else {
ok = mid;
}
}
final int end = this.size() - 1;
this.add(end, this.get(end) - 1);
return Pair.of(low, ok);
}
final int[] lcpArray() {
final int n = this.size() - 1;
final int[] lcp = new int[n + 1], rank = new int[n + 1];
for(int i = 0; i <= n; ++i) {
rank[this.get(i)] = i;
}
int h = 0;
for(int i = 0; i <= n; ++i) {
if(rank[i] < n) {
final int j = this.get(rank[i] + 1);
for(; j + h < n && i + h < n; ++h) {
if(vs.charAt(j + h) != vs.charAt(i + h)) {
break;
}
}
lcp[rank[i] + 1] = h;
if(h > 0) {
h--;
}
}
}
return lcp;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < this.size(); ++i) {
sb.append(i + ":[" + this.get(i) + "]");
for(int j = this.get(i); j < vs.length(); ++j) {
sb.append(" " + vs.charAt(j));
}
if(i + 1 != this.size()) {
sb.append("\n");
}
}
return sb.toString();
}
}
final class Deque<T> implements Iterable<T> {
private int n, head, tail;
private Object[] buf;
Deque(){ this(1 << 17); }
private Deque(final int n) {
this.n = n;
head = tail = 0;
buf = new Object[n];
}
Deque(final T[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
private final int next(final int index) {
final int next = index + 1;
return next == n ? 0 : next;
}
private final int prev(final int index) {
final int prev = index - 1;
return prev == -1 ? n - 1 : prev;
}
private final int index(final int i) {
final int size = size();
assert i < size;
final int id = head + i;
return n <= id ? id - n : id;
}
private final void arraycopy(final int fromId, final T[] a, final int from, final int len) {
assert fromId + len <= size();
final int h = index(fromId);
if(h + len < n) {
System.arraycopy(buf, h, a, from, len);
} else {
final int back = n - h;
System.arraycopy(buf, h, a, from, back);
System.arraycopy(buf, 0, a, from + back, len - back);
}
}
@SuppressWarnings("unchecked")
private final void extend() {
final Object[] tmp = new Object[n << 1];
arraycopy(0, (T[]) tmp, 0, size());
buf = tmp;
n = buf.length;
}
final boolean isEmpty(){ return size() == 0; }
final int size() {
final int size = tail - head;
return size < 0 ? size + n : size;
}
final void addFirst(final T x) {
if(prev(head) == tail) {
extend();
}
head = prev(head);
buf[head] = x;
}
final void addLast(final T x) {
if(next(tail) == head) {
extend();
}
buf[tail] = x;
tail = next(tail);
}
final void removeFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
head = next(head);
}
final void removeLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
}
@SuppressWarnings("unchecked")
final T pollFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
final T ans = (T) buf[head];
head = next(head);
return ans;
}
@SuppressWarnings("unchecked")
final T pollLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
return (T) buf[tail];
}
final T peekFirst(){ return get(0); }
final T peekLast(){ return get(n - 1); }
@SuppressWarnings("unchecked")
final T get(final int i){ return (T) buf[index(i)]; }
final void set(final int i, final T x){ buf[index(i)] = x; }
final void add(final T x){ addLast(x); }
final T poll(){ return pollFirst(); }
final T peek(){ return peekFirst(); }
@SuppressWarnings("unchecked")
final void swap(final int a, final int b) {
final int i = index(a), j = index(b);
final T num = (T) buf[i];
buf[i] = buf[j];
buf[j] = num;
}
final void clear(){ head = tail = 0; }
@SuppressWarnings("unchecked")
final T[] toArray() {
final Object[] array = new Object[size()];
arraycopy(0, (T[]) array, 0, size());
return (T[]) array;
}
@Override
public final String toString(){ return Arrays.toString(toArray()); }
@Override
public final Iterator<T> iterator(){ return new DequeIterator(); }
private class DequeIterator implements Iterator<T> {
private int now = head;
private int rem = size();
@Override
public boolean hasNext(){ return rem > 0; }
@Override
public final T next() {
if(!hasNext()) {
throw new NoSuchElementException();
}
@SuppressWarnings("unchecked")
final T res = (T) buf[now];
now = (now + 1) % n;
rem--;
return res;
}
@Override
public final void remove() {
if(isEmpty()) {
throw new IllegalStateException();
}
now = (now - 1 + n) % n;
buf[now] = null;
head = (head + 1) % n;
rem++;
}
}
}
final class IntDeque {
private int n, head, tail;
private long[] buf;
IntDeque(){ this(1 << 17); }
private IntDeque(final int n) {
this.n = n;
head = tail = 0;
buf = new long[n];
}
IntDeque(final int[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
IntDeque(final long[] a) {
this(a.length);
Arrays.stream(a).forEach(i -> add(i));
}
private final int next(final int index) {
final int next = index + 1;
return next == n ? 0 : next;
}
private final int prev(final int index) {
final int prev = index - 1;
return prev == -1 ? n - 1 : prev;
}
private final int index(final int i) {
final int size = size();
assert i < size;
final int id = head + i;
return n <= id ? id - n : id;
}
private final void arraycopy(final int fromId, final long[] a, final int from, final int len) {
assert fromId + len <= size();
final int h = index(fromId);
if(h + len < n) {
System.arraycopy(buf, h, a, from, len);
} else {
final int back = n - h;
System.arraycopy(buf, h, a, from, back);
System.arraycopy(buf, 0, a, from + back, len - back);
}
}
private final void extend() {
final long[] tmp = new long[n << 1];
arraycopy(0, tmp, 0, size());
buf = tmp;
n = buf.length;
}
final boolean isEmpty(){ return size() == 0; }
final int size() {
final int size = tail - head;
return size < 0 ? size + n : size;
}
final void addFirst(final long x) {
head = prev(head);
if(head == tail) {
extend();
}
buf[head] = x;
}
final void addLast(final long x) {
if(next(tail) == head) {
extend();
}
buf[tail] = x;
tail = next(tail);
}
final void removeFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
head = next(head);
}
final void removeLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
}
final long pollFirst() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
final long ans = buf[head];
head = next(head);
return ans;
}
final long pollLast() {
if(head == tail) {
throw new NoSuchElementException("Deque is empty");
}
tail = prev(tail);
return buf[tail];
}
final long peekFirst(){ return get(0); }
final long peekLast(){ return get(n - 1); }
final long get(final int i){ return buf[index(i)]; }
final void set(final int i, final long x){ buf[index(i)] = x; }
final void add(final long x){ addLast(x); }
final long poll(){ return pollFirst(); }
final long peek(){ return peekFirst(); }
final void swap(final int a, final int b) {
final int i = index(a);
final int j = index(b);
final long num = buf[i];
buf[i] = buf[j];
buf[j] = num;
}
final void clear(){ head = tail = 0; }
final long[] toArray(){ return Arrays.copyOf(buf, size()); }
@Override
public final String toString(){ return Arrays.toString(toArray()); }
}
final class AVLTree<T extends Comparable<? super T>> {
static final class Node<T extends Comparable<? super T>> {
T val;
@SuppressWarnings("unchecked")
Node<T>[] ch = new Node[2];
int dep, size;
Node(final T val, final Node<T> l, final Node<T> r) {
this.val = val;
dep = size = 1;
ch[0] = l;
ch[1] = r;
}
}
private Node<T> root;
private final int depth(final Node<T> t){ return t == null ? 0 : t.dep; }
private final int count(final Node<T> t){ return t == null ? 0 : t.size; }
private final Node<T> update(final Node<T> t) {
t.dep = max(depth(t.ch[0]), depth(t.ch[1])) + 1;
t.size = count(t.ch[0]) + count(t.ch[1]) + 1;
return t;
}
private final Node<T> rotate(Node<T> t, final int b) {
Node<T> s = t.ch[1 - b];
t.ch[1 - b] = s.ch[b];
s.ch[b] = t;
t = update(t);
s = update(s);
return s;
}
private final Node<T> fetch(Node<T> t) {
if(t == null) {
return t;
}
if(depth(t.ch[0]) - depth(t.ch[1]) == 2) {
if(depth(t.ch[0].ch[1]) > depth(t.ch[0].ch[0])) {
t.ch[0] = rotate(t.ch[0], 0);
}
t = rotate(t, 1);
}
else if(depth(t.ch[0]) - depth(t.ch[1]) == -2) {
if (depth(t.ch[1].ch[0]) > depth(t.ch[1].ch[1])) {
t.ch[1] = rotate(t.ch[1], 1);
}
t = rotate(t, 0);
}
return t;
}
private final Node<T> insert(final Node<T> t, final int k, final T v) {
if(t == null) {
return new Node<T>(v, null, null);
}
final int c = count(t.ch[0]), b = (k > c) ? 1 : 0;
t.ch[b] = insert(t.ch[b], k - (b == 1 ? (c + 1) : 0), v);
update(t);
return fetch(t);
}
private final Node<T> erase(final Node<T> t) {
if(t == null || t.ch[0] == null && t.ch[1] == null) {
return null;
}
if(t.ch[0] == null || t.ch[1] == null) {
return t.ch[t.ch[0] == null ? 1 : 0];
}
return fetch(update(new Node<T>(find(t.ch[1], 0).val, t.ch[0], erase(t.ch[1], 0))));
}
private final Node<T> erase(Node<T> t, final int k) {
if(t == null) {
return null;
}
final int c = count(t.ch[0]);
if(k < c) {
t.ch[0] = erase(t.ch[0], k);
t = update(t);
}
else if(k > c) {
t.ch[1] = erase(t.ch[1], k - (c + 1));
t = update(t);
}
else {
t = erase(t);
}
return fetch(t);
}
private final Node<T> find(final Node<T> t, final int k) {
if(t == null) {
return t;
}
final int c = count(t.ch[0]);
return k < c ? find(t.ch[0], k) : k == c ? t : find(t.ch[1], k - (c + 1));
}
private final int cnt(final Node<T> t, final T v) {
if(t == null) {
return 0;
}
if(t.val.compareTo(v) < 0) {
return count(t.ch[0]) + 1 + cnt(t.ch[1], v);
}
if(t.val.equals(v)) {
return count(t.ch[0]);
}
return cnt(t.ch[0], v);
}
AVLTree(){ root = null; }
final void add(final T val){ root = insert(root, cnt(root, val), val); }
final void remove(final int k){ root = erase(root, k); }
final T get(final int k){ return find(root, k).val; }
final int count(final T val){ return cnt(root, val); }
final int size(){ return root.size; }
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < root.size;) {
sb.append(" ");
sb.append(get(i));
}
return "[" + sb.toString() + "]";
}
}
final class DoubleEndedPriorityQueue<T extends Number> {
private final ArrayList<T> d;
DoubleEndedPriorityQueue(final ArrayList<T> d) {
this.d = d;
makeHeap();
}
private final void makeHeap() {
for(int i = d.size(); i-- > 0;) {
if (i % 2 == 1 && d.get(i - 1).longValue() < d.get(i).longValue()) {
Collections.swap(d, i - 1, i);
}
up(down(i), i);
}
}
private final int down(int k) {
final int n = d.size();
if(k % 2 == 1) {
while(2 * k + 1 < n) {
int c = 2 * k + 3;
if(n <= c || d.get(c - 2).longValue() < d.get(c).longValue()) {
c -= 2;
}
if(c < n && d.get(c).longValue() < d.get(k).longValue()) {
Collections.swap(d, k, c);
k = c;
}
else {
break;
}
}
} else {
while(2 * k + 2 < n) {
int c = 2 * k + 4;
if(n <= c || d.get(c).longValue() < d.get(c - 2).longValue()) {
c -= 2;
}
if(c < n && d.get(k).longValue() < d.get(c).longValue()) {
Collections.swap(d, k, c);
k = c;
}
else {
break;
}
}
}
return k;
}
private final int up(int k, final int root) {
if((k | 1) < d.size() && d.get(k & ~1).longValue() < d.get(k | 1).longValue()) {
Collections.swap(d, k & ~1, k | 1);
k ^= 1;
}
int p;
while(root < k && d.get(p = parent(k)).longValue() < d.get(k).longValue()) {
Collections.swap(d, p, k);
k = p;
}
while(root < k && d.get(k).longValue() < d.get(p = parent(k) | 1).longValue()) {
Collections.swap(d, p, k);
k = p;
}
return k;
}
private final int parent(final int k){ return ((k >> 1) - 1) & ~1; }
private final void popBack(final ArrayList<T> d){ d.remove(d.size() - 1); }
final void push(final T x) {
final int k = d.size();
d.add(x);
up(k, 1);
}
final T popMin() {
final T res = getMin();
if(d.size() < 3) {
popBack(d);
} else {
Collections.swap(d, 1, d.size() - 1);
popBack(d);
up(down(1), 1);
}
return res;
}
final T popMax() {
final T res = getMax();
if(d.size() < 2) {
popBack(d);
} else {
Collections.swap(d, 0, d.size() - 1);
popBack(d);
up(down(0), 1);
}
return res;
}
final T getMin(){ return d.size() < 2 ? d.get(0) : d.get(1); }
final T getMax(){ return d.get(0); }
final int size(){ return d.size(); }
final boolean isEmpty(){ return d.isEmpty(); }
}
final class FenwickTree {
private final int n;
private final long[] data;
FenwickTree(final int n) {
this.n = n + 2;
data = new long[this.n + 1];
}
FenwickTree(final int[] a) {
this(a.length);
IntStream.range(0, a.length).forEach(i -> add(i, a[i]));
}
FenwickTree(final long[] a) {
this(a.length);
IntStream.range(0, a.length).forEach(i -> add(i, a[i]));
}
final long sum(int k) {
if(k < 0) {
return 0;
}
long ret = 0;
for(++k; k > 0; k -= k & -k) {
ret += data[k];
}
return ret;
}
final long sum(final int l, final int r){ return sum(r) - sum(l - 1); }
final long get(final int k){ return sum(k) - sum(k - 1); }
final void add(int k, final long x) {
for(++k; k < n; k += k & -k) {
data[k] += x;
}
}
final void add(final int l, final int r, final long x) {
add(l, x);
add(r + 1, -x);
}
private final int lg(final int n){ return 31 - Integer.numberOfLeadingZeros(n); }
final int lowerBound(long w) {
if(w <= 0) {
return 0;
}
int x = 0;
for(int k = 1 << lg(n); k > 0; k >>= 1) {
if(x + k <= n - 1 && data[x + k] < w) {
w -= data[x + k];
x += k;
}
}
return x;
}
final int upperBound(long w) {
if(w < 0) {
return 0;
}
int x = 0;
for(int k = 1 << lg(n); k > 0; k >>= 1) {
if(x + k <= n - 1 && data[x + k] <= w) {
w -= data[x + k];
x += k;
}
}
return x;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(sum(0));
for(int i = 0; ++i < n - 2;) {
sb.append(" " + sum(i));
}
return sb.toString();
}
}
final class RangeBIT {
private final int n;
private final FenwickTree a, b;
RangeBIT(final int n) {
this.n = n;
a = new FenwickTree(n + 1);
b = new FenwickTree(n + 1);
}
RangeBIT(final int[] arr) {
this(arr.length);
for(int i = 0; i < arr.length; ++i) {
add(i, i, arr[i]);
}
}
RangeBIT(final long[] arr) {
this(arr.length);
for(int i = 0; i < arr.length; ++i) {
add(i, i, arr[i]);
}
}
final void add(final int l, final int r, final long x) {
a.add(l, x);
a.add(r, -x);
b.add(l, x * (1 - l));
b.add(r, x * (r - 1));
}
final long get(final int i){ return sum(i, i + 1); }
final long sum(int l, int r) {
l--;
r--;
return a.sum(r) * r + b.sum(r) - a.sum(l) * l - b.sum(l);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class SegmentTree<T> {
private int n = 1, rank = 0;
private final int fini;
private final BinaryOperator<T> op;
private final T e;
private final Object[] dat;
SegmentTree(final int fini, final BinaryOperator<T> op, final T e) {
this.fini = fini;
this.op = op;
this.e = e;
while(this.fini > n) {
n <<= 1;
rank++;
}
dat = new Object[2 * n];
Arrays.fill(dat, e);
}
SegmentTree(final T[] a, final BinaryOperator<T> op, final T e) {
this(a.length, op, e);
IntStream.range(0, a.length).forEach(i -> update(i, a[i]));
}
@SuppressWarnings("unchecked")
final void update(int i, final T x) {
i += n;
dat[i] = x;
do {
i >>= 1;
dat[i] = op.apply((T) dat[2 * i], (T) dat[2 * i + 1]);
} while(i > 0);
}
final T get(final int i){ return query(i, i + 1); }
@SuppressWarnings("unchecked")
final T query(int a, int b) {
T l = e, r = e;
for(a += n, b += n; a < b; a >>= 1, b >>= 1) {
if(a % 2 == 1) {
l = op.apply(l, (T) dat[a++]);
}
if(b % 2 == 1) {
r = op.apply((T) dat[--b], r);
}
}
return op.apply(l, r);
}
@SuppressWarnings("unchecked")
final T all(){ return (T) dat[1]; }
@SuppressWarnings("unchecked")
final int findLeft(final int r, final Predicate<T> fn) {
if(r == 0) {
return 0;
}
int h = 0, i = r + n;
T val = e;
for(; h <= rank; h++) {
if(i >> (h & 1) > 0) {
final T val2 = op.apply(val, (T) dat[i >> (h ^ 1)]);
if(fn.test(val2)){
i -= 1 << h;
if(i == n) {
return 0;
}
val = val2;
}
else {
break;
}
}
}
for(; h-- > 0;) {
final T val2 = op.apply(val, (T) dat[(i >> h) - 1]);
if(fn.test(val2)){
i -= 1 << h;
if(i == n) {
return 0;
}
val = val2;
}
}
return i - n;
}
@SuppressWarnings("unchecked")
final int findRight(final int l, final Predicate<T> fn) {
if(l == fini) {
return fini;
}
int h = 0, i = l + n;
T val = e;
for(; h <= rank; h++) {
if(i >> (h & 1) > 0){
final T val2 = op.apply(val, (T) dat[i >> h]);
if(fn.test(val2)){
i += 1 << h;
if(i == n * 2) {
return fini;
}
val = val2;
}
else {
break;
}
}
}
for(; h-- > 0;) {
final T val2 = op.apply(val, (T) dat[i >> h]);
if(fn.test(val2)) {
i += 1 << h;
if(i == n * 2) {
return fini;
}
val = val2;
}
}
return min(i - n, fini);
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < fini;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
class LazySegmentTree<T, U extends Comparable<? super U>> {
private final int n;
private int sz, h;
private final Object[] data, lazy;
private final BinaryOperator<T> f;
private final BiFunction<T, U, T> map;
private final BinaryOperator<U> comp;
private final T e;
private final U id;
@SuppressWarnings("unchecked")
private final void update(final int k){ data[k] = f.apply((T) data[2 * k], (T) data[2 * k + 1]); }
@SuppressWarnings("unchecked")
private final void allApply(final int k, final U x) {
data[k] = map.apply((T) data[k], x);
if(k < sz) {
lazy[k] = comp.apply((U) lazy[k], x);
}
}
@SuppressWarnings("unchecked")
private final void propagate(final int k) {
if(!lazy[k].equals(id)) {
allApply(2 * k, (U) lazy[k]);
allApply(2 * k + 1, (U) lazy[k]);
lazy[k] = id;
}
}
LazySegmentTree(final int n, final BinaryOperator<T> f, final BiFunction<T, U, T> map, final BinaryOperator<U> comp, final T e, final U id) {
this.n = n;
this.f = f;
this.map = map;
this.comp = comp;
this.e = e;
this.id = id;
sz = 1;
h = 0;
while(sz < n) {
sz <<= 1;
h++;
}
data = new Object[2 * sz];
Arrays.fill(data, e);
lazy = new Object[2 * sz];
Arrays.fill(lazy, id);
}
LazySegmentTree(final T[] a, final BinaryOperator<T> f, final BiFunction<T, U, T> map, final BinaryOperator<U> comp, final T e, final U id) {
this(a.length, f, map, comp, e, id);
build(a);
}
final void build(final T[] a) {
assert n == a.length;
for(int k = 0; k < n; ++k) {
data[k + sz] = a[k];
}
for(int k = sz; --k > 0;) {
update(k);
}
}
final void set(int k, final T x) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
data[k] = x;
for(int i = 0; ++i <= h;) {
update(k >> i);
}
}
@SuppressWarnings("unchecked")
final T get(int k) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
return (T) data[k];
}
@SuppressWarnings("unchecked")
final T query(int l, int r) {
if(l >= r) {
return e;
}
l += sz;
r += sz;
for(int i = h; i > 0; i--) {
if(((l >> i) << i) != l) {
propagate(l >> i);
}
if(((r >> i) << i) != r) {
propagate((r - 1) >> i);
}
}
T l2 = e, r2 = e;
for(; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
l2 = f.apply(l2, (T) data[l++]);
}
if(r % 2 == 1) {
r2 = f.apply((T) data[--r], r2);
}
}
return f.apply(l2, r2);
}
@SuppressWarnings("unchecked")
final T all(){ return (T) data[1]; }
@SuppressWarnings("unchecked")
final void apply(int k, final U x) {
k += sz;
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
data[k] = map.apply((T) data[k], x);
for(int i = 0; ++i <= h;) {
update(k >> i);
}
}
final void apply(int l, int r, final U x) {
if(l >= r) {
return;
}
l += sz;
r += sz;
for(int i = h; i > 0; i--) {
if(((l >> i) << i) != l) {
propagate(l >> i);
}
if(((r >> i) << i) != r) {
propagate((r - 1) >> i);
}
}
int l2 = l, r2 = r;
for(; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
allApply(l++, x);
}
if(r % 2 == 1) {
allApply(--r, x);
}
}
l = l2;
r = r2;
for(int i = 0; ++i <= h;) {
if(((l >> i) << i) != l) {
update(l >> i);
}
if(((r >> i) << i) != r) {
update((r - 1) >> i);
}
}
}
@SuppressWarnings("unchecked")
final int findFirst(int l, final Predicate<T> fn) {
if(l >= n) {
return n;
}
l += sz;
for(int i = h; i > 0; i--) {
propagate(l >> i);
}
T sum = e;
do {
while((l & 1) == 0) {
l >>= 1;
}
if(fn.test(f.apply(sum, (T) data[l]))) {
while(l < sz) {
propagate(l);
l <<= 1;
final T nxt = f.apply(sum, (T) data[l]);
if(!fn.test(nxt)) {
sum = nxt;
l++;
}
}
return l + 1 - sz;
}
sum = f.apply(sum, (T) data[l++]);
} while((l & -l) != l);
return n;
}
@SuppressWarnings("unchecked")
final int findLast(int r, final Predicate<T> fn) {
if(r <= 0) {
return -1;
}
r += sz;
for(int i = h; i > 0; i--) {
propagate((r - 1) >> i);
}
T sum = e;
do {
r--;
while(r > 1 && r % 2 == 1) {
r >>= 1;
}
if(fn.test(f.apply((T) data[r], sum))) {
while(r < sz) {
propagate(r);
r = (r << 1) + 1;
final T nxt = f.apply((T) data[r], sum);
if(!fn.test(nxt)) {
sum = nxt;
r--;
}
}
return r - sz;
}
sum = f.apply((T) data[r], sum);
} while((r & -r) != r);
return -1;
}
final void clear(){ Arrays.fill(data, e); }
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class Zwei<T> implements Cloneable {
public T first, second;
private Zwei(final T first, final T second) {
this.first = first;
this.second = second;
}
static final <T> Zwei<T> of(final T f, final T s){ return new Zwei<>(f, s); }
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Zwei<?> z = (Zwei<?>) o;
return first.equals(z.first) && second.equals(z.second);
}
@Override
public final int hashCode(){ return Objects.hash(first, second); }
@Override
public final String toString(){ return String.valueOf(first); }
@SuppressWarnings("unchecked")
@Override
public final Zwei<T> clone() {
try {
return (Zwei<T>) super.clone();
} catch(final CloneNotSupportedException e){
e.printStackTrace();
}
throw new Error();
}
}
final class RAMX extends LazySegmentTree<Long, Long> {
RAMX(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, Long::sum, Long::sum, Long.valueOf(Long.MIN_VALUE), Long.valueOf(0)); }
RAMX(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, Long::sum, Long::sum, Long.valueOf(Long.MIN_VALUE), Long.valueOf(0)); }
}
final class RAMN extends LazySegmentTree<Long, Long> {
RAMN(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, Long::sum, Long::sum, Long.valueOf(Long.MAX_VALUE), Long.valueOf(0)); }
RAMN(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, Long::sum, Long::sum, Long.valueOf(Long.MAX_VALUE), Long.valueOf(0)); }
}
final class RASM extends LazySegmentTree<Zwei<Long>, Long> {
private final int n;
private final Zwei<Long>[] b;
@SuppressWarnings("unchecked")
RASM(final int[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.first.longValue() + x.second.longValue() * y.longValue(), x.second.longValue()), Long::sum, Zwei.of(0L, 0L), Long.valueOf(0));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of((long) a[i], 1L);
}
build(b);
}
@SuppressWarnings("unchecked")
RASM(final long[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.first.longValue() + x.second.longValue() * y.longValue(), x.second.longValue()), Long::sum, Zwei.of(0L, 0L), Long.valueOf(0));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of(a[i], 1L);
}
build(b);
}
}
final class RUMX extends LazySegmentTree<Long, Long> {
RUMX(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE)); }
RUMX(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::max, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE)); }
}
final class RUMN extends LazySegmentTree<Long, Long> {
RUMN(final int[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE)); }
RUMN(final long[] a){ super(Arrays.stream(a).boxed().toArray(Long[]::new), Long::min, (x, y) -> y, (x, y) -> y, Long.valueOf(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE)); }
}
final class RUSM extends LazySegmentTree<Zwei<Long>, Long> {
private final int n;
private final Zwei<Long>[] b;
@SuppressWarnings("unchecked")
RUSM(final int[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.second.longValue() * y.longValue(), x.second.longValue()), (x, y) -> y, Zwei.of(0L, 0L), Long.valueOf(Long.MIN_VALUE));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of((long) a[i], 1L);
}
build(b);
}
@SuppressWarnings("unchecked")
RUSM(final long[] a) {
super(a.length, (x, y) -> Zwei.of(x.first.longValue() + y.first.longValue(), x.second.longValue() + y.second.longValue()), (x, y) -> Zwei.of(x.second.longValue() * y.longValue(), x.second.longValue()), (x, y) -> y, Zwei.of(0L, 0L), Long.valueOf(Long.MIN_VALUE));
n = a.length;
b = new Zwei[n];
for(int i = 0; i < n; ++i) {
b[i] = Zwei.of(a[i], 1L);
}
build(b);
}
}
final class DualSegmentTree<T> {
private final int n;
private int sz, h;
private final Object[] lazy;
private final T id;
private final BinaryOperator<T> ap;
@SuppressWarnings("unchecked")
private final void propagate(final int k) {
if(lazy[k] != id) {
lazy[2 * k] = ap.apply((T) lazy[2 * k], (T) lazy[k]);
lazy[2 * k + 1] = ap.apply((T) lazy[2 * k + 1], (T) lazy[k]);
lazy[k] = id;
}
}
private final void thrust(final int k) {
for(int i = h; i > 0; i--) {
propagate(k >> i);
}
}
DualSegmentTree(final int n, final BinaryOperator<T> ap, final T id) {
this.n = n;
this.ap = ap;
this.id = id;
sz = 1;
h = 0;
while(sz < n) {
sz <<= 1;
h++;
}
lazy = new Object[2 * sz];
Arrays.fill(lazy, id);
}
@SuppressWarnings("unchecked")
final void apply(int a, int b, final T x) {
thrust(a += sz);
thrust(b += sz - 1);
for(int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if(l % 2 == 1) {
lazy[l] = ap.apply((T) lazy[l], x);
l++;
}
if(r % 2 == 1) {
r--;
lazy[r] = ap.apply((T) lazy[r], x);
}
}
}
@SuppressWarnings("unchecked")
final T get(int k) {
thrust(k += sz);
return (T) lazy[k];
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder();
sb.append(get(0));
for(int i = 0; ++i < n;) {
sb.append(" " + get(i));
}
return sb.toString();
}
}
final class SparseTable {
private final long[][] st;
private final int[] lookup;
private final LongBinaryOperator op;
SparseTable(final int[] a, final LongBinaryOperator op) {
this.op = op;
int b = 0;
while((1 << b) <= a.length) {
++b;
}
st = new long[b][1 << b];
for(int i = 0; i < a.length; i++) {
st[0][i] = a[i];
}
for(int i = 1; i < b; i++) {
for(int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = op.applyAsLong(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
lookup = new int[a.length + 1];
for(int i = 2; i < lookup.length; i++) {
lookup[i] = lookup[i >> 1] + 1;
}
}
SparseTable(final long[] a, final LongBinaryOperator op) {
this.op = op;
int b = 0;
while((1 << b) <= a.length) {
++b;
}
st = new long[b][1 << b];
for(int i = 0; i < a.length; i++) {
st[0][i] = a[i];
}
for(int i = 1; i < b; i++) {
for(int j = 0; j + (1 << i) <= (1 << b); j++) {
st[i][j] = op.applyAsLong(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
lookup = new int[a.length + 1];
for(int i = 2; i < lookup.length; i++) {
lookup[i] = lookup[i >> 1] + 1;
}
}
final long query(final int l, final int r) {
final int b = lookup[r - l];
return op.applyAsLong(st[b][l], st[b][r - (1 << b)]);
}
final int minLeft(final int x, final LongPredicate fn) {
if(x == 0) {
return 0;
}
int ok = x, ng = -1;
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(query(mid, x) - 1)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
final int maxRight(final int x, final LongPredicate fn) {
if(x == lookup.length - 1) {
return lookup.length - 1;
}
int ok = x, ng = lookup.length;
while(abs(ok - ng) > 1) {
final int mid = (ok + ng) / 2;
if(fn.test(query(x, mid))) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
}
final class WaveletMatrix {
private final WaveletMatrixBeta mat;
private final long[] ys;
WaveletMatrix(final int[] arr){ this(arr, 20); }
WaveletMatrix(final long[] arr){ this(arr, 20); }
WaveletMatrix(final int[] arr, final int log) {
ys = Arrays.stream(arr).asLongStream().sorted().distinct().toArray();
final long[] t = new long[arr.length];
Arrays.setAll(t, i -> index(arr[i]));
mat = new WaveletMatrixBeta(t, log);
}
WaveletMatrix(final long[] arr, final int log) {
ys = Arrays.stream(arr).sorted().distinct().toArray();
final long[] t = new long[arr.length];
Arrays.setAll(t, i -> index(arr[i]));
mat = new WaveletMatrixBeta(t, log);
}
private final int index(final long x){ return Utility.lowerBound(ys, x); }
final long get(final int k){ return ys[(int) mat.access(k)]; }
final int rank(final int r, final long x) {
final int pos = index(x);
if(pos == ys.length || ys[pos] != x) {
return 0;
}
return mat.rank(pos, r);
}
final int rank(final int l, final int r, final long x){ return rank(r, x) - rank(l, x); }
final long kthMin(final int l, final int r, final int k){ return ys[(int) mat.kthMin(l, r, k)]; }
final long kthMax(final int l, final int r, final int k){ return ys[(int) mat.kthMax(l, r, k)]; }
final int rangeFreq(final int l, final int r, final long upper){ return mat.rangeFreq(l, r, index(upper)); }
final int rangeFreq(final int l, final int r, final long lower, final long upper){ return mat.rangeFreq(l, r, index(lower), index(upper)); }
final long prev(final int l, final int r, final long upper) {
final long ret = mat.prev(l, r, index(upper));
return ret == -1 ? -1 : ys[(int) ret];
}
final long next(final int l, final int r, final long lower) {
final long ret = mat.next(l, r, index(lower));
return ret == -1 ? -1 : ys[(int) ret];
}
private final class WaveletMatrixBeta {
private final int log;
private final SuccinctIndexableDictionary[] matrix;
private final int[] mid;
WaveletMatrixBeta(final long[] arr, final int log) {
final int len = arr.length;
this.log = log;
matrix = new SuccinctIndexableDictionary[log];
mid = new int[log];
final long[] l = new long[len], r = new long[len];
for(int level = log; --level >= 0;) {
matrix[level] = new SuccinctIndexableDictionary(len + 1);
int left = 0, right = 0;
for(int i = 0; i < len; ++i) {
if(((arr[i] >> level) & 1) == 1) {
matrix[level].set(i);
r[right++] = arr[i];
} else {
l[left++] = arr[i];
}
}
mid[level] = left;
matrix[level].build();
final long[] tmp = new long[len];
System.arraycopy(arr, 0, tmp, 0, len);
System.arraycopy(l, 0, arr, 0, len);
System.arraycopy(tmp, 0, l, 0, len);
for(int i = 0; i < right; ++i) {
arr[left + i] = r[i];
}
}
}
private final IntPair succ(final boolean f, final int l, final int r, final int level){ return IntPair.of(matrix[level].rank(f, l) + mid[level] * (f ? 1 : 0), matrix[level].rank(f, r) + mid[level] * (f ? 1 : 0)); }
final long access(int k) {
long ret = 0;
for(int level = log; --level >= 0;) {
final boolean f = matrix[level].get(k);
if(f) {
ret |= 1L << level;
}
k = matrix[level].rank(f, k) + mid[level] * (f ? 1 : 0);
}
return ret;
}
final int rank(final long x, int r) {
int l = 0;
for(int level = log; --level >= 0;) {
final IntPair p = succ(((x >> level) & 1) == 1, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return r - l;
}
final long kthMin(int l, int r, int k) {
if(!Utility.scope(0, k, r - l - 1)) {
throw new IndexOutOfBoundsException();
}
long ret = 0;
for(int level = log; --level >= 0;) {
final int cnt = matrix[level].rank(false, r) - matrix[level].rank(false, l);
final boolean f = cnt <= k;
if(f) {
ret |= 1 << level;
k -= cnt;
}
final IntPair p = succ(f, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return ret;
}
final long kthMax(final int l, final int r, final int k){ return kthMin(l, r, r - l - k - 1); }
final int rangeFreq(int l, int r, final long upper) {
int ret = 0;
for(int level = log; --level >= 0;) {
final boolean f = ((upper >> level) & 1) == 1;
if(f) {
ret += matrix[level].rank(false, r) - matrix[level].rank(false, l);
}
final IntPair p = succ(f, l, r, level);
l = p.first.intValue();
r = p.second.intValue();
}
return ret;
}
final int rangeFreq(final int l, final int r, final long lower, final long upper){ return rangeFreq(l, r, upper) - rangeFreq(l, r, lower); }
final long prev(final int l, final int r, final long upper) {
final int cnt = rangeFreq(l, r, upper);
return cnt == 0 ? -1 : kthMin(l, r, cnt - 1);
}
final long next(final int l, final int r, final long lower) {
final int cnt = rangeFreq(l, r, lower);
return cnt == r - l ? -1 : kthMin(l, r, cnt);
}
private final class SuccinctIndexableDictionary {
private final int blk;
private final int[] bit, sum;
SuccinctIndexableDictionary(final int len) {
blk = (len + 31) >> 5;
bit = new int[blk];
sum = new int[blk];
}
final void set(final int k){ bit[k >> 5] |= 1 << (k & 31); }
final void build() {
sum[0] = 0;
for(int i = 0; i + 1 < blk; ++i) {
sum[i + 1] = sum[i] + Integer.bitCount(bit[i]);
}
}
final boolean get(final int k){ return ((bit[k >> 5] >> (k & 31)) & 1) == 1; }
final int rank(final int k){ return (sum[k >> 5] + Integer.bitCount(bit[k >> 5] & ((1 << (k & 31)) - 1))); }
final int rank(final boolean val, final int k){ return val ? rank(k) : k - rank(k); }
}
}
} | ConDefects/ConDefects/Code/abc346_d/Java/51641038 |
condefects-java_data_120 | import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
@SuppressWarnings({"unused"})
public final class Main {
// @SuppressWarnings({"unchecked"})
public static final void main(String[] args) {
final int N = getNextInt();
final String S = getNext();
final int[] C = getIntArray(N);
final long[][] cumulCost = new long[2][N];
cumulCost[0][0] = S.charAt(0) == '0' ? 0 : C[0];
cumulCost[1][0] = S.charAt(0) == '1' ? 0 : C[0];
for(int idx = 1; idx < N; idx++) {
cumulCost[0][idx] = cumulCost[0][idx - 1] + (S.charAt(idx) == '0' + idx % 2 ? 0 : C[idx]);
cumulCost[1][idx] = cumulCost[1][idx - 1] + (S.charAt(idx) == '1' - idx % 2 ? 0 : C[idx]);
}
long minCost = Long.MAX_VALUE;
for(int idx = 0; idx < N; idx++) {
minCost = Math.min(minCost, cumulCost[0][idx] + cumulCost[1][N - 1] - cumulCost[1][idx]);
minCost = Math.min(minCost, cumulCost[1][idx] + cumulCost[0][N - 1] - cumulCost[0][idx]);
}
println(minCost);
flush();
}
// 以下Utility
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static String[] readBuffer = new String[] {};
private static int readBufferCursor = 0;
private static PrintWriter writer = new PrintWriter(System.out);
// private static BufferedReader reader;
// static {
// try {
// reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
// }
private static int[] concat(int[]... arys) {
return Arrays.stream(arys).flatMapToInt(ary -> Arrays.stream(ary)).toArray();
// IntStream st = Arrays.stream(arys[0]);
// for(int idx = 1; idx < arys.length; idx++) {
// st = IntStream.concat(st, Arrays.stream(arys[idx]));
// }
// return st.toArray();
}
@SafeVarargs
private static <E> List<E> concat(List<E>... lists) {
return Arrays.stream(lists).flatMap(list -> list.stream()).toList();
// Stream<E> st = lists[0].stream();
// for(int idx = 1; idx < lists.length; idx++) {
// st = Stream.concat(st, lists[idx].stream());
// }
// return st.collect(Collectors.toList());
}
private static String getNextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private static String getNext() {
// return scanner.next();
if(readBuffer.length == readBufferCursor) {
readBuffer = getNextLine().trim().split("\\s");
readBufferCursor = 0;
}
return readBuffer[readBufferCursor++];
}
private static int[] getCharIntArray() {
return getCharIntArray(v -> v);
}
private static int[] getCharIntArray(IntUnaryOperator mapper) {
return getNext().chars().map(mapper).toArray();
}
private static char[][] get2dCharArray(int rows) {
return Stream.generate(() -> getNext().toCharArray()).limit(rows).toArray(char[][]::new);
}
private static char[][] get2dCharArrayWithBorder(int rows, int cols, char borderChar) {
Stream.Builder<char[]> sb = Stream.builder();
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
for(int idx = 0; idx < rows; idx++) {
sb.add((Character.toString(borderChar) + getNext() + Character.toString(borderChar)).toCharArray());
}
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
return sb.build().toArray(char[][]::new);
}
private static int[][] get2dCharIntArray(int rows) {
return get2dCharIntArray(rows, v -> v);
}
private static int[][] get2dCharIntArray(int rows, IntUnaryOperator mapper) {
return Stream.generate(() -> getNext().chars().map(mapper).toArray()).limit(rows).toArray(int[][]::new);
}
private static int getNextInt() {
return Integer.parseInt(getNext());
}
private static long getNextLong() {
return Long.parseLong(getNext());
}
private static double getNextDouble() {
return Double.parseDouble(getNext());
}
private static int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(() -> getNextInt()).limit(length).map(mapper).toArray();
}
private static int[][] getIntArrayWithSeq(int length) {
return getIntArrayWithSeq(length, v -> v);
}
private static int[][] getIntArrayWithSeq(int length, IntUnaryOperator mapper) {
int[][] array = new int[length][2];
for(int counter = 0; counter < length; counter++) {
array[counter][0] = counter;
array[counter][1] = mapper.applyAsInt(getNextInt());
}
return array;
}
private static int getBitLineInt() {
final int[] line = getCharIntArray(c -> c - '0');
int result = 0;
for(int pos = 0; pos < line.length; pos++) {
result <<= 1;
result |= line[pos];
}
return result;
}
private static int[] getBitLineIntAry(int length) {
final int[] bitAry = new int[length];
for(int idx = 0; idx < length; idx++) {
bitAry[idx] = getBitLineInt();
}
return bitAry;
}
private static List<Integer> getIntList(int length) {
return getIntList(length, v -> v);
}
private static List<Integer> getIntList(int length, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getNextInt()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(() -> getNextLong()).limit(length).map(mapper).toArray();
}
private static List<Long> getLongList(int length) {
return getLongList(length, v -> v);
}
private static List<Long> getLongList(int length, Function<Long, Long> mapper) {
return Stream.generate(() -> getNextLong()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static double[] getDoubleArray(int length) {
return DoubleStream.generate(() -> getNextDouble()).limit(length).toArray();
}
private static int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(() -> getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static List<List<Integer>> get2dIntList(int rows, int cols) {
return get2dIntList(rows, cols, v -> v);
}
private static List<List<Integer>> get2dIntList(int rows, int cols, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getIntList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(() -> getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static List<List<Long>> get2dLongList(int rows, int cols) {
return get2dLongList(rows, cols, v -> v);
}
private static List<List<Long>> get2dLongList(int rows, int cols, Function<Long, Long> mapper) {
return Stream.generate(() -> getLongList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static void print(int... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(long... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(char[] ary) {
print(String.valueOf(ary));
}
private static void print(Collection<?> list) {
for(Iterator<?> itr = list.iterator(); itr.hasNext();) {
print(itr.next() + (itr.hasNext() ? " " : ""));
}
}
private static void print(Object obj) {
writer.print(obj);
}
private static void println(int... ary) {
print(ary);
println();
}
private static void println(long... ary) {
print(ary);
println();
}
private static void println(char[] ary) {
print(ary);
println();
}
private static void println(char[][] cmap) {
Arrays.stream(cmap).forEach(line -> println(line));
}
private static void println(Collection<?> list) {
print(list);
println();
}
private static void println(Object obj) {
print(obj);
println();
}
private static void println() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
@SuppressWarnings({"unused"})
public final class Main {
// @SuppressWarnings({"unchecked"})
public static final void main(String[] args) {
final int N = getNextInt();
final String S = getNext();
final int[] C = getIntArray(N);
final long[][] cumulCost = new long[2][N];
cumulCost[0][0] = S.charAt(0) == '0' ? 0 : C[0];
cumulCost[1][0] = S.charAt(0) == '1' ? 0 : C[0];
for(int idx = 1; idx < N; idx++) {
cumulCost[0][idx] = cumulCost[0][idx - 1] + (S.charAt(idx) == '0' + idx % 2 ? 0 : C[idx]);
cumulCost[1][idx] = cumulCost[1][idx - 1] + (S.charAt(idx) == '1' - idx % 2 ? 0 : C[idx]);
}
long minCost = Long.MAX_VALUE;
for(int idx = 0; idx < N - 1; idx++) {
minCost = Math.min(minCost, cumulCost[0][idx] + cumulCost[1][N - 1] - cumulCost[1][idx]);
minCost = Math.min(minCost, cumulCost[1][idx] + cumulCost[0][N - 1] - cumulCost[0][idx]);
}
println(minCost);
flush();
}
// 以下Utility
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static String[] readBuffer = new String[] {};
private static int readBufferCursor = 0;
private static PrintWriter writer = new PrintWriter(System.out);
// private static BufferedReader reader;
// static {
// try {
// reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
// }
private static int[] concat(int[]... arys) {
return Arrays.stream(arys).flatMapToInt(ary -> Arrays.stream(ary)).toArray();
// IntStream st = Arrays.stream(arys[0]);
// for(int idx = 1; idx < arys.length; idx++) {
// st = IntStream.concat(st, Arrays.stream(arys[idx]));
// }
// return st.toArray();
}
@SafeVarargs
private static <E> List<E> concat(List<E>... lists) {
return Arrays.stream(lists).flatMap(list -> list.stream()).toList();
// Stream<E> st = lists[0].stream();
// for(int idx = 1; idx < lists.length; idx++) {
// st = Stream.concat(st, lists[idx].stream());
// }
// return st.collect(Collectors.toList());
}
private static String getNextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private static String getNext() {
// return scanner.next();
if(readBuffer.length == readBufferCursor) {
readBuffer = getNextLine().trim().split("\\s");
readBufferCursor = 0;
}
return readBuffer[readBufferCursor++];
}
private static int[] getCharIntArray() {
return getCharIntArray(v -> v);
}
private static int[] getCharIntArray(IntUnaryOperator mapper) {
return getNext().chars().map(mapper).toArray();
}
private static char[][] get2dCharArray(int rows) {
return Stream.generate(() -> getNext().toCharArray()).limit(rows).toArray(char[][]::new);
}
private static char[][] get2dCharArrayWithBorder(int rows, int cols, char borderChar) {
Stream.Builder<char[]> sb = Stream.builder();
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
for(int idx = 0; idx < rows; idx++) {
sb.add((Character.toString(borderChar) + getNext() + Character.toString(borderChar)).toCharArray());
}
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
return sb.build().toArray(char[][]::new);
}
private static int[][] get2dCharIntArray(int rows) {
return get2dCharIntArray(rows, v -> v);
}
private static int[][] get2dCharIntArray(int rows, IntUnaryOperator mapper) {
return Stream.generate(() -> getNext().chars().map(mapper).toArray()).limit(rows).toArray(int[][]::new);
}
private static int getNextInt() {
return Integer.parseInt(getNext());
}
private static long getNextLong() {
return Long.parseLong(getNext());
}
private static double getNextDouble() {
return Double.parseDouble(getNext());
}
private static int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(() -> getNextInt()).limit(length).map(mapper).toArray();
}
private static int[][] getIntArrayWithSeq(int length) {
return getIntArrayWithSeq(length, v -> v);
}
private static int[][] getIntArrayWithSeq(int length, IntUnaryOperator mapper) {
int[][] array = new int[length][2];
for(int counter = 0; counter < length; counter++) {
array[counter][0] = counter;
array[counter][1] = mapper.applyAsInt(getNextInt());
}
return array;
}
private static int getBitLineInt() {
final int[] line = getCharIntArray(c -> c - '0');
int result = 0;
for(int pos = 0; pos < line.length; pos++) {
result <<= 1;
result |= line[pos];
}
return result;
}
private static int[] getBitLineIntAry(int length) {
final int[] bitAry = new int[length];
for(int idx = 0; idx < length; idx++) {
bitAry[idx] = getBitLineInt();
}
return bitAry;
}
private static List<Integer> getIntList(int length) {
return getIntList(length, v -> v);
}
private static List<Integer> getIntList(int length, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getNextInt()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(() -> getNextLong()).limit(length).map(mapper).toArray();
}
private static List<Long> getLongList(int length) {
return getLongList(length, v -> v);
}
private static List<Long> getLongList(int length, Function<Long, Long> mapper) {
return Stream.generate(() -> getNextLong()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static double[] getDoubleArray(int length) {
return DoubleStream.generate(() -> getNextDouble()).limit(length).toArray();
}
private static int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(() -> getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static List<List<Integer>> get2dIntList(int rows, int cols) {
return get2dIntList(rows, cols, v -> v);
}
private static List<List<Integer>> get2dIntList(int rows, int cols, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getIntList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(() -> getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static List<List<Long>> get2dLongList(int rows, int cols) {
return get2dLongList(rows, cols, v -> v);
}
private static List<List<Long>> get2dLongList(int rows, int cols, Function<Long, Long> mapper) {
return Stream.generate(() -> getLongList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static void print(int... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(long... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(char[] ary) {
print(String.valueOf(ary));
}
private static void print(Collection<?> list) {
for(Iterator<?> itr = list.iterator(); itr.hasNext();) {
print(itr.next() + (itr.hasNext() ? " " : ""));
}
}
private static void print(Object obj) {
writer.print(obj);
}
private static void println(int... ary) {
print(ary);
println();
}
private static void println(long... ary) {
print(ary);
println();
}
private static void println(char[] ary) {
print(ary);
println();
}
private static void println(char[][] cmap) {
Arrays.stream(cmap).forEach(line -> println(line));
}
private static void println(Collection<?> list) {
print(list);
println();
}
private static void println(Object obj) {
print(obj);
println();
}
private static void println() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
| ConDefects/ConDefects/Code/abc346_d/Java/52706157 |
condefects-java_data_121 | import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
int[] A = new int[N];
int[] C = new int[N];
for(int i = 0; i < N; i++){
if(i == N-1){
A[i] = Integer.valueOf(S.substring(i));
}
else{
A[i] = Integer.valueOf(S.substring(i,i+1));
}
}
for(int i = 0; i < N; i++){
C[i] = sc.nextInt();
}
long[] F0 = new long[N];
long[] F1 = new long[N];
if(A[0] == 0){
F0[0] = 0;
F1[0] = C[0];
}
else{
F0[0] = C[0];
F1[0] = 0;
}
for(int i = 1; i < N; i++){
int ai = A[i];
if(ai == i%2){
F1[i] = F1[i-1] + C[i];
F0[i] = F0[i-1];
}
else{
F1[i] = F1[i-1];
F0[i] = F0[i-1] + C[i];
}
}
long min = F0[N-1]+F1[N-1];
for(int i = 1; i < N; i++){
long iSum0 = F1[N-1] - F1[i] + F0[i];
long iSum1 = F0[N-1] - F0[i] + F1[i];
long iSum = Math.min(iSum0, iSum1);
if(min > iSum){
min = iSum;
}
}
System.out.println(min);
}
}
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
int[] A = new int[N];
int[] C = new int[N];
for(int i = 0; i < N; i++){
if(i == N-1){
A[i] = Integer.valueOf(S.substring(i));
}
else{
A[i] = Integer.valueOf(S.substring(i,i+1));
}
}
for(int i = 0; i < N; i++){
C[i] = sc.nextInt();
}
long[] F0 = new long[N];
long[] F1 = new long[N];
if(A[0] == 0){
F0[0] = 0;
F1[0] = C[0];
}
else{
F0[0] = C[0];
F1[0] = 0;
}
for(int i = 1; i < N; i++){
int ai = A[i];
if(ai == i%2){
F1[i] = F1[i-1] + C[i];
F0[i] = F0[i-1];
}
else{
F1[i] = F1[i-1];
F0[i] = F0[i-1] + C[i];
}
}
long min = F0[N-1]+F1[N-1];
for(int i = 0; i < N-1; i++){
long iSum0 = F1[N-1] - F1[i] + F0[i];
long iSum1 = F0[N-1] - F0[i] + F1[i];
long iSum = Math.min(iSum0, iSum1);
if(min > iSum){
min = iSum;
}
}
System.out.println(min);
}
} | ConDefects/ConDefects/Code/abc346_d/Java/52263057 |
condefects-java_data_122 |
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();
String str = sc.next();
long cost[] = Arrays.stream(new long[n]).map(e -> sc.nextInt()).toArray();
long dp[][] = new long[n + 1][2];
for(int i = 0; i < n; i++) {
switch ((str.charAt(i) - '0' + i) % 2) {
case 0 -> {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][1] + cost[i];
}
case 1 -> {
dp[i + 1][0] = dp[i][0] + cost[i];
dp[i + 1][1] = dp[i][1];
}
}
}
// for(int i = 1; i <= n; i++) {
// System.out.println(dp[i][0] + " " + dp[i][1]);
// }
long result = Long.MAX_VALUE;
for(int i = 0; i < n ; i++) {
long tmp1 = dp[i][0] + (dp[n][1] -dp[i][1]);
long tmp2 = dp[i][1] + (dp[n][0] -dp[i][0]);
// System.out.println("i = " + i + " " + tmp1 + " " + tmp2);
result = Math.min(result, Math.min(tmp1, tmp2));
}
System.out.println(result);
}
}
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();
String str = sc.next();
long cost[] = Arrays.stream(new long[n]).map(e -> sc.nextInt()).toArray();
long dp[][] = new long[n + 1][2];
for(int i = 0; i < n; i++) {
switch ((str.charAt(i) - '0' + i) % 2) {
case 0 -> {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][1] + cost[i];
}
case 1 -> {
dp[i + 1][0] = dp[i][0] + cost[i];
dp[i + 1][1] = dp[i][1];
}
}
}
// for(int i = 1; i <= n; i++) {
// System.out.println(dp[i][0] + " " + dp[i][1]);
// }
long result = Long.MAX_VALUE;
for(int i = 1; i < n ; i++) {
long tmp1 = dp[i][0] + (dp[n][1] -dp[i][1]);
long tmp2 = dp[i][1] + (dp[n][0] -dp[i][0]);
// System.out.println("i = " + i + " " + tmp1 + " " + tmp2);
result = Math.min(result, Math.min(tmp1, tmp2));
}
System.out.println(result);
}
} | ConDefects/ConDefects/Code/abc346_d/Java/51718933 |
condefects-java_data_123 | import java.util.*;
import java.io.*;
// -------------------------Main class-------------------------
public class Main {
static long MOD = (long)1e9+7;
static int a[];
static long b[];
static long dp[][][];
// -------------------------Main function-------------------------
public static void main(String args[]) throws IOException {
FastReader sc = new FastReader();
PrintWriter pw = new PrintWriter(System.out);
int t = 1;
for (int i = 0; i <t; i++) {
int n=sc.nextInt();
String s=sc.next();
a=new int[n];
b=new long[n];
for(int j=0;j<n;j++)
{
a[j]=Character.getNumericValue(s.charAt(j));
b[j]=sc.nextLong();
}
dp=new long[n][2][2];
for(int j=0;j<n;j++)
{
for(int k=0;k<2;k++)
Arrays.fill(dp[j][k],-1);
}
pw.write(Math.min(getAns(1,a[0],0),b[0]+getAns(1,(a[0]+1)%2,0))+"\n");
}
pw.flush();
pw.close();
}
static long getAns(int curr, int prev, int found_or_not)
{
if(curr==a.length)
{
if(found_or_not==0)
return Long.MAX_VALUE;
else
return 0;
}
else if(dp[curr][prev][found_or_not]!=-1)
return dp[curr][prev][found_or_not];
else
{
long currans=0;
if(found_or_not==1)
{
if(a[curr]==prev)
currans=b[curr]+getAns(curr+1,(a[curr]+1)%2,1);
else
currans=getAns(curr+1,a[curr],1);
}
else
{
long change=b[curr]+getAns(curr+1,(a[curr]+1)%2,a[curr]==prev?0:1);
long notchange=getAns(curr+1,a[curr],a[curr]==prev?1:0);
currans=Math.min(change,notchange);
}
return dp[curr][prev][found_or_not]=currans;
}
}
// -------------------------Other functions-------------------------
// Time Complexity : log(n)
static long fast_power_mod(long n, long mod) {
long pow2 = 2;
long res = 1;
while (n > 0) {
if (n % 2 == 1)
res = (res % mod * pow2 % mod) % mod;
pow2 = (pow2 % mod * pow2 % mod) % mod;
n >>= 1;
}
return res;
}
// Time Complexity : O(n)
// Best mod values for hashing = 1e9 + 9
static void prefixHashAndModInverse(String s, long[] prefixhash, long[] modInversePowP)
{
long p = 31;
long currhash = 0;
long powP = 1;
for(int j=0;j<s.length();j++) {
char c = s.charAt(j);
currhash = (currhash + (c - '0' + 1) * powP) % MOD;
prefixhash[j] = currhash;
powP = (powP * p) % MOD;
}
for(int j=0;j<s.length();j++)
modInversePowP[j]=inverseMOD(power(p,j,MOD), MOD)%MOD;
}
// Use this for multiple nCr queries
// Time Complexity : n*r
static long nCrModpDP(long n, long r, long p) {
long c[] = new long[(int) r + 1];
c[0] = 1;
for (long j = 1; j <= n; j++) {
for (long k = Math.min(j, r); k > 0; k--)
c[(int) k] = (c[(int) k] % p + c[(int) k - 1] % p) % p;
}
return c[(int) r];
}
// Use this for multiple nCr queries
// Time Complexity : log(n) * n * r
static long nCrModpLucas(long n, long r, long p) {
if (r == 0)
return 1;
long ni = n % p;
long ri = r % p;
return (nCrModpLucas(n / p, r / p, p) % p * nCrModpDP(ni, ri, p) % p) % p;
}
// Use this for single nCr calculation when n <= 1e6
// Time Complexity : n
public static long nCrModpFermat(long n, long r, long p) {
if (n < r)
return 0;
if (r == 0)
return 1;
long[] fac = new long[(int) (n + 1)];
fac[0] = 1;
for (long i = 1; i <= n; i++)
fac[(int)i] = (fac[(int)i - 1] * i) % p;
return (fac[(int) n] * inverseMOD(fac[(int)r], p) % p * inverseMOD(fac[(int) (n - r)], p) % p) % p;
}
// Time Complexity : log(mod)
static long inverseMOD(long x, long mod)
{
return power(x,mod-2,mod)%mod;
}
// Time Complexity : log(exponent)
static long power(long base, long exponent, long mod) {
long ans = 1;
base = base % mod;
while (exponent > 0)
{
if (exponent%2!=0)
ans = (ans * base) % mod;
exponent/=2;
base = (base * base) % mod;
}
return ans;
}
// Time Complexity : log(max(a,b))
static long bitwiseAND(long a, long b) {
long shiftcount = 0;
while (a != b && a > 0) {
shiftcount++;
a = a >> 1;
b = b >> 1;
}
return (long) (a << shiftcount);
}
// Time Complexity : n*m
static void dfs(int j, ArrayList<ArrayList<Integer>> al, boolean[] visited) {
visited[j] = true;
for (int x = 0; x < al.get(j).size(); x++) {
if (!visited[al.get(j).get(x)])
dfs(al.get(j).get(x), al, visited);
}
}
// Time Complexity : log(n) for composite numbers, n for prime numbers
static long getPrimeFactors(long n) {
int x = 2;
long count = 0;
// ArrayList<Integer> al=new ArrayList<>();
while (n > 1) {
if (n % x == 0) {
// if(!al.contains(x))
// al.add(x);
count++;
n /= x;
} else
x++;
}
return count;
}
// Time Complexity : log(n)
static ArrayList<Integer> primeFactorization(int x, int[] spf) {
HashMap<Integer, Integer> map = new HashMap<>();
ArrayList<Integer> al = new ArrayList<>();
while (x != 1) {
if (!al.contains(spf[x]))
al.add(spf[x]);
map.put(spf[x], map.getOrDefault(spf[x], 0) + 1);
x /= spf[x];
}
return al;
// return map;
}
// Time Complexity : n*10
static long[][] getBitMap(long[] a) {
int n = a.length;
long[][] bit_map = new long[n][60];
for (int j = 0; j < n; j++)
Arrays.fill(bit_map[j], 0);
long b[] = new long[n];
for (int j = 0; j < n; j++)
b[j] = a[j];
for (int j = 0; j < n; j++) {
int counter = 0;
while (b[j] != 0) {
bit_map[j][counter] = b[j] % 2;
b[j] /= 2;
counter++;
}
}
return bit_map;
}
// Time Complexity : n*log(log(n))
static ArrayList<Integer> sieveOfEratosthenes(int n) {
boolean prime[] = new boolean[n + 1];
for (int j = 0; j <= n; j++)
prime[j] = true;
for (long p = 2; p * p <= n; p++) {
if (prime[(int) p]) {
for (long j = p * p; j <= n; j += p)
prime[(int) j] = false;
}
}
ArrayList<Integer> al = new ArrayList<>();
for (long j = 2; j <= n; j++) {
if (prime[(int) j])
al.add((int) j);
}
return al;
}
// Time Complexity : n
static boolean sortedIncreasing(int[] a) {
int f = 0;
for (int j = 1; j < a.length; j++) {
if (a[j] < a[j - 1])
f = 1;
}
return f == 0 ? true : false;
}
// Time Complexity : n
static boolean sortedDecreasing(int[] a) {
int f = 0;
for (int j = 1; j < a.length; j++) {
if (a[j] > a[j - 1])
f = 1;
}
return f == 0 ? true : false;
}
// Time Complexity : sqrt(n)
static ArrayList<Long> getFactors(long n) {
ArrayList<Long> al = new ArrayList<>();
// int count = 0;
for (long i = 1; i * i <= n; i++) {
if (n % i == 0) {
al.add( i);
// count++;
if (n / i != i) {
al.add( (n / i));
// count++;
}
}
}
Collections.sort(al);
return al;
// return count;
}
// Time Complexity : n*log(n)
static void sort(int[] a) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
static void sort(char[] a) {
ArrayList<Character> l = new ArrayList<>();
for (char i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
// Time Complexity : n*log(n)
static void sort(long[] a) {
ArrayList<Long> l = new ArrayList<>();
for (long i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
// Time Complexity : log(min(a,b))
static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
// Time Complexity : log(min(a,b))
static long gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
// Time Complexity : log(min(a,b))
static long lcm(long a, long b) {
return ((a / gcd(a, b)) * b);
}
// Time Complexity : log(min(a,b))
static long lcm(int a, int b) {
return ((a / gcd(a, b)) * b);
}
// Time Complexity : log(n)
static long floorSqrt(long x) {
if (x == 0 || x == 1)
return x;
long l = 1;
long r = (long) Math.sqrt(x) + 1;
long ans = 0;
while (l <= r) {
long mid = l + (r - l) / 2;
long curr = mid * mid;
if (curr == x)
return mid;
else if (curr > 0 && curr <= x) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
// Time Complexity : log(n*logn)
static long getRemainderSum(long[] a, long totalsum, int x) {
long k = 0;
outer: for (int mul = x;; mul += x) {
int l = 0;
int r = a.length - 1;
int index = -1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (a[mid] >= mul) {
index = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (index == -1)
break outer;
else
k += a.length - index;
}
return (totalsum - k * x);
}
// -------------------------BIT-------------------------
// private static class BIT {
// long[] bit;
// long[] arr;
// int len;
// public BIT(int len) {
// bit = new long[len + 1];
// arr = new long[len];
// this.len = len;
// }
// public void add(int ind, long val) {
// arr[ind] += val;
// ind++;
// for (; ind <= len; ind += ind & -ind) {
// bit[ind] += val;
// }
// }
// public long query(int ind) {
// ind++;
// long sum = 0;
// for (; ind > 0; ind -= ind & -ind) {
// sum += bit[ind];
// }
// return sum;
// }
// }
// -------------------------Input class-------------------------
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
// -------------------------Other classes-------------------------
class Pair {
// int first = 0;
// int second = 0;
// char first = 'a';
// int second = -1;
// Pair(int x, int y) {
// first = x;
// second = y;
// }
// Pair(char x, int y) {
// first = x;
// second = y;
// }
}
class ArrayComparator implements Comparator<long[]> {
public int compare(long[] a, long[] b) {
return Long.compare(b[0], a[0]);
}
}
import java.util.*;
import java.io.*;
// -------------------------Main class-------------------------
public class Main {
static long MOD = (long)1e9+7;
static int a[];
static long b[];
static long dp[][][];
// -------------------------Main function-------------------------
public static void main(String args[]) throws IOException {
FastReader sc = new FastReader();
PrintWriter pw = new PrintWriter(System.out);
int t = 1;
for (int i = 0; i <t; i++) {
int n=sc.nextInt();
String s=sc.next();
a=new int[n];
b=new long[n];
for(int j=0;j<n;j++)
{
a[j]=Character.getNumericValue(s.charAt(j));
b[j]=sc.nextLong();
}
dp=new long[n][2][2];
for(int j=0;j<n;j++)
{
for(int k=0;k<2;k++)
Arrays.fill(dp[j][k],-1);
}
pw.write(Math.min(getAns(1,a[0],0),b[0]+getAns(1,(a[0]+1)%2,0))+"\n");
}
pw.flush();
pw.close();
}
static long getAns(int curr, int prev, int found_or_not)
{
if(curr==a.length)
{
if(found_or_not==0)
return Long.MAX_VALUE-(long)1e9;
else
return 0;
}
else if(dp[curr][prev][found_or_not]!=-1)
return dp[curr][prev][found_or_not];
else
{
long currans=0;
if(found_or_not==1)
{
if(a[curr]==prev)
currans=b[curr]+getAns(curr+1,(a[curr]+1)%2,1);
else
currans=getAns(curr+1,a[curr],1);
}
else
{
long change=b[curr]+getAns(curr+1,(a[curr]+1)%2,a[curr]==prev?0:1);
long notchange=getAns(curr+1,a[curr],a[curr]==prev?1:0);
currans=Math.min(change,notchange);
}
return dp[curr][prev][found_or_not]=currans;
}
}
// -------------------------Other functions-------------------------
// Time Complexity : log(n)
static long fast_power_mod(long n, long mod) {
long pow2 = 2;
long res = 1;
while (n > 0) {
if (n % 2 == 1)
res = (res % mod * pow2 % mod) % mod;
pow2 = (pow2 % mod * pow2 % mod) % mod;
n >>= 1;
}
return res;
}
// Time Complexity : O(n)
// Best mod values for hashing = 1e9 + 9
static void prefixHashAndModInverse(String s, long[] prefixhash, long[] modInversePowP)
{
long p = 31;
long currhash = 0;
long powP = 1;
for(int j=0;j<s.length();j++) {
char c = s.charAt(j);
currhash = (currhash + (c - '0' + 1) * powP) % MOD;
prefixhash[j] = currhash;
powP = (powP * p) % MOD;
}
for(int j=0;j<s.length();j++)
modInversePowP[j]=inverseMOD(power(p,j,MOD), MOD)%MOD;
}
// Use this for multiple nCr queries
// Time Complexity : n*r
static long nCrModpDP(long n, long r, long p) {
long c[] = new long[(int) r + 1];
c[0] = 1;
for (long j = 1; j <= n; j++) {
for (long k = Math.min(j, r); k > 0; k--)
c[(int) k] = (c[(int) k] % p + c[(int) k - 1] % p) % p;
}
return c[(int) r];
}
// Use this for multiple nCr queries
// Time Complexity : log(n) * n * r
static long nCrModpLucas(long n, long r, long p) {
if (r == 0)
return 1;
long ni = n % p;
long ri = r % p;
return (nCrModpLucas(n / p, r / p, p) % p * nCrModpDP(ni, ri, p) % p) % p;
}
// Use this for single nCr calculation when n <= 1e6
// Time Complexity : n
public static long nCrModpFermat(long n, long r, long p) {
if (n < r)
return 0;
if (r == 0)
return 1;
long[] fac = new long[(int) (n + 1)];
fac[0] = 1;
for (long i = 1; i <= n; i++)
fac[(int)i] = (fac[(int)i - 1] * i) % p;
return (fac[(int) n] * inverseMOD(fac[(int)r], p) % p * inverseMOD(fac[(int) (n - r)], p) % p) % p;
}
// Time Complexity : log(mod)
static long inverseMOD(long x, long mod)
{
return power(x,mod-2,mod)%mod;
}
// Time Complexity : log(exponent)
static long power(long base, long exponent, long mod) {
long ans = 1;
base = base % mod;
while (exponent > 0)
{
if (exponent%2!=0)
ans = (ans * base) % mod;
exponent/=2;
base = (base * base) % mod;
}
return ans;
}
// Time Complexity : log(max(a,b))
static long bitwiseAND(long a, long b) {
long shiftcount = 0;
while (a != b && a > 0) {
shiftcount++;
a = a >> 1;
b = b >> 1;
}
return (long) (a << shiftcount);
}
// Time Complexity : n*m
static void dfs(int j, ArrayList<ArrayList<Integer>> al, boolean[] visited) {
visited[j] = true;
for (int x = 0; x < al.get(j).size(); x++) {
if (!visited[al.get(j).get(x)])
dfs(al.get(j).get(x), al, visited);
}
}
// Time Complexity : log(n) for composite numbers, n for prime numbers
static long getPrimeFactors(long n) {
int x = 2;
long count = 0;
// ArrayList<Integer> al=new ArrayList<>();
while (n > 1) {
if (n % x == 0) {
// if(!al.contains(x))
// al.add(x);
count++;
n /= x;
} else
x++;
}
return count;
}
// Time Complexity : log(n)
static ArrayList<Integer> primeFactorization(int x, int[] spf) {
HashMap<Integer, Integer> map = new HashMap<>();
ArrayList<Integer> al = new ArrayList<>();
while (x != 1) {
if (!al.contains(spf[x]))
al.add(spf[x]);
map.put(spf[x], map.getOrDefault(spf[x], 0) + 1);
x /= spf[x];
}
return al;
// return map;
}
// Time Complexity : n*10
static long[][] getBitMap(long[] a) {
int n = a.length;
long[][] bit_map = new long[n][60];
for (int j = 0; j < n; j++)
Arrays.fill(bit_map[j], 0);
long b[] = new long[n];
for (int j = 0; j < n; j++)
b[j] = a[j];
for (int j = 0; j < n; j++) {
int counter = 0;
while (b[j] != 0) {
bit_map[j][counter] = b[j] % 2;
b[j] /= 2;
counter++;
}
}
return bit_map;
}
// Time Complexity : n*log(log(n))
static ArrayList<Integer> sieveOfEratosthenes(int n) {
boolean prime[] = new boolean[n + 1];
for (int j = 0; j <= n; j++)
prime[j] = true;
for (long p = 2; p * p <= n; p++) {
if (prime[(int) p]) {
for (long j = p * p; j <= n; j += p)
prime[(int) j] = false;
}
}
ArrayList<Integer> al = new ArrayList<>();
for (long j = 2; j <= n; j++) {
if (prime[(int) j])
al.add((int) j);
}
return al;
}
// Time Complexity : n
static boolean sortedIncreasing(int[] a) {
int f = 0;
for (int j = 1; j < a.length; j++) {
if (a[j] < a[j - 1])
f = 1;
}
return f == 0 ? true : false;
}
// Time Complexity : n
static boolean sortedDecreasing(int[] a) {
int f = 0;
for (int j = 1; j < a.length; j++) {
if (a[j] > a[j - 1])
f = 1;
}
return f == 0 ? true : false;
}
// Time Complexity : sqrt(n)
static ArrayList<Long> getFactors(long n) {
ArrayList<Long> al = new ArrayList<>();
// int count = 0;
for (long i = 1; i * i <= n; i++) {
if (n % i == 0) {
al.add( i);
// count++;
if (n / i != i) {
al.add( (n / i));
// count++;
}
}
}
Collections.sort(al);
return al;
// return count;
}
// Time Complexity : n*log(n)
static void sort(int[] a) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
static void sort(char[] a) {
ArrayList<Character> l = new ArrayList<>();
for (char i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
// Time Complexity : n*log(n)
static void sort(long[] a) {
ArrayList<Long> l = new ArrayList<>();
for (long i : a)
l.add(i);
Collections.sort(l);
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
}
// Time Complexity : log(min(a,b))
static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
// Time Complexity : log(min(a,b))
static long gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
// Time Complexity : log(min(a,b))
static long lcm(long a, long b) {
return ((a / gcd(a, b)) * b);
}
// Time Complexity : log(min(a,b))
static long lcm(int a, int b) {
return ((a / gcd(a, b)) * b);
}
// Time Complexity : log(n)
static long floorSqrt(long x) {
if (x == 0 || x == 1)
return x;
long l = 1;
long r = (long) Math.sqrt(x) + 1;
long ans = 0;
while (l <= r) {
long mid = l + (r - l) / 2;
long curr = mid * mid;
if (curr == x)
return mid;
else if (curr > 0 && curr <= x) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
// Time Complexity : log(n*logn)
static long getRemainderSum(long[] a, long totalsum, int x) {
long k = 0;
outer: for (int mul = x;; mul += x) {
int l = 0;
int r = a.length - 1;
int index = -1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (a[mid] >= mul) {
index = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (index == -1)
break outer;
else
k += a.length - index;
}
return (totalsum - k * x);
}
// -------------------------BIT-------------------------
// private static class BIT {
// long[] bit;
// long[] arr;
// int len;
// public BIT(int len) {
// bit = new long[len + 1];
// arr = new long[len];
// this.len = len;
// }
// public void add(int ind, long val) {
// arr[ind] += val;
// ind++;
// for (; ind <= len; ind += ind & -ind) {
// bit[ind] += val;
// }
// }
// public long query(int ind) {
// ind++;
// long sum = 0;
// for (; ind > 0; ind -= ind & -ind) {
// sum += bit[ind];
// }
// return sum;
// }
// }
// -------------------------Input class-------------------------
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
// -------------------------Other classes-------------------------
class Pair {
// int first = 0;
// int second = 0;
// char first = 'a';
// int second = -1;
// Pair(int x, int y) {
// first = x;
// second = y;
// }
// Pair(char x, int y) {
// first = x;
// second = y;
// }
}
class ArrayComparator implements Comparator<long[]> {
public int compare(long[] a, long[] b) {
return Long.compare(b[0], a[0]);
}
} | ConDefects/ConDefects/Code/abc346_d/Java/51673342 |
condefects-java_data_124 |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
char[] S = sc.next().toCharArray();
int[] C = new int[N];
for (int i = 0; i < N; i++) {
C[i] = sc.nextInt();
}
int[][][] dp = new int[N][2][2];
dp[0][0][0] = 0;
dp[0][0][1] = C[0];
dp[0][1][0] = Integer.MAX_VALUE;
dp[0][1][1] = Integer.MAX_VALUE;
dp[1][1][1] = S[0] == S[1] ? C[0]+C[1]: C[1];
dp[1][0][1] = S[0] == S[1] ? C[1] : C[0] + C[1];
dp[1][0][0] = S[0] == S[1] ? C[0] : 0;
dp[1][1][0] = S[0] == S[1] ? 0 : C[0];
for (int i = 2; i < S.length; i++) {
dp[i][0][0] = S[i] == S[i - 1] ? dp[i - 1][0][1] : dp[i - 1][0][0];
dp[i][1][0] = S[i] == S[i - 1] ? Math.min(dp[i - 1][1][1], dp[i - 1][0][0]) : Math.min(dp[i - 1][0][1], dp[i - 1][1][0]);
dp[i][0][1] = S[i] == S[i - 1] ? dp[i - 1][0][0] + C[i] : dp[i - 1][0][1] + C[i];
dp[i][1][1] = S[i] == S[i - 1] ? Math.min(dp[i - 1][1][0], dp[i - 1][0][1]) + C[i] : Math.min(dp[i - 1][1][1], dp[i - 1][0][0]) + C[i];
}
System.out.println(Math.min(dp[S.length - 1][1][0], dp[S.length - 1][1][1]));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
char[] S = sc.next().toCharArray();
int[] C = new int[N];
for (int i = 0; i < N; i++) {
C[i] = sc.nextInt();
}
long[][][] dp = new long[N][2][2];
dp[0][0][0] = 0;
dp[0][0][1] = C[0];
dp[0][1][0] = Integer.MAX_VALUE;
dp[0][1][1] = Integer.MAX_VALUE;
dp[1][1][1] = S[0] == S[1] ? C[0]+C[1]: C[1];
dp[1][0][1] = S[0] == S[1] ? C[1] : C[0] + C[1];
dp[1][0][0] = S[0] == S[1] ? C[0] : 0;
dp[1][1][0] = S[0] == S[1] ? 0 : C[0];
for (int i = 2; i < S.length; i++) {
dp[i][0][0] = S[i] == S[i - 1] ? dp[i - 1][0][1] : dp[i - 1][0][0];
dp[i][1][0] = S[i] == S[i - 1] ? Math.min(dp[i - 1][1][1], dp[i - 1][0][0]) : Math.min(dp[i - 1][0][1], dp[i - 1][1][0]);
dp[i][0][1] = S[i] == S[i - 1] ? dp[i - 1][0][0] + C[i] : dp[i - 1][0][1] + C[i];
dp[i][1][1] = S[i] == S[i - 1] ? Math.min(dp[i - 1][1][0], dp[i - 1][0][1]) + C[i] : Math.min(dp[i - 1][1][1], dp[i - 1][0][0]) + C[i];
}
System.out.println(Math.min(dp[S.length - 1][1][0], dp[S.length - 1][1][1]));
}
}
| ConDefects/ConDefects/Code/abc346_d/Java/51700200 |
condefects-java_data_125 |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
static long MAX = 0;
static long[][][] dp;
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int n = in.nextInt();
String c = in.next();
long[] data = new long[n];
for (int i = 0; i < n; i++) {
data[i] = in.nextInt();
MAX += data[i];
}
dp = new long[2][2][n];
for (long[][] a : dp) {
for (long[] b : a) {
Arrays.fill(b, -1);
}
}
out.println(Long.min(cal(0, 1, 0, c, data), cal(0, 0, 0, c, data)));
out.close();
}
static long cal(int index, int last, int re, String c, long[] data) {
if (index == data.length) {
if (re == 0) {
return MAX;
}
return 0;
}
if (dp[last][re][index] != -1) {
return dp[last][re][index];
}
int cur = c.charAt(index) - '0';
long res = cal(index + 1, 1 - last, re, c, data);
if (res != MAX) {
res += (cur == last ? data[index] : 0);
}
if (re == 0) {
long tmp = cal(index + 1, last, 1, c, data);
if (tmp != MAX) {
tmp += (cur == last ? 0 : data[index]);
}
res = Long.min(res, tmp);
}
return dp[last][re][index] = res;
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point implements Comparable<Point> {
int x, y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
@Override
public int compareTo(Point o) {
if (x != o.x) {
return Integer.compare(x, o.x);
}
return Integer.compare(y, o.y);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x &&
y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, int b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
static long MAX = 0;
static long[][][] dp;
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int n = in.nextInt();
String c = in.next();
long[] data = new long[n];
for (int i = 0; i < n; i++) {
data[i] = in.nextInt();
MAX += data[i];
}
dp = new long[2][2][n];
for (long[][] a : dp) {
for (long[] b : a) {
Arrays.fill(b, -1);
}
}
out.println(Long.min(cal(0, 1, 0, c, data), cal(0, 0, 0, c, data)));
out.close();
}
static long cal(int index, int last, int re, String c, long[] data) {
if (index == data.length) {
if (re == 0) {
return MAX;
}
return 0;
}
if (dp[last][re][index] != -1) {
return dp[last][re][index];
}
int cur = c.charAt(index) - '0';
long res = cal(index + 1, 1 - last, re, c, data);
if (res != MAX) {
res += (cur == last ? data[index] : 0);
}
if (re == 0 && index != 0) {
long tmp = cal(index + 1, last, 1, c, data);
if (tmp != MAX) {
tmp += (cur == last ? 0 : data[index]);
}
res = Long.min(res, tmp);
}
return dp[last][re][index] = res;
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point implements Comparable<Point> {
int x, y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
@Override
public int compareTo(Point o) {
if (x != o.x) {
return Integer.compare(x, o.x);
}
return Integer.compare(y, o.y);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x &&
y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, int b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
| ConDefects/ConDefects/Code/abc346_d/Java/51742460 |
condefects-java_data_126 | import java.util.*;
public class Main {
public static void main(String[] args){
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int[] numArray = new int[N];
int max = 0;
for(int i = 0;i<N;i++){
int num = sc.nextInt();
numArray[i] = num;
if(i > 1){
if(numArray[i-1] > num){
max= i-1;
}
}
}
int maxNum = numArray[max];
int maxNum2 = 0;
int max2 = 0;
for(int i=max;i<N;i++){
int num = numArray[i];
if(num < maxNum){
if(num > maxNum2){
maxNum2 = num;
max2 = i;
}
}
}
numArray[max2] = maxNum;
numArray[max] = maxNum2;
int temp = 0;
for(int i=max+1;i<N;i++){
for(int j=N-1;j>=i;j--){
if(numArray[j] > numArray[j-1]){
temp = numArray[j];
numArray[j] = numArray[j-1];
numArray[j-1] = temp;
}
}
}
for(int i=0;i<N;i++){
if(i!=0){
System.out.print(" ");
}
System.out.print(numArray[i]);
}System.out.println("");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int[] numArray = new int[N];
int max = 0;
for(int i = 0;i<N;i++){
int num = sc.nextInt();
numArray[i] = num;
if(i > 1){
if(numArray[i-1] > num){
max= i-1;
}
}
}
int maxNum = numArray[max];
int maxNum2 = 0;
int max2 = 0;
for(int i=max;i<N;i++){
int num = numArray[i];
if(num < maxNum){
if(num > maxNum2){
maxNum2 = num;
max2 = i;
}
}
}
numArray[max2] = maxNum;
numArray[max] = maxNum2;
int temp = 0;
for(int i=max+1;i<N;i++){
for(int j=N-1;j>i;j--){
if(numArray[j] > numArray[j-1]){
temp = numArray[j];
numArray[j] = numArray[j-1];
numArray[j-1] = temp;
}
}
}
for(int i=0;i<N;i++){
if(i!=0){
System.out.print(" ");
}
System.out.print(numArray[i]);
}System.out.println("");
}
}
}
| ConDefects/ConDefects/Code/abc276_c/Java/37124187 |
condefects-java_data_127 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static FastReader sc = new FastReader();
// static class Pair implements Comparable<Pair> {
// int a, b;
//
// public Pair(int a) {
// this.a = a;
// }
//
// @Override
// public int compareTo(Pair o) {
// if (a == o.a) return b - o.b;
// return a - o.a;
// }
// }
static final int N = 200010;
static int n;
static StringBuilder ans = new StringBuilder();
static void solve() {
sc.nextInt();
String s = sc.next();
char c = s.charAt(0);
boolean flag = false;
for (int i = 1; i < s.length(); i++) {
if (s.charAt(i) > c) {
flag = true;
break;
} else if (s.charAt(i) == c && isGreater(s.substring(0, i), s.substring(i))) {
flag = true;
break;
}
}
if (flag) ans.append("Yes\n");
else ans.append("No\n");
}
static boolean isGreater(String s, String t) {
int x = Math.min(s.length(), t.length());
for (int i = 0; i < x; i++) {
if (s.charAt(i) < t.charAt(i)) return true;
else if (s.charAt(i) > t.charAt(i)) return false;
}
return false;
}
public static void main(String[] args) {
int t = sc.nextInt();
while (t-- > 0) {
solve();
}
System.out.print(ans);
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static FastReader sc = new FastReader();
// static class Pair implements Comparable<Pair> {
// int a, b;
//
// public Pair(int a) {
// this.a = a;
// }
//
// @Override
// public int compareTo(Pair o) {
// if (a == o.a) return b - o.b;
// return a - o.a;
// }
// }
static final int N = 200010;
static int n;
static StringBuilder ans = new StringBuilder();
static void solve() {
sc.nextInt();
String s = sc.next();
char c = s.charAt(0);
boolean flag = false;
for (int i = 1; i < s.length(); i++) {
if (s.charAt(i) > c) {
flag = true;
break;
} else if (s.charAt(i) == c && isGreater(s.substring(0, i), s.substring(i))) {
flag = true;
break;
}
}
if (flag) ans.append("Yes\n");
else ans.append("No\n");
}
static boolean isGreater(String s, String t) {
int x = Math.min(s.length(), t.length());
for (int i = 0; i < x; i++) {
if (s.charAt(i) < t.charAt(i)) return true;
else if (s.charAt(i) > t.charAt(i)) return false;
}
return s.length() < t.length();
}
public static void main(String[] args) {
int t = sc.nextInt();
while (t-- > 0) {
solve();
}
System.out.print(ans);
}
} | ConDefects/ConDefects/Code/arc163_a/Java/43193494 |
condefects-java_data_128 | import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
class RUQ {
int N;
int[] originalData;
int[] tree;
int INT_MIN = Integer.MIN_VALUE / 2;
RUQ(int[] original) {
this.originalData = Arrays.copyOf(original, original.length);
int n = originalData.length;
this.N = 1;
while (N < n)
N *= 2;
this.tree = new int[N * 2];
for (int i = 0; i < N * 2; i++) {
tree[i] = INT_MIN;
}
build();
}
void build() {
for (int i = 0; i < originalData.length; i++) {
update(i, originalData[i]);
}
}
void update(int i, int x) {
i = N + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = marge(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
int query(int start, int end) {
return query(start, end, 0, 0, N);
}
private int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INT_MIN;
if (a <= l && r <= b) {
return tree[k];
} else {
int lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
int rb = query(a, b, 2 * k + 2, (l + r) / 2, r);
return marge(lv, rb);
}
}
private int marge(int l, int r) {
return Math.max(l, r);
}
}
class RMQ {
int N;
int[] originalData;
int[] tree;
int INT_MAX = Integer.MAX_VALUE / 2;
RMQ(int[] original) {
this.originalData = Arrays.copyOf(original, original.length);
int n = originalData.length;
this.N = 1;
while (N < n)
N *= 2;
this.tree = new int[N * 2];
for (int i = 0; i < N * 2; i++) {
tree[i] = INT_MAX;
}
build();
}
void build() {
for (int i = 0; i < originalData.length; i++) {
update(i, originalData[i]);
}
}
void update(int i, int x) {
i = N + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = marge(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
int query(int start, int end) {
return query(start, end, 0, 0, N);
}
private int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INT_MAX;
if (a <= l && r <= b) {
return tree[k];
} else {
int lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
int rb = query(a, b, 2 * k + 2, (l + r) / 2, r);
return marge(lv, rb);
}
}
private int marge(int l, int r) {
return Math.min(l, r);
}
}
class BIT {
long bit[] = new long[0];
int N = 0;
BIT(int n) {
bit = new long[n + 1];
N = n;
}
void add(int a, long w) {
for (int x = a; x <= N; x += (x & -x))
bit[x] += w;
}
long sum(int a) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x)
ret += bit[x];
return ret;
}
long modsum(int a, int mod) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x) {
ret += bit[x];
ret %= mod;
}
return ret;
}
}
class MODBIT {
long bit[] = new long[0];
int N = 0;
int mod = 0;
MODBIT(int n, int m) {
bit = new long[n + 1];
N = n;
mod = m;
}
void add(int a, long w) {
for (int x = a; x < N; x += (x & -x)) {
bit[x] += w;
bit[x] %= mod;
}
}
long modsum(int a, long mod2) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x) {
ret += bit[x];
ret %= mod2;
}
return ret;
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextchar() {
return next().charAt(0);
}
}
class Unionfind {
private int n;
private int[] parentOrSize;
public Unionfind(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class Comb {
int N = 0;
int mod = 0;
long fact[], ifact[], inv[];
Comb(int n, int m) {
N = n;
mod = m;
fact = new long[N + 10];
ifact = new long[N + 10];
inv = new long[N + 10];
inv[1] = 1;
for (int i = 2; i < N; i++)
inv[i] = 1l * (mod - mod / i) * inv[mod % i] % mod;
fact[0] = ifact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = 1l * fact[i - 1] * i % mod;
ifact[i] = 1l * ifact[i - 1] * inv[i] % mod;
}
}
public long C(int x, int y) {
if (x < 0 || y < 0 || x < y)
return 0;
return 1l * fact[x] * ifact[y] % mod * ifact[x - y] % mod;
}
}
public class Main {
static class Pair<T, E> {
public T first;
public E second;
public Pair(T x, E y) {
first = x;
second = y;
}
void set(T x, E y) {
first = x;
second = y;
}
@Override
public int hashCode() {
return Objects.hash(this.first,this.second);
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair) {
Pair p=(Pair)obj;
return Objects.equals(first, p.first)&&Objects.equals(second, p.second);
}
else {
return false;
}
}
}
static class Tpair {
public int first;
public int second;
public long third;
Tpair(int x, int y, long z) {
first = x;
second = y;
third = z;
}
void set(int x, int y, long z) {
first = x;
second = y;
third = z;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Tpair) {
Tpair other=(Tpair)obj;
return other.first==this.first&&other.second==this.second&&other.third==this.third;
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(this.first,this.second,this.third);
}
}
static class Pint {
@Override
public boolean equals(Object obj) {
if (obj instanceof Pint) {
Pint other = (Pint) obj;
return other.first == this.first && other.second == this.second;
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(this.first, this.second);
}
public int first;
public int second;
Pint(int x, int y) {
first = x;
second = y;
}
void set(int x, int y) {
first = x;
second = y;
}
}
static FastScanner scan = new FastScanner();
static Scanner scanner = new Scanner(System.in);
static Random rand = new Random();
static int mod = 1000000007;
static double eps = 1.0E-14;
static int big = Integer.MAX_VALUE / 2;
static double PI = 3.141592653589793;
static long modlcm(long a, long b) {
return a * b * modinv(GCD(a, b), mod);
}
static long GCD(long a, long b) {
return b > 0 ? GCD(b, a % b) : a;
}
static long lcm(long a, long b) {
return a * b / GCD(a, b);
}
static int min(int a, int b) {
return a < b ? a : b;
}
static long factorial(int i) {
return i == 1 ? 1 : i * factorial(i - 1);
}
static int max(int... i) {
int x = i[0];
for (int e : i)
x = Math.max(x, e);
return x;
}
static int min(int... i) {
int x = i[0];
for (int e : i)
x = Math.min(x, e);
return x;
}
static long gcd(long... i) {
long x = i[0];
for (long e : i)
x = GCD(x, e);
return x;
}
static long lmax(long... i) {
long x = i[0];
for (long e : i)
x = Math.max(x, e);
return x;
}
static long lmin(long... i) {
long x = i[0];
for (long e : i)
x = Math.min(x, e);
return x;
}
static long nCr(long n, long r, long m) {
long ans = 1;
for (long i = 0; i < r; i++) {
ans *= (n - i);
ans %= m;
}
for (long i = 1; i <= r; i++) {
ans *= modinv(i, m);
ans %= m;
}
return ans;
}
static int lower_bound(long[] b, long cost) {
int ok = b.length;
int ng = -1;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (b[mid] >= cost)
ok = mid;
else
ng = mid;
}
return ok;
}
static int upper_bound(int[] b, int cost) {
int ok = b.length;
int ng = -1;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (b[mid] > cost)
ok = mid;
else
ng = mid;
}
return ok;
}
static boolean isPrime(long n) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
double d = Math.sqrt(n);
for (int i = 3; i <= d; i += 2)
if (n % i == 0) {
return false;
}
return true;
}
static int upper_division(int a, int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
static long lupper_division(long a, long b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
static int[] setArray(int a) {
int b[] = new int[a];
for (int i = 0; i < a; i++) {
b[i] = scan.nextInt();
}
return b;
}
static long[] lsetArray(int a) {
long b[] = new long[a];
for (int i = 0; i < a; i++) {
b[i] = scan.nextLong();
}
return b;
}
static String reverse(String str) {
char ch[] = new char[str.length()];
char chch[] = str.toCharArray();
int a = str.length();
for (int i = 0; i < upper_division(a, 2); i++) {
ch[i] = chch[ch.length - i - 1];
ch[ch.length - 1 - i] = chch[i];
}
return String.valueOf(ch);
}
public static void printArray(int[] que) {
for (int i = 0; i < que.length - 1; i++) {
System.out.print(que[i] + " ");
}
System.out.println(que[que.length - 1]);
}
public static void lprintArray(long[] que) {
for (int i = 0; i < que.length - 1; i++) {
System.out.print(que[i] + " ");
}
System.out.println(que[que.length - 1]);
}
static long modpow(long x, long n, long mo) {
long sum = 1;
while (n > 0) {
if ((n & 1) == 1) {
sum = sum * x % mo;
}
x = x * x % mo;
n >>= 1;
}
return sum;
}
static long pow(long x, long n) {
long sum = 1;
while (n > 0) {
if ((n & 1) == 1) {
sum = sum * x;
}
x = x * x;
n >>= 1;
}
return sum;
}
public static char[] revch(char ch[]) {
char ret[] = new char[ch.length];
for (int i = ch.length - 1, j = 0; i >= 0; i--, j++) {
ret[j] = ch[i];
}
return ret;
}
public static int[] revint(int ch[]) {
int ret[] = new int[ch.length];
for (int i = ch.length - 1, j = 0; i >= 0; i--, j++) {
ret[j] = ch[i];
}
return ret;
}
public static void warshall_floyd(long v[][]) {
int n = v[0].length;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
v[i][j] = lmin(v[i][j], v[i][k] + v[k][j]);
}
public static long modinv(long a, long m) {
long b = m, u = 1, v = 0;
while (b != 0) {
long t = a / b;
a -= t * b;
long x = a;
a = b;
b = x;
u -= t * v;
x = u;
u = v;
v = x;
}
u %= m;
if (u < 0)
u += m;
return u;
}
public static long lmod(long i, long j) {
return (i % j) < 0 ? (i % j) + 0 + (j < 0 ? -j : j) : (i % j + 0);
}
public static int next_combination(int sub) {
int x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
static long sum(long... a) {
long cnt = 0;
for (int j = 0; j < a.length; j++) {
cnt += a[j];
}
return cnt;
}
static class Dijkstra {
public int node;
public long cost;
Dijkstra(int x, long y) {
node = x;
cost = y;
}
}
static int sum(int... a) {
int x=0;
for(int e:a)x+=e;
return x;
}
static boolean isrevstr(char ch[]) {
boolean ret=true;
for(int i=0;i<ch.length;i++) {
if(ch[i]!=ch[ch.length-1-i]) {
ret=false;
break;
}
}
return ret;
}
public static void doublesort(int a[][]){
merge(0,a.length-1,a);
return;
}
public static boolean compare(int a,int b,int[][]origin) {
for(int i=0;i<origin[a].length;i++) {
if(origin[a][i]>origin[b][i]) {
return false;
}
else if(origin[a][i]<origin[b][i]) {
return true;
}
}
return true;
}
public static void merge(int left,int right,int[][]origin) {
if(left==right) {
return;
}
else {
int mid=(left+right)/2;
merge(left,mid,origin);
merge(mid+1,right,origin);
int hoge2[][]=new int[right-left+1][origin[0].length];
int itr=0;
int leftcount=0;
int rightcount=0;
while(leftcount<=(mid-left)||rightcount<=(right-(mid+1))) {
if(leftcount==mid-left+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
else if(rightcount==right-(mid+1)+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
if(compare(left+leftcount,mid+rightcount+1,origin)) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
}
itr++;
}
for(int i=0;i<(right-left+1);i++) {
for(int j=0;j<origin[0].length;j++) {
origin[left+i][j]=hoge2[i][j];
}
}
}
}
public static void ldoublesort(long a[][]){
lmerge(0,a.length-1,a);
return;
}
public static boolean lcompare(int a,int b,long[][]origin) {
for(int i=0;i<origin[a].length;i++) {
if(origin[a][i]>origin[b][i]) {
return false;
}
else if(origin[a][i]<origin[b][i]) {
return true;
}
}
return true;
}
public static void lmerge(int left,int right,long[][]origin) {
if(left==right) {
return;
}
else {
int mid=(left+right)/2;
lmerge(left,mid,origin);
lmerge(mid+1,right,origin);
long hoge2[][]=new long[right-left+1][origin[0].length];
int itr=0;
int leftcount=0;
int rightcount=0;
while(leftcount<=(mid-left)||rightcount<=(right-(mid+1))) {
if(leftcount==mid-left+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
else if(rightcount==right-(mid+1)+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
if(lcompare(left+leftcount,mid+rightcount+1,origin)) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
}
itr++;
}
for(int i=0;i<(right-left+1);i++) {
for(int j=0;j<origin[0].length;j++) {
origin[left+i][j]=hoge2[i][j];
}
}
}
}
public static void main(String[] $) throws IOException {
int t=scan.nextInt();
while(t>0) {
t--;
int n=scan.nextInt();
boolean bool=false;
char ch[]=scan.next().toCharArray();
loop:for(int i=0;i<n-1;i++) {//[0,i+1],[i+2,n-1]
char c1[]=new char[i+1];
char c2[]=new char[n-(i+2)+1];
for(int j=0;j<i+1;j++) {
c1[j]=ch[j];
}
for(int j=0;j<n-(i+2)+1;j++) {
c2[j]=ch[j+i+1];
}
int minlen=min(c1.length,c2.length);
for(int j=0;j<minlen;j++) {
if(c1[j]<c2[j]) {
bool=true;
break loop;
}
else if(c1[j]>c2[j]) {
continue loop;
}
}
if(minlen==c1.length) {
bool=true;
break loop;
}
}
System.out.println(bool?"Yes":"No");
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
class RUQ {
int N;
int[] originalData;
int[] tree;
int INT_MIN = Integer.MIN_VALUE / 2;
RUQ(int[] original) {
this.originalData = Arrays.copyOf(original, original.length);
int n = originalData.length;
this.N = 1;
while (N < n)
N *= 2;
this.tree = new int[N * 2];
for (int i = 0; i < N * 2; i++) {
tree[i] = INT_MIN;
}
build();
}
void build() {
for (int i = 0; i < originalData.length; i++) {
update(i, originalData[i]);
}
}
void update(int i, int x) {
i = N + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = marge(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
int query(int start, int end) {
return query(start, end, 0, 0, N);
}
private int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INT_MIN;
if (a <= l && r <= b) {
return tree[k];
} else {
int lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
int rb = query(a, b, 2 * k + 2, (l + r) / 2, r);
return marge(lv, rb);
}
}
private int marge(int l, int r) {
return Math.max(l, r);
}
}
class RMQ {
int N;
int[] originalData;
int[] tree;
int INT_MAX = Integer.MAX_VALUE / 2;
RMQ(int[] original) {
this.originalData = Arrays.copyOf(original, original.length);
int n = originalData.length;
this.N = 1;
while (N < n)
N *= 2;
this.tree = new int[N * 2];
for (int i = 0; i < N * 2; i++) {
tree[i] = INT_MAX;
}
build();
}
void build() {
for (int i = 0; i < originalData.length; i++) {
update(i, originalData[i]);
}
}
void update(int i, int x) {
i = N + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = marge(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
int query(int start, int end) {
return query(start, end, 0, 0, N);
}
private int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return INT_MAX;
if (a <= l && r <= b) {
return tree[k];
} else {
int lv = query(a, b, 2 * k + 1, l, (l + r) / 2);
int rb = query(a, b, 2 * k + 2, (l + r) / 2, r);
return marge(lv, rb);
}
}
private int marge(int l, int r) {
return Math.min(l, r);
}
}
class BIT {
long bit[] = new long[0];
int N = 0;
BIT(int n) {
bit = new long[n + 1];
N = n;
}
void add(int a, long w) {
for (int x = a; x <= N; x += (x & -x))
bit[x] += w;
}
long sum(int a) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x)
ret += bit[x];
return ret;
}
long modsum(int a, int mod) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x) {
ret += bit[x];
ret %= mod;
}
return ret;
}
}
class MODBIT {
long bit[] = new long[0];
int N = 0;
int mod = 0;
MODBIT(int n, int m) {
bit = new long[n + 1];
N = n;
mod = m;
}
void add(int a, long w) {
for (int x = a; x < N; x += (x & -x)) {
bit[x] += w;
bit[x] %= mod;
}
}
long modsum(int a, long mod2) {
long ret = 0;
for (int x = a; x > 0; x -= x & -x) {
ret += bit[x];
ret %= mod2;
}
return ret;
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextchar() {
return next().charAt(0);
}
}
class Unionfind {
private int n;
private int[] parentOrSize;
public Unionfind(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class Comb {
int N = 0;
int mod = 0;
long fact[], ifact[], inv[];
Comb(int n, int m) {
N = n;
mod = m;
fact = new long[N + 10];
ifact = new long[N + 10];
inv = new long[N + 10];
inv[1] = 1;
for (int i = 2; i < N; i++)
inv[i] = 1l * (mod - mod / i) * inv[mod % i] % mod;
fact[0] = ifact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = 1l * fact[i - 1] * i % mod;
ifact[i] = 1l * ifact[i - 1] * inv[i] % mod;
}
}
public long C(int x, int y) {
if (x < 0 || y < 0 || x < y)
return 0;
return 1l * fact[x] * ifact[y] % mod * ifact[x - y] % mod;
}
}
public class Main {
static class Pair<T, E> {
public T first;
public E second;
public Pair(T x, E y) {
first = x;
second = y;
}
void set(T x, E y) {
first = x;
second = y;
}
@Override
public int hashCode() {
return Objects.hash(this.first,this.second);
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair) {
Pair p=(Pair)obj;
return Objects.equals(first, p.first)&&Objects.equals(second, p.second);
}
else {
return false;
}
}
}
static class Tpair {
public int first;
public int second;
public long third;
Tpair(int x, int y, long z) {
first = x;
second = y;
third = z;
}
void set(int x, int y, long z) {
first = x;
second = y;
third = z;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Tpair) {
Tpair other=(Tpair)obj;
return other.first==this.first&&other.second==this.second&&other.third==this.third;
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(this.first,this.second,this.third);
}
}
static class Pint {
@Override
public boolean equals(Object obj) {
if (obj instanceof Pint) {
Pint other = (Pint) obj;
return other.first == this.first && other.second == this.second;
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(this.first, this.second);
}
public int first;
public int second;
Pint(int x, int y) {
first = x;
second = y;
}
void set(int x, int y) {
first = x;
second = y;
}
}
static FastScanner scan = new FastScanner();
static Scanner scanner = new Scanner(System.in);
static Random rand = new Random();
static int mod = 1000000007;
static double eps = 1.0E-14;
static int big = Integer.MAX_VALUE / 2;
static double PI = 3.141592653589793;
static long modlcm(long a, long b) {
return a * b * modinv(GCD(a, b), mod);
}
static long GCD(long a, long b) {
return b > 0 ? GCD(b, a % b) : a;
}
static long lcm(long a, long b) {
return a * b / GCD(a, b);
}
static int min(int a, int b) {
return a < b ? a : b;
}
static long factorial(int i) {
return i == 1 ? 1 : i * factorial(i - 1);
}
static int max(int... i) {
int x = i[0];
for (int e : i)
x = Math.max(x, e);
return x;
}
static int min(int... i) {
int x = i[0];
for (int e : i)
x = Math.min(x, e);
return x;
}
static long gcd(long... i) {
long x = i[0];
for (long e : i)
x = GCD(x, e);
return x;
}
static long lmax(long... i) {
long x = i[0];
for (long e : i)
x = Math.max(x, e);
return x;
}
static long lmin(long... i) {
long x = i[0];
for (long e : i)
x = Math.min(x, e);
return x;
}
static long nCr(long n, long r, long m) {
long ans = 1;
for (long i = 0; i < r; i++) {
ans *= (n - i);
ans %= m;
}
for (long i = 1; i <= r; i++) {
ans *= modinv(i, m);
ans %= m;
}
return ans;
}
static int lower_bound(long[] b, long cost) {
int ok = b.length;
int ng = -1;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (b[mid] >= cost)
ok = mid;
else
ng = mid;
}
return ok;
}
static int upper_bound(int[] b, int cost) {
int ok = b.length;
int ng = -1;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (b[mid] > cost)
ok = mid;
else
ng = mid;
}
return ok;
}
static boolean isPrime(long n) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
double d = Math.sqrt(n);
for (int i = 3; i <= d; i += 2)
if (n % i == 0) {
return false;
}
return true;
}
static int upper_division(int a, int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
static long lupper_division(long a, long b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
static int[] setArray(int a) {
int b[] = new int[a];
for (int i = 0; i < a; i++) {
b[i] = scan.nextInt();
}
return b;
}
static long[] lsetArray(int a) {
long b[] = new long[a];
for (int i = 0; i < a; i++) {
b[i] = scan.nextLong();
}
return b;
}
static String reverse(String str) {
char ch[] = new char[str.length()];
char chch[] = str.toCharArray();
int a = str.length();
for (int i = 0; i < upper_division(a, 2); i++) {
ch[i] = chch[ch.length - i - 1];
ch[ch.length - 1 - i] = chch[i];
}
return String.valueOf(ch);
}
public static void printArray(int[] que) {
for (int i = 0; i < que.length - 1; i++) {
System.out.print(que[i] + " ");
}
System.out.println(que[que.length - 1]);
}
public static void lprintArray(long[] que) {
for (int i = 0; i < que.length - 1; i++) {
System.out.print(que[i] + " ");
}
System.out.println(que[que.length - 1]);
}
static long modpow(long x, long n, long mo) {
long sum = 1;
while (n > 0) {
if ((n & 1) == 1) {
sum = sum * x % mo;
}
x = x * x % mo;
n >>= 1;
}
return sum;
}
static long pow(long x, long n) {
long sum = 1;
while (n > 0) {
if ((n & 1) == 1) {
sum = sum * x;
}
x = x * x;
n >>= 1;
}
return sum;
}
public static char[] revch(char ch[]) {
char ret[] = new char[ch.length];
for (int i = ch.length - 1, j = 0; i >= 0; i--, j++) {
ret[j] = ch[i];
}
return ret;
}
public static int[] revint(int ch[]) {
int ret[] = new int[ch.length];
for (int i = ch.length - 1, j = 0; i >= 0; i--, j++) {
ret[j] = ch[i];
}
return ret;
}
public static void warshall_floyd(long v[][]) {
int n = v[0].length;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
v[i][j] = lmin(v[i][j], v[i][k] + v[k][j]);
}
public static long modinv(long a, long m) {
long b = m, u = 1, v = 0;
while (b != 0) {
long t = a / b;
a -= t * b;
long x = a;
a = b;
b = x;
u -= t * v;
x = u;
u = v;
v = x;
}
u %= m;
if (u < 0)
u += m;
return u;
}
public static long lmod(long i, long j) {
return (i % j) < 0 ? (i % j) + 0 + (j < 0 ? -j : j) : (i % j + 0);
}
public static int next_combination(int sub) {
int x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
static long sum(long... a) {
long cnt = 0;
for (int j = 0; j < a.length; j++) {
cnt += a[j];
}
return cnt;
}
static class Dijkstra {
public int node;
public long cost;
Dijkstra(int x, long y) {
node = x;
cost = y;
}
}
static int sum(int... a) {
int x=0;
for(int e:a)x+=e;
return x;
}
static boolean isrevstr(char ch[]) {
boolean ret=true;
for(int i=0;i<ch.length;i++) {
if(ch[i]!=ch[ch.length-1-i]) {
ret=false;
break;
}
}
return ret;
}
public static void doublesort(int a[][]){
merge(0,a.length-1,a);
return;
}
public static boolean compare(int a,int b,int[][]origin) {
for(int i=0;i<origin[a].length;i++) {
if(origin[a][i]>origin[b][i]) {
return false;
}
else if(origin[a][i]<origin[b][i]) {
return true;
}
}
return true;
}
public static void merge(int left,int right,int[][]origin) {
if(left==right) {
return;
}
else {
int mid=(left+right)/2;
merge(left,mid,origin);
merge(mid+1,right,origin);
int hoge2[][]=new int[right-left+1][origin[0].length];
int itr=0;
int leftcount=0;
int rightcount=0;
while(leftcount<=(mid-left)||rightcount<=(right-(mid+1))) {
if(leftcount==mid-left+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
else if(rightcount==right-(mid+1)+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
if(compare(left+leftcount,mid+rightcount+1,origin)) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
}
itr++;
}
for(int i=0;i<(right-left+1);i++) {
for(int j=0;j<origin[0].length;j++) {
origin[left+i][j]=hoge2[i][j];
}
}
}
}
public static void ldoublesort(long a[][]){
lmerge(0,a.length-1,a);
return;
}
public static boolean lcompare(int a,int b,long[][]origin) {
for(int i=0;i<origin[a].length;i++) {
if(origin[a][i]>origin[b][i]) {
return false;
}
else if(origin[a][i]<origin[b][i]) {
return true;
}
}
return true;
}
public static void lmerge(int left,int right,long[][]origin) {
if(left==right) {
return;
}
else {
int mid=(left+right)/2;
lmerge(left,mid,origin);
lmerge(mid+1,right,origin);
long hoge2[][]=new long[right-left+1][origin[0].length];
int itr=0;
int leftcount=0;
int rightcount=0;
while(leftcount<=(mid-left)||rightcount<=(right-(mid+1))) {
if(leftcount==mid-left+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
else if(rightcount==right-(mid+1)+1) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
if(lcompare(left+leftcount,mid+rightcount+1,origin)) {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[left+leftcount][i];
}
leftcount++;
}
else {
for(int i=0;i<origin[0].length;i++) {
hoge2[itr][i]=origin[mid+rightcount+1][i];
}
rightcount++;
}
}
itr++;
}
for(int i=0;i<(right-left+1);i++) {
for(int j=0;j<origin[0].length;j++) {
origin[left+i][j]=hoge2[i][j];
}
}
}
}
public static void main(String[] $) throws IOException {
int t=scan.nextInt();
while(t>0) {
t--;
int n=scan.nextInt();
boolean bool=false;
char ch[]=scan.next().toCharArray();
loop:for(int i=0;i<n-1;i++) {//[0,i+1],[i+2,n-1]
char c1[]=new char[i+1];
char c2[]=new char[n-(i+2)+1];
for(int j=0;j<i+1;j++) {
c1[j]=ch[j];
}
for(int j=0;j<n-(i+2)+1;j++) {
c2[j]=ch[j+i+1];
}
int minlen=min(c1.length,c2.length);
for(int j=0;j<minlen;j++) {
if(c1[j]<c2[j]) {
bool=true;
break loop;
}
else if(c1[j]>c2[j]) {
continue loop;
}
}
if(minlen==c1.length&&minlen!=c2.length) {
bool=true;
break loop;
}
}
System.out.println(bool?"Yes":"No");
}
}
} | ConDefects/ConDefects/Code/arc163_a/Java/43448745 |
condefects-java_data_129 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
public final class Main{
public static void main(String[] args) throws Exception{
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out,false),log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log).solve()).ifPresent(out::println);
out.flush();
}
}
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = true;
public Object solve(){
long[] A = new long[6];
long[] B = new long[6];
for (int i = 1;i <= 5;i++)
A[i] = in.lg();
for (int i = 1;i <= 5;i++)
B[i] = in.lg();
f(A,B,5,5);
f(A,B,4,4);
f(A,B,3,3);
f(A,B,4,5);
f(A,B,3,4);
f(A,B,3,5);
for (int b = 5;b >= 2;b--)
f(A,B,2,b);
for (int b = 5;b >= 1;b--)
f(A,B,1,b);
for (var a:A)
if (a > 0)
return false;
return true;
}
private void f(long[] A,long[] B,int a,int b){
long n = min(A[a],B[b]);
A[a] -= n;
B[b] -= n;
B[b -a] += n;
}
}
class Grid{
private int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
private int H,W;
public Grid(int H,int W){
this.H = H;
this.W = W;
}
// public int[] sur(int p){
// int[][] tmp = sur(toi(p),toj(p));
// int[] ret = new int[tmp.length];
// for (int i = 0;i < tmp.length;i++)
// ret[i] = top(tmp[i][0],tmp[i][1]);
// return ret;
// }
public MyList<int[]> sur(int i,int j){
MyList<int[]> ret = new MyList<>();
for (var d:dirs) {
int ni = i +d[0];
int nj = j +d[1];
if (valid(ni,H) && valid(nj,W))
ret.add(new int[]{ni, nj});
}
return ret;
}
private boolean valid(int i,int N){ return 0 <= i && i < N; }
public int top(int i,int j){ return i *W +j; }
public int toi(int p){ return p /W; }
public int toj(int p){ return p %W; }
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e();
private Node root;
private V[] ret = Util.cast(new BaseV[2]);
private int ri;
public AVLSegmentTree(int n){
this();
root = new Node(e(),n);
}
public AVLSegmentTree(){
ret[ri] = e();
ri ^= 1;
}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int i,int n,IntFunction<V> init){
if (n < 2)
return n < 1 ? null : new Node(init.apply(i),1);
var ret = new Node(e(),n);
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
return ret.merge();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.lft == null && (i == 0 || i == nd.sz)) {
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
return nd.merge();
}
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.cld(-1,ins(nd.lft,i,v,k));
else
nd.cld(1,ins(nd.rht,i -nd.lft.sz,v,k));
return balance(nd);
}
public V del(int i){
var ret = e();
root = del(ret,root,i);
return ret;
}
private Node del(V ret,Node nd,int i){
if (nd.lft == null) {
nd.sz--;
ag(ret,e,nd.val);
return 0 < nd.sz ? nd : null;
}
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(ret,nd.lft,i) : del(ret,nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (l == r)
return;
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
return nd.prop(f);
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.cld(-1,upd(nd.lft,l,min(nd.lft.sz,r),f));
if (nd.lft.sz < r)
nd.cld(1,upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f));
return balance(nd);
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
return merge(nd.lft,nd,toggle(nd.rht,0,r -l));
}
if (r < nd.sz) {
split(nd,r);
return merge(toggle(nd.lft,l,r),nd,nd.rht);
}
return nd.toggle();
}
private void split(Node nd,int i){
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
if (i < nd.lft.sz) {
split(nd.lft,i);
var lft = nd.lft;
nd.cld(-1,lft.lft);
nd.cld(1,merge(lft.rht,lft,nd.rht));
} else if (nd.lft.sz < i) {
split(nd.rht,i -nd.lft.sz);
var rht = nd.rht;
nd.cld(1,rht.rht);
nd.cld(-1,merge(nd.lft,rht,rht.lft));
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.cld(-1,lft);
nd.cld(1,rht);
} else if (lft.rnk > rht.rnk) {
lft.push().cld(1,merge(lft.rht,nd,rht));
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push().cld(-1,merge(lft,nd,rht.lft));
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(root,i); }
private V get(Node nd,int i){
if (nd.sz == 1)
return nd.val;
nd.push();
return i < nd.lft.sz ? get(nd.lft,i) : get(nd.rht,i -nd.lft.sz);
}
public V get(int l,int r){
ret[ri] = e();
ri ^= 1;
if (root != null)
get(root,l,min(r,size()));
return ret[ri ^= 1];
}
private void get(Node nd,int l,int r){
if (0 == l && r == nd.sz || nd.lft == null)
ag(ret[ri],ret[ri ^= 1],nd.lft == null ? pw(nd.val,r -l) : nd.val());
else {
nd.push();
if (l < nd.lft.sz)
get(nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected void pow(V v,V a,int n){
for (var t = ag(e(),e,a);0 < n;n >>= 1,ag(t,t,t))
if (0 < (n &1))
ag(v,v,t);
}
private V pw(V a,int n){
V ret = e();
pow(ret,a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? (nd = rotate(nd)) : nd).merge(); }
private Node rotate(Node u){
var v = u.cld(u.bis).push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
private class Node{
private int sz,bis,rnk,tog;
private V val;
private F laz;
private Node lft,rht;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node merge(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
return this;
}
private Node push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
return this;
}
private Node prop(F f){
map(val,f);
if (lft != null)
laz = laz == null ? f : comp(laz,f);
return this;
}
private Node toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (lft != null)
tog ^= 1;
return this;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return lft == null && 1 < sz ? pw(val,sz) : val; }
}
}
class RollingHash{
private static long MASK30 = (1L <<30) -1;
private static long MASK31 = (1L <<31) -1;
private static long MOD = (1L <<61) -1;
private static long m = base();
private static long[] pow = {1};
int n;
private long[] hash,S;
private boolean updatable;
private RollingHash rev;
public RollingHash(char[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(long[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int n,IntToLongFunction f,boolean updatale){
S = new long[n];
updatable = updatale;
this.n = S.length;
hash = new long[n +1];
setPow(n);
for (int i = 0;i < n;i++)
set(i,f.applyAsLong(i));
}
public long get(int l,int r){
if (l > r)
return (rev == null ? rev = rev() : rev).get(n -l,n -r);
return mod(hash(r) -mul(hash(l),pow[r -l]));
}
public void upd(int i,long v){
assert updatable;
set(i,v);
if (rev != null)
rev.set(n -i -1,v);
}
private void set(int i,long v){
if (updatable)
for (int x = i +1;x <= n;x += x &-x)
hash[x] = mod(hash[x] +mul(v -S[i],pow[x -i -1]));
else
hash[i +1] = mod(mul(hash[i],m) +v);
S[i] = v;
}
private long hash(int i){
long ret = 0;
if (updatable)
for (int x = i;x > 0;x -= x &-x)
ret = mod(ret +mul(hash[x],pow[i -x]));
else
ret = hash[i];
return ret;
}
private void setPow(int n){
if (n < pow.length)
return;
int s = pow.length;
pow = copyOf(pow,max(pow.length <<1,n +1));
for (int i = s;i < pow.length;i++)
pow[i] = mul(pow[i -1],m);
}
private RollingHash rev(){
long[] s = new long[n];
for (int i = 0;i < n;i++)
s[i] = S[n -1 -i];
return new RollingHash(s,updatable);
}
private static long mul(long a,long b){
long lu = a >>31;
long ld = a &MASK31;
long ru = b >>31;
long rd = b &MASK31;
long mid = ld *ru +lu *rd;
return mod((lu *ru <<1) +ld *rd +((mid &MASK30) <<31) +(mid >>30));
}
private static long mod(long val){
while (val < 0)
val += MOD;
val = (val &MOD) +(val >>61);
return val > MOD ? val -MOD : val;
}
private static long pow(long x,long n){
long ret = 1;
do {
if ((n &1) == 1)
ret = mul(ret,x);
x = mul(x,x);
} while (0 < (n >>= 1));
return ret;
}
private static long base(){
long m = 0;
for (int k = 1;m < Util.infI;m = pow(37,k))
while (!isPrimeRoot(k))
k = ThreadLocalRandom.current().nextInt(Util.infI);
return m;
}
private static boolean isPrimeRoot(long a){
long b = MOD -1;
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a > 1;
}
}
class PrefixSum{
private long[] sum;
private int i;
public PrefixSum(int n){ sum = new long[n +1]; }
public PrefixSum(long[] a){
this(a.length);
for (int i = 0;i < a.length;i++)
sum[i +1] = sum[i] +a[i];
}
public void add(long a){ sum[i +1] = sum[i++] +a; }
public long get(int l,int r){ return sum[r] -sum[l]; }
public long get(int i){ return get(i,i +1); }
}
class Permutation{
private int n;
int[] arr;
public Permutation(int n){ this(Util.arrI(n,i -> i)); }
public Permutation(int[] arr){
n = arr.length;
this.arr = copyOf(arr,n);
}
public boolean increment(){ return crement(1); }
public boolean decrement(){ return crement(-1); }
private boolean crement(int d){
int l = n -2;
while (0 <= l && arr[l] *d >= arr[l +1] *d)
l--;
if (l < 0)
return false;
int r = n -1;
while (arr[l] *d >= arr[r] *d)
r--;
swap(l,r);
l++;
r = n -1;
while (l < r)
swap(l++,r--);
return true;
}
private void swap(int l,int r){
arr[l] ^= arr[r];
arr[r] ^= arr[l];
arr[l] ^= arr[r];
}
}
class Prime{
private long[] spf,
arrI = {2, 7, 61},
arrL = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
public Prime(){ this(1_000_000); }
public Prime(int n){
spf = new long[n +1];
Arrays.setAll(spf,i -> i);
for (int p = 2;p *p <= n;p++)
if (spf[p] == p)
for (int l = p *p;l <= n;l += p)
spf[l] = p;
}
public long[] divisors(long n){
long[] fs = factorize(n);
int l = fs.length > 0 ? 2 : 1,id = 0;
for (int i = 1,sz = 1;i < fs.length;i++,l += sz)
if (fs[i -1] < fs[i])
sz = l;
long[] ret = new long[l];
ret[id++] = 1;
for (int i = 0,s = 0,sz = 1;i < fs.length;i++,s += sz) {
if (0 < i && fs[i -1] < fs[i]) {
sz = id;
s = 0;
}
for (int j = s;j < s +sz;j++)
ret[id++] = ret[j] *fs[i];
}
sort(ret);
return ret;
}
public long[] factorize(long n){
if (n < 2)
return new long[0];
long[] ret = new long[64];
int h = 0,t = 0;
ret[t++] = n;
while (h < t) {
long cur = ret[h++];
if (!isPrime(cur)) {
var p = rho(cur);
ret[--h] = p;
ret[t++] = cur /p;
}
}
sort(ret,0,t);
return copyOf(ret,t);
}
public boolean isPrime(long n){
if (n < spf.length)
return 1 < n && spf[(int) n] == n;
if ((n &1) == 0)
return false;
ModInt bm = new ModInt(n);
long lsb = n -1 &-n +1;
long m = (n -1) /lsb;
a:for (var a:n < 1 <<30 ? arrI : arrL) {
long z = bm.pow(a %n,m);
if (z < 2)
continue;
for (long k = 1;k <= lsb;k <<= 1)
if (z == n -1)
continue a;
else
z = bm.mul(z,z);
return false;
}
return true;
}
private long rho(long n){
if (n < spf.length)
return spf[(int) n];
if ((n &1) == 0)
return 2;
ModInt bm = new ModInt(n);
for (long t;;) {
long x = 0,y = x,q = 1,c = Util.rd.nextLong(n -1) +1;
a:for (int k = 1;;k <<= 1,y = x,q = 1)
for (int i = k;i-- > 0;) {
x = bm.mul(x,x) +c;
if (n <= x)
x -= n;
q = bm.mul(q,abs(x -y));
if ((i &127) == 0 && (t = gcd(q,n)) > 1)
break a;
}
if (t < n)
return t;
}
}
private long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
class ModInt{
private long n,r2,ni;
public ModInt(long n){
this.n = n;
r2 = (1L <<62) %n;
for (int i = 0;i < 66;i++) {
r2 <<= 1;
if (r2 >= n)
r2 -= n;
}
ni = n;
for (int i = 0;i < 5;++i)
ni *= 2 -n *ni;
}
private static long high(long x,long y){ return multiplyHigh(x,y) +(x >>63 &y) +(y >>63 &x); }
private long mr(long x,long y){ return high(x,y) +high(-ni *x *y,n) +(x *y == 0 ? 0 : 1); }
public long mod(long x){ return x < n ? x : x -n; }
public long mul(long x,long y){ return mod(mr(mr(x,r2),y)); }
public long pow(long x,long y){
long z = mr(x,r2);
long r = 1;
while (y > 0) {
if ((y &1) == 1)
r = mr(r,z);
z = mr(z,z);
y >>= 1;
}
return mod(r);
}
}
}
class Combin{
int n = 2;
long[] f,fi;
long mod = Util.mod;
public Combin(int n){
this();
grow(n);
}
public Combin(){ f = fi = new long[]{1, 1}; }
public void grow(int n){
n = min((int) mod,n);
f = copyOf(f,n);
fi = copyOf(fi,n);
for (int i = this.n;i < n;i++)
f[i] = f[i -1] *i %mod;
fi[n -1] = pow(f[n -1],mod -2);
for (int i = n;--i > this.n;)
fi[i -1] = fi[i] *i %mod;
this.n = n;
}
private long pow(long x,long n){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
public long nHr(int n,int r){ return r < 0 ? 0 : nCr(n +r -1,r); }
public long nCr(int n,int r){
if (r < 0 || n -r < 0)
return 0;
if (this.n <= n)
grow(max(this.n <<1,n +1));
return f[n] *(fi[r] *fi[n -r] %mod) %mod;
}
}
class Data extends BaseV{
long v,c;
public Data(long v){ this.v = v; }
@Override
public String toString(){ return "" +v; }
}
abstract class DigitDp<T> {
private int B;
private int[] N;
private T[] dp;
public DigitDp(char[] N){ this(N,10); }
public DigitDp(char[] N,int B){
this.N = new int[N.length];
for (int i = 0;i < N.length;i++)
this.N[i] = N[i] -'0';
dp = Util.cast(Array.newInstance(init().getClass(),N.length +1 <<1));
this.B = B;
setAll(dp,i -> init());
}
protected abstract T init();
protected abstract void f(T pd,T dp,int n,int k);
protected void mod(T dp){}
public T get(int i,int same){ return dp[i *2 +same]; }
public void calc(){
for (int i = 0;i < N.length;i++) {
int t = N[i];
for (int n = 0;n < B;n++) {
if (n == t)
f(get(i +1,1),get(i,1),n,N.length -1 -i);
if (n < t)
f(get(i +1,0),get(i,1),n,N.length -1 -i);
if (0 < i)
f(get(i +1,0),get(i,0),n,N.length -1 -i);
}
mod(get(i +1,0));
mod(get(i +1,1));
}
}
}
abstract class Dijkstra<E, L> extends Graph<E>{
private Comparator<L> cmp;
private L[] len;
private int[] hep,idx;
private Edge<E>[] pre;
private int sz;
public Dijkstra(int n,boolean dir){
super(n,dir);
hep = new int[n];
idx = new int[n];
cmp = cmp();
}
protected abstract L zero();
protected abstract L inf();
protected abstract L f(L l,Edge<E> e);
protected Comparator<L> cmp(){ return Util.cast(Comparator.naturalOrder()); }
public L[] calc(int s){ return calc(s,-1); }
public L[] calc(int s,int g){
len = Util.cast(Array.newInstance(zero().getClass(),sz = n));
pre = Util.cast(new Edge[n]);
fill(len,inf());
setAll(hep,i -> i);
setAll(idx,i -> i);
set(s,zero());
for (int cur;0 < sz && (cur = poll()) != g;)
for (var e:go(cur))
set((pre[e.v] = e).v,f(len[cur],e));
return len;
}
public L get(int t){ return len[t]; }
public Deque<Edge<E>> path(int t){
Deque<Edge<E>> ret = new ArrayDeque<>();
while (pre[t] != null) {
ret.addFirst(pre[t]);
t = pre[t].u;
}
return ret;
}
private void set(int i,L l){
if (idx[i] < sz && cmp.compare(l,len[i]) < 0) {
len[i] = l;
heapfy(idx[i]);
}
}
private int poll(){
int ret = hep[0];
heapfy(swap(0,--sz));
return ret;
}
private void heapfy(int k){
int p = k -1 >>1;
if (0 <= p && cmp.compare(len[hep[p]],len[hep[k]]) > 0) {
heapfy(swap(p,k));
return;
}
int c = k <<1 |1;
if (sz <= c)
return;
if (c +1 < sz && cmp.compare(len[hep[c]],len[hep[c +1]]) > 0)
c++;
if (cmp.compare(len[hep[c]],len[hep[k]]) < 0)
heapfy(swap(c,k));
}
private int swap(int i,int j){
hep[i] ^= hep[j];
hep[j] ^= hep[i];
hep[i] ^= hep[j];
idx[hep[i]] = i;
idx[hep[j]] = j;
return i;
}
}
class UnionFind{
int num;
protected int[] dat;
protected int[] nxt;
public UnionFind(int n){
dat = new int[n];
nxt = new int[n];
setAll(nxt,i -> i);
fill(dat,-1);
num = n;
}
public int root(int x){ return dat[x] < 0 ? x : (dat[x] = root(dat[x])); }
public boolean same(int u,int v){ return root(u) == root(v); }
public boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (dat[u] > dat[v]) {
u ^= v;
v ^= u;
u ^= v;
}
dat[u] += dat[v];
dat[v] = u;
num--;
nxt[u] ^= nxt[v];
nxt[v] ^= nxt[u];
nxt[u] ^= nxt[v];
return true;
}
public int size(int x){ return -dat[root(x)]; }
public int[] getGroup(int x){
int[] ret = new int[size(x)];
for (int i = 0,c = root(x);i < ret.length;i++)
ret[i] = c = nxt[c];
return ret;
}
}
abstract class ReRootingDp<L, D, A> extends Graph<L>{
private D[] dp;
private A[] ans;
public ReRootingDp(int N){
super(N,false);
dp = Util.cast(new Object[2 *N]);
ans = Util.cast(Array.newInstance(ans(0,e()).getClass(),n));
}
protected abstract D e();
protected abstract D agg(D a,D b);
protected abstract D adj(D v,Edge<L> e);
protected abstract A ans(int u,D sum);
protected MyList<D> sur(int u){ return go(u).map(e -> dp[e.id]); }
public A[] calc(){
for (var e:es)
e.re.id = e.id +n;
var stk = new MyStack<Edge<L>>();
var se = new Edge<L>(n -1,-1,0,null);
stk.add(se);
while (!stk.isEmpty()) {
var e = stk.pop();
if (dp[e.id] == null) {
dp[e.id] = e();
for (var ee:go(e.v))
if (ee != e.re) {
stk.add(ee);
stk.add(ee);
}
} else {
for (var ee:go(e.v))
if (ee != e.re)
dp[e.id] = agg(dp[e.id],dp[ee.id]);
if (e.u > -1)
dp[e.id] = adj(dp[e.id],e);
}
}
stk.add(se);
while (!stk.isEmpty()) {
var e = stk.pop();
var es = go(e.v);
int n = es.size();
D[] pre = Util.cast(new Object[n +1]),suf = Util.cast(new Object[n +1]);
pre[0] = e();
suf[n] = e();
for (int i = 0;i < n;i++) {
pre[i +1] = agg(pre[i],dp[es.get(i).id]);
suf[n -1 -i] = agg(dp[es.get(n -1 -i).id],suf[n -i]);
}
ans[e.v] = ans(e.v,suf[0]);
for (int i = 0;i < n;i++) {
Edge<L> ee = es.get(i);
if (ee != e.re) {
dp[ee.re.id] = adj(agg(pre[i],suf[i +1]),ee.re);
stk.add(ee);
}
}
}
return ans;
}
}
class Edge<L> {
public int id,u,v;
public L val;
public Edge<L> re;
public Edge(int id,int u,int v,L val){
this.id = id;
this.u = u;
this.v = v;
this.val = val;
}
}
class Graph<L> {
public int n;
public MyList<Edge<L>> es;
private MyList<Edge<L>>[] go,bk;
public Graph(int n,boolean dir){
this.n = n;
go = Util.cast(new MyList[n]);
bk = dir ? Util.cast(new MyList[n]) : go;
for (int i = 0;i < n;i++) {
go[i] = new MyList<>();
bk[i] = new MyList<>();
}
es = new MyList<>();
}
protected L inv(L l){ return l; }
public void addEdge(int u,int v){ addEdge(u,v,null); }
public void addEdge(int u,int v,L l){
var e = new Edge<>(es.size(),u,v,l);
var re = new Edge<>(e.id,e.v,e.u,inv(e.val));
es.add(e);
go[u].add(re.re = e);
bk[v].add(e.re = re);
}
public MyList<Edge<L>> go(int u){ return go[u]; }
public MyList<Edge<L>> bk(int u){ return bk[u]; }
}
abstract class SparseTable2D{
int h,w,hl,wl;
long[][][][] tbl;
SparseTable2D(int h,int w){
hl = max(1,32 -Integer.numberOfLeadingZeros((this.h = h) -1));
wl = max(1,32 -Integer.numberOfLeadingZeros((this.w = w) -1));
tbl = new long[hl][wl][][];
for (int hi = 0;hi < hl;hi++)
for (int wi = 0;wi < wl;wi++) {
int hhl = h -(1 <<hi) +1;
int wwl = w -(1 <<wi) +1;
tbl[hi][wi] = new long[hhl][wwl];
for (int i = 0;i < hhl;i++)
for (int j = 0;j < wwl;j++)
if ((hi |wi) == 0)
tbl[0][0][i][j] = init(i,j);
else if (0 < hi)
tbl[hi][wi][i][j] = agg(tbl[hi -1][wi][i][j],tbl[hi -1][wi][i +(1 <<hi -1)][j]);
else
tbl[hi][wi][i][j] = agg(tbl[hi][wi -1][i][j],tbl[hi][wi -1][i][j +(1 <<wi -1)]);
}
}
abstract protected long init(int i,int j);
abstract protected long agg(long a,long b);
long get(int i0,int j0,int i1,int j1){
int il = max(0,31 -Integer.numberOfLeadingZeros(i1 -i0 -1));
int jl = max(0,31 -Integer.numberOfLeadingZeros(j1 -j0 -1));
i1 = max(0,i1 -(1 <<il));
j1 = max(0,j1 -(1 <<jl));
long[][] tmp = tbl[il][jl];
long ret = agg(tmp[i0][j0],tmp[i0][j1]);
ret = agg(ret,tmp[i1][j0]);
ret = agg(ret,tmp[i1][j1]);
return ret;
}
}
abstract class SparseTable{
int n;
long[] tbl;
SparseTable(int n){
int K = max(1,32 -Integer.numberOfLeadingZeros(n -1));
this.n = 1 <<K;
tbl = new long[K *this.n];
for (int i = 0;i < this.n;i++)
tbl[i] = i < n ? init(i) : 0;
for (int k = 1;k < K;k++)
for (int s = 1 <<k;s < this.n;s += 2 <<k) {
int b = k *this.n;
tbl[b +s] = s < n ? init(s) : 0;
tbl[b +s -1] = s < n ? init(s -1) : 0;
for (int i = 1;i < 1 <<k;i++) {
tbl[b +s +i] = agg(tbl[b +s +i -1],tbl[s +i]);
tbl[b +s -1 -i] = agg(tbl[b +s -i],tbl[s -1 -i]);
}
}
}
abstract protected long init(int i);
abstract protected long agg(long a,long b);
long get(int l,int r){
r--;
if (l == r)
return tbl[l];
int k = 31 -Integer.numberOfLeadingZeros(l ^r);
return agg(tbl[k *n +l],tbl[k *n +r]);
}
}
abstract class Sum2D{
private long[] sum;
private int w;
public Sum2D(int h,int w){
this.w = w;
sum = new long[(h +1) *(w +1)];
for (int i = 0;i < h;i++)
for (int j = 0;j < w;j++)
sum[top(i +1,j +1)] = a(i,j) +sum[top(i +1,j)] +sum[top(i,j +1)] -sum[top(i,j)];
}
abstract long a(int i,int j);
private int top(int i,int j){ return i *(w +1) +j; }
long get(int il,int ir,int jl,int jr){ return sum[top(ir,jr)] -sum[top(il,jr)] -sum[top(ir,jl)] +sum[top(il,jl)]; }
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyListLong{
private long[] arr;
private int sz;
public MyListLong(){ this(16); }
public MyListLong(int n){ arr = new long[n]; }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public long get(int i){ return arr[i]; }
public void add(long t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public long[] toArray(){ return copyOf(arr,sz); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){
if (sz == 0)
return Util.cast(new Object[0]);
T[] ret = Util.cast(Array.newInstance(arr[0].getClass(),sz));
for (int i = 0;i < sz;i++)
ret[i] = arr[i];
return ret;
}
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x){ return pow(x,mod -2); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
public long lcm(long a,long b){ return b /gcd(a,b) *a; }
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<61 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return Util.arrI(N,i -> it()); }
public int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return Util.arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return Util.arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return Util.arr(new String[N],i -> str()); }
public String[][] str(int H,int W){ return Util.arr(new String[H][],i -> str(W)); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
public final class Main{
public static void main(String[] args) throws Exception{
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out,false),log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log).solve()).ifPresent(out::println);
out.flush();
}
}
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = true;
public Object solve(){
long[] A = new long[6];
long[] B = new long[6];
for (int i = 1;i <= 5;i++)
A[i] = in.lg();
for (int i = 1;i <= 5;i++)
B[i] = in.lg();
f(A,B,5,5);
f(A,B,4,4);
f(A,B,3,3);
f(A,B,3,5);
f(A,B,4,5);
f(A,B,3,4);
for (int b = 5;b >= 2;b--)
f(A,B,2,b);
for (int b = 5;b >= 1;b--)
f(A,B,1,b);
for (var a:A)
if (a > 0)
return false;
return true;
}
private void f(long[] A,long[] B,int a,int b){
long n = min(A[a],B[b]);
A[a] -= n;
B[b] -= n;
B[b -a] += n;
}
}
class Grid{
private int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
private int H,W;
public Grid(int H,int W){
this.H = H;
this.W = W;
}
// public int[] sur(int p){
// int[][] tmp = sur(toi(p),toj(p));
// int[] ret = new int[tmp.length];
// for (int i = 0;i < tmp.length;i++)
// ret[i] = top(tmp[i][0],tmp[i][1]);
// return ret;
// }
public MyList<int[]> sur(int i,int j){
MyList<int[]> ret = new MyList<>();
for (var d:dirs) {
int ni = i +d[0];
int nj = j +d[1];
if (valid(ni,H) && valid(nj,W))
ret.add(new int[]{ni, nj});
}
return ret;
}
private boolean valid(int i,int N){ return 0 <= i && i < N; }
public int top(int i,int j){ return i *W +j; }
public int toi(int p){ return p /W; }
public int toj(int p){ return p %W; }
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e();
private Node root;
private V[] ret = Util.cast(new BaseV[2]);
private int ri;
public AVLSegmentTree(int n){
this();
root = new Node(e(),n);
}
public AVLSegmentTree(){
ret[ri] = e();
ri ^= 1;
}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int i,int n,IntFunction<V> init){
if (n < 2)
return n < 1 ? null : new Node(init.apply(i),1);
var ret = new Node(e(),n);
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
return ret.merge();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.lft == null && (i == 0 || i == nd.sz)) {
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
return nd.merge();
}
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.cld(-1,ins(nd.lft,i,v,k));
else
nd.cld(1,ins(nd.rht,i -nd.lft.sz,v,k));
return balance(nd);
}
public V del(int i){
var ret = e();
root = del(ret,root,i);
return ret;
}
private Node del(V ret,Node nd,int i){
if (nd.lft == null) {
nd.sz--;
ag(ret,e,nd.val);
return 0 < nd.sz ? nd : null;
}
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(ret,nd.lft,i) : del(ret,nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (l == r)
return;
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
return nd.prop(f);
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.cld(-1,upd(nd.lft,l,min(nd.lft.sz,r),f));
if (nd.lft.sz < r)
nd.cld(1,upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f));
return balance(nd);
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
return merge(nd.lft,nd,toggle(nd.rht,0,r -l));
}
if (r < nd.sz) {
split(nd,r);
return merge(toggle(nd.lft,l,r),nd,nd.rht);
}
return nd.toggle();
}
private void split(Node nd,int i){
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
if (i < nd.lft.sz) {
split(nd.lft,i);
var lft = nd.lft;
nd.cld(-1,lft.lft);
nd.cld(1,merge(lft.rht,lft,nd.rht));
} else if (nd.lft.sz < i) {
split(nd.rht,i -nd.lft.sz);
var rht = nd.rht;
nd.cld(1,rht.rht);
nd.cld(-1,merge(nd.lft,rht,rht.lft));
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.cld(-1,lft);
nd.cld(1,rht);
} else if (lft.rnk > rht.rnk) {
lft.push().cld(1,merge(lft.rht,nd,rht));
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push().cld(-1,merge(lft,nd,rht.lft));
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(root,i); }
private V get(Node nd,int i){
if (nd.sz == 1)
return nd.val;
nd.push();
return i < nd.lft.sz ? get(nd.lft,i) : get(nd.rht,i -nd.lft.sz);
}
public V get(int l,int r){
ret[ri] = e();
ri ^= 1;
if (root != null)
get(root,l,min(r,size()));
return ret[ri ^= 1];
}
private void get(Node nd,int l,int r){
if (0 == l && r == nd.sz || nd.lft == null)
ag(ret[ri],ret[ri ^= 1],nd.lft == null ? pw(nd.val,r -l) : nd.val());
else {
nd.push();
if (l < nd.lft.sz)
get(nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected void pow(V v,V a,int n){
for (var t = ag(e(),e,a);0 < n;n >>= 1,ag(t,t,t))
if (0 < (n &1))
ag(v,v,t);
}
private V pw(V a,int n){
V ret = e();
pow(ret,a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? (nd = rotate(nd)) : nd).merge(); }
private Node rotate(Node u){
var v = u.cld(u.bis).push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
private class Node{
private int sz,bis,rnk,tog;
private V val;
private F laz;
private Node lft,rht;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node merge(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
return this;
}
private Node push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
return this;
}
private Node prop(F f){
map(val,f);
if (lft != null)
laz = laz == null ? f : comp(laz,f);
return this;
}
private Node toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (lft != null)
tog ^= 1;
return this;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return lft == null && 1 < sz ? pw(val,sz) : val; }
}
}
class RollingHash{
private static long MASK30 = (1L <<30) -1;
private static long MASK31 = (1L <<31) -1;
private static long MOD = (1L <<61) -1;
private static long m = base();
private static long[] pow = {1};
int n;
private long[] hash,S;
private boolean updatable;
private RollingHash rev;
public RollingHash(char[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(long[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int n,IntToLongFunction f,boolean updatale){
S = new long[n];
updatable = updatale;
this.n = S.length;
hash = new long[n +1];
setPow(n);
for (int i = 0;i < n;i++)
set(i,f.applyAsLong(i));
}
public long get(int l,int r){
if (l > r)
return (rev == null ? rev = rev() : rev).get(n -l,n -r);
return mod(hash(r) -mul(hash(l),pow[r -l]));
}
public void upd(int i,long v){
assert updatable;
set(i,v);
if (rev != null)
rev.set(n -i -1,v);
}
private void set(int i,long v){
if (updatable)
for (int x = i +1;x <= n;x += x &-x)
hash[x] = mod(hash[x] +mul(v -S[i],pow[x -i -1]));
else
hash[i +1] = mod(mul(hash[i],m) +v);
S[i] = v;
}
private long hash(int i){
long ret = 0;
if (updatable)
for (int x = i;x > 0;x -= x &-x)
ret = mod(ret +mul(hash[x],pow[i -x]));
else
ret = hash[i];
return ret;
}
private void setPow(int n){
if (n < pow.length)
return;
int s = pow.length;
pow = copyOf(pow,max(pow.length <<1,n +1));
for (int i = s;i < pow.length;i++)
pow[i] = mul(pow[i -1],m);
}
private RollingHash rev(){
long[] s = new long[n];
for (int i = 0;i < n;i++)
s[i] = S[n -1 -i];
return new RollingHash(s,updatable);
}
private static long mul(long a,long b){
long lu = a >>31;
long ld = a &MASK31;
long ru = b >>31;
long rd = b &MASK31;
long mid = ld *ru +lu *rd;
return mod((lu *ru <<1) +ld *rd +((mid &MASK30) <<31) +(mid >>30));
}
private static long mod(long val){
while (val < 0)
val += MOD;
val = (val &MOD) +(val >>61);
return val > MOD ? val -MOD : val;
}
private static long pow(long x,long n){
long ret = 1;
do {
if ((n &1) == 1)
ret = mul(ret,x);
x = mul(x,x);
} while (0 < (n >>= 1));
return ret;
}
private static long base(){
long m = 0;
for (int k = 1;m < Util.infI;m = pow(37,k))
while (!isPrimeRoot(k))
k = ThreadLocalRandom.current().nextInt(Util.infI);
return m;
}
private static boolean isPrimeRoot(long a){
long b = MOD -1;
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a > 1;
}
}
class PrefixSum{
private long[] sum;
private int i;
public PrefixSum(int n){ sum = new long[n +1]; }
public PrefixSum(long[] a){
this(a.length);
for (int i = 0;i < a.length;i++)
sum[i +1] = sum[i] +a[i];
}
public void add(long a){ sum[i +1] = sum[i++] +a; }
public long get(int l,int r){ return sum[r] -sum[l]; }
public long get(int i){ return get(i,i +1); }
}
class Permutation{
private int n;
int[] arr;
public Permutation(int n){ this(Util.arrI(n,i -> i)); }
public Permutation(int[] arr){
n = arr.length;
this.arr = copyOf(arr,n);
}
public boolean increment(){ return crement(1); }
public boolean decrement(){ return crement(-1); }
private boolean crement(int d){
int l = n -2;
while (0 <= l && arr[l] *d >= arr[l +1] *d)
l--;
if (l < 0)
return false;
int r = n -1;
while (arr[l] *d >= arr[r] *d)
r--;
swap(l,r);
l++;
r = n -1;
while (l < r)
swap(l++,r--);
return true;
}
private void swap(int l,int r){
arr[l] ^= arr[r];
arr[r] ^= arr[l];
arr[l] ^= arr[r];
}
}
class Prime{
private long[] spf,
arrI = {2, 7, 61},
arrL = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
public Prime(){ this(1_000_000); }
public Prime(int n){
spf = new long[n +1];
Arrays.setAll(spf,i -> i);
for (int p = 2;p *p <= n;p++)
if (spf[p] == p)
for (int l = p *p;l <= n;l += p)
spf[l] = p;
}
public long[] divisors(long n){
long[] fs = factorize(n);
int l = fs.length > 0 ? 2 : 1,id = 0;
for (int i = 1,sz = 1;i < fs.length;i++,l += sz)
if (fs[i -1] < fs[i])
sz = l;
long[] ret = new long[l];
ret[id++] = 1;
for (int i = 0,s = 0,sz = 1;i < fs.length;i++,s += sz) {
if (0 < i && fs[i -1] < fs[i]) {
sz = id;
s = 0;
}
for (int j = s;j < s +sz;j++)
ret[id++] = ret[j] *fs[i];
}
sort(ret);
return ret;
}
public long[] factorize(long n){
if (n < 2)
return new long[0];
long[] ret = new long[64];
int h = 0,t = 0;
ret[t++] = n;
while (h < t) {
long cur = ret[h++];
if (!isPrime(cur)) {
var p = rho(cur);
ret[--h] = p;
ret[t++] = cur /p;
}
}
sort(ret,0,t);
return copyOf(ret,t);
}
public boolean isPrime(long n){
if (n < spf.length)
return 1 < n && spf[(int) n] == n;
if ((n &1) == 0)
return false;
ModInt bm = new ModInt(n);
long lsb = n -1 &-n +1;
long m = (n -1) /lsb;
a:for (var a:n < 1 <<30 ? arrI : arrL) {
long z = bm.pow(a %n,m);
if (z < 2)
continue;
for (long k = 1;k <= lsb;k <<= 1)
if (z == n -1)
continue a;
else
z = bm.mul(z,z);
return false;
}
return true;
}
private long rho(long n){
if (n < spf.length)
return spf[(int) n];
if ((n &1) == 0)
return 2;
ModInt bm = new ModInt(n);
for (long t;;) {
long x = 0,y = x,q = 1,c = Util.rd.nextLong(n -1) +1;
a:for (int k = 1;;k <<= 1,y = x,q = 1)
for (int i = k;i-- > 0;) {
x = bm.mul(x,x) +c;
if (n <= x)
x -= n;
q = bm.mul(q,abs(x -y));
if ((i &127) == 0 && (t = gcd(q,n)) > 1)
break a;
}
if (t < n)
return t;
}
}
private long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
class ModInt{
private long n,r2,ni;
public ModInt(long n){
this.n = n;
r2 = (1L <<62) %n;
for (int i = 0;i < 66;i++) {
r2 <<= 1;
if (r2 >= n)
r2 -= n;
}
ni = n;
for (int i = 0;i < 5;++i)
ni *= 2 -n *ni;
}
private static long high(long x,long y){ return multiplyHigh(x,y) +(x >>63 &y) +(y >>63 &x); }
private long mr(long x,long y){ return high(x,y) +high(-ni *x *y,n) +(x *y == 0 ? 0 : 1); }
public long mod(long x){ return x < n ? x : x -n; }
public long mul(long x,long y){ return mod(mr(mr(x,r2),y)); }
public long pow(long x,long y){
long z = mr(x,r2);
long r = 1;
while (y > 0) {
if ((y &1) == 1)
r = mr(r,z);
z = mr(z,z);
y >>= 1;
}
return mod(r);
}
}
}
class Combin{
int n = 2;
long[] f,fi;
long mod = Util.mod;
public Combin(int n){
this();
grow(n);
}
public Combin(){ f = fi = new long[]{1, 1}; }
public void grow(int n){
n = min((int) mod,n);
f = copyOf(f,n);
fi = copyOf(fi,n);
for (int i = this.n;i < n;i++)
f[i] = f[i -1] *i %mod;
fi[n -1] = pow(f[n -1],mod -2);
for (int i = n;--i > this.n;)
fi[i -1] = fi[i] *i %mod;
this.n = n;
}
private long pow(long x,long n){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
public long nHr(int n,int r){ return r < 0 ? 0 : nCr(n +r -1,r); }
public long nCr(int n,int r){
if (r < 0 || n -r < 0)
return 0;
if (this.n <= n)
grow(max(this.n <<1,n +1));
return f[n] *(fi[r] *fi[n -r] %mod) %mod;
}
}
class Data extends BaseV{
long v,c;
public Data(long v){ this.v = v; }
@Override
public String toString(){ return "" +v; }
}
abstract class DigitDp<T> {
private int B;
private int[] N;
private T[] dp;
public DigitDp(char[] N){ this(N,10); }
public DigitDp(char[] N,int B){
this.N = new int[N.length];
for (int i = 0;i < N.length;i++)
this.N[i] = N[i] -'0';
dp = Util.cast(Array.newInstance(init().getClass(),N.length +1 <<1));
this.B = B;
setAll(dp,i -> init());
}
protected abstract T init();
protected abstract void f(T pd,T dp,int n,int k);
protected void mod(T dp){}
public T get(int i,int same){ return dp[i *2 +same]; }
public void calc(){
for (int i = 0;i < N.length;i++) {
int t = N[i];
for (int n = 0;n < B;n++) {
if (n == t)
f(get(i +1,1),get(i,1),n,N.length -1 -i);
if (n < t)
f(get(i +1,0),get(i,1),n,N.length -1 -i);
if (0 < i)
f(get(i +1,0),get(i,0),n,N.length -1 -i);
}
mod(get(i +1,0));
mod(get(i +1,1));
}
}
}
abstract class Dijkstra<E, L> extends Graph<E>{
private Comparator<L> cmp;
private L[] len;
private int[] hep,idx;
private Edge<E>[] pre;
private int sz;
public Dijkstra(int n,boolean dir){
super(n,dir);
hep = new int[n];
idx = new int[n];
cmp = cmp();
}
protected abstract L zero();
protected abstract L inf();
protected abstract L f(L l,Edge<E> e);
protected Comparator<L> cmp(){ return Util.cast(Comparator.naturalOrder()); }
public L[] calc(int s){ return calc(s,-1); }
public L[] calc(int s,int g){
len = Util.cast(Array.newInstance(zero().getClass(),sz = n));
pre = Util.cast(new Edge[n]);
fill(len,inf());
setAll(hep,i -> i);
setAll(idx,i -> i);
set(s,zero());
for (int cur;0 < sz && (cur = poll()) != g;)
for (var e:go(cur))
set((pre[e.v] = e).v,f(len[cur],e));
return len;
}
public L get(int t){ return len[t]; }
public Deque<Edge<E>> path(int t){
Deque<Edge<E>> ret = new ArrayDeque<>();
while (pre[t] != null) {
ret.addFirst(pre[t]);
t = pre[t].u;
}
return ret;
}
private void set(int i,L l){
if (idx[i] < sz && cmp.compare(l,len[i]) < 0) {
len[i] = l;
heapfy(idx[i]);
}
}
private int poll(){
int ret = hep[0];
heapfy(swap(0,--sz));
return ret;
}
private void heapfy(int k){
int p = k -1 >>1;
if (0 <= p && cmp.compare(len[hep[p]],len[hep[k]]) > 0) {
heapfy(swap(p,k));
return;
}
int c = k <<1 |1;
if (sz <= c)
return;
if (c +1 < sz && cmp.compare(len[hep[c]],len[hep[c +1]]) > 0)
c++;
if (cmp.compare(len[hep[c]],len[hep[k]]) < 0)
heapfy(swap(c,k));
}
private int swap(int i,int j){
hep[i] ^= hep[j];
hep[j] ^= hep[i];
hep[i] ^= hep[j];
idx[hep[i]] = i;
idx[hep[j]] = j;
return i;
}
}
class UnionFind{
int num;
protected int[] dat;
protected int[] nxt;
public UnionFind(int n){
dat = new int[n];
nxt = new int[n];
setAll(nxt,i -> i);
fill(dat,-1);
num = n;
}
public int root(int x){ return dat[x] < 0 ? x : (dat[x] = root(dat[x])); }
public boolean same(int u,int v){ return root(u) == root(v); }
public boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (dat[u] > dat[v]) {
u ^= v;
v ^= u;
u ^= v;
}
dat[u] += dat[v];
dat[v] = u;
num--;
nxt[u] ^= nxt[v];
nxt[v] ^= nxt[u];
nxt[u] ^= nxt[v];
return true;
}
public int size(int x){ return -dat[root(x)]; }
public int[] getGroup(int x){
int[] ret = new int[size(x)];
for (int i = 0,c = root(x);i < ret.length;i++)
ret[i] = c = nxt[c];
return ret;
}
}
abstract class ReRootingDp<L, D, A> extends Graph<L>{
private D[] dp;
private A[] ans;
public ReRootingDp(int N){
super(N,false);
dp = Util.cast(new Object[2 *N]);
ans = Util.cast(Array.newInstance(ans(0,e()).getClass(),n));
}
protected abstract D e();
protected abstract D agg(D a,D b);
protected abstract D adj(D v,Edge<L> e);
protected abstract A ans(int u,D sum);
protected MyList<D> sur(int u){ return go(u).map(e -> dp[e.id]); }
public A[] calc(){
for (var e:es)
e.re.id = e.id +n;
var stk = new MyStack<Edge<L>>();
var se = new Edge<L>(n -1,-1,0,null);
stk.add(se);
while (!stk.isEmpty()) {
var e = stk.pop();
if (dp[e.id] == null) {
dp[e.id] = e();
for (var ee:go(e.v))
if (ee != e.re) {
stk.add(ee);
stk.add(ee);
}
} else {
for (var ee:go(e.v))
if (ee != e.re)
dp[e.id] = agg(dp[e.id],dp[ee.id]);
if (e.u > -1)
dp[e.id] = adj(dp[e.id],e);
}
}
stk.add(se);
while (!stk.isEmpty()) {
var e = stk.pop();
var es = go(e.v);
int n = es.size();
D[] pre = Util.cast(new Object[n +1]),suf = Util.cast(new Object[n +1]);
pre[0] = e();
suf[n] = e();
for (int i = 0;i < n;i++) {
pre[i +1] = agg(pre[i],dp[es.get(i).id]);
suf[n -1 -i] = agg(dp[es.get(n -1 -i).id],suf[n -i]);
}
ans[e.v] = ans(e.v,suf[0]);
for (int i = 0;i < n;i++) {
Edge<L> ee = es.get(i);
if (ee != e.re) {
dp[ee.re.id] = adj(agg(pre[i],suf[i +1]),ee.re);
stk.add(ee);
}
}
}
return ans;
}
}
class Edge<L> {
public int id,u,v;
public L val;
public Edge<L> re;
public Edge(int id,int u,int v,L val){
this.id = id;
this.u = u;
this.v = v;
this.val = val;
}
}
class Graph<L> {
public int n;
public MyList<Edge<L>> es;
private MyList<Edge<L>>[] go,bk;
public Graph(int n,boolean dir){
this.n = n;
go = Util.cast(new MyList[n]);
bk = dir ? Util.cast(new MyList[n]) : go;
for (int i = 0;i < n;i++) {
go[i] = new MyList<>();
bk[i] = new MyList<>();
}
es = new MyList<>();
}
protected L inv(L l){ return l; }
public void addEdge(int u,int v){ addEdge(u,v,null); }
public void addEdge(int u,int v,L l){
var e = new Edge<>(es.size(),u,v,l);
var re = new Edge<>(e.id,e.v,e.u,inv(e.val));
es.add(e);
go[u].add(re.re = e);
bk[v].add(e.re = re);
}
public MyList<Edge<L>> go(int u){ return go[u]; }
public MyList<Edge<L>> bk(int u){ return bk[u]; }
}
abstract class SparseTable2D{
int h,w,hl,wl;
long[][][][] tbl;
SparseTable2D(int h,int w){
hl = max(1,32 -Integer.numberOfLeadingZeros((this.h = h) -1));
wl = max(1,32 -Integer.numberOfLeadingZeros((this.w = w) -1));
tbl = new long[hl][wl][][];
for (int hi = 0;hi < hl;hi++)
for (int wi = 0;wi < wl;wi++) {
int hhl = h -(1 <<hi) +1;
int wwl = w -(1 <<wi) +1;
tbl[hi][wi] = new long[hhl][wwl];
for (int i = 0;i < hhl;i++)
for (int j = 0;j < wwl;j++)
if ((hi |wi) == 0)
tbl[0][0][i][j] = init(i,j);
else if (0 < hi)
tbl[hi][wi][i][j] = agg(tbl[hi -1][wi][i][j],tbl[hi -1][wi][i +(1 <<hi -1)][j]);
else
tbl[hi][wi][i][j] = agg(tbl[hi][wi -1][i][j],tbl[hi][wi -1][i][j +(1 <<wi -1)]);
}
}
abstract protected long init(int i,int j);
abstract protected long agg(long a,long b);
long get(int i0,int j0,int i1,int j1){
int il = max(0,31 -Integer.numberOfLeadingZeros(i1 -i0 -1));
int jl = max(0,31 -Integer.numberOfLeadingZeros(j1 -j0 -1));
i1 = max(0,i1 -(1 <<il));
j1 = max(0,j1 -(1 <<jl));
long[][] tmp = tbl[il][jl];
long ret = agg(tmp[i0][j0],tmp[i0][j1]);
ret = agg(ret,tmp[i1][j0]);
ret = agg(ret,tmp[i1][j1]);
return ret;
}
}
abstract class SparseTable{
int n;
long[] tbl;
SparseTable(int n){
int K = max(1,32 -Integer.numberOfLeadingZeros(n -1));
this.n = 1 <<K;
tbl = new long[K *this.n];
for (int i = 0;i < this.n;i++)
tbl[i] = i < n ? init(i) : 0;
for (int k = 1;k < K;k++)
for (int s = 1 <<k;s < this.n;s += 2 <<k) {
int b = k *this.n;
tbl[b +s] = s < n ? init(s) : 0;
tbl[b +s -1] = s < n ? init(s -1) : 0;
for (int i = 1;i < 1 <<k;i++) {
tbl[b +s +i] = agg(tbl[b +s +i -1],tbl[s +i]);
tbl[b +s -1 -i] = agg(tbl[b +s -i],tbl[s -1 -i]);
}
}
}
abstract protected long init(int i);
abstract protected long agg(long a,long b);
long get(int l,int r){
r--;
if (l == r)
return tbl[l];
int k = 31 -Integer.numberOfLeadingZeros(l ^r);
return agg(tbl[k *n +l],tbl[k *n +r]);
}
}
abstract class Sum2D{
private long[] sum;
private int w;
public Sum2D(int h,int w){
this.w = w;
sum = new long[(h +1) *(w +1)];
for (int i = 0;i < h;i++)
for (int j = 0;j < w;j++)
sum[top(i +1,j +1)] = a(i,j) +sum[top(i +1,j)] +sum[top(i,j +1)] -sum[top(i,j)];
}
abstract long a(int i,int j);
private int top(int i,int j){ return i *(w +1) +j; }
long get(int il,int ir,int jl,int jr){ return sum[top(ir,jr)] -sum[top(il,jr)] -sum[top(ir,jl)] +sum[top(il,jl)]; }
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyListLong{
private long[] arr;
private int sz;
public MyListLong(){ this(16); }
public MyListLong(int n){ arr = new long[n]; }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public long get(int i){ return arr[i]; }
public void add(long t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public long[] toArray(){ return copyOf(arr,sz); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){
if (sz == 0)
return Util.cast(new Object[0]);
T[] ret = Util.cast(Array.newInstance(arr[0].getClass(),sz));
for (int i = 0;i < sz;i++)
ret[i] = arr[i];
return ret;
}
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x){ return pow(x,mod -2); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
public long lcm(long a,long b){ return b /gcd(a,b) *a; }
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<61 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return Util.arrI(N,i -> it()); }
public int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return Util.arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return Util.arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return Util.arr(new String[N],i -> str()); }
public String[][] str(int H,int W){ return Util.arr(new String[H][],i -> str(W)); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
| ConDefects/ConDefects/Code/abc226_g/Java/52905648 |
condefects-java_data_130 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
long C = Long.parseLong(sc.next());
int c = Long.bitCount(C);
int L = 60;
for(int n00 = 0; n00 <= L; n00++) {
for(int n01 = 0; n01 <= c; n01++) {
int n10 = c - n01;
int n11 = L - c - n00;
if(n10 + n11 != a) continue;
if(n01 + n11 != b) continue;
long x = 0;
long y = 0;
for(int i = 0; i < L; i++) {
if((C >> i & 1) > 0) {
if(n10-- > 0) x |= 1L << i;
else y |= 1L << i;
}else {
if(n11-- > 0) {
x |= 1L << i;
y |= 1L << i;
}
}
}
System.out.println(x + " " + y);
return;
}
}
System.out.println(-1);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
long C = Long.parseLong(sc.next());
int c = Long.bitCount(C);
int L = 60;
for(int n00 = 0; n00 <= L - c; n00++) {
for(int n01 = 0; n01 <= c; n01++) {
int n10 = c - n01;
int n11 = L - c - n00;
if(n10 + n11 != a) continue;
if(n01 + n11 != b) continue;
long x = 0;
long y = 0;
for(int i = 0; i < L; i++) {
if((C >> i & 1) > 0) {
if(n10-- > 0) x |= 1L << i;
else y |= 1L << i;
}else {
if(n11-- > 0) {
x |= 1L << i;
y |= 1L << i;
}
}
}
System.out.println(x + " " + y);
return;
}
}
System.out.println(-1);
}
}
}
| ConDefects/ConDefects/Code/abc347_d/Java/52285114 |
condefects-java_data_131 | import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
long cbig = scanner.nextLong();
int ccnt = 0;
String cstr = "";
while(cbig > 0){
cstr = cbig % 2 + cstr;
if(cbig%2 == 1)ccnt++;
cbig /= 2;
}
if(a + b >= ccnt && (a + b - ccnt) % 2 == 0 && Math.abs(a - b) <= ccnt){
ccnt = (a + b) - ccnt;
ccnt /= 2;
String astr = "";
String bstr = "";
a -= ccnt;
b -= ccnt;
for(int i = cstr.length() - 1; i >= 0; i--){
if(cstr.charAt(i) == '0'){
if(ccnt > 0){
ccnt--;
astr = "1" + astr;
bstr = "1" + bstr;
}
else{
astr = "0" + astr;
bstr = "0" + bstr;
}
}
else{
if(a > 0){
a--;
astr = "1" + astr;
bstr = "0" + bstr;
}
else{
b--;
astr = "0" + astr;
bstr = "1" + bstr;
}
}
}
for(int i = 0; i < ccnt; i++){
astr = "1" + astr;
bstr = "1" + bstr;
}
long aans = 0;
for(int i = 0; i < astr.length(); i++){
aans *= 2;
aans += (astr.charAt(i) - '0');
}
long bans = 0;
for(int i = 0; i < bstr.length(); i++){
bans *= 2;
bans += (bstr.charAt(i) - '0');
}
if(aans > Math.pow(2, 60) || bans > Math.pow(2, 60)){
System.out.println(-1);
return;
}
System.out.println(aans + " " + bans);
}
else{
System.out.println(-1);
}
}
}
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
long cbig = scanner.nextLong();
int ccnt = 0;
String cstr = "";
while(cbig > 0){
cstr = cbig % 2 + cstr;
if(cbig%2 == 1)ccnt++;
cbig /= 2;
}
if(a + b >= ccnt && (a + b - ccnt) % 2 == 0 && Math.abs(a - b) <= ccnt && a + b + ccnt <= 120){
ccnt = (a + b) - ccnt;
ccnt /= 2;
String astr = "";
String bstr = "";
a -= ccnt;
b -= ccnt;
for(int i = cstr.length() - 1; i >= 0; i--){
if(cstr.charAt(i) == '0'){
if(ccnt > 0){
ccnt--;
astr = "1" + astr;
bstr = "1" + bstr;
}
else{
astr = "0" + astr;
bstr = "0" + bstr;
}
}
else{
if(a > 0){
a--;
astr = "1" + astr;
bstr = "0" + bstr;
}
else{
b--;
astr = "0" + astr;
bstr = "1" + bstr;
}
}
}
for(int i = 0; i < ccnt; i++){
astr = "1" + astr;
bstr = "1" + bstr;
}
long aans = 0;
for(int i = 0; i < astr.length(); i++){
aans *= 2;
aans += (astr.charAt(i) - '0');
}
long bans = 0;
for(int i = 0; i < bstr.length(); i++){
bans *= 2;
bans += (bstr.charAt(i) - '0');
}
if(aans > Math.pow(2, 60) || bans > Math.pow(2, 60)){
System.out.println(-1);
return;
}
System.out.println(aans + " " + bans);
}
else{
System.out.println(-1);
}
}
} | ConDefects/ConDefects/Code/abc347_d/Java/52030403 |
condefects-java_data_132 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
long c = Long.parseLong(sc.next());
sc.close();
int pc = Long.bitCount(c);
if (a + b < pc || (a + b + pc) % 2 == 1 || (a + b + pc) > 120) {
System.out.println(-1);
} else {
long x = 0L;
int px = 0;
long y = 0L;
int d = (a + b - pc) / 2;//重なり部分
int e = 0;//重なり処理回数
long z = 1L;
for (int i = 0; i < 60; i++) {
if (c % 2L == 1L) {
if (px < a - d) {
x += z;
px++;
} else {
y += z;
}
} else if (e < d) {
x += z;
y += z;
e++;
}
c /= 2L;
z *= 2L;
}
System.out.println(x + " " + y);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
long c = Long.parseLong(sc.next());
sc.close();
int pc = Long.bitCount(c);
if (a + b < pc || (a + b + pc) % 2 == 1 || (a + b + pc) > 120 || a > b + pc || b > a + pc) {
System.out.println(-1);
} else {
long x = 0L;
int px = 0;
long y = 0L;
int d = (a + b - pc) / 2;//重なり部分
int e = 0;//重なり処理回数
long z = 1L;
for (int i = 0; i < 60; i++) {
if (c % 2L == 1L) {
if (px < a - d) {
x += z;
px++;
} else {
y += z;
}
} else if (e < d) {
x += z;
y += z;
e++;
}
c /= 2L;
z *= 2L;
}
System.out.println(x + " " + y);
}
}
} | ConDefects/ConDefects/Code/abc347_d/Java/54770948 |
condefects-java_data_133 |
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
String t = sc.next();
int firstA = n;
int lastB = -1;
for(int i = 0; i < n; i++) {
char c = t.charAt(i);
if(c == 'A') {
firstA = Math.min(firstA, i);
}
else {
lastB = Math.max(lastB, i);
}
}
Deque<Integer> queA = new ArrayDeque<Integer>();
Deque<Integer> queB = new ArrayDeque<Integer>();
int stockA = 0;
int stockB = 0;
int resultA = 0;
int resultB = 0;
int result = 0;
for(int i = 0; i < n; i++) {
if(s.charAt(i) == 'B' && t.charAt(i) == 'A') {
if(i >= lastB) {
// System.out.println("i = " + i);
System.out.println(-1);
return;
}
else {
if(stockA > 0) {
stockA--;
}
else {
result++;
stockB++;
}
// resultA++;
// stockB++;
}
}
if(s.charAt(i) == 'A' && t.charAt(i) == 'B') {
if(i <= firstA) {
System.out.println(-1);
return;
}
else {
if(stockB > 0) {
stockB--;
}
else {
result++;
stockA++;
}
// resultB++;
}
}
}
System.out.println(result);
}
}
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
String t = sc.next();
int firstA = n;
int lastB = -1;
for(int i = 0; i < n; i++) {
char c = t.charAt(i);
if(c == 'A') {
firstA = Math.min(firstA, i);
}
else {
lastB = Math.max(lastB, i);
}
}
Deque<Integer> queA = new ArrayDeque<Integer>();
Deque<Integer> queB = new ArrayDeque<Integer>();
int stockA = 0;
int stockB = 0;
int resultA = 0;
int resultB = 0;
int result = 0;
for(int i = 0; i < n; i++) {
if(s.charAt(i) == 'B' && t.charAt(i) == 'A') {
if(i >= lastB) {
// System.out.println("i = " + i);
System.out.println(-1);
return;
}
else {
if(stockA > 0) {
stockA--;
}
else {
result++;
stockB++;
}
// resultA++;
// stockB++;
}
}
if(s.charAt(i) == 'A' && t.charAt(i) == 'B') {
if(i <= firstA) {
System.out.println(-1);
return;
}
else {
if(stockB > 0) {
stockB--;
}
else {
result++;
// stockA++;
}
// resultB++;
}
}
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/arc170_a/Java/49641651 |
condefects-java_data_134 | import java.util.ArrayList;
import java.util.List;
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+1];
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
}
int[] b = new int[n+1];
int j = 1;
int k = 1;
while(b[j]==0) {
b[j] = k;
k++;
j = a[j];
}
int j2 = k-b[j];
List<Integer> list = new ArrayList<>();
for (int i = 0; i < j2; i++) {
list.add(j);
j=a[j];
}
System.out.println(k-1);
for (Integer i : list) {
System.out.print(i + " ");
}
}
}
import java.util.ArrayList;
import java.util.List;
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+1];
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
}
int[] b = new int[n+1];
int j = 1;
int k = 1;
while(b[j]==0) {
b[j] = k;
k++;
j = a[j];
}
int j2 = k-b[j];
List<Integer> list = new ArrayList<>();
for (int i = 0; i < j2; i++) {
list.add(j);
j=a[j];
}
System.out.println(j2);
for (Integer i : list) {
System.out.print(i + " ");
}
}
}
| ConDefects/ConDefects/Code/abc311_c/Java/44146044 |
condefects-java_data_135 | import java.util.*;
import java.io.*;
public class Main
{
static int start=0;
static int end=0;
static HashMap<Integer,Integer> map=new HashMap<>();
public static boolean cyclic(ArrayList<ArrayList<Integer>> arr,int src,int v[],int sv[])
{
v[src]=1;
sv[src]=1;
boolean flag1=false;
for(Integer dep:arr.get(src))
{
if(v[dep]==1)
{
if(sv[dep]==1)
{
start=dep;
end=src;
flag1=true;
}
}
else
{
map.put(dep,src);
flag1|=cyclic(arr,dep,v,sv);
}
}
sv[src]=0;
return flag1;
}
public static void process()throws IOException
{
int n=I();
int a[]=Ai(n);
ArrayList<ArrayList<Integer>> arr=new ArrayList<>();
for(int i=0;i<=n;i++)
{
arr.add(new ArrayList<Integer>());
}
for(int i=0;i<n;i++)
{
arr.get(i+1).add(a[i]);
}
int v[]=new int[n+1];
int sv[]=new int[n+1];
boolean flag=true;
for(int i=1;i<=n;i++)
{
if(cyclic(arr,i,v,sv))
{
flag=false;
break;
}
}
ArrayList<Integer> res=new ArrayList<Integer>();
if(!flag)
{
while(end!=start)
{
res.add(end);
end=map.get(end);
}
}
res.add(start);
for(int i=0;i<res.size();i++)
{
p(res.get(i)+" ");
}
pn("");
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static void sort(char[] a) {
int n = a.length;
Random r = new Random();
for (int i = 0; i < a.length; i++) {
int oi = r.nextInt(n);
char temp = a[i];
a[i] = a[oi];
a[oi] = temp;
}
Arrays.sort(a);
}
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static void pn(Object o){out.println(o);out.flush();}
static void p(Object o){out.print(o);out.flush();}
static void pni(Object o){out.println(o);System.out.flush();}
static int I() throws IOException{return sc.nextInt();}
static long L() throws IOException{return sc.nextLong();}
static double D() throws IOException{return sc.nextDouble();}
static String S() throws IOException{return sc.next();}
static char C() throws IOException{return sc.next().charAt(0);}
static int[] Ai(int n) throws IOException{int[] arr = new int[n];for (int i = 0; i < n; i++)arr[i] = I();return arr;}
static String[] As(int n) throws IOException{String s[] = new String[n];for (int i = 0; i < n; i++)s[i] = S();return s;}
static long[] Al(int n) throws IOException {long[] arr = new long[n];for (int i = 0; i < n; i++)arr[i] = L();return arr;}
static void dyn(int dp[][],int n,int m,int z)throws IOException {for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ dp[i][j]=z;}} }
// *--------------------------------------------------------------------------------------------------------------------------------*//
public static void main(String[] args)throws IOException{try{boolean oj=true;if(oj==true)
{PrintWriter out=new PrintWriter(System.out);}
else
{out=new PrintWriter("output.txt");}
{long startTime = System.currentTimeMillis();
process();
long endTime = System.currentTimeMillis();
}out.flush();out.close();}catch(Exception e){return;}}}
//*-----------------------------------------------------------------------------------------------------------------------------------
import java.util.*;
import java.io.*;
public class Main
{
static int start=0;
static int end=0;
static HashMap<Integer,Integer> map=new HashMap<>();
public static boolean cyclic(ArrayList<ArrayList<Integer>> arr,int src,int v[],int sv[])
{
v[src]=1;
sv[src]=1;
boolean flag1=false;
for(Integer dep:arr.get(src))
{
if(v[dep]==1)
{
if(sv[dep]==1)
{
start=dep;
end=src;
flag1=true;
}
}
else
{
map.put(dep,src);
flag1|=cyclic(arr,dep,v,sv);
}
}
sv[src]=0;
return flag1;
}
public static void process()throws IOException
{
int n=I();
int a[]=Ai(n);
ArrayList<ArrayList<Integer>> arr=new ArrayList<>();
for(int i=0;i<=n;i++)
{
arr.add(new ArrayList<Integer>());
}
for(int i=0;i<n;i++)
{
arr.get(i+1).add(a[i]);
}
int v[]=new int[n+1];
int sv[]=new int[n+1];
boolean flag=true;
for(int i=1;i<=n;i++)
{
if(cyclic(arr,i,v,sv))
{
flag=false;
break;
}
}
ArrayList<Integer> res=new ArrayList<Integer>();
if(!flag)
{
while(end!=start)
{
res.add(end);
end=map.get(end);
}
}
res.add(start);
Collections.reverse(res);
pn(res.size());
for(int i=0;i<res.size();i++)
{
p(res.get(i)+" ");
}
pn("");
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static void sort(char[] a) {
int n = a.length;
Random r = new Random();
for (int i = 0; i < a.length; i++) {
int oi = r.nextInt(n);
char temp = a[i];
a[i] = a[oi];
a[oi] = temp;
}
Arrays.sort(a);
}
static FastReader sc = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static void pn(Object o){out.println(o);out.flush();}
static void p(Object o){out.print(o);out.flush();}
static void pni(Object o){out.println(o);System.out.flush();}
static int I() throws IOException{return sc.nextInt();}
static long L() throws IOException{return sc.nextLong();}
static double D() throws IOException{return sc.nextDouble();}
static String S() throws IOException{return sc.next();}
static char C() throws IOException{return sc.next().charAt(0);}
static int[] Ai(int n) throws IOException{int[] arr = new int[n];for (int i = 0; i < n; i++)arr[i] = I();return arr;}
static String[] As(int n) throws IOException{String s[] = new String[n];for (int i = 0; i < n; i++)s[i] = S();return s;}
static long[] Al(int n) throws IOException {long[] arr = new long[n];for (int i = 0; i < n; i++)arr[i] = L();return arr;}
static void dyn(int dp[][],int n,int m,int z)throws IOException {for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ dp[i][j]=z;}} }
// *--------------------------------------------------------------------------------------------------------------------------------*//
public static void main(String[] args)throws IOException{try{boolean oj=true;if(oj==true)
{PrintWriter out=new PrintWriter(System.out);}
else
{out=new PrintWriter("output.txt");}
{long startTime = System.currentTimeMillis();
process();
long endTime = System.currentTimeMillis();
}out.flush();out.close();}catch(Exception e){return;}}}
//*----------------------------------------------------------------------------------------------------------------------------------- | ConDefects/ConDefects/Code/abc311_c/Java/44091406 |
condefects-java_data_136 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.Scanner;
public class Main {
static final Scanner sc = new Scanner(System.in);
static int N;
static int[] A;
static HashMap<Integer,Integer> history;
static ArrayList<Integer> way;
public static void main(String[] args) {
N = inputInt();
A = new int[N];
way = new ArrayList<>();
history = new HashMap<>();
for (int i = 0; i < N; i++) {
A[i] = inputInt() - 1;
//println(A[i]);
}
for (int i = 0; i < N; i++) {
if(history.containsKey(i)) {
way.clear();
way.add(i);
search(i,0);
}
}
}
private static void search(int now,int index) {
// TODO 自動生成されたメソッド・スタブ
int next = A[now];
//println(next);
if (!history.containsKey(next)) {
way.add(next);
history.put(next,index);
index++;
search(next,index);
} else {
int start = history.get(next)+1;
println(way.size()-start);
for(int i=start;i<way.size();i++) {
print((way.get(i)+1)+" ");
}
// ln();
// for(int i=0;i<way.size();i++) {
// print((way.get(i)+1)+" ");
// }
System.exit(0);
}
}
public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(HashMap<K, V> map, boolean ascending) {
List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
if (ascending) {
quickSortAscending(list, 0, list.size() - 1);
} else {
quickSortDescending(list, 0, list.size() - 1);
}
Map<K, V> sortedMap = new LinkedHashMap<>();
for (Map.Entry<K, V> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
private static <K extends Comparable<? super K>, V> void quickSortAscending(List<Map.Entry<K, V>> list, int low,
int high) {
if (low < high) {
int pivotIndex = partitionAscending(list, low, high);
quickSortAscending(list, low, pivotIndex - 1);
quickSortAscending(list, pivotIndex + 1, high);
}
}
private static <K extends Comparable<? super K>, V> int partitionAscending(List<Map.Entry<K, V>> list, int low,
int high) {
Map.Entry<K, V> pivot = list.get(high);
int i = low - 1;
for (int j = low; j < high; j++) {
if (list.get(j).getKey().compareTo(pivot.getKey()) <= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, high);
return i + 1;
}
private static <K extends Comparable<? super K>, V> void quickSortDescending(List<Map.Entry<K, V>> list, int low,
int high) {
if (low < high) {
int pivotIndex = partitionDescending(list, low, high);
quickSortDescending(list, low, pivotIndex - 1);
quickSortDescending(list, pivotIndex + 1, high);
}
}
private static <K extends Comparable<? super K>, V> int partitionDescending(List<Map.Entry<K, V>> list, int low,
int high) {
Map.Entry<K, V> pivot = list.get(high);
int i = low - 1;
for (int j = low; j < high; j++) {
if (list.get(j).getKey().compareTo(pivot.getKey()) >= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, high);
return i + 1;
}
private static int dfs(int N, int T, int M, ArrayList<Integer> hate, ArrayList<Integer> teams, int now) {
// TODO 自動生成されたメソッド・スタブ
if (now == N)
return teams.size() == T ? 1 : 0;
int ans = 0;
for (int i = 0; i < teams.size(); i++) {
int team = teams.get(i);
if ((team & hate.get(now)) == 0) {
teams.set(i, team | (1 << now));
ans += dfs(N, T, M, hate, teams, now + 1);
teams.set(i, team);
}
}
if (teams.size() < T) {
teams.add(1 << now);
ans += dfs(N, T, M, hate, teams, now + 1);
teams.remove(teams.size() - 1);
}
return ans;
}
public static int nand(int a, int b) {
if (a == 1 && b == 1) {
return 0;
} else {
return 1;
}
}
private static void printMinus() {
System.out.print(-1);
}
/**
* 幅優先探索でnowから最も離れたノードまでの経路数を返す
* @param graph
* @param now
* @return
*/
private static int bfs(HashMap<Integer, ArrayList<Integer>> graph, int now) {
// TODO 自動生成されたメソッド・スタブ
HashMap<Integer, Integer> history = new HashMap<>();
Queue<Integer> q = new LinkedList<>();
q.add(now);
history.put(now, 0);
while (q.size() > 0) {
int x = q.poll();
for (int i = 0; i < graph.get(x).size(); i++) {
int y = graph.get(x).get(i);
if (!history.containsKey(y)) {
history.put(y, history.get(x) + 1);
q.add(y);
}
}
}
Collection<Integer> values = history.values();
return Collections.max(values);
}
public static class MinHeap<T extends Comparable<T>> {
private T[] heap;
private int size;
private int capacity;
public MinHeap(int capacity) {
this.capacity = capacity;
this.size = 0;
this.heap = (T[]) new Comparable[capacity];
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void insert(T value) {
if (size == capacity) {
throw new IllegalStateException("Heap is full");
}
// 新しい要素を末尾に追加
heap[size] = value;
size++;
// ヒープを再構築
heapifyUp(size - 1);
}
/**
* 最小値を取り出す
* @return
*/
public T get() {
if (isEmpty()) {
throw new IllegalStateException("Heap is empty");
}
T minValue = heap[0];
heap[0] = heap[size - 1];
size--;
// ヒープを再構築
heapifyDown(0);
return minValue;
}
private void heapifyUp(int index) {
int parentIndex = (index - 1) / 2;
if (index > 0 && heap[index].compareTo(heap[parentIndex]) < 0) {
swap(index, parentIndex);
heapifyUp(parentIndex);
}
}
private void heapifyDown(int index) {
int leftChildIndex = 2 * index + 1;
int rightChildIndex = 2 * index + 2;
int smallestIndex = index;
if (leftChildIndex < size && heap[leftChildIndex].compareTo(heap[smallestIndex]) < 0) {
smallestIndex = leftChildIndex;
}
if (rightChildIndex < size && heap[rightChildIndex].compareTo(heap[smallestIndex]) < 0) {
smallestIndex = rightChildIndex;
}
if (smallestIndex != index) {
swap(index, smallestIndex);
heapifyDown(smallestIndex);
}
}
private void swap(int i, int j) {
T temp = heap[i];
heap[i] = heap[j];
heap[j] = temp;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(heap, size));
}
}
public static class Tuple<A extends Comparable<A>, B extends Comparable<B>> implements Comparable<Tuple<A, B>> {
private A first;
private B second;
public Tuple(A first, B second) {
this.first = first;
this.second = second;
}
public A getFirst() {
return first;
}
public B getSecond() {
return second;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Tuple<?, ?> tuple = (Tuple<?, ?>) o;
return Objects.equals(first, tuple.first) && Objects.equals(second, tuple.second);
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public int compareTo(Tuple<A, B> other) {
if (first.compareTo(other.getFirst()) != 0) {
return first.compareTo(other.getFirst());
}
return second.toString().compareTo(other.getSecond().toString());
}
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
}
public static <T extends Comparable<T>> void sort(List<T> list, boolean isQuick) {
if (isQuick) {
quickSort(list);
} else {
mergeSort(list, 0, list.size() - 1);
}
}
public static <T extends Comparable<T>> void quickSort(List<T> list) {
quickSortHelper(list, 0, list.size() - 1);
}
private static <T extends Comparable<T>> void quickSortHelper(List<T> list, int left, int right) {
if (left < right) {
int pivotIndex = partition(list, left, right);
quickSortHelper(list, left, pivotIndex - 1);
quickSortHelper(list, pivotIndex + 1, right);
}
}
private static <T extends Comparable<T>> int partition(List<T> list, int left, int right) {
T pivot = list.get(right);
int i = left - 1;
for (int j = left; j < right; j++) {
if (list.get(j).compareTo(pivot) <= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, right);
return i + 1;
}
private static <T> void swap(List<T> list, int i, int j) {
T temp = list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
}
public static <T extends Comparable<T>> void mergeSort(List<T> list, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(list, left, mid);
mergeSort(list, mid + 1, right);
merge(list, left, mid, right);
}
}
public static <T extends Comparable<T>> void merge(List<T> list, int left, int mid, int right) {
List<T> leftList = new ArrayList<>();
List<T> rightList = new ArrayList<>();
for (int i = left; i <= mid; i++) {
leftList.add(list.get(i));
}
for (int j = mid + 1; j <= right; j++) {
rightList.add(list.get(j));
}
int i = 0, j = 0;
int k = left;
while (i < leftList.size() && j < rightList.size()) {
if (leftList.get(i).compareTo(rightList.get(j)) <= 0) {
list.set(k, leftList.get(i));
i++;
} else {
list.set(k, rightList.get(j));
j++;
}
k++;
}
while (i < leftList.size()) {
list.set(k, leftList.get(i));
i++;
k++;
}
while (j < rightList.size()) {
list.set(k, rightList.get(j));
j++;
k++;
}
}
public static void sort(int[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void sort(double[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void sort(long[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static void quickSort(double[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static void quickSort(long[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static int partition(double[] arr, int low, int high) {
double pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static int partition(long[] arr, int low, int high) {
long pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(double[] arr, int i, int j) {
double temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(long[] arr, int i, int j) {
long temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void printArray(double[] arr) {
for (double num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void printArray(long[] arr) {
for (long num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void mergeSort(double[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void mergeSort(long[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void merge(int[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int[] leftArray = new int[n1];
int[] rightArray = new int[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static void merge(double[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
double[] leftArray = new double[n1];
double[] rightArray = new double[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static void merge(long[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
long[] leftArray = new long[n1];
long[] rightArray = new long[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static int inputInt() {
return sc.nextInt();
}
public static double inputDouble() {
return sc.nextDouble();
}
public static long inputLong() {
return sc.nextLong();
}
private static String[] inputString(int N) {
String[] s = new String[N];
for (int i = 0; i < N; i++) {
s[i] = sc.next();
}
return s;
}
private static char[] inputChar() {
return sc.next().toCharArray();
}
public static void yesEnd() {
printYes();
System.exit(0);
}
public static void noEnd() {
printNo();
System.exit(0);
}
public static HashMap<Integer, ArrayList<Integer>> inputGraph(int N, int M) {
HashMap<Integer, ArrayList<Integer>> graph = new HashMap<>();
for (int i = 0; i < N; i++) {
graph.put(i + 1, new ArrayList<>());
}
for (int i = 0; i < M; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
graph.get(a).add(b);
graph.get(b).add(a);
}
return graph;
}
static class UnionFind {
private int[] parents;
// N+1で代入すること
public UnionFind(int n) {
parents = new int[n];
Arrays.fill(parents, -1);
}
/**
* グラフの根を探すメソッド
*
* @param x 根を探したいノード
* @return 根のノード
*/
public int find(int x) {
if (parents[x] < 0) {
return x;
} else {
parents[x] = find(parents[x]);
return parents[x];
}
}
/**
* ノードとノードを合体するメソッド
*
* @param x 合体したいノード
* @param y 合体したいノード
*/
public void union(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
parents[x] += parents[y];
parents[y] = x;
}
/**
* xを含むノードのサイズを返すメソッド
*
* @param x サイズを測定したいグラフのノード
* @return xを含むノードのサイズ
*/
public int size(int x) {
return -parents[find(x)];
}
/**
* xとyが同じグラフに属しているか判定するメソッド
*
* @param x
* @param y
* @return
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* xのグラフのメンバーを返すメソッド
*
* @param x
* @return
*/
public List<Integer> getMembers(int x) {
int root = find(x);
List<Integer> members = new ArrayList<>();
for (int i = 0; i < parents.length; i++) {
if (find(i) == root) {
members.add(i);
}
}
return members;
}
/**
* ルートの集合を返すメソッド
*
* @return
*/
public List<Integer> getRoots() {
List<Integer> roots = new ArrayList<>();
for (int i = 0; i < parents.length; i++) {
if (parents[i] < 0) {
roots.add(i);
}
}
return roots;
}
/**
* グラフ数を返すメソッド
*
* @return
*/
public int groupCount() {
return getRoots().size();
}
/**
* 全てのグラフを返すメソッド
*
* @return
*/
public Map<Integer, List<Integer>> allGroupMembers() {
Map<Integer, List<Integer>> groupMembers = new HashMap<>();
for (int member = 0; member < parents.length; member++) {
int root = find(member);
if (!groupMembers.containsKey(root)) {
groupMembers.put(root, new ArrayList<>());
}
groupMembers.get(root).add(member);
}
return groupMembers;
}
}
public static int[] inputInt(int N) {
int[] a = new int[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
return a;
}
public static double[] inputDouble(int N) {
double[] a = new double[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextDouble();
}
return a;
}
public static long[] inputLong(int N) {
long[] a = new long[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextLong();
}
return a;
}
public static void print(int i) {
System.out.print(i);
}
public static void println(int i) {
System.out.println(i);
}
public static void print(double i) {
System.out.print(i);
}
public static void println(double i) {
System.out.println(i);
}
public static void print(boolean i) {
System.out.print(i);
}
public static void println(boolean i) {
System.out.println(i);
}
public static void print(char i) {
System.out.print(i);
}
public static void println(char i) {
System.out.println(i);
}
public static void print(long i) {
System.out.print(i);
}
public static void println(long i) {
System.out.println(i);
}
public static void print(String i) {
System.out.print(i);
}
public static void println(String i) {
System.out.println(i);
}
public static void ln() {
System.out.println();
}
public static void printYes() {
System.out.println("Yes");
}
public static void printNo() {
System.out.println("No");
}
public static void judge(boolean flag) {
if (flag) {
printYes();
} else {
printNo();
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.Scanner;
public class Main {
static final Scanner sc = new Scanner(System.in);
static int N;
static int[] A;
static HashMap<Integer,Integer> history;
static ArrayList<Integer> way;
public static void main(String[] args) {
N = inputInt();
A = new int[N];
way = new ArrayList<>();
history = new HashMap<>();
for (int i = 0; i < N; i++) {
A[i] = inputInt() - 1;
//println(A[i]);
}
for (int i = 0; i < N; i++) {
if(!history.containsKey(i)) {
way.clear();
way.add(i);
search(i,0);
}
}
}
private static void search(int now,int index) {
// TODO 自動生成されたメソッド・スタブ
int next = A[now];
//println(next);
if (!history.containsKey(next)) {
way.add(next);
history.put(next,index);
index++;
search(next,index);
} else {
int start = history.get(next)+1;
println(way.size()-start);
for(int i=start;i<way.size();i++) {
print((way.get(i)+1)+" ");
}
// ln();
// for(int i=0;i<way.size();i++) {
// print((way.get(i)+1)+" ");
// }
System.exit(0);
}
}
public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(HashMap<K, V> map, boolean ascending) {
List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
if (ascending) {
quickSortAscending(list, 0, list.size() - 1);
} else {
quickSortDescending(list, 0, list.size() - 1);
}
Map<K, V> sortedMap = new LinkedHashMap<>();
for (Map.Entry<K, V> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
private static <K extends Comparable<? super K>, V> void quickSortAscending(List<Map.Entry<K, V>> list, int low,
int high) {
if (low < high) {
int pivotIndex = partitionAscending(list, low, high);
quickSortAscending(list, low, pivotIndex - 1);
quickSortAscending(list, pivotIndex + 1, high);
}
}
private static <K extends Comparable<? super K>, V> int partitionAscending(List<Map.Entry<K, V>> list, int low,
int high) {
Map.Entry<K, V> pivot = list.get(high);
int i = low - 1;
for (int j = low; j < high; j++) {
if (list.get(j).getKey().compareTo(pivot.getKey()) <= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, high);
return i + 1;
}
private static <K extends Comparable<? super K>, V> void quickSortDescending(List<Map.Entry<K, V>> list, int low,
int high) {
if (low < high) {
int pivotIndex = partitionDescending(list, low, high);
quickSortDescending(list, low, pivotIndex - 1);
quickSortDescending(list, pivotIndex + 1, high);
}
}
private static <K extends Comparable<? super K>, V> int partitionDescending(List<Map.Entry<K, V>> list, int low,
int high) {
Map.Entry<K, V> pivot = list.get(high);
int i = low - 1;
for (int j = low; j < high; j++) {
if (list.get(j).getKey().compareTo(pivot.getKey()) >= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, high);
return i + 1;
}
private static int dfs(int N, int T, int M, ArrayList<Integer> hate, ArrayList<Integer> teams, int now) {
// TODO 自動生成されたメソッド・スタブ
if (now == N)
return teams.size() == T ? 1 : 0;
int ans = 0;
for (int i = 0; i < teams.size(); i++) {
int team = teams.get(i);
if ((team & hate.get(now)) == 0) {
teams.set(i, team | (1 << now));
ans += dfs(N, T, M, hate, teams, now + 1);
teams.set(i, team);
}
}
if (teams.size() < T) {
teams.add(1 << now);
ans += dfs(N, T, M, hate, teams, now + 1);
teams.remove(teams.size() - 1);
}
return ans;
}
public static int nand(int a, int b) {
if (a == 1 && b == 1) {
return 0;
} else {
return 1;
}
}
private static void printMinus() {
System.out.print(-1);
}
/**
* 幅優先探索でnowから最も離れたノードまでの経路数を返す
* @param graph
* @param now
* @return
*/
private static int bfs(HashMap<Integer, ArrayList<Integer>> graph, int now) {
// TODO 自動生成されたメソッド・スタブ
HashMap<Integer, Integer> history = new HashMap<>();
Queue<Integer> q = new LinkedList<>();
q.add(now);
history.put(now, 0);
while (q.size() > 0) {
int x = q.poll();
for (int i = 0; i < graph.get(x).size(); i++) {
int y = graph.get(x).get(i);
if (!history.containsKey(y)) {
history.put(y, history.get(x) + 1);
q.add(y);
}
}
}
Collection<Integer> values = history.values();
return Collections.max(values);
}
public static class MinHeap<T extends Comparable<T>> {
private T[] heap;
private int size;
private int capacity;
public MinHeap(int capacity) {
this.capacity = capacity;
this.size = 0;
this.heap = (T[]) new Comparable[capacity];
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void insert(T value) {
if (size == capacity) {
throw new IllegalStateException("Heap is full");
}
// 新しい要素を末尾に追加
heap[size] = value;
size++;
// ヒープを再構築
heapifyUp(size - 1);
}
/**
* 最小値を取り出す
* @return
*/
public T get() {
if (isEmpty()) {
throw new IllegalStateException("Heap is empty");
}
T minValue = heap[0];
heap[0] = heap[size - 1];
size--;
// ヒープを再構築
heapifyDown(0);
return minValue;
}
private void heapifyUp(int index) {
int parentIndex = (index - 1) / 2;
if (index > 0 && heap[index].compareTo(heap[parentIndex]) < 0) {
swap(index, parentIndex);
heapifyUp(parentIndex);
}
}
private void heapifyDown(int index) {
int leftChildIndex = 2 * index + 1;
int rightChildIndex = 2 * index + 2;
int smallestIndex = index;
if (leftChildIndex < size && heap[leftChildIndex].compareTo(heap[smallestIndex]) < 0) {
smallestIndex = leftChildIndex;
}
if (rightChildIndex < size && heap[rightChildIndex].compareTo(heap[smallestIndex]) < 0) {
smallestIndex = rightChildIndex;
}
if (smallestIndex != index) {
swap(index, smallestIndex);
heapifyDown(smallestIndex);
}
}
private void swap(int i, int j) {
T temp = heap[i];
heap[i] = heap[j];
heap[j] = temp;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(heap, size));
}
}
public static class Tuple<A extends Comparable<A>, B extends Comparable<B>> implements Comparable<Tuple<A, B>> {
private A first;
private B second;
public Tuple(A first, B second) {
this.first = first;
this.second = second;
}
public A getFirst() {
return first;
}
public B getSecond() {
return second;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Tuple<?, ?> tuple = (Tuple<?, ?>) o;
return Objects.equals(first, tuple.first) && Objects.equals(second, tuple.second);
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public int compareTo(Tuple<A, B> other) {
if (first.compareTo(other.getFirst()) != 0) {
return first.compareTo(other.getFirst());
}
return second.toString().compareTo(other.getSecond().toString());
}
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
}
public static <T extends Comparable<T>> void sort(List<T> list, boolean isQuick) {
if (isQuick) {
quickSort(list);
} else {
mergeSort(list, 0, list.size() - 1);
}
}
public static <T extends Comparable<T>> void quickSort(List<T> list) {
quickSortHelper(list, 0, list.size() - 1);
}
private static <T extends Comparable<T>> void quickSortHelper(List<T> list, int left, int right) {
if (left < right) {
int pivotIndex = partition(list, left, right);
quickSortHelper(list, left, pivotIndex - 1);
quickSortHelper(list, pivotIndex + 1, right);
}
}
private static <T extends Comparable<T>> int partition(List<T> list, int left, int right) {
T pivot = list.get(right);
int i = left - 1;
for (int j = left; j < right; j++) {
if (list.get(j).compareTo(pivot) <= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, right);
return i + 1;
}
private static <T> void swap(List<T> list, int i, int j) {
T temp = list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
}
public static <T extends Comparable<T>> void mergeSort(List<T> list, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(list, left, mid);
mergeSort(list, mid + 1, right);
merge(list, left, mid, right);
}
}
public static <T extends Comparable<T>> void merge(List<T> list, int left, int mid, int right) {
List<T> leftList = new ArrayList<>();
List<T> rightList = new ArrayList<>();
for (int i = left; i <= mid; i++) {
leftList.add(list.get(i));
}
for (int j = mid + 1; j <= right; j++) {
rightList.add(list.get(j));
}
int i = 0, j = 0;
int k = left;
while (i < leftList.size() && j < rightList.size()) {
if (leftList.get(i).compareTo(rightList.get(j)) <= 0) {
list.set(k, leftList.get(i));
i++;
} else {
list.set(k, rightList.get(j));
j++;
}
k++;
}
while (i < leftList.size()) {
list.set(k, leftList.get(i));
i++;
k++;
}
while (j < rightList.size()) {
list.set(k, rightList.get(j));
j++;
k++;
}
}
public static void sort(int[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void sort(double[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void sort(long[] array, boolean isQuick) {
if (isQuick) {
quickSort(array, 0, array.length - 1);
} else {
mergeSort(array, 0, array.length - 1);
}
}
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static void quickSort(double[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static void quickSort(long[] arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
public static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static int partition(double[] arr, int low, int high) {
double pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static int partition(long[] arr, int low, int high) {
long pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return i + 1;
}
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(double[] arr, int i, int j) {
double temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(long[] arr, int i, int j) {
long temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void printArray(double[] arr) {
for (double num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void printArray(long[] arr) {
for (long num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void mergeSort(double[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void mergeSort(long[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
public static void merge(int[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int[] leftArray = new int[n1];
int[] rightArray = new int[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static void merge(double[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
double[] leftArray = new double[n1];
double[] rightArray = new double[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static void merge(long[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
long[] leftArray = new long[n1];
long[] rightArray = new long[n2];
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public static int inputInt() {
return sc.nextInt();
}
public static double inputDouble() {
return sc.nextDouble();
}
public static long inputLong() {
return sc.nextLong();
}
private static String[] inputString(int N) {
String[] s = new String[N];
for (int i = 0; i < N; i++) {
s[i] = sc.next();
}
return s;
}
private static char[] inputChar() {
return sc.next().toCharArray();
}
public static void yesEnd() {
printYes();
System.exit(0);
}
public static void noEnd() {
printNo();
System.exit(0);
}
public static HashMap<Integer, ArrayList<Integer>> inputGraph(int N, int M) {
HashMap<Integer, ArrayList<Integer>> graph = new HashMap<>();
for (int i = 0; i < N; i++) {
graph.put(i + 1, new ArrayList<>());
}
for (int i = 0; i < M; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
graph.get(a).add(b);
graph.get(b).add(a);
}
return graph;
}
static class UnionFind {
private int[] parents;
// N+1で代入すること
public UnionFind(int n) {
parents = new int[n];
Arrays.fill(parents, -1);
}
/**
* グラフの根を探すメソッド
*
* @param x 根を探したいノード
* @return 根のノード
*/
public int find(int x) {
if (parents[x] < 0) {
return x;
} else {
parents[x] = find(parents[x]);
return parents[x];
}
}
/**
* ノードとノードを合体するメソッド
*
* @param x 合体したいノード
* @param y 合体したいノード
*/
public void union(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
parents[x] += parents[y];
parents[y] = x;
}
/**
* xを含むノードのサイズを返すメソッド
*
* @param x サイズを測定したいグラフのノード
* @return xを含むノードのサイズ
*/
public int size(int x) {
return -parents[find(x)];
}
/**
* xとyが同じグラフに属しているか判定するメソッド
*
* @param x
* @param y
* @return
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* xのグラフのメンバーを返すメソッド
*
* @param x
* @return
*/
public List<Integer> getMembers(int x) {
int root = find(x);
List<Integer> members = new ArrayList<>();
for (int i = 0; i < parents.length; i++) {
if (find(i) == root) {
members.add(i);
}
}
return members;
}
/**
* ルートの集合を返すメソッド
*
* @return
*/
public List<Integer> getRoots() {
List<Integer> roots = new ArrayList<>();
for (int i = 0; i < parents.length; i++) {
if (parents[i] < 0) {
roots.add(i);
}
}
return roots;
}
/**
* グラフ数を返すメソッド
*
* @return
*/
public int groupCount() {
return getRoots().size();
}
/**
* 全てのグラフを返すメソッド
*
* @return
*/
public Map<Integer, List<Integer>> allGroupMembers() {
Map<Integer, List<Integer>> groupMembers = new HashMap<>();
for (int member = 0; member < parents.length; member++) {
int root = find(member);
if (!groupMembers.containsKey(root)) {
groupMembers.put(root, new ArrayList<>());
}
groupMembers.get(root).add(member);
}
return groupMembers;
}
}
public static int[] inputInt(int N) {
int[] a = new int[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
return a;
}
public static double[] inputDouble(int N) {
double[] a = new double[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextDouble();
}
return a;
}
public static long[] inputLong(int N) {
long[] a = new long[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextLong();
}
return a;
}
public static void print(int i) {
System.out.print(i);
}
public static void println(int i) {
System.out.println(i);
}
public static void print(double i) {
System.out.print(i);
}
public static void println(double i) {
System.out.println(i);
}
public static void print(boolean i) {
System.out.print(i);
}
public static void println(boolean i) {
System.out.println(i);
}
public static void print(char i) {
System.out.print(i);
}
public static void println(char i) {
System.out.println(i);
}
public static void print(long i) {
System.out.print(i);
}
public static void println(long i) {
System.out.println(i);
}
public static void print(String i) {
System.out.print(i);
}
public static void println(String i) {
System.out.println(i);
}
public static void ln() {
System.out.println();
}
public static void printYes() {
System.out.println("Yes");
}
public static void printNo() {
System.out.println("No");
}
public static void judge(boolean flag) {
if (flag) {
printYes();
} else {
printNo();
}
}
}
| ConDefects/ConDefects/Code/abc311_c/Java/44022436 |
condefects-java_data_137 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = false;
public Object solve(){
int N = in.it();
String[] SS = in.str(N);
a:for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++) {
if (i == j)
continue;
if (SS[i].contains(SS[j])) {
SS[j] = SS[N -1];
N--;
i--;
continue a;
}
}
char[][] S = new char[N][];
for (int i = 0;i < N;i++)
S[i] = SS[i].toCharArray();
RollingHash[] rhs = new RollingHash[N];
for (int i = 0;i < N;i++)
rhs[i] = new RollingHash(S[i],false);
int[][] E = new int[N][N];
for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++)
for (int l = 1;l <= min(S[i].length,S[j].length);l++)
if (rhs[i].get(S[i].length -l,S[i].length) == rhs[j].get(0,l))
E[i][j] = l;
long[][] dp = new long[1 <<N][N];
for (int bit = 0;bit < 1 <<N;bit++)
for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++) {
if ((bit >>i &1) == 0 || (bit >>j &1) == 1)
continue;
dp[bit |1 <<j][j] = max(dp[bit |1 <<j][j],dp[bit][i] +E[i][j]);
}
long sum = 0;
for (var s:S)
sum += s.length;
long ans = infL;
for (int i = 0;i < N;i++)
ans = min(ans,sum -dp[(1 <<N) -1][i]);
return ans;
}
<T extends BaseV> void log(Seg<T, ?> seg,int n){
T[] a = (T[]) new BaseV[n];
for (int i = 0;i < n;i++)
a[i] = seg.get(i);
log.println(a);
}
long min(long... a){
long ret = a[0];
for (var aa:a)
ret = Math.min(ret,aa);
return ret;
}
long max(long... a){
long ret = a[0];
for (var aa:a)
ret = Math.max(ret,aa);
return ret;
}
private long hash(int[] A){
long ret = 0;
for (var a:A) {
ret = Mul(ret,972029) +a;
if (ret >= MOD)
ret -= MOD;
}
return ret;
}
final static long MASK30 = (1L <<30) -1;
final static long MASK31 = (1L <<31) -1;
final static long MOD = (1L <<61) -1;
private static long Mul(final long l,final long r){
final long lu = l >>31;
final long ld = l &MASK31;
final long ru = r >>31;
final long rd = r &MASK31;
final long middleBit = ld *ru +lu *rd;
return (lu *ru <<1) +ld *rd +((middleBit &MASK30) <<31) +(middleBit >>30);
}
}
class Data extends BaseV{
long[][] arr;
public Data(){ arr = new long[2][2]; }
public Data(int v){
this();
arr[0][0] = v;
arr[0][1] = 1;
}
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e(),t = e();
private Node root;
public AVLSegmentTree(int n){ root = new Node(e(),n); }
public AVLSegmentTree(){}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int i,int n,IntFunction<V> init){
if (n < 2)
return n < 1 ? null : new Node(init.apply(i),1);
var ret = new Node(e(),n);
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
return ret.merge();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.leaf && (i == 0 || i == nd.sz)) {
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
return nd.merge();
}
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.cld(-1,ins(nd.lft,i,v,k));
else
nd.cld(1,ins(nd.rht,i -nd.lft.sz,v,k));
return balance(nd);
}
public V del(int i){
var ret = e();
root = del(ret,root,i);
return ret;
}
private Node del(V ret,Node nd,int i){
if (nd.leaf) {
nd.sz--;
ag(ret,e,nd.val);
return 0 < nd.sz ? nd : null;
}
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(ret,nd.lft,i) : del(ret,nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (l == r)
return;
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
return nd.prop(f);
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.cld(-1,upd(nd.lft,l,min(nd.lft.sz,r),f));
if (nd.lft.sz < r)
nd.cld(1,upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f));
return balance(nd);
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
return merge(nd.lft,nd,toggle(nd.rht,0,r -l));
}
if (r < nd.sz) {
split(nd,r);
return merge(toggle(nd.lft,l,r),nd,nd.rht);
}
return nd.toggle();
}
private void split(Node nd,int i){
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
if (i < nd.lft.sz) {
split(nd.lft,i);
var lft = nd.lft;
nd.cld(-1,lft.lft);
nd.cld(1,merge(lft.rht,lft,nd.rht));
} else if (nd.lft.sz < i) {
split(nd.rht,i -nd.lft.sz);
var rht = nd.rht;
nd.cld(1,rht.rht);
nd.cld(-1,merge(nd.lft,rht,rht.lft));
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.cld(-1,lft);
nd.cld(1,rht);
} else if (lft.rnk > rht.rnk) {
lft.push().cld(1,merge(lft.rht,nd,rht));
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push().cld(-1,merge(lft,nd,rht.lft));
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(i,i +1); }
public V get(int l,int r){
V ret = e();
if (root != null)
get(ret,root,l,min(r,size()));
return ret;
}
private void get(V ret,Node nd,int l,int r){
if (l == 0 && r == nd.sz)
ag(ret,ret,nd.val());
else if (nd.leaf)
ag(ret,ret,pw(t,nd.val,r -l));
else {
nd.push();
if (l < nd.lft.sz)
get(ret,nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(ret,nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected void pow(V v,V a,int n){
for (ag(t,e,a);0 < n;n >>= 1,ag(t,t,t))
if (0 < (n &1))
ag(v,v,t);
}
private V pw(V ret,V a,int n){
pow(ret,a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? (nd = rotate(nd)) : nd).merge(); }
private Node rotate(Node u){
var v = u.cld(u.bis).push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
private class Node{
private int sz,rnk,bis,tog;
private V val;
private F laz;
private Node lft,rht;
private boolean leaf = true;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node merge(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
leaf = false;
return this;
}
private Node push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
return this;
}
private Node prop(F f){
map(val,f);
if (!leaf)
laz = laz == null ? f : comp(laz,f);
return this;
}
private Node toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (!leaf)
tog ^= 1;
return this;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return leaf && 1 < sz ? pw(e(),val,sz) : val; }
}
}
abstract class KetaDp<T> {
private int B;
private int[] N;
private T[] dp;
public KetaDp(char[] N){ this(N,10); }
public KetaDp(char[] N,int B){
this.N = new int[N.length];
for (int i = 0;i < N.length;i++)
this.N[i] = N[i] -'0';
dp = Util.cast(Array.newInstance(init().getClass(),N.length +1 <<1));
this.B = B;
setAll(dp,i -> init());
}
protected abstract T init();
protected abstract void f(T pd,T dp,int n,int k);
protected void mod(T dp){}
public T get(int i,int same){ return dp[i *2 +same]; }
public void calc(){
for (int i = 0;i < N.length;i++) {
int t = N[i];
for (int n = 0;n < B;n++) {
if (n == t)
f(get(i +1,1),get(i,1),n,N.length -1 -i);
if (n < t)
f(get(i +1,0),get(i,1),n,N.length -1 -i);
if (0 < i)
f(get(i +1,0),get(i,0),n,N.length -1 -i);
}
mod(get(i +1,0));
mod(get(i +1,1));
}
}
}
abstract class RelationalUnionFind<F> extends UnionFind{
private F[] dist;
@SuppressWarnings("unchecked")
public RelationalUnionFind(int n){
super(n);
dist = (F[]) new Object[n];
setAll(dist,i -> id());
}
protected abstract F id();
protected abstract F comp(F a,F b);
protected abstract F inv(F v);
protected abstract boolean eq(F a,F b);
@Override
public int root(int x){
if (dat[x] < 0)
return x;
int r = root(dat[x]);
dist[x] = comp(dist[dat[x]],dist[x]);
return dat[x] = r;
}
public boolean valid(int u,int v,F c){ return !same(u,v) || eq(dist(u,v),c); }
@Deprecated
@Override
public boolean unite(int u,int v){ return unite(u,v,id()); }
public boolean unite(int u,int v,F f){
if (!valid(u,v,f))
return false;
if (same(u,v))
return true;
f = comp(dist(u),f);
f = comp(f,inv(dist(v)));
super.unite(u = root(u),v = root(v));
if (dat[u] > dat[v])
dist[u] = inv(f);
else
dist[v] = f;
return true;
}
public F dist(int x){
root(x);
return dist[x];
}
public F dist(int u,int v){ return !same(u,v) ? null : comp(inv(dist(u)),dist(v)); }
}
class Combin{
int n = 2;
long[] f,fi;
long mod = Util.mod;
public Combin(int n){
this();
grow(n);
}
public Combin(){ f = fi = new long[]{1, 1}; }
public void grow(int n){
n = min((int) mod,n);
f = copyOf(f,n);
fi = copyOf(fi,n);
for (int i = this.n;i < n;i++)
f[i] = f[i -1] *i %mod;
fi[n -1] = pow(f[n -1],mod -2);
for (int i = n;--i > this.n;)
fi[i -1] = fi[i] *i %mod;
this.n = n;
}
private long pow(long x,long n){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
public long nHr(int n,int r){ return r < 0 ? 0 : nCr(n +r -1,r); }
public long nCr(int n,int r){
if (r < 0 || n -r < 0)
return 0;
if (this.n <= n)
grow(max(this.n <<1,n +1));
return f[n] *(fi[r] *fi[n -r] %mod) %mod;
}
}
class RollingHash{
private static long MASK30 = (1L <<30) -1;
private static long MASK31 = (1L <<31) -1;
private static long MOD = (1L <<61) -1;
private static long m = base();
private static long[] pow = {1};
int n;
private long[] hash,S;
private boolean updatable;
private RollingHash rev;
public RollingHash(char[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(long[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int n,IntToLongFunction f,boolean updatale){
S = new long[n];
updatable = updatale;
this.n = S.length;
hash = new long[n +1];
setPow(n);
for (int i = 0;i < n;i++)
set(i,f.applyAsLong(i));
}
public long get(int l,int r){
if (l > r)
return (rev == null ? rev = rev() : rev).get(n -l,n -r);
return mod(hash(r) -mul(hash(l),pow[r -l]));
}
public void upd(int i,long v){
assert updatable;
set(i,v);
if (rev != null)
rev.set(n -i -1,v);
}
public static boolean equal(RollingHash rhS,int sl,int sr,RollingHash rhT,int tl,int tr){
return rhS.get(sl,sr) == rhT.get(tl,tr);
}
private void set(int i,long v){
if (updatable)
for (int x = i +1;x <= n;x += x &-x)
hash[x] = mod(hash[x] +mul(v -S[i],pow[x -i -1]));
else
hash[i +1] = mod(mul(hash[i],m) +v);
S[i] = v;
}
private long hash(int i){
long ret = 0;
if (updatable)
for (int x = i;x > 0;x -= x &-x)
ret = mod(ret +mul(hash[x],pow[i -x]));
else
ret = hash[i];
return ret;
}
private void setPow(int n){
if (n < pow.length)
return;
int s = pow.length;
pow = copyOf(pow,max(pow.length <<1,n +1));
for (int i = s;i < pow.length;i++)
pow[i] = mul(pow[i -1],m);
}
private RollingHash rev(){
long[] s = new long[n];
for (int i = 0;i < n;i++)
s[i] = S[n -1 -i];
return new RollingHash(s,updatable);
}
private static long mul(long a,long b){
long lu = a >>31;
long ld = a &MASK31;
long ru = b >>31;
long rd = b &MASK31;
long mid = ld *ru +lu *rd;
return mod((lu *ru <<1) +ld *rd +((mid &MASK30) <<31) +(mid >>30));
}
private static long mod(long val){
while (val < 0)
val += MOD;
val = (val &MOD) +(val >>61);
return val > MOD ? val -MOD : val;
}
private static long pow(long x,long n){
long ret = 1;
do {
if ((n &1) == 1)
ret = mul(ret,x);
x = mul(x,x);
} while (0 < (n >>= 1));
return ret;
}
private static long base(){
long m = 0;
for (int k = 1;m < Util.infI;m = pow(37,k))
while (!isPrimeRoot(k))
k = ThreadLocalRandom.current().nextInt(Util.infI);
return m;
}
private static boolean isPrimeRoot(long a){
long b = MOD -1;
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a > 1;
}
}
abstract class LazySegmentTree<V extends BaseV, F> extends Seg<V, F>{
public LazySegmentTree(int n){ super(n); }
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
up(l,r);
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
down(l,r);
return super.get(l,r);
}
}
abstract class Seg<V extends BaseV, F> {
private int n,log;
private V[] val;
private F[] lazy;
protected Seg(int n){
this.n = n;
while (1 <<log <= n)
log++;
val = Util.cast(new BaseV[n <<1]);
lazy = Util.cast(new Object[n]);
for (int i = -1;++i < n;)
(val[i +n] = init(i)).sz = 1;
for (int i = n;--i > 0;merge(i))
(val[i] = e()).sz = val[i <<1].sz +val[i <<1 |1].sz;
}
public void upd(int i,F f){ prop(i +n,f); }
public void upd(int l,int r,F f){
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1)
prop(l++,f);
if ((r &1) == 1)
prop(--r,f);
}
}
public V get(int i){ return val[i +n]; }
public V get(int l,int r){
V[] ret = Util.cast(new BaseV[]{e(), e()});
int i = 0;
for (var v:getList(l,r)) {
agg(ret[i],ret[i ^1],v);
ret[i].sz = ret[i ^= 1].sz +v.sz;
}
return ret[i ^1];
}
public V[] getList(int l,int r){
int sz = 0;
for (int li = l += n,ri = r += n;li < ri;li = li +1 >>1,ri >>= 1)
sz += (li &1) +(ri &1);
V[] arr = Util.cast(Array.newInstance(e().getClass(),sz));
for (int i = 0;l < r;l >>= 1,r >>= 1) {
if ((l &1) > 0)
arr[i++] = val[l++];
if ((r &1) > 0)
arr[--sz] = val[--r];
}
return arr;
}
public V[] getPath(int i){
int sz = 32 -Integer.numberOfLeadingZeros(i +n);
V[] arr = Util.cast(Array.newInstance(e().getClass(),sz));
for (i += n;0 < i;i >>= 1)
arr[--sz] = val[i];
return arr;
}
protected V init(int i){ return e(); }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected void up(int l,int r){
for (l = oddPart(l +n),r = oddPart(r +n);l != r;)
merge(l > r ? (l >>= 1) : (r >>= 1));
while (1 < l)
merge(l >>= 1);
}
protected void down(int l,int r){
int i = log;
for (l = oddPart(l +n),r = oddPart(r +n);i > 0;i--) {
push(l >>i);
push(r >>i);
}
}
private void merge(int i){ agg(val[i],val[i <<1],val[i <<1 |1]); }
private void push(int i){
if (lazy[i] != null) {
prop(i <<1,lazy[i]);
prop(i <<1 |1,lazy[i]);
lazy[i] = null;
}
}
private void prop(int i,F f){
map(val[i],f);
if (i < n) {
lazy[i] = lazy[i] == null ? f : comp(lazy[i],f);
if (val[i].fail) {
push(i);
merge(i);
}
}
}
private int oddPart(int i){ return i /(i &-i); }
}
abstract class SegmentTree<V extends BaseV, F> extends Seg<V, F>{
public SegmentTree(int n){ super(n); }
@Override
protected F comp(F f,F g){ return null; }
@Override
public void upd(int i,F f){
super.upd(i,f);
up(i,i +1);
}
}
abstract class DualSegmentTree<V extends BaseV, F> extends Seg<V, F>{
public DualSegmentTree(int n){ super(n); }
@Override
protected void agg(V v,V a,V b){}
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
public V get(int i){
down(i,i +1);
return super.get(i);
}
}
class UnionFind{
int num;
protected int[] dat;
protected int[] nxt;
public UnionFind(int n){
dat = new int[n];
nxt = new int[n];
setAll(nxt,i -> i);
fill(dat,-1);
num = n;
}
public int root(int x){ return dat[x] < 0 ? x : (dat[x] = root(dat[x])); }
public boolean same(int u,int v){ return root(u) == root(v); }
public boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (dat[u] > dat[v]) {
u ^= v;
v ^= u;
u ^= v;
}
dat[u] += dat[v];
dat[v] = u;
num--;
nxt[u] ^= nxt[v];
nxt[v] ^= nxt[u];
nxt[u] ^= nxt[v];
return true;
}
public int size(int x){ return -dat[root(x)]; }
public int[] getGroup(int x){
int[] ret = new int[size(x)];
for (int i = 0,c = root(x);i < ret.length;i++)
ret[i] = c = nxt[c];
return ret;
}
}
abstract class Dijkstra<E, L> extends Graph<E>{
private Comparator<L> cmp;
private L[] len;
private int[] hep,idx;
private Edge<E>[] pre;
private int sz;
public Dijkstra(int n,boolean dir){
super(n,dir);
hep = new int[n];
idx = new int[n];
cmp = cmp();
}
protected abstract L zero();
protected abstract L inf();
protected abstract L f(L l,Edge<E> e);
protected Comparator<L> cmp(){ return Util.cast(Comparator.naturalOrder()); }
public L[] calc(int s){ return calc(s,-1); }
public L[] calc(int s,int g){
len = Util.cast(Array.newInstance(zero().getClass(),sz = n));
pre = Util.cast(new Edge[n]);
fill(len,inf());
setAll(hep,i -> i);
setAll(idx,i -> i);
set(s,zero());
for (int cur;0 < sz && (cur = poll()) != g;)
for (var e:go(cur))
set((pre[e.v] = e).v,f(len[cur],e));
return len;
}
public L get(int t){ return len[t]; }
public Deque<Edge<E>> path(int t){
Deque<Edge<E>> ret = new ArrayDeque<>();
while (pre[t] != null) {
ret.addFirst(pre[t]);
t = pre[t].u;
}
return ret;
}
private void set(int i,L l){
if (idx[i] < sz && cmp.compare(l,len[i]) < 0) {
len[i] = l;
heapfy(idx[i]);
}
}
private int poll(){
int ret = hep[0];
heapfy(swap(0,--sz));
return ret;
}
private void heapfy(int k){
int p = k -1 >>1;
if (0 <= p && cmp.compare(len[hep[p]],len[hep[k]]) > 0) {
heapfy(swap(p,k));
return;
}
int c = k <<1 |1;
if (sz <= c)
return;
if (c +1 < sz && cmp.compare(len[hep[c]],len[hep[c +1]]) > 0)
c++;
if (cmp.compare(len[hep[c]],len[hep[k]]) < 0)
heapfy(swap(c,k));
}
private int swap(int i,int j){
hep[i] ^= hep[j];
hep[j] ^= hep[i];
hep[i] ^= hep[j];
idx[hep[i]] = i;
idx[hep[j]] = j;
return i;
}
}
class Edge<L> {
public int id,u,v;
public L val;
public Edge<L> re;
public Edge(int id,int u,int v,L val){
this.id = id;
this.u = u;
this.v = v;
this.val = val;
}
}
class Graph<L> {
public int n;
public MyList<Edge<L>> es;
private MyList<Edge<L>>[] go,bk;
public Graph(int n,boolean dir){
this.n = n;
go = Util.cast(new MyList[n]);
bk = dir ? Util.cast(new MyList[n]) : go;
for (int i = 0;i < n;i++) {
go[i] = new MyList<>();
bk[i] = new MyList<>();
}
es = new MyList<>();
}
protected L inv(L l){ return l; }
public void addEdge(int u,int v){ addEdge(u,v,null); }
public void addEdge(int u,int v,L l){
var e = new Edge<>(es.size(),u,v,l);
var re = new Edge<>(e.id,e.v,e.u,inv(e.val));
es.add(e);
go[u].add(re.re = e);
bk[v].add(e.re = re);
}
public MyList<Edge<L>> go(int u){ return go[u]; }
public MyList<Edge<L>> bk(int u){ return bk[u]; }
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){ return copyOf(arr,sz); }
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x,long mod){ return pow(x,mod -2,mod); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<60 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader extends Util{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return arrI(N,i -> it()); }
public int[][] it(int H,int W){ return arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return arr(new String[N],i -> str()); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
var in = new MyReader(System.in);
var out = new MyWriter(System.out,false);
var log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log)
.solve()).ifPresent(out::println);
out.flush();
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = false;
public Object solve(){
int N = in.it();
String[] SS = in.str(N);
a:for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++) {
if (i == j)
continue;
if (SS[i].contains(SS[j])) {
SS[j] = SS[N -1];
N--;
i = -1;
continue a;
}
}
char[][] S = new char[N][];
for (int i = 0;i < N;i++)
S[i] = SS[i].toCharArray();
RollingHash[] rhs = new RollingHash[N];
for (int i = 0;i < N;i++)
rhs[i] = new RollingHash(S[i],false);
int[][] E = new int[N][N];
for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++)
for (int l = 1;l <= min(S[i].length,S[j].length);l++)
if (rhs[i].get(S[i].length -l,S[i].length) == rhs[j].get(0,l))
E[i][j] = l;
long[][] dp = new long[1 <<N][N];
for (int bit = 0;bit < 1 <<N;bit++)
for (int i = 0;i < N;i++)
for (int j = 0;j < N;j++) {
if ((bit >>i &1) == 0 || (bit >>j &1) == 1)
continue;
dp[bit |1 <<j][j] = max(dp[bit |1 <<j][j],dp[bit][i] +E[i][j]);
}
long sum = 0;
for (var s:S)
sum += s.length;
long ans = infL;
for (int i = 0;i < N;i++)
ans = min(ans,sum -dp[(1 <<N) -1][i]);
return ans;
}
<T extends BaseV> void log(Seg<T, ?> seg,int n){
T[] a = (T[]) new BaseV[n];
for (int i = 0;i < n;i++)
a[i] = seg.get(i);
log.println(a);
}
long min(long... a){
long ret = a[0];
for (var aa:a)
ret = Math.min(ret,aa);
return ret;
}
long max(long... a){
long ret = a[0];
for (var aa:a)
ret = Math.max(ret,aa);
return ret;
}
private long hash(int[] A){
long ret = 0;
for (var a:A) {
ret = Mul(ret,972029) +a;
if (ret >= MOD)
ret -= MOD;
}
return ret;
}
final static long MASK30 = (1L <<30) -1;
final static long MASK31 = (1L <<31) -1;
final static long MOD = (1L <<61) -1;
private static long Mul(final long l,final long r){
final long lu = l >>31;
final long ld = l &MASK31;
final long ru = r >>31;
final long rd = r &MASK31;
final long middleBit = ld *ru +lu *rd;
return (lu *ru <<1) +ld *rd +((middleBit &MASK30) <<31) +(middleBit >>30);
}
}
class Data extends BaseV{
long[][] arr;
public Data(){ arr = new long[2][2]; }
public Data(int v){
this();
arr[0][0] = v;
arr[0][1] = 1;
}
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e(),t = e();
private Node root;
public AVLSegmentTree(int n){ root = new Node(e(),n); }
public AVLSegmentTree(){}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int i,int n,IntFunction<V> init){
if (n < 2)
return n < 1 ? null : new Node(init.apply(i),1);
var ret = new Node(e(),n);
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
return ret.merge();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.leaf && (i == 0 || i == nd.sz)) {
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
return nd.merge();
}
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.cld(-1,ins(nd.lft,i,v,k));
else
nd.cld(1,ins(nd.rht,i -nd.lft.sz,v,k));
return balance(nd);
}
public V del(int i){
var ret = e();
root = del(ret,root,i);
return ret;
}
private Node del(V ret,Node nd,int i){
if (nd.leaf) {
nd.sz--;
ag(ret,e,nd.val);
return 0 < nd.sz ? nd : null;
}
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(ret,nd.lft,i) : del(ret,nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (l == r)
return;
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
return nd.prop(f);
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.cld(-1,upd(nd.lft,l,min(nd.lft.sz,r),f));
if (nd.lft.sz < r)
nd.cld(1,upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f));
return balance(nd);
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
return merge(nd.lft,nd,toggle(nd.rht,0,r -l));
}
if (r < nd.sz) {
split(nd,r);
return merge(toggle(nd.lft,l,r),nd,nd.rht);
}
return nd.toggle();
}
private void split(Node nd,int i){
if (nd.leaf)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
if (i < nd.lft.sz) {
split(nd.lft,i);
var lft = nd.lft;
nd.cld(-1,lft.lft);
nd.cld(1,merge(lft.rht,lft,nd.rht));
} else if (nd.lft.sz < i) {
split(nd.rht,i -nd.lft.sz);
var rht = nd.rht;
nd.cld(1,rht.rht);
nd.cld(-1,merge(nd.lft,rht,rht.lft));
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.cld(-1,lft);
nd.cld(1,rht);
} else if (lft.rnk > rht.rnk) {
lft.push().cld(1,merge(lft.rht,nd,rht));
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push().cld(-1,merge(lft,nd,rht.lft));
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(i,i +1); }
public V get(int l,int r){
V ret = e();
if (root != null)
get(ret,root,l,min(r,size()));
return ret;
}
private void get(V ret,Node nd,int l,int r){
if (l == 0 && r == nd.sz)
ag(ret,ret,nd.val());
else if (nd.leaf)
ag(ret,ret,pw(t,nd.val,r -l));
else {
nd.push();
if (l < nd.lft.sz)
get(ret,nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(ret,nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected void pow(V v,V a,int n){
for (ag(t,e,a);0 < n;n >>= 1,ag(t,t,t))
if (0 < (n &1))
ag(v,v,t);
}
private V pw(V ret,V a,int n){
pow(ret,a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? (nd = rotate(nd)) : nd).merge(); }
private Node rotate(Node u){
var v = u.cld(u.bis).push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
private class Node{
private int sz,rnk,bis,tog;
private V val;
private F laz;
private Node lft,rht;
private boolean leaf = true;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node merge(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
leaf = false;
return this;
}
private Node push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
return this;
}
private Node prop(F f){
map(val,f);
if (!leaf)
laz = laz == null ? f : comp(laz,f);
return this;
}
private Node toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (!leaf)
tog ^= 1;
return this;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return leaf && 1 < sz ? pw(e(),val,sz) : val; }
}
}
abstract class KetaDp<T> {
private int B;
private int[] N;
private T[] dp;
public KetaDp(char[] N){ this(N,10); }
public KetaDp(char[] N,int B){
this.N = new int[N.length];
for (int i = 0;i < N.length;i++)
this.N[i] = N[i] -'0';
dp = Util.cast(Array.newInstance(init().getClass(),N.length +1 <<1));
this.B = B;
setAll(dp,i -> init());
}
protected abstract T init();
protected abstract void f(T pd,T dp,int n,int k);
protected void mod(T dp){}
public T get(int i,int same){ return dp[i *2 +same]; }
public void calc(){
for (int i = 0;i < N.length;i++) {
int t = N[i];
for (int n = 0;n < B;n++) {
if (n == t)
f(get(i +1,1),get(i,1),n,N.length -1 -i);
if (n < t)
f(get(i +1,0),get(i,1),n,N.length -1 -i);
if (0 < i)
f(get(i +1,0),get(i,0),n,N.length -1 -i);
}
mod(get(i +1,0));
mod(get(i +1,1));
}
}
}
abstract class RelationalUnionFind<F> extends UnionFind{
private F[] dist;
@SuppressWarnings("unchecked")
public RelationalUnionFind(int n){
super(n);
dist = (F[]) new Object[n];
setAll(dist,i -> id());
}
protected abstract F id();
protected abstract F comp(F a,F b);
protected abstract F inv(F v);
protected abstract boolean eq(F a,F b);
@Override
public int root(int x){
if (dat[x] < 0)
return x;
int r = root(dat[x]);
dist[x] = comp(dist[dat[x]],dist[x]);
return dat[x] = r;
}
public boolean valid(int u,int v,F c){ return !same(u,v) || eq(dist(u,v),c); }
@Deprecated
@Override
public boolean unite(int u,int v){ return unite(u,v,id()); }
public boolean unite(int u,int v,F f){
if (!valid(u,v,f))
return false;
if (same(u,v))
return true;
f = comp(dist(u),f);
f = comp(f,inv(dist(v)));
super.unite(u = root(u),v = root(v));
if (dat[u] > dat[v])
dist[u] = inv(f);
else
dist[v] = f;
return true;
}
public F dist(int x){
root(x);
return dist[x];
}
public F dist(int u,int v){ return !same(u,v) ? null : comp(inv(dist(u)),dist(v)); }
}
class Combin{
int n = 2;
long[] f,fi;
long mod = Util.mod;
public Combin(int n){
this();
grow(n);
}
public Combin(){ f = fi = new long[]{1, 1}; }
public void grow(int n){
n = min((int) mod,n);
f = copyOf(f,n);
fi = copyOf(fi,n);
for (int i = this.n;i < n;i++)
f[i] = f[i -1] *i %mod;
fi[n -1] = pow(f[n -1],mod -2);
for (int i = n;--i > this.n;)
fi[i -1] = fi[i] *i %mod;
this.n = n;
}
private long pow(long x,long n){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
public long nHr(int n,int r){ return r < 0 ? 0 : nCr(n +r -1,r); }
public long nCr(int n,int r){
if (r < 0 || n -r < 0)
return 0;
if (this.n <= n)
grow(max(this.n <<1,n +1));
return f[n] *(fi[r] *fi[n -r] %mod) %mod;
}
}
class RollingHash{
private static long MASK30 = (1L <<30) -1;
private static long MASK31 = (1L <<31) -1;
private static long MOD = (1L <<61) -1;
private static long m = base();
private static long[] pow = {1};
int n;
private long[] hash,S;
private boolean updatable;
private RollingHash rev;
public RollingHash(char[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(long[] S,boolean updatable){ this(S.length,i -> S[i],updatable); }
public RollingHash(int n,IntToLongFunction f,boolean updatale){
S = new long[n];
updatable = updatale;
this.n = S.length;
hash = new long[n +1];
setPow(n);
for (int i = 0;i < n;i++)
set(i,f.applyAsLong(i));
}
public long get(int l,int r){
if (l > r)
return (rev == null ? rev = rev() : rev).get(n -l,n -r);
return mod(hash(r) -mul(hash(l),pow[r -l]));
}
public void upd(int i,long v){
assert updatable;
set(i,v);
if (rev != null)
rev.set(n -i -1,v);
}
public static boolean equal(RollingHash rhS,int sl,int sr,RollingHash rhT,int tl,int tr){
return rhS.get(sl,sr) == rhT.get(tl,tr);
}
private void set(int i,long v){
if (updatable)
for (int x = i +1;x <= n;x += x &-x)
hash[x] = mod(hash[x] +mul(v -S[i],pow[x -i -1]));
else
hash[i +1] = mod(mul(hash[i],m) +v);
S[i] = v;
}
private long hash(int i){
long ret = 0;
if (updatable)
for (int x = i;x > 0;x -= x &-x)
ret = mod(ret +mul(hash[x],pow[i -x]));
else
ret = hash[i];
return ret;
}
private void setPow(int n){
if (n < pow.length)
return;
int s = pow.length;
pow = copyOf(pow,max(pow.length <<1,n +1));
for (int i = s;i < pow.length;i++)
pow[i] = mul(pow[i -1],m);
}
private RollingHash rev(){
long[] s = new long[n];
for (int i = 0;i < n;i++)
s[i] = S[n -1 -i];
return new RollingHash(s,updatable);
}
private static long mul(long a,long b){
long lu = a >>31;
long ld = a &MASK31;
long ru = b >>31;
long rd = b &MASK31;
long mid = ld *ru +lu *rd;
return mod((lu *ru <<1) +ld *rd +((mid &MASK30) <<31) +(mid >>30));
}
private static long mod(long val){
while (val < 0)
val += MOD;
val = (val &MOD) +(val >>61);
return val > MOD ? val -MOD : val;
}
private static long pow(long x,long n){
long ret = 1;
do {
if ((n &1) == 1)
ret = mul(ret,x);
x = mul(x,x);
} while (0 < (n >>= 1));
return ret;
}
private static long base(){
long m = 0;
for (int k = 1;m < Util.infI;m = pow(37,k))
while (!isPrimeRoot(k))
k = ThreadLocalRandom.current().nextInt(Util.infI);
return m;
}
private static boolean isPrimeRoot(long a){
long b = MOD -1;
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a > 1;
}
}
abstract class LazySegmentTree<V extends BaseV, F> extends Seg<V, F>{
public LazySegmentTree(int n){ super(n); }
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
up(l,r);
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
down(l,r);
return super.get(l,r);
}
}
abstract class Seg<V extends BaseV, F> {
private int n,log;
private V[] val;
private F[] lazy;
protected Seg(int n){
this.n = n;
while (1 <<log <= n)
log++;
val = Util.cast(new BaseV[n <<1]);
lazy = Util.cast(new Object[n]);
for (int i = -1;++i < n;)
(val[i +n] = init(i)).sz = 1;
for (int i = n;--i > 0;merge(i))
(val[i] = e()).sz = val[i <<1].sz +val[i <<1 |1].sz;
}
public void upd(int i,F f){ prop(i +n,f); }
public void upd(int l,int r,F f){
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1)
prop(l++,f);
if ((r &1) == 1)
prop(--r,f);
}
}
public V get(int i){ return val[i +n]; }
public V get(int l,int r){
V[] ret = Util.cast(new BaseV[]{e(), e()});
int i = 0;
for (var v:getList(l,r)) {
agg(ret[i],ret[i ^1],v);
ret[i].sz = ret[i ^= 1].sz +v.sz;
}
return ret[i ^1];
}
public V[] getList(int l,int r){
int sz = 0;
for (int li = l += n,ri = r += n;li < ri;li = li +1 >>1,ri >>= 1)
sz += (li &1) +(ri &1);
V[] arr = Util.cast(Array.newInstance(e().getClass(),sz));
for (int i = 0;l < r;l >>= 1,r >>= 1) {
if ((l &1) > 0)
arr[i++] = val[l++];
if ((r &1) > 0)
arr[--sz] = val[--r];
}
return arr;
}
public V[] getPath(int i){
int sz = 32 -Integer.numberOfLeadingZeros(i +n);
V[] arr = Util.cast(Array.newInstance(e().getClass(),sz));
for (i += n;0 < i;i >>= 1)
arr[--sz] = val[i];
return arr;
}
protected V init(int i){ return e(); }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected void up(int l,int r){
for (l = oddPart(l +n),r = oddPart(r +n);l != r;)
merge(l > r ? (l >>= 1) : (r >>= 1));
while (1 < l)
merge(l >>= 1);
}
protected void down(int l,int r){
int i = log;
for (l = oddPart(l +n),r = oddPart(r +n);i > 0;i--) {
push(l >>i);
push(r >>i);
}
}
private void merge(int i){ agg(val[i],val[i <<1],val[i <<1 |1]); }
private void push(int i){
if (lazy[i] != null) {
prop(i <<1,lazy[i]);
prop(i <<1 |1,lazy[i]);
lazy[i] = null;
}
}
private void prop(int i,F f){
map(val[i],f);
if (i < n) {
lazy[i] = lazy[i] == null ? f : comp(lazy[i],f);
if (val[i].fail) {
push(i);
merge(i);
}
}
}
private int oddPart(int i){ return i /(i &-i); }
}
abstract class SegmentTree<V extends BaseV, F> extends Seg<V, F>{
public SegmentTree(int n){ super(n); }
@Override
protected F comp(F f,F g){ return null; }
@Override
public void upd(int i,F f){
super.upd(i,f);
up(i,i +1);
}
}
abstract class DualSegmentTree<V extends BaseV, F> extends Seg<V, F>{
public DualSegmentTree(int n){ super(n); }
@Override
protected void agg(V v,V a,V b){}
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
public V get(int i){
down(i,i +1);
return super.get(i);
}
}
class UnionFind{
int num;
protected int[] dat;
protected int[] nxt;
public UnionFind(int n){
dat = new int[n];
nxt = new int[n];
setAll(nxt,i -> i);
fill(dat,-1);
num = n;
}
public int root(int x){ return dat[x] < 0 ? x : (dat[x] = root(dat[x])); }
public boolean same(int u,int v){ return root(u) == root(v); }
public boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (dat[u] > dat[v]) {
u ^= v;
v ^= u;
u ^= v;
}
dat[u] += dat[v];
dat[v] = u;
num--;
nxt[u] ^= nxt[v];
nxt[v] ^= nxt[u];
nxt[u] ^= nxt[v];
return true;
}
public int size(int x){ return -dat[root(x)]; }
public int[] getGroup(int x){
int[] ret = new int[size(x)];
for (int i = 0,c = root(x);i < ret.length;i++)
ret[i] = c = nxt[c];
return ret;
}
}
abstract class Dijkstra<E, L> extends Graph<E>{
private Comparator<L> cmp;
private L[] len;
private int[] hep,idx;
private Edge<E>[] pre;
private int sz;
public Dijkstra(int n,boolean dir){
super(n,dir);
hep = new int[n];
idx = new int[n];
cmp = cmp();
}
protected abstract L zero();
protected abstract L inf();
protected abstract L f(L l,Edge<E> e);
protected Comparator<L> cmp(){ return Util.cast(Comparator.naturalOrder()); }
public L[] calc(int s){ return calc(s,-1); }
public L[] calc(int s,int g){
len = Util.cast(Array.newInstance(zero().getClass(),sz = n));
pre = Util.cast(new Edge[n]);
fill(len,inf());
setAll(hep,i -> i);
setAll(idx,i -> i);
set(s,zero());
for (int cur;0 < sz && (cur = poll()) != g;)
for (var e:go(cur))
set((pre[e.v] = e).v,f(len[cur],e));
return len;
}
public L get(int t){ return len[t]; }
public Deque<Edge<E>> path(int t){
Deque<Edge<E>> ret = new ArrayDeque<>();
while (pre[t] != null) {
ret.addFirst(pre[t]);
t = pre[t].u;
}
return ret;
}
private void set(int i,L l){
if (idx[i] < sz && cmp.compare(l,len[i]) < 0) {
len[i] = l;
heapfy(idx[i]);
}
}
private int poll(){
int ret = hep[0];
heapfy(swap(0,--sz));
return ret;
}
private void heapfy(int k){
int p = k -1 >>1;
if (0 <= p && cmp.compare(len[hep[p]],len[hep[k]]) > 0) {
heapfy(swap(p,k));
return;
}
int c = k <<1 |1;
if (sz <= c)
return;
if (c +1 < sz && cmp.compare(len[hep[c]],len[hep[c +1]]) > 0)
c++;
if (cmp.compare(len[hep[c]],len[hep[k]]) < 0)
heapfy(swap(c,k));
}
private int swap(int i,int j){
hep[i] ^= hep[j];
hep[j] ^= hep[i];
hep[i] ^= hep[j];
idx[hep[i]] = i;
idx[hep[j]] = j;
return i;
}
}
class Edge<L> {
public int id,u,v;
public L val;
public Edge<L> re;
public Edge(int id,int u,int v,L val){
this.id = id;
this.u = u;
this.v = v;
this.val = val;
}
}
class Graph<L> {
public int n;
public MyList<Edge<L>> es;
private MyList<Edge<L>>[] go,bk;
public Graph(int n,boolean dir){
this.n = n;
go = Util.cast(new MyList[n]);
bk = dir ? Util.cast(new MyList[n]) : go;
for (int i = 0;i < n;i++) {
go[i] = new MyList<>();
bk[i] = new MyList<>();
}
es = new MyList<>();
}
protected L inv(L l){ return l; }
public void addEdge(int u,int v){ addEdge(u,v,null); }
public void addEdge(int u,int v,L l){
var e = new Edge<>(es.size(),u,v,l);
var re = new Edge<>(e.id,e.v,e.u,inv(e.val));
es.add(e);
go[u].add(re.re = e);
bk[v].add(e.re = re);
}
public MyList<Edge<L>> go(int u){ return go[u]; }
public MyList<Edge<L>> bk(int u){ return bk[u]; }
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){ return copyOf(arr,sz); }
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x,long mod){ return pow(x,mod -2,mod); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<60 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader extends Util{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return arrI(N,i -> it()); }
public int[][] it(int H,int W){ return arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return arr(new String[N],i -> str()); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
var in = new MyReader(System.in);
var out = new MyWriter(System.out,false);
var log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log)
.solve()).ifPresent(out::println);
out.flush();
}
}
| ConDefects/ConDefects/Code/abc343_g/Java/50835129 |
condefects-java_data_138 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.InputMismatchException;
public class Main {
static RealFastReader sc = new RealFastReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
int t = 1;
while (t-- > 0) {
solve();
}
out.close();
}
static int s;
public static void solve() {
int[][] g = sc.nmi(3,3);
int[][] h = new int[3][3];
for(int[] w: h){
Arrays.fill(w,-1);
}
s = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
s += g[i][j];
}
}
if(dfs(g, 0, 0, h)){
out.println("Takahashi");
}else {
out.println("Aoki");
}
}
private static boolean dfs(int[][] g, int now, int f, int[][] h){
if(now == ((1<<9)-1)){
long a = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if(h[i][j] == f){
a += g[i][j];
}
}
}
return a > s - a;
}
boolean r = false;
for (int i = 0; i < 9; i++) {
if(((1<<i)&now) == (1<<i)){
continue;
}
h[i/3][i%3] = f;
if(check(h)){
h[i/3][i%3] = -1;
r = true;
break;
}
r |= !(dfs(g, (1<<i)| now, f^1, h));
h[i/3][i%3] = -1;
if(r){
break;
}
}
return r;
}
private static boolean check(int[][] h){
if( h[0][0] == h[0][1] && h[0][2] == h[0][1] && h[0][0]!=-1){
return true;
}
if(h[1][1] == h[1][0] && h[1][2] == h[1][1] && h[1][0]!=-1){
return true;
}
if(h[2][1] == h[2][0] && h[2][2] == h[2][1] && h[2][0]!=-1){
return true;
}
if(h[0][0] == h[1][0] && h[1][0] == h[2][0] && h[0][0]!=-1){
return true;
}
if(h[0][1] == h[1][1] && h[1][1] == h[2][1] && h[0][1]!=-1){
return true;
}
if(h[0][2] == h[1][2] && h[1][2] == h[2][2] && h[0][2]!=-1){
return true;
}
if(h[0][0] == h[1][1] && h[1][1] == h[2][2] && h[0][0]!=-1){
return true;
}
if(h[0][2] == h[1][1] && h[1][1] == h[2][0] && h[0][2]!=-1){
return true;
}
return false;
}
public static class RealFastReader {
InputStream is;
public RealFastReader(final InputStream is) {
this.is = is;
}
private byte[] inbuf = new byte[8192];
public int lenbuf = 0, ptrbuf = 0;
public int readByte() {
if (lenbuf == -1) {
throw new InputMismatchException();
}
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) {
return -1;
}
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b))
;
return b;
}
public double nd() {
return Double.parseDouble(ns());
}
public char nc() {
return (char) skip();
}
public String ns() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public char[] ns(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
public int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}
public long[] nal(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nl();
}
return a;
}
public char[][] nm(int n, int m) {
char[][] map = new char[n][];
for (int i = 0; i < n; i++) {
map[i] = ns(m);
}
return map;
}
public int[][] nmi(int n, int m) {
int[][] map = new int[n][];
for (int i = 0; i < n; i++) {
map[i] = na(m);
}
return map;
}
public int ni() {
int num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public long nl() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.InputMismatchException;
public class Main {
static RealFastReader sc = new RealFastReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
int t = 1;
while (t-- > 0) {
solve();
}
out.close();
}
static long s;
public static void solve() {
int[][] g = sc.nmi(3,3);
int[][] h = new int[3][3];
for(int[] w: h){
Arrays.fill(w,-1);
}
s = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
s += g[i][j];
}
}
if(dfs(g, 0, 0, h)){
out.println("Takahashi");
}else {
out.println("Aoki");
}
}
private static boolean dfs(int[][] g, int now, int f, int[][] h){
if(now == ((1<<9)-1)){
long a = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if(h[i][j] == f){
a += g[i][j];
}
}
}
return a > s - a;
}
boolean r = false;
for (int i = 0; i < 9; i++) {
if(((1<<i)&now) == (1<<i)){
continue;
}
h[i/3][i%3] = f;
if(check(h)){
h[i/3][i%3] = -1;
r = true;
break;
}
r |= !(dfs(g, (1<<i)| now, f^1, h));
h[i/3][i%3] = -1;
if(r){
break;
}
}
return r;
}
private static boolean check(int[][] h){
if( h[0][0] == h[0][1] && h[0][2] == h[0][1] && h[0][0]!=-1){
return true;
}
if(h[1][1] == h[1][0] && h[1][2] == h[1][1] && h[1][0]!=-1){
return true;
}
if(h[2][1] == h[2][0] && h[2][2] == h[2][1] && h[2][0]!=-1){
return true;
}
if(h[0][0] == h[1][0] && h[1][0] == h[2][0] && h[0][0]!=-1){
return true;
}
if(h[0][1] == h[1][1] && h[1][1] == h[2][1] && h[0][1]!=-1){
return true;
}
if(h[0][2] == h[1][2] && h[1][2] == h[2][2] && h[0][2]!=-1){
return true;
}
if(h[0][0] == h[1][1] && h[1][1] == h[2][2] && h[0][0]!=-1){
return true;
}
if(h[0][2] == h[1][1] && h[1][1] == h[2][0] && h[0][2]!=-1){
return true;
}
return false;
}
public static class RealFastReader {
InputStream is;
public RealFastReader(final InputStream is) {
this.is = is;
}
private byte[] inbuf = new byte[8192];
public int lenbuf = 0, ptrbuf = 0;
public int readByte() {
if (lenbuf == -1) {
throw new InputMismatchException();
}
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) {
return -1;
}
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b))
;
return b;
}
public double nd() {
return Double.parseDouble(ns());
}
public char nc() {
return (char) skip();
}
public String ns() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public char[] ns(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
public int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}
public long[] nal(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nl();
}
return a;
}
public char[][] nm(int n, int m) {
char[][] map = new char[n][];
for (int i = 0; i < n; i++) {
map[i] = ns(m);
}
return map;
}
public int[][] nmi(int n, int m) {
int[][] map = new int[n][];
for (int i = 0; i < n; i++) {
map[i] = na(m);
}
return map;
}
public int ni() {
int num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
public long nl() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
}
}
| ConDefects/ConDefects/Code/abc349_e/Java/52364394 |
condefects-java_data_139 | import java.util.ArrayList;
public class Main{
public static void main(String[] args){
var sc=new java.util.Scanner(System.in);
int[] ban=new int[9],possess=new int[9];
for(int i=0;i<9;i++)ban[i]=sc.nextInt();
System.out.println(solve(ban,possess,1)==1?"Takahashi":"Aoki");
}
private static int solve(int[] ban,int[] possess,int player){
int[][] check=new int[][]{
{0,1,2},
{3,4,5},
{6,7,8},
{0,3,6},
{1,4,7},
{2,5,8},
{0,4,8},
{2,4,6}
};
for(int[] ch:check){
if(Math.abs(possess[ch[0]]+possess[ch[1]]+possess[ch[2]])==3)return possess[ch[0]];
}
boolean noSpace=true;
int t1=0,t2=0;
for(int i=0;i<9;i++){
switch(possess[i]){
case 0:
noSpace=false;
possess[i]=player;
int result=solve(ban,possess,-player);
possess[i]=0;
if(result==player)return player;
break;
case 1:
t1+=ban[i];
break;
default:
t2+=ban[i];
break;
}
}
if(noSpace)return t1>t2?1:-1;
else return -player;
}
}
import java.util.ArrayList;
public class Main{
public static void main(String[] args){
var sc=new java.util.Scanner(System.in);
int[] ban=new int[9],possess=new int[9];
for(int i=0;i<9;i++)ban[i]=sc.nextInt();
System.out.println(solve(ban,possess,1)==1?"Takahashi":"Aoki");
}
private static int solve(int[] ban,int[] possess,int player){
int[][] check=new int[][]{
{0,1,2},
{3,4,5},
{6,7,8},
{0,3,6},
{1,4,7},
{2,5,8},
{0,4,8},
{2,4,6}
};
for(int[] ch:check){
if(Math.abs(possess[ch[0]]+possess[ch[1]]+possess[ch[2]])==3)return possess[ch[0]];
}
boolean noSpace=true;
long t1=0,t2=0;
for(int i=0;i<9;i++){
switch(possess[i]){
case 0:
noSpace=false;
possess[i]=player;
int result=solve(ban,possess,-player);
possess[i]=0;
if(result==player)return player;
break;
case 1:
t1+=ban[i];
break;
default:
t2+=ban[i];
break;
}
}
if(noSpace)return t1>t2?1:-1;
else return -player;
}
} | ConDefects/ConDefects/Code/abc349_e/Java/52374275 |
condefects-java_data_140 | import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static int n = 3;
static int[][] a, vis;
public static int check() {
for (int i = 0; i < n; i++) {
if (vis[i][0] != -1 && vis[i][0] == vis[i][1] && vis[i][1] == vis[i][2]) return vis[i][0];
if (vis[0][i] != -1 && vis[0][i] == vis[1][i] && vis[1][i] == vis[2][i]) return vis[0][i];
}
if (vis[0][0] != -1 && vis[0][0] == vis[1][1] && vis[1][1] == vis[2][2]) return vis[0][0];
if (vis[0][2] != -1 && vis[0][2] == vis[1][1] && vis[1][1] == vis[2][0]) return vis[0][2];
int sum1 = 0, sum2 = 0;
int tot = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (vis[i][j] == 0) sum1 += a[i][j];
else if (vis[i][j] == 1) sum2 += a[i][j];
else tot++;
}
}
if (tot == 0) return sum1 > sum2 ? 0 : 1;
return 2;
}
public static int dfs(int op) {
int x = check();
if (x != 2) return x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (vis[i][j] != -1) continue;
vis[i][j] = op;
int ans = dfs(op^1);
vis[i][j] = -1;
if (ans == op) return ans;
}
}
return op == 0 ? 1 : 0;
}
public static void solve() throws IOException{
a = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = in.nextInt();
}
}
vis = new int[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(vis[i], -1);
}
if (dfs(0) == 0) out.println("Takahashi");
else out.println("Aoki");
}
static boolean MULTI_CASE = false;
public static void main(String[] args) throws IOException {
if (MULTI_CASE) {
int T = in.nextInt();
for (int i = 0; i < T; ++i) {
solve();
}
} else {
solve();
}
out.close();
}
static InputReader in = new InputReader();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static class InputReader {
private StringTokenizer st;
private BufferedReader bf;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
st = null;
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public String nextLine() throws IOException {
return bf.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
/*
*/
import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static int n = 3;
static int[][] a, vis;
public static int check() {
for (int i = 0; i < n; i++) {
if (vis[i][0] != -1 && vis[i][0] == vis[i][1] && vis[i][1] == vis[i][2]) return vis[i][0];
if (vis[0][i] != -1 && vis[0][i] == vis[1][i] && vis[1][i] == vis[2][i]) return vis[0][i];
}
if (vis[0][0] != -1 && vis[0][0] == vis[1][1] && vis[1][1] == vis[2][2]) return vis[0][0];
if (vis[0][2] != -1 && vis[0][2] == vis[1][1] && vis[1][1] == vis[2][0]) return vis[0][2];
long sum1 = 0, sum2 = 0;
int tot = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (vis[i][j] == 0) sum1 += a[i][j];
else if (vis[i][j] == 1) sum2 += a[i][j];
else tot++;
}
}
if (tot == 0) return sum1 > sum2 ? 0 : 1;
return 2;
}
public static int dfs(int op) {
int x = check();
if (x != 2) return x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (vis[i][j] != -1) continue;
vis[i][j] = op;
int ans = dfs(op^1);
vis[i][j] = -1;
if (ans == op) return ans;
}
}
return op == 0 ? 1 : 0;
}
public static void solve() throws IOException{
a = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = in.nextInt();
}
}
vis = new int[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(vis[i], -1);
}
if (dfs(0) == 0) out.println("Takahashi");
else out.println("Aoki");
}
static boolean MULTI_CASE = false;
public static void main(String[] args) throws IOException {
if (MULTI_CASE) {
int T = in.nextInt();
for (int i = 0; i < T; ++i) {
solve();
}
} else {
solve();
}
out.close();
}
static InputReader in = new InputReader();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static class InputReader {
private StringTokenizer st;
private BufferedReader bf;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
st = null;
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public String nextLine() throws IOException {
return bf.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
/*
*/ | ConDefects/ConDefects/Code/abc349_e/Java/52407979 |
condefects-java_data_141 | import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = ns();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
long a[] = nl(n);
int cnt2[] = new int[n];
int cnt3[] = new int[n];
for(int i = 0; i < n; i ++) {
while(a[i] % 2 == 0) {
cnt2[i] ++;
a[i] /= 2;
}
while(a[i] % 3 == 0) {
cnt2[i] ++;
a[i] /= 3;
}
}
for(int i = 0; i < n - 1; i ++) {
if(a[i] != a[i + 1]) {
prtln(-1);
return;
}
}
prtln(sum(cnt2) + sum(cnt3) - (min(cnt2) + min(cnt3)) * n);
}
}
}
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = ns();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
long a[] = nl(n);
int cnt2[] = new int[n];
int cnt3[] = new int[n];
for(int i = 0; i < n; i ++) {
while(a[i] % 2 == 0) {
cnt2[i] ++;
a[i] /= 2;
}
while(a[i] % 3 == 0) {
cnt3[i] ++;
a[i] /= 3;
}
}
for(int i = 0; i < n - 1; i ++) {
if(a[i] != a[i + 1]) {
prtln(-1);
return;
}
}
prtln(sum(cnt2) + sum(cnt3) - (min(cnt2) + min(cnt3)) * n);
}
}
}
| ConDefects/ConDefects/Code/abc276_d/Java/39219588 |
condefects-java_data_142 | import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main implements Runnable {
public static void solve () {
int n = nextInt();
int[] count2 = new int[n], count3 = new int[n];
Set<Integer> remain = new HashSet<>();
for (int i=0; i<n; i++) {
int temp = nextInt();
while (temp%2 == 0) {
count2[i] += 1;
temp /= 2;
}
while (temp%3 == 0) {
count2[i] += 1;
temp /= 3;
}
remain.add(temp);
}
if (remain.size() > 1) {
println(-1);
return;
}
Arrays.sort(count2);
Arrays.sort(count3);
int min2 = count2[0], min3 = count3[0];
long ans = 0;
for (int i=0; i<n; i++) {
ans += count2[i] - min2;
ans += count3[i] - min3;
}
println(ans);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
// public static int[] dy = {-1, 0, 1, 0};
// public static int[] dx = {0, 1, 0, -1};
public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
new Thread(null, new Main(), "", 16 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
}
import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main implements Runnable {
public static void solve () {
int n = nextInt();
int[] count2 = new int[n], count3 = new int[n];
Set<Integer> remain = new HashSet<>();
for (int i=0; i<n; i++) {
int temp = nextInt();
while (temp%2 == 0) {
count2[i] += 1;
temp /= 2;
}
while (temp%3 == 0) {
count3[i] += 1;
temp /= 3;
}
remain.add(temp);
}
if (remain.size() > 1) {
println(-1);
return;
}
Arrays.sort(count2);
Arrays.sort(count3);
int min2 = count2[0], min3 = count3[0];
long ans = 0;
for (int i=0; i<n; i++) {
ans += count2[i] - min2;
ans += count3[i] - min3;
}
println(ans);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
// public static int[] dy = {-1, 0, 1, 0};
// public static int[] dx = {0, 1, 0, -1};
public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
new Thread(null, new Main(), "", 16 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc276_d/Java/39476917 |
condefects-java_data_143 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
Map<Integer, List<Integer>> slotNumSt = new HashMap<>();
int ansTime = 999999;
// 0-9の目ごとに何秒で止まるかリストで
for(int i = 0; i < 10; i++) slotNumSt.put(i, new ArrayList<Integer>());
for(int j = 0; j < num; j++) {
String[] s = sc.next().split("");
for(int k = 0; k < 10; k++) {
slotNumSt.get(Integer.parseInt(s[k])).add(k);
}
}
for(int slNum = 0; slNum < 10; slNum++) {
List<Integer> numList = slotNumSt.get(slNum);
Collections.sort(numList);
// 0-9までの目で最大何秒かかるかみたい
int maxT = 0;
//ループの回数と最終ループでは何秒で止まるか
int sLoop = 0;
int stopNum = 0;
// temp 数字毎のスロットループ回数確認
int tempCount = 0;
int tempNum = -1;
for(int sIndexCheck = 0; sIndexCheck < num; sIndexCheck++) {
if(tempNum != numList.get(sIndexCheck)) {
tempNum = numList.get(sIndexCheck);
tempCount = 0;
continue;
}
tempCount++;
if(tempCount >= sLoop) {
sLoop = tempCount;
stopNum = tempNum;
}
}
stopNum = tempNum;
maxT = sLoop * 10 + stopNum;
if(ansTime > maxT) ansTime = maxT;
}
System.out.print(ansTime);
sc.close();
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
Map<Integer, List<Integer>> slotNumSt = new HashMap<>();
int ansTime = 999999;
// 0-9の目ごとに何秒で止まるかリストで
for(int i = 0; i < 10; i++) slotNumSt.put(i, new ArrayList<Integer>());
for(int j = 0; j < num; j++) {
String[] s = sc.next().split("");
for(int k = 0; k < 10; k++) {
slotNumSt.get(Integer.parseInt(s[k])).add(k);
}
}
for(int slNum = 0; slNum < 10; slNum++) {
List<Integer> numList = slotNumSt.get(slNum);
Collections.sort(numList);
// 0-9までの目で最大何秒かかるかみたい
int maxT = 0;
//ループの回数と最終ループでは何秒で止まるか
int sLoop = 0;
int stopNum = 0;
// temp 数字毎のスロットループ回数確認
int tempCount = 0;
int tempNum = -1;
for(int sIndexCheck = 0; sIndexCheck < num; sIndexCheck++) {
if(tempNum != numList.get(sIndexCheck)) {
tempNum = numList.get(sIndexCheck);
tempCount = 0;
continue;
}
tempCount++;
if(tempCount >= sLoop) {
sLoop = tempCount;
stopNum = tempNum;
}
}
if(tempCount >= sLoop) stopNum = tempNum;
maxT = sLoop * 10 + stopNum;
if(ansTime > maxT) ansTime = maxT;
}
System.out.print(ansTime);
sc.close();
}
} | ConDefects/ConDefects/Code/abc252_c/Java/39526653 |
condefects-java_data_144 | import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int maxInt = Integer.MAX_VALUE/3;
static long maxLong = Long.MAX_VALUE/3;
public static void main(String[] args) throws IOException {
new Thread(new Task()).start();
}
static class Task implements Runnable {
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
InputReader in = new InputReader(inputStream);
// for(int i=4;i<=4;i++) {
// InputStream uinputStream = new FileInputStream("timeline.in");
// String f = i+".in";
// InputStream uinputStream = new FileInputStream(f);
// InputReader in = new InputReader(uinputStream);
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
// }
//PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
try {
solve(in, out);
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
public void solve(InputReader in, PrintWriter out) throws IOException {
//System.out.println(Long.MAX_VALUE);
int n = in.nextInt();
long k = in.nextLong();
int[] arr = in.readIntArray(n);
long s[] = new long[n+1];
long sum = 0;
int cur = 0;
int step[] = new int[n];
int cnt = 0;
while(step[cur]==0) {
cnt++;
step[cur] = cnt;
sum+=arr[cur];
cur = (int) sum%n;
s[cnt] = sum;
}
int start = step[cur];
int end = cnt;
long cycle_sum = s[end] - s[start-1];
int sz = end-start+1;
long ret = 0;
if(end<=k) {
ret = s[start-1];
k-=(start-1);
ret += cycle_sum*(k/sz);
k%=sz;
ret += s[(int)k+start-1]-s[start-1];
}else {
ret = s[(int)k];
}
out.println(ret);
}
public static long modPow(long X, long K) {
long ret = 1;
while (K > 0) {
if ((K & 1) != 0) ret = (ret * X) % 998244353;
X = (X * X) % 998244353;
K = K >> 1;
}
return ret;
}
public static long inverse(long X) {
return modPow(X, 998244353 - 2);
}
public long GCD(long a, long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
class pair{
int f,t; long len;
public pair(int a, int b, long c) {
f = a;t=b;len=c;
}
}
public ArrayList<edge>[] getG(int n){
ArrayList<edge>[] g = new ArrayList[n];
for(int i=0;i<n;i++) g[i] = new ArrayList<edge>();
return g;
}
public class edge implements Comparable<edge> {
int f, t;
int len;
int id;
public edge(int a, int b, int c, int d) {
f = a;
t = b;
len = c;
id = d;
}
@Override
public int compareTo(Main.Task.edge o) {
if (this.len - o.len < 0)
return -1;
else if (this.len == o.len)
return 0;
else
return 1;
}
}
List<List<Integer>> convert(int arr[][]) {
int n = arr.length;
List<List<Integer>> ret = new ArrayList<>();
for (int i = 0; i < n; i++) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int j = 0; j < arr[i].length; j++)
tmp.add(arr[i][j]);
ret.add(tmp);
}
return ret;
}
}
static class ArrayUtils {
static final long seed = System.nanoTime();
static final Random rand = new Random(seed);
public static void sort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
public static void sort(long[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(long[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
long t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
static class BIT {
long arr[];
int n;
public BIT(int a) {
n = a;
arr = new long[n];
}
long sum(int p) {
long s = 0;
while (p > 0) {
s += arr[p];
p -= p & (-p);
}
return s;
}
void add(int p, long v) {
while (p < n) {
arr[p] += v;
p += p & (-p);
}
}
}
static class DSU {
int[] arr;
int[] sz;
public DSU(int n) {
arr = new int[n];
sz = new int[n];
for (int i = 0; i < n; i++)
arr[i] = i;
Arrays.fill(sz, 1);
}
public int find(int a) {
if (arr[a] != a)
arr[a] = find(arr[a]);
return arr[a];
}
public void union(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y)
return;
arr[y] = x;
sz[x] += sz[y];
}
public int size(int x) {
return sz[find(x)];
}
}
private static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int zcurChar;
private int znumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (znumChars == -1)
throw new InputMismatchException();
if (zcurChar >= znumChars) {
zcurChar = 0;
try {
znumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (znumChars <= 0)
return -1;
}
return buf[zcurChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] readIntArray(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = nextInt();
}
return ret;
}
}
static class Dumper {
static void print_int_arr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_char_arr(char[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_double_arr(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(int[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(boolean[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print(Object o) {
System.out.println(o.toString());
}
static void getc() {
System.out.println("here");
}
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int maxInt = Integer.MAX_VALUE/3;
static long maxLong = Long.MAX_VALUE/3;
public static void main(String[] args) throws IOException {
new Thread(new Task()).start();
}
static class Task implements Runnable {
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
InputReader in = new InputReader(inputStream);
// for(int i=4;i<=4;i++) {
// InputStream uinputStream = new FileInputStream("timeline.in");
// String f = i+".in";
// InputStream uinputStream = new FileInputStream(f);
// InputReader in = new InputReader(uinputStream);
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
// }
//PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
try {
solve(in, out);
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
public void solve(InputReader in, PrintWriter out) throws IOException {
//System.out.println(Long.MAX_VALUE);
int n = in.nextInt();
long k = in.nextLong();
int[] arr = in.readIntArray(n);
long s[] = new long[n+1];
long sum = 0;
int cur = 0;
int step[] = new int[n];
int cnt = 0;
while(step[cur]==0) {
cnt++;
step[cur] = cnt;
sum+=arr[cur];
cur = (int) (sum%n);
s[cnt] = sum;
}
int start = step[cur];
int end = cnt;
long cycle_sum = s[end] - s[start-1];
int sz = end-start+1;
long ret = 0;
if(end<=k) {
ret = s[start-1];
k-=(start-1);
ret += cycle_sum*(k/sz);
k%=sz;
ret += s[(int)k+start-1]-s[start-1];
}else {
ret = s[(int)k];
}
out.println(ret);
}
public static long modPow(long X, long K) {
long ret = 1;
while (K > 0) {
if ((K & 1) != 0) ret = (ret * X) % 998244353;
X = (X * X) % 998244353;
K = K >> 1;
}
return ret;
}
public static long inverse(long X) {
return modPow(X, 998244353 - 2);
}
public long GCD(long a, long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
class pair{
int f,t; long len;
public pair(int a, int b, long c) {
f = a;t=b;len=c;
}
}
public ArrayList<edge>[] getG(int n){
ArrayList<edge>[] g = new ArrayList[n];
for(int i=0;i<n;i++) g[i] = new ArrayList<edge>();
return g;
}
public class edge implements Comparable<edge> {
int f, t;
int len;
int id;
public edge(int a, int b, int c, int d) {
f = a;
t = b;
len = c;
id = d;
}
@Override
public int compareTo(Main.Task.edge o) {
if (this.len - o.len < 0)
return -1;
else if (this.len == o.len)
return 0;
else
return 1;
}
}
List<List<Integer>> convert(int arr[][]) {
int n = arr.length;
List<List<Integer>> ret = new ArrayList<>();
for (int i = 0; i < n; i++) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int j = 0; j < arr[i].length; j++)
tmp.add(arr[i][j]);
ret.add(tmp);
}
return ret;
}
}
static class ArrayUtils {
static final long seed = System.nanoTime();
static final Random rand = new Random(seed);
public static void sort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
public static void sort(long[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(long[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
long t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
static class BIT {
long arr[];
int n;
public BIT(int a) {
n = a;
arr = new long[n];
}
long sum(int p) {
long s = 0;
while (p > 0) {
s += arr[p];
p -= p & (-p);
}
return s;
}
void add(int p, long v) {
while (p < n) {
arr[p] += v;
p += p & (-p);
}
}
}
static class DSU {
int[] arr;
int[] sz;
public DSU(int n) {
arr = new int[n];
sz = new int[n];
for (int i = 0; i < n; i++)
arr[i] = i;
Arrays.fill(sz, 1);
}
public int find(int a) {
if (arr[a] != a)
arr[a] = find(arr[a]);
return arr[a];
}
public void union(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y)
return;
arr[y] = x;
sz[x] += sz[y];
}
public int size(int x) {
return sz[find(x)];
}
}
private static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int zcurChar;
private int znumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (znumChars == -1)
throw new InputMismatchException();
if (zcurChar >= znumChars) {
zcurChar = 0;
try {
znumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (znumChars <= 0)
return -1;
}
return buf[zcurChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] readIntArray(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = nextInt();
}
return ret;
}
}
static class Dumper {
static void print_int_arr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_char_arr(char[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_double_arr(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(int[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(boolean[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print(Object o) {
System.out.println(o.toString());
}
static void getc() {
System.out.println("here");
}
}
} | ConDefects/ConDefects/Code/abc241_e/Java/40546302 |
condefects-java_data_145 | import java.util.*;
import java.io.*;
/*
08-06-2024 18:35
*/
class Main {
/*-----------------------your solution goes here----------------------*/
static void solve() throws IOException {
String s = ns();
long n = Long.parseLong(s);
long r = pow(10,s.length());
long gpSumNumerator = (pow(r,n)-1+mod)%mod; // gpSum = a*(r^n-1)/(r-1);
long gpSumDenominator = pow(((r-1+mod)%mod),mod-2);
long GPSum = (gpSumNumerator * gpSumDenominator)%mod;
long ans = (n * GPSum)%mod; // since n has taken as common so multiply it with GP sum.
pl(ans);
}
/*-------------------------------Main Method-----------------------------*/
public static void main(String[] args) throws IOException {
long startTime = System.nanoTime();
long initialMemoryUsed = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
boolean localFileReader = fileReader();
int testcase = 1;
while (testcase-- > 0) {
solve();
}
if (localFileReader) {
timeAndMemoryDetails(startTime, initialMemoryUsed);
}
close();
}
/*----------------------------Time and Memory------------------------------*/
static void timeAndMemoryDetails(long startTime, long initialMemory) {
final long MEGABYTE = 1024L * 1024L;
final long millisecond = 1000_000L;
long afterUsedMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
p("--------------------------\nExecution Time :");
p((System.nanoTime() - startTime) / millisecond);
p("ms \nMemory used :");
p((afterUsedMem - initialMemory) / MEGABYTE);
pl("MB");
}
/*------------------------------Variables -----------------------------*/
final static int imax = Integer.MAX_VALUE;
final static int i_min = Integer.MIN_VALUE;
final static long lmax = Long.MAX_VALUE;
final static long l_min = Long.MIN_VALUE;
final static int mod = 998244353;
final static int maxArraySize = 2_000_001;
static long[] fact;
/*--------------------------------------FastIO Class-------------------*/
static final private int BUFFER_SIZE = 1 << 16;
static private DataInputStream din = new DataInputStream(System.in);
static private final byte[] buffer = new byte[BUFFER_SIZE];
static private int bufferPointer, bytesRead;
/*-----------------local file reader ---------------------------------------*/
public static boolean fileReader() throws IOException {
String File = "someFile";
try {
File = System.getProperty("user.dir");
} catch (Exception ignored) {
}
if (new File(File).getName().equals("CP")) {
din = new DataInputStream(new FileInputStream("src/Input.txt"));
out = new PrintWriter(new FileOutputStream("src/Output.txt"));
return true;
}
return false;
}
/*-----------------------input methods-----------------------------------------*/
static String next() throws IOException {
StringBuilder buf = new StringBuilder();
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == ' ' || c == '\n' || c == '\r' || c == '\0') {
if (cnt == 0) continue;
else break;
} else
buf.append((char) c);
cnt++;
}
return buf.toString();
}
static char nc() throws IOException {
int c;
while ((c = read()) == '\n' || c == '\0' || c == '\r' || c == ' ') ;
return (char) c;
}
static char[] nca(int n) throws IOException {
char[] a = new char[n];
for (int i = 0; i < n; i++) {
a[i] = nc();
}
return a;
}
static int ni() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
static long nl() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
static double nd() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
static String ns() throws IOException {
return next();
}
static public String nextLine() throws IOException {
StringBuilder buf = new StringBuilder();
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n' || c == '\r' || c == '\0') {
if (cnt != 0) break;
else continue;
} else
buf.append((char) c);
cnt++;
}
return buf.toString();
}
static int[] nia(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}
static long[] nla(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nl();
}
return a;
}
static double[] nda(int n) throws IOException {
double[] a = new double[n];
for (int i = 0; i < n; i++) {
a[i] = nd();
}
return a;
}
static String[] nsa(int n) throws IOException {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = ns();
}
return s;
}
static private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
static private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
/*---------------------------------output methods-----------------------------------------------*/
static PrintWriter out = new PrintWriter(System.out);
/**
* print single space.
*/
static void ps() {
out.print(' ');
}
static void pl(int n) {
out.println(n);
}
static void pl(long n) {
out.println(n);
}
static void pl(char c) {
out.println(c);
}
static void pl(double n) {
out.println(n);
}
static void pl(String s) {
out.println(s);
}
/**
* print YES for true and NO for false.
*/
static void pl(boolean flag) {
pl(flag ? "YES" : "NO");
}
/**
* Print new line
*/
static void PL() {
out.println();
}
static <E> void pl(List<E> a) {
for (E e : a) {
p(e);
}
PL();
}
static void pl(Object o) {
out.println(o);
}
static <E> void p(List<E> a) {
for (E e : a) {
p(e);
}
}
static void p(int n) {
out.print(n);
ps();
}
static void p(long n) {
out.print(n);
ps();
}
static void p(double d) {
out.print(d);
ps();
}
static void p(char c) {
out.print(c);
ps();
}
static void p(String s) {
out.print(s);
ps();
}
static void p(Object o) {
out.print(o);
ps();
}
static void pl(int[] a) {
for (int e : a) {
p(e);
}
PL();
}
static void pl(long[] a) {
for (long e : a) {
p(e);
}
PL();
}
static void pl(String[] a) {
for (String e : a) {
p(e);
}
PL();
}
static void pl(char[] a) {
for (char e : a) {
p(e);
}
PL();
}
static void pl(double[] a) {
for (double e : a) {
p(e);
}
PL();
}
static void pl(boolean[] a) {
for (boolean e : a) {
out.print(e);
ps();
}
PL();
}
static void pl(Object[] a) {
for (Object e : a) {
p(e);
}
PL();
}
static void pl(int[][] a) {
for (int[] e : a) {
pl(e);
}
}
static void pl(long[][] a) {
for (long[] e : a) pl(e);
}
static void pl(double[][] a) {
for (double[] e : a) {
pl(e);
}
}
static void pl(char[][] a) {
for (char[] e : a) pl(e);
}
static void pl(Object[][] s) {
for (Object[] e : s) pl(e);
}
/**
* Closes the stream and releases any system resources associated with it.
* Closing a previously closed stream has no effect.
*/
static void close() throws IOException {
if (din != null) din.close();
out.close();
}
/*---------------------------------Frequently used methods------------------------------------------*/
static void reverse(int[] a) {
int n = a.length - 1, temp;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static void reverse(long[] a) {
long temp;
int n = a.length - 1;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static void reverse(double[] a) {
double temp;
int n = a.length - 1;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static double rootX(double a, double b, double c) {
double d = (b * b) - 4 * a * c;
return (Math.sqrt(d) - b) / (2 * a);
}
static double rootY(double a, double b, double c) {
double d = (b * b) - 4 * a * c;
return (-Math.sqrt(d) - b) / (2 * a);
}
static int gcd(int a, int b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
static int upperBound(int[] a, int key) {
int low = 0, high = a.length - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a[mid] >= key) {
ans = mid;
high = mid - 1;
} else low = mid + 1;
}
return ans;
}
static int lowerBound(int[] a, int key) {
int low = 0, high = a.length - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a[mid] <= key) {
ans = mid;
low = mid + 1;
} else high = mid - 1;
}
return ans;
}
static <Number extends Comparable<Number>> int lowerBound(List<Number> a, Number key) {
int low = 0, high = a.size() - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a.get(mid).compareTo(key) <= 0) {
ans = mid;
low = mid + 1;
} else high = mid - 1;
}
return ans;
}
static <Number extends Comparable<Number>> int upperBound(List<Number> a, Number key) {
int low = 0, high = a.size() - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a.get(mid).compareTo(key) >= 0) {
ans = mid;
high = mid - 1;
} else low = mid + 1;
}
return ans;
}
static boolean isPrime(int n) {
if (n < 2) return false;
int i = 1;
while (++i <= Math.sqrt(n))
if (n % i == 0) return false;
return true;
}//return true or false for prime check
static boolean isPrime(long l) {
if (l < 2) return false;
long i = 1;
while (++i <= Math.sqrt(l))
if (l % i == 0) return false;
return true;
}
static long pow(long a, long n) {
long ans = 1L;
while (n > 0L) {
if ((n & 1L) != 0L) {
ans = ((ans % mod) * a) % mod;
}
a = (a * a) % mod;
n >>= 1L;
}
return ans % mod;
}
static long pow(long a, int n) {
long ans = 1L;
while (n > 0) {
if ((n & 1L) != 0) {
ans = ((ans % mod) * a) % mod;
}
a = (a * a) % mod;
n >>= 1;
}
return ans % mod;
}
static String reverse(String s) {
StringBuilder reversedString = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; i++) {
reversedString.append(s.charAt(i));
}
return reversedString.reverse().toString();
}//Reverse the string;
static long nCr(long n, long r) {
if ((n - r) < r) {
return nCr(n, n - r);
}
long ans = 1;
for (long i = 1; i <= r; i++, n--) {
if (n % i == 0) {
ans = n / i * ans;
} else if (ans % i == 0) {
ans = ans / i * n;
} else {
ans = (ans * n) / i;
}
}
return ans;
}
static long rootFloor(long n) {
double tentativeRoot = Math.sqrt(n);
long low = (long) tentativeRoot - 3;
long ans = 0;
long high = low + 6;
while (low <= high) {
long mid = low + (high - low) / 2;
if ((mid * mid) <= n) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
return ans;
}
static long rootHigher(long n) {
return rootFloor(n) + 1;
}
static long rootCeil(long n) {
double tentativeRoot = Math.sqrt(n);
long low = (long) tentativeRoot - 3;
long ans = 0;
long high = low + 6;
while (low <= high) {
long mid = low + (high - low) / 2;
if ((mid * mid) >= n) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
static long rootLower(long n) {
return rootCeil(n) - 1;
}
static long inv(long val) {
return pow(val, mod - 2);
}
static long nCrWithMod(int n, int r) {
return ((fact[n] * inv(fact[r]) % mod) * inv(fact[n - r])) % mod;
}
static void factorial() {
fact = new long[maxArraySize];
fact[0] = 1;
for (int i = 1; i < maxArraySize; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
}
import java.util.*;
import java.io.*;
/*
08-06-2024 18:35
*/
class Main {
/*-----------------------your solution goes here----------------------*/
static void solve() throws IOException {
String s = ns();
long n = Long.parseLong(s);
long r = pow(10,s.length());
long gpSumNumerator = (pow(r,n)-1+mod)%mod; // gpSum = a*(r^n-1)/(r-1);
long gpSumDenominator = pow(((r-1+mod)%mod),mod-2);
long GPSum = (gpSumNumerator * gpSumDenominator)%mod;
long ans = ((n%mod) * GPSum)%mod; // since n has taken as common so multiply it with GP sum.
pl(ans);
}
/*-------------------------------Main Method-----------------------------*/
public static void main(String[] args) throws IOException {
long startTime = System.nanoTime();
long initialMemoryUsed = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
boolean localFileReader = fileReader();
int testcase = 1;
while (testcase-- > 0) {
solve();
}
if (localFileReader) {
timeAndMemoryDetails(startTime, initialMemoryUsed);
}
close();
}
/*----------------------------Time and Memory------------------------------*/
static void timeAndMemoryDetails(long startTime, long initialMemory) {
final long MEGABYTE = 1024L * 1024L;
final long millisecond = 1000_000L;
long afterUsedMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
p("--------------------------\nExecution Time :");
p((System.nanoTime() - startTime) / millisecond);
p("ms \nMemory used :");
p((afterUsedMem - initialMemory) / MEGABYTE);
pl("MB");
}
/*------------------------------Variables -----------------------------*/
final static int imax = Integer.MAX_VALUE;
final static int i_min = Integer.MIN_VALUE;
final static long lmax = Long.MAX_VALUE;
final static long l_min = Long.MIN_VALUE;
final static int mod = 998244353;
final static int maxArraySize = 2_000_001;
static long[] fact;
/*--------------------------------------FastIO Class-------------------*/
static final private int BUFFER_SIZE = 1 << 16;
static private DataInputStream din = new DataInputStream(System.in);
static private final byte[] buffer = new byte[BUFFER_SIZE];
static private int bufferPointer, bytesRead;
/*-----------------local file reader ---------------------------------------*/
public static boolean fileReader() throws IOException {
String File = "someFile";
try {
File = System.getProperty("user.dir");
} catch (Exception ignored) {
}
if (new File(File).getName().equals("CP")) {
din = new DataInputStream(new FileInputStream("src/Input.txt"));
out = new PrintWriter(new FileOutputStream("src/Output.txt"));
return true;
}
return false;
}
/*-----------------------input methods-----------------------------------------*/
static String next() throws IOException {
StringBuilder buf = new StringBuilder();
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == ' ' || c == '\n' || c == '\r' || c == '\0') {
if (cnt == 0) continue;
else break;
} else
buf.append((char) c);
cnt++;
}
return buf.toString();
}
static char nc() throws IOException {
int c;
while ((c = read()) == '\n' || c == '\0' || c == '\r' || c == ' ') ;
return (char) c;
}
static char[] nca(int n) throws IOException {
char[] a = new char[n];
for (int i = 0; i < n; i++) {
a[i] = nc();
}
return a;
}
static int ni() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
static long nl() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
static double nd() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg)
return -ret;
return ret;
}
static String ns() throws IOException {
return next();
}
static public String nextLine() throws IOException {
StringBuilder buf = new StringBuilder();
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n' || c == '\r' || c == '\0') {
if (cnt != 0) break;
else continue;
} else
buf.append((char) c);
cnt++;
}
return buf.toString();
}
static int[] nia(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}
static long[] nla(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nl();
}
return a;
}
static double[] nda(int n) throws IOException {
double[] a = new double[n];
for (int i = 0; i < n; i++) {
a[i] = nd();
}
return a;
}
static String[] nsa(int n) throws IOException {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = ns();
}
return s;
}
static private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0,
BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
static private byte read() throws IOException {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
}
/*---------------------------------output methods-----------------------------------------------*/
static PrintWriter out = new PrintWriter(System.out);
/**
* print single space.
*/
static void ps() {
out.print(' ');
}
static void pl(int n) {
out.println(n);
}
static void pl(long n) {
out.println(n);
}
static void pl(char c) {
out.println(c);
}
static void pl(double n) {
out.println(n);
}
static void pl(String s) {
out.println(s);
}
/**
* print YES for true and NO for false.
*/
static void pl(boolean flag) {
pl(flag ? "YES" : "NO");
}
/**
* Print new line
*/
static void PL() {
out.println();
}
static <E> void pl(List<E> a) {
for (E e : a) {
p(e);
}
PL();
}
static void pl(Object o) {
out.println(o);
}
static <E> void p(List<E> a) {
for (E e : a) {
p(e);
}
}
static void p(int n) {
out.print(n);
ps();
}
static void p(long n) {
out.print(n);
ps();
}
static void p(double d) {
out.print(d);
ps();
}
static void p(char c) {
out.print(c);
ps();
}
static void p(String s) {
out.print(s);
ps();
}
static void p(Object o) {
out.print(o);
ps();
}
static void pl(int[] a) {
for (int e : a) {
p(e);
}
PL();
}
static void pl(long[] a) {
for (long e : a) {
p(e);
}
PL();
}
static void pl(String[] a) {
for (String e : a) {
p(e);
}
PL();
}
static void pl(char[] a) {
for (char e : a) {
p(e);
}
PL();
}
static void pl(double[] a) {
for (double e : a) {
p(e);
}
PL();
}
static void pl(boolean[] a) {
for (boolean e : a) {
out.print(e);
ps();
}
PL();
}
static void pl(Object[] a) {
for (Object e : a) {
p(e);
}
PL();
}
static void pl(int[][] a) {
for (int[] e : a) {
pl(e);
}
}
static void pl(long[][] a) {
for (long[] e : a) pl(e);
}
static void pl(double[][] a) {
for (double[] e : a) {
pl(e);
}
}
static void pl(char[][] a) {
for (char[] e : a) pl(e);
}
static void pl(Object[][] s) {
for (Object[] e : s) pl(e);
}
/**
* Closes the stream and releases any system resources associated with it.
* Closing a previously closed stream has no effect.
*/
static void close() throws IOException {
if (din != null) din.close();
out.close();
}
/*---------------------------------Frequently used methods------------------------------------------*/
static void reverse(int[] a) {
int n = a.length - 1, temp;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static void reverse(long[] a) {
long temp;
int n = a.length - 1;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static void reverse(double[] a) {
double temp;
int n = a.length - 1;
for (int i = 0; i < (n + 1) / 2; i++) {
temp = a[i];
a[i] = a[n - i];
a[n - i] = temp;
}
}
static double rootX(double a, double b, double c) {
double d = (b * b) - 4 * a * c;
return (Math.sqrt(d) - b) / (2 * a);
}
static double rootY(double a, double b, double c) {
double d = (b * b) - 4 * a * c;
return (-Math.sqrt(d) - b) / (2 * a);
}
static int gcd(int a, int b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
static int upperBound(int[] a, int key) {
int low = 0, high = a.length - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a[mid] >= key) {
ans = mid;
high = mid - 1;
} else low = mid + 1;
}
return ans;
}
static int lowerBound(int[] a, int key) {
int low = 0, high = a.length - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a[mid] <= key) {
ans = mid;
low = mid + 1;
} else high = mid - 1;
}
return ans;
}
static <Number extends Comparable<Number>> int lowerBound(List<Number> a, Number key) {
int low = 0, high = a.size() - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a.get(mid).compareTo(key) <= 0) {
ans = mid;
low = mid + 1;
} else high = mid - 1;
}
return ans;
}
static <Number extends Comparable<Number>> int upperBound(List<Number> a, Number key) {
int low = 0, high = a.size() - 1;
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (a.get(mid).compareTo(key) >= 0) {
ans = mid;
high = mid - 1;
} else low = mid + 1;
}
return ans;
}
static boolean isPrime(int n) {
if (n < 2) return false;
int i = 1;
while (++i <= Math.sqrt(n))
if (n % i == 0) return false;
return true;
}//return true or false for prime check
static boolean isPrime(long l) {
if (l < 2) return false;
long i = 1;
while (++i <= Math.sqrt(l))
if (l % i == 0) return false;
return true;
}
static long pow(long a, long n) {
long ans = 1L;
while (n > 0L) {
if ((n & 1L) != 0L) {
ans = ((ans % mod) * a) % mod;
}
a = (a * a) % mod;
n >>= 1L;
}
return ans % mod;
}
static long pow(long a, int n) {
long ans = 1L;
while (n > 0) {
if ((n & 1L) != 0) {
ans = ((ans % mod) * a) % mod;
}
a = (a * a) % mod;
n >>= 1;
}
return ans % mod;
}
static String reverse(String s) {
StringBuilder reversedString = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; i++) {
reversedString.append(s.charAt(i));
}
return reversedString.reverse().toString();
}//Reverse the string;
static long nCr(long n, long r) {
if ((n - r) < r) {
return nCr(n, n - r);
}
long ans = 1;
for (long i = 1; i <= r; i++, n--) {
if (n % i == 0) {
ans = n / i * ans;
} else if (ans % i == 0) {
ans = ans / i * n;
} else {
ans = (ans * n) / i;
}
}
return ans;
}
static long rootFloor(long n) {
double tentativeRoot = Math.sqrt(n);
long low = (long) tentativeRoot - 3;
long ans = 0;
long high = low + 6;
while (low <= high) {
long mid = low + (high - low) / 2;
if ((mid * mid) <= n) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
return ans;
}
static long rootHigher(long n) {
return rootFloor(n) + 1;
}
static long rootCeil(long n) {
double tentativeRoot = Math.sqrt(n);
long low = (long) tentativeRoot - 3;
long ans = 0;
long high = low + 6;
while (low <= high) {
long mid = low + (high - low) / 2;
if ((mid * mid) >= n) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
static long rootLower(long n) {
return rootCeil(n) - 1;
}
static long inv(long val) {
return pow(val, mod - 2);
}
static long nCrWithMod(int n, int r) {
return ((fact[n] * inv(fact[r]) % mod) * inv(fact[n - r])) % mod;
}
static void factorial() {
fact = new long[maxArraySize];
fact[0] = 1;
for (int i = 1; i < maxArraySize; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
}
| ConDefects/ConDefects/Code/abc357_d/Java/54480933 |
condefects-java_data_146 | import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static long m = 998244353;
private static long mod(long a) { return ((a % m) + m) % m; }
private static long mul(long a, long b) { return mod(mod(a) * mod(b)); }
private static long mexp(long a, long p) {
long res = 1;
while(p > 0) { if((p & 1) == 1) res = mul(res, a); a = mul(a, a); p >>= 1; }
return res;
}
public static void main(String[] args) {
long n = sc.nextLong(); int len = String.valueOf(n).length();
long req = mexp(10, len);
long num = mexp(req, n) - 1, den = mexp(req - 1, m - 1);
System.out.println(mul(n, mul(num, den)));
}
}
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static long m = 998244353;
private static long mod(long a) { return ((a % m) + m) % m; }
private static long mul(long a, long b) { return mod(mod(a) * mod(b)); }
private static long mexp(long a, long p) {
long res = 1;
while(p > 0) { if((p & 1) == 1) res = mul(res, a); a = mul(a, a); p >>= 1; }
return res;
}
public static void main(String[] args) {
long n = sc.nextLong(); int len = String.valueOf(n).length();
long req = mexp(10, len);
long num = mexp(req, n) - 1, den = mexp(req - 1, m - 2);
System.out.println(mul(n, mul(num, den)));
}
} | ConDefects/ConDefects/Code/abc357_d/Java/54429197 |
condefects-java_data_147 | import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static ContestPrinter pw = new ContestPrinter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
//int T = sc.nextInt();
//for(int i = 0; i < T; i++)solve();
solve();
pw.flush();
}
public static void solve() {
int[] a = {2,3,5,7,11,13,17,19,23};
ArrayList<Integer> arr = new ArrayList<>();
int index = 1;
for(int loops : a){
for(int i = 1; i <= loops; i++){
if(i != loops){
arr.add(index+i);
sb.append(index+i).append(" ");
}else{
arr.add(index);
sb.append(index).append(" ");
}
}
index += loops;
}
long[] r = new long[a.length];
long[] m = new long[a.length];
System.out.println(arr.size());
System.out.println(sb.toString().trim());
int[] answer = sc.nextIntArray(arr.size());
index = 1;
int ri = 0;
for(int loops : a){
m[ri] = loops;
if(answer[index-1] == index){
r[ri] = loops-1;
}else{
r[ri] = answer[index-1]-(index+1);
}
index += loops;
ri++;
}
//r...modで割ったあまり m...mod 各要素番号iごとに定義
long[] ans = MathLib.crt(r,m);
System.out.println(ans[0]+1);
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
class MathLib{
private static long safe_mod(long x, long m){
x %= m;
if(x<0) x += m;
return x;
}
private static long[] inv_gcd(long a, long b){
a = safe_mod(a, b);
if(a==0) return new long[]{b,0};
long s=b, t=a;
long m0=0, m1=1;
while(t>0){
long u = s/t;
s -= t*u;
m0 -= m1*u;
long tmp = s; s = t; t = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0<0) m0 += b/s;
return new long[]{s,m0};
}
public static long pow_mod(long x, long n, int m){
assert n >= 0;
assert m >= 1;
if(m == 1)return 0L;
x = safe_mod(x, m);
long ans = 1L;
while(n > 0){
if((n&1) == 1) ans = (ans * x) % m;
x = (x*x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m){
assert(r.length == m.length);
int n = r.length;
long r0=0, m0=1;
for(int i=0; i<n; i++){
assert(1 <= m[i]);
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if(m0 < m1){
long tmp = r0; r0 = r1; r1 = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0%m1 == 0){
if(r0%m1 != r1) return new long[]{0,0};
continue;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1/g;
if((r1-r0)%g != 0) return new long[]{0,0};
long x = (r1-r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if(r0<0) r0 += m0;
//System.err.printf("%d %d\n", r0, m0);
}
return new long[]{r0, m0};
}
public static long floor_sum(long n, long m, long a, long b){
long ans = 0;
if(a >= m){
ans += (n-1) * n * (a/m) / 2;
a %= m;
}
if(b >= m){
ans += n * (b/m);
b %= m;
}
long y_max = (a*n+b) / m;
long x_max = y_max * m - b;
if(y_max == 0) return ans;
ans += (n - (x_max+a-1)/a) * y_max;
ans += floor_sum(y_max, a, m, (a-x_max%a)%a);
return ans;
}
}
/**
* refercence : https://github.com/NASU41/AtCoderLibraryForJava/blob/master/ContestIO/ContestScanner.java
*/
class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in){
this.in = in;
}
public ContestScanner(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
public ContestScanner(){
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit)
);
}
n = n * 10 + digit;
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long[] nextLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = this.nextInt();
return array;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width){
long[][] mat = new long[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width){
int[][] mat = new int[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width){
double[][] mat = new double[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = this.next();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
class ContestPrinter extends PrintWriter {
public ContestPrinter(PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printlnArray(String[] array) {
for (String i : array)
super.println(i);
}
public void printSpace(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++) {
super.print(o[i]);
super.print(" ");
}
super.println(o[n]);
}
public void println(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.println(o[n]);
}
public void printYN(boolean o) {
super.println(o ? "Yes" : "No");
}
public void print(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.print(o[n]);
}
public void printArray(Object[] array) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(" ");
}
super.println(array[n]);
}
public void printlnArray(Object[] array) {
for (Object i : array)
super.println(i);
}
public void printArray(int[] array, String separator) {
int n = array.length - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(int[] array) {
for (int i : array)
super.println(i);
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n]));
}
public void printlnArray(int[] array, java.util.function.IntUnaryOperator map) {
for (int i : array)
super.println(map.applyAsInt(i));
}
public void printlnArray(long[] array, java.util.function.LongUnaryOperator map) {
for (long i : array)
super.println(map.applyAsLong(i));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printlnArray(long[] array) {
for (long i : array)
super.println(i);
}
public void printArray(double[] array) {
printArray(array, " ");
}
public void printArray(double[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(double[] array) {
for (double i : array)
super.println(i);
}
public void printArray(boolean[] array, String a, String b) {
int n = array.length - 1;
for (int i = 0; i < n; i++)
super.print((array[i] ? a : b) + " ");
super.println(array[n] ? a : b);
}
public void printArray(boolean[] array) {
this.printArray(array, "Y", "N");
}
public void printArray(char[] array) {
for (char c : array)
this.print(c);
this.println();
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(ArrayList<?> array) {
this.printArray(array, " ");
}
public void printArray(ArrayList<?> array, String separator) {
int n = array.size() - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array.get(i).toString());
super.print(separator);
}
super.println(array.get(n).toString());
}
public void printlnArray(ArrayList<?> array) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(array.get(i).toString());
}
public void printlnArray(ArrayList<Integer> array, java.util.function.IntUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsInt(array.get(i)));
}
public void printlnArray(ArrayList<Long> array, java.util.function.LongUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsLong(array.get(i)));
}
public void printArray(int[][] array) {
for (int[] a : array)
this.printArray(a);
}
public void printArray(int[][] array, java.util.function.IntUnaryOperator map) {
for (int[] a : array)
this.printArray(a, map);
}
public void printArray(long[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] + " ");
super.println(array[i][m]);
}
}
public void printArray(long[][] array, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
super.print(map.applyAsLong(array[i][j]));
super.print(" ");
}
super.println(map.applyAsLong(array[i][m]));
}
}
public void printArray(boolean[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] ? "○ " : "× ");
super.println(array[i][m] ? "○" : "×");
}
}
public void printArray(char[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j]);
super.println();
}
}
}
import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static ContestPrinter pw = new ContestPrinter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
//int T = sc.nextInt();
//for(int i = 0; i < T; i++)solve();
solve();
pw.flush();
}
public static void solve() {
int[] a = {4,9,5,7,11,13,17,19,23};
ArrayList<Integer> arr = new ArrayList<>();
int index = 1;
for(int loops : a){
for(int i = 1; i <= loops; i++){
if(i != loops){
arr.add(index+i);
sb.append(index+i).append(" ");
}else{
arr.add(index);
sb.append(index).append(" ");
}
}
index += loops;
}
long[] r = new long[a.length];
long[] m = new long[a.length];
System.out.println(arr.size());
System.out.println(sb.toString().trim());
int[] answer = sc.nextIntArray(arr.size());
index = 1;
int ri = 0;
for(int loops : a){
m[ri] = loops;
if(answer[index-1] == index){
r[ri] = loops-1;
}else{
r[ri] = answer[index-1]-(index+1);
}
index += loops;
ri++;
}
//r...modで割ったあまり m...mod 各要素番号iごとに定義
long[] ans = MathLib.crt(r,m);
System.out.println(ans[0]+1);
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
class MathLib{
private static long safe_mod(long x, long m){
x %= m;
if(x<0) x += m;
return x;
}
private static long[] inv_gcd(long a, long b){
a = safe_mod(a, b);
if(a==0) return new long[]{b,0};
long s=b, t=a;
long m0=0, m1=1;
while(t>0){
long u = s/t;
s -= t*u;
m0 -= m1*u;
long tmp = s; s = t; t = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0<0) m0 += b/s;
return new long[]{s,m0};
}
public static long pow_mod(long x, long n, int m){
assert n >= 0;
assert m >= 1;
if(m == 1)return 0L;
x = safe_mod(x, m);
long ans = 1L;
while(n > 0){
if((n&1) == 1) ans = (ans * x) % m;
x = (x*x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m){
assert(r.length == m.length);
int n = r.length;
long r0=0, m0=1;
for(int i=0; i<n; i++){
assert(1 <= m[i]);
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if(m0 < m1){
long tmp = r0; r0 = r1; r1 = tmp;
tmp = m0; m0 = m1; m1 = tmp;
}
if(m0%m1 == 0){
if(r0%m1 != r1) return new long[]{0,0};
continue;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1/g;
if((r1-r0)%g != 0) return new long[]{0,0};
long x = (r1-r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if(r0<0) r0 += m0;
//System.err.printf("%d %d\n", r0, m0);
}
return new long[]{r0, m0};
}
public static long floor_sum(long n, long m, long a, long b){
long ans = 0;
if(a >= m){
ans += (n-1) * n * (a/m) / 2;
a %= m;
}
if(b >= m){
ans += n * (b/m);
b %= m;
}
long y_max = (a*n+b) / m;
long x_max = y_max * m - b;
if(y_max == 0) return ans;
ans += (n - (x_max+a-1)/a) * y_max;
ans += floor_sum(y_max, a, m, (a-x_max%a)%a);
return ans;
}
}
/**
* refercence : https://github.com/NASU41/AtCoderLibraryForJava/blob/master/ContestIO/ContestScanner.java
*/
class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in){
this.in = in;
}
public ContestScanner(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
public ContestScanner(){
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit)
);
}
n = n * 10 + digit;
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long[] nextLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = this.nextInt();
return array;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width){
long[][] mat = new long[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width){
int[][] mat = new int[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width){
double[][] mat = new double[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = this.next();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
class ContestPrinter extends PrintWriter {
public ContestPrinter(PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printlnArray(String[] array) {
for (String i : array)
super.println(i);
}
public void printSpace(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++) {
super.print(o[i]);
super.print(" ");
}
super.println(o[n]);
}
public void println(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.println(o[n]);
}
public void printYN(boolean o) {
super.println(o ? "Yes" : "No");
}
public void print(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.print(o[n]);
}
public void printArray(Object[] array) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(" ");
}
super.println(array[n]);
}
public void printlnArray(Object[] array) {
for (Object i : array)
super.println(i);
}
public void printArray(int[] array, String separator) {
int n = array.length - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(int[] array) {
for (int i : array)
super.println(i);
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n]));
}
public void printlnArray(int[] array, java.util.function.IntUnaryOperator map) {
for (int i : array)
super.println(map.applyAsInt(i));
}
public void printlnArray(long[] array, java.util.function.LongUnaryOperator map) {
for (long i : array)
super.println(map.applyAsLong(i));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printlnArray(long[] array) {
for (long i : array)
super.println(i);
}
public void printArray(double[] array) {
printArray(array, " ");
}
public void printArray(double[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(double[] array) {
for (double i : array)
super.println(i);
}
public void printArray(boolean[] array, String a, String b) {
int n = array.length - 1;
for (int i = 0; i < n; i++)
super.print((array[i] ? a : b) + " ");
super.println(array[n] ? a : b);
}
public void printArray(boolean[] array) {
this.printArray(array, "Y", "N");
}
public void printArray(char[] array) {
for (char c : array)
this.print(c);
this.println();
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(ArrayList<?> array) {
this.printArray(array, " ");
}
public void printArray(ArrayList<?> array, String separator) {
int n = array.size() - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array.get(i).toString());
super.print(separator);
}
super.println(array.get(n).toString());
}
public void printlnArray(ArrayList<?> array) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(array.get(i).toString());
}
public void printlnArray(ArrayList<Integer> array, java.util.function.IntUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsInt(array.get(i)));
}
public void printlnArray(ArrayList<Long> array, java.util.function.LongUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsLong(array.get(i)));
}
public void printArray(int[][] array) {
for (int[] a : array)
this.printArray(a);
}
public void printArray(int[][] array, java.util.function.IntUnaryOperator map) {
for (int[] a : array)
this.printArray(a, map);
}
public void printArray(long[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] + " ");
super.println(array[i][m]);
}
}
public void printArray(long[][] array, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
super.print(map.applyAsLong(array[i][j]));
super.print(" ");
}
super.println(map.applyAsLong(array[i][m]));
}
}
public void printArray(boolean[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] ? "○ " : "× ");
super.println(array[i][m] ? "○" : "×");
}
}
public void printArray(char[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j]);
super.println();
}
}
}
| ConDefects/ConDefects/Code/abc286_f/Java/43252733 |
condefects-java_data_148 | import java.util.*;
public class Main{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int k=sc.nextInt();
int nums[]=new int[n];
for(int i=0;i<n;i++)
{
nums[i]=sc.nextInt();
}
int idx=0;
int cnt=0;
int temp=k;
while(idx<n)
{
if(nums[idx]<=temp)
{
temp-=nums[idx];
}else
{
cnt++;
temp=k;
temp-=nums[idx];
}
idx++;
}
System.out.println(cnt);
}
}
import java.util.*;
public class Main{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int k=sc.nextInt();
int nums[]=new int[n];
for(int i=0;i<n;i++)
{
nums[i]=sc.nextInt();
}
int idx=0;
int cnt=1;
int temp=k;
while(idx<n)
{
if(nums[idx]<=temp)
{
temp-=nums[idx];
}else
{
cnt++;
temp=k;
temp-=nums[idx];
}
idx++;
}
System.out.println(cnt);
}
} | ConDefects/ConDefects/Code/abc353_b/Java/53985222 |
condefects-java_data_149 | import java.util.*;
public class Main{
public static void main(String[]args){
Scanner scan = new Scanner(System.in);
Queue<Integer> queue = new PriorityQueue<Integer> ();
int [] line=new int[scan.nextInt()];
int cap = scan.nextInt();
int on = 0;
int count =1;
for(int j =0;j<line.length;j++)
line[j]=scan.nextInt();
for(int i =0;i<line.length;i++){
if(line[i]<cap-on)
on = on + line[i];
else{
count++;
on = line[i];
}
}
System.out.println(count);}}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner scan = new Scanner(System.in);
Queue<Integer> queue = new PriorityQueue<Integer> ();
int [] line=new int[scan.nextInt()];
int cap = scan.nextInt();
int on = 0;
int count =1;
for(int j =0;j<line.length;j++)
line[j]=scan.nextInt();
for(int i =0;i<line.length;i++){
if(line[i]<=cap-on)
on = on + line[i];
else{
count++;
on = line[i];
}
}
System.out.println(count);}} | ConDefects/ConDefects/Code/abc353_b/Java/53753876 |
condefects-java_data_150 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner (System.in);
int N,K,i,j;
int count = 0;
i=0;
N = s.nextInt();
K = s.nextInt();
int A[] = new int[N];
A[i] = s.nextInt();
j=A[0];
// System.out.println(j);
// System.out.println(K);
for(i=1; i<N ;i++) {
A[i] = s.nextInt();
// System.out.print(A[i] + "a ");
if(K-j < A[i]) { //K-j:残席数<次の乗る人数 発車する場合
count=count+1; //発車数
// System.out.println(count);
j=A[i]; //乗ってる人数
}
else if(K-j == A[i]){
count++;
j = 0;
}
else {
j = j +A[i]; //乗ってる人数
// System.out.print(j + "j ");
}
}
// System.out.println("ループからぬけたよー");
if(K-j==0) {
System.out.println(count);
}
else {
System.out.println(count+1);
}
s.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner (System.in);
int N,K,i,j;
int count = 0;
i=0;
N = s.nextInt();
K = s.nextInt();
int A[] = new int[N];
A[i] = s.nextInt();
j=A[0];
// System.out.println(j);
// System.out.println(K);
for(i=1; i<N ;i++) {
A[i] = s.nextInt();
// System.out.print(A[i] + "a ");
if(K-j < A[i]) { //K-j:残席数<次の乗る人数 発車する場合
count=count+1; //発車数
// System.out.println(count);
j=A[i]; //乗ってる人数
}
else if(K-j == A[i]){
count++;
j = 0;
}
else {
j = j +A[i]; //乗ってる人数
// System.out.print(j + "j ");
}
}
// System.out.println("ループからぬけたよー");
if(j==0) {
System.out.println(count);
}
else {
System.out.println(count+1);
}
s.close();
}
}
| ConDefects/ConDefects/Code/abc353_b/Java/54226692 |
condefects-java_data_151 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n, k;
n = s.nextInt();
k = s.nextInt();
int a[] = new int[n];
int i;
for(i = 0; i < n; i++) {
a[i] = s.nextInt();
}
// for(i = 0; i < n; i++) {
// System.out.println(a[i]);
// }
int count = 0, result = k;
for(i = 0; i < n; i++) {
if(result > a[i]) {
result -= a[i];
}else if(result == a[i]) {
result = k;
count++;
}else {
count++;
result = k - a[i];
}
// if(i == n-1 && k > result) {
// count++;
// }
}
if(result > 0) {
count++;
}
System.out.println(count);
s.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n, k;
n = s.nextInt();
k = s.nextInt();
int a[] = new int[n];
int i;
for(i = 0; i < n; i++) {
a[i] = s.nextInt();
}
// for(i = 0; i < n; i++) {
// System.out.println(a[i]);
// }
int count = 0, result = k;
for(i = 0; i < n; i++) {
if(result > a[i]) {
result -= a[i];
}else if(result == a[i]) {
result = k;
count++;
}else {
count++;
result = k - a[i];
}
// if(i == n-1 && k > result) {
// count++;
// }
}
if(result != k) {
count++;
}
System.out.println(count);
s.close();
}
}
| ConDefects/ConDefects/Code/abc353_b/Java/54201847 |
condefects-java_data_152 | import java.util.*;
import java.io.*;
public class Main {
static final Random random=new Random();
public static void main(String args[]) {
Scanner ans = new Scanner(System.in);
int n = ans.nextInt(); int k = ans.nextInt();
int[] arr = new int[n];
for (int i = 0; i <n; i++) {
arr[i] = ans.nextInt();
}
int kco = k; int sum = 0; int ans1 =0;
for (int i = 0; i < n; i++) {
kco = kco -arr[i];
if(kco<0){
ans1 = ans1+1;
kco = k-arr[i];
if(kco==0 && i ==n-1){
ans1 = ans1+1;
kco = k;
}
}
else if (kco==0 || i ==n-1) {
kco = k;
ans1 = ans1+1;
}
}
System.out.println(ans1);
}
static void ruffleSort(int[] a) {
int n=a.length;
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
}
import java.util.*;
import java.io.*;
public class Main {
static final Random random=new Random();
public static void main(String args[]) {
Scanner ans = new Scanner(System.in);
int n = ans.nextInt(); int k = ans.nextInt();
int[] arr = new int[n];
for (int i = 0; i <n; i++) {
arr[i] = ans.nextInt();
}
int kco = k; int sum = 0; int ans1 =0;
for (int i = 0; i < n; i++) {
kco = kco -arr[i];
if(kco<0){
ans1 = ans1+1;
kco = k-arr[i];
if(kco==0 || i ==n-1){
ans1 = ans1+1;
kco = k;
}
}
else if (kco==0 || i ==n-1) {
kco = k;
ans1 = ans1+1;
}
}
System.out.println(ans1);
}
static void ruffleSort(int[] a) {
int n=a.length;
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
}
| ConDefects/ConDefects/Code/abc353_b/Java/53683202 |
condefects-java_data_153 |
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
@SuppressWarnings("unused")
public class Main {
static InputStream is;
static PrintWriter out;
static String INPUT = "";
//global
private final static int BASE = 998244353;
private static long[] BIT;
private static void update(int i, long k) {
while (i<BIT.length) {
BIT[i] = (BIT[i] + k)%BASE;
i = i + (i&(-i));
}
}
private static long get(int i) {
long tmp=0;
while (i>0) {
tmp = (tmp+BIT[i]) % BASE;
i = i - (i&(-i));
}
return tmp;
}
static void solve() {
int N = readInt();
int[] A = readIntArray(N);
BIT = new long[N+1];
long[] S = new long[N+1];
S[0] = 1l*A[0];
for (int i=1;i<N;i++) S[i] = S[i-1] + 1L*A[i];
Set<Long> used = new HashSet<>();
for (int i=0;i<N;i++) {
if (used.contains(S[i])) continue;
used.add(S[i]);
update(i+1, 1);
}
Map<Long, Integer> last = new HashMap<>();
for (int i=0;i<N-1;i++) {
//withou suffix = 0
long F;
if (!last.containsKey(S[i])) {
F = get(i);
} else {
F = (get(i) - get(last.get(S[i])) + BASE) % BASE;
}
last.put(S[i], i);
update(i+1, F);
}
out.println((get(N) - get(0) + 1 + BASE)%BASE);
}
public static void main(String[] args) throws Exception
{
long S = System.currentTimeMillis();
if (INPUT=="") {
is = System.in;
} else {
File file = new File(INPUT);
is = new FileInputStream(file);
}
out = new PrintWriter(System.out);
solve();
out.flush();
long G = System.currentTimeMillis();
}
private static class ListComparator<T extends Comparable<T>> implements Comparator<List<T>> {
public ListComparator() {}
@Override
public int compare(List<T> o1, List<T> o2) {
for (int i = 0; i < Math.min(o1.size(), o2.size()); i++) {
int c = o1.get(i).compareTo(o2.get(i));
if (c != 0) {
return c;
}
}
return Integer.compare(o1.size(), o2.size());
}
}
private static boolean eof()
{
if(lenbuf == -1)return true;
int lptr = ptrbuf;
while(lptr < lenbuf)if(!isSpaceChar(inbuf[lptr++]))return false;
try {
is.mark(1000);
while(true){
int b = is.read();
if(b == -1){
is.reset();
return true;
}else if(!isSpaceChar(b)){
is.reset();
return false;
}
}
} catch (IOException e) {
return true;
}
}
private static byte[] inbuf = new byte[1024];
static int lenbuf = 0, ptrbuf = 0;
private static int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
// private static boolean isSpaceChar(int c) { return !(c >= 32 && c <= 126); }
private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private static double readDouble() { return Double.parseDouble(readString()); }
private static char readChar() { return (char)skip(); }
private static String readString()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private static char[] readChar(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private static char[][] readTable(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = readChar(m);
return map;
}
private static int[] readIntArray(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = readInt();
return a;
}
private static long[] readLongArray(int n) {
long[] a = new long[n];
for (int i=0;i<n;i++) a[i] = readLong();
return a;
}
private static int readInt()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static long readLong()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
}
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
@SuppressWarnings("unused")
public class Main {
static InputStream is;
static PrintWriter out;
static String INPUT = "";
//global
private final static int BASE = 998244353;
private static long[] BIT;
private static void update(int i, long k) {
while (i<BIT.length) {
BIT[i] = (BIT[i] + k)%BASE;
i = i + (i&(-i));
}
}
private static long get(int i) {
long tmp=0;
while (i>0) {
tmp = (tmp+BIT[i]) % BASE;
i = i - (i&(-i));
}
return tmp;
}
static void solve() {
int N = readInt();
int[] A = readIntArray(N);
BIT = new long[N+1];
long[] S = new long[N+1];
S[0] = 1l*A[0];
for (int i=1;i<N;i++) S[i] = S[i-1] + 1L*A[i];
Set<Long> used = new HashSet<>();
for (int i=0;i<N-1;i++) {
if (used.contains(S[i])) continue;
used.add(S[i]);
update(i+1, 1);
}
Map<Long, Integer> last = new HashMap<>();
for (int i=0;i<N-1;i++) {
//withou suffix = 0
long F;
if (!last.containsKey(S[i])) {
F = get(i);
} else {
F = (get(i) - get(last.get(S[i])) + BASE) % BASE;
}
last.put(S[i], i);
update(i+1, F);
}
out.println((get(N) - get(0) + 1 + BASE)%BASE);
}
public static void main(String[] args) throws Exception
{
long S = System.currentTimeMillis();
if (INPUT=="") {
is = System.in;
} else {
File file = new File(INPUT);
is = new FileInputStream(file);
}
out = new PrintWriter(System.out);
solve();
out.flush();
long G = System.currentTimeMillis();
}
private static class ListComparator<T extends Comparable<T>> implements Comparator<List<T>> {
public ListComparator() {}
@Override
public int compare(List<T> o1, List<T> o2) {
for (int i = 0; i < Math.min(o1.size(), o2.size()); i++) {
int c = o1.get(i).compareTo(o2.get(i));
if (c != 0) {
return c;
}
}
return Integer.compare(o1.size(), o2.size());
}
}
private static boolean eof()
{
if(lenbuf == -1)return true;
int lptr = ptrbuf;
while(lptr < lenbuf)if(!isSpaceChar(inbuf[lptr++]))return false;
try {
is.mark(1000);
while(true){
int b = is.read();
if(b == -1){
is.reset();
return true;
}else if(!isSpaceChar(b)){
is.reset();
return false;
}
}
} catch (IOException e) {
return true;
}
}
private static byte[] inbuf = new byte[1024];
static int lenbuf = 0, ptrbuf = 0;
private static int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
// private static boolean isSpaceChar(int c) { return !(c >= 32 && c <= 126); }
private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private static double readDouble() { return Double.parseDouble(readString()); }
private static char readChar() { return (char)skip(); }
private static String readString()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private static char[] readChar(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private static char[][] readTable(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = readChar(m);
return map;
}
private static int[] readIntArray(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = readInt();
return a;
}
private static long[] readLongArray(int n) {
long[] a = new long[n];
for (int i=0;i<n;i++) a[i] = readLong();
return a;
}
private static int readInt()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static long readLong()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private static void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
}
| ConDefects/ConDefects/Code/abc230_f/Java/31402681 |
condefects-java_data_154 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
public class Main{
public static void main(String[] args){
InputStreamReader input = new InputStreamReader(System.in);
BufferedReader buff = new BufferedReader(input);
try{
String[] str = buff.readLine().split(" ");
int N = Integer.parseInt(str[0]);
int M = Integer.parseInt(str[1]);
long ans = 0L;
String[] tmp = buff.readLine().split(" ");
long[] dish = new long[M];
int[] aa = new int[N];
for( int i = 0; i < N; i++){
aa[i] = Integer.parseInt(tmp[i]);
}
Arrays.sort(aa);
System.out.println(Arrays.toString(aa));
for( int i = N - 1, min = N - M, j = 0 ; i >= min; i--, j++){
dish[j] += aa[i];
}
for( int i = N - M - 1, j = M - 1; i >= 0 ; i--, j-- ){
dish[j] += aa[i];
}
for( int i = 0 ; i < M; i++){
long a = dish[i];
ans += a*a;
}
System.out.print(ans);
buff.close();
}catch( IOException e){
System.out.println(e);
}
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
public class Main{
public static void main(String[] args){
InputStreamReader input = new InputStreamReader(System.in);
BufferedReader buff = new BufferedReader(input);
try{
String[] str = buff.readLine().split(" ");
int N = Integer.parseInt(str[0]);
int M = Integer.parseInt(str[1]);
long ans = 0L;
String[] tmp = buff.readLine().split(" ");
long[] dish = new long[M];
int[] aa = new int[N];
for( int i = 0; i < N; i++){
aa[i] = Integer.parseInt(tmp[i]);
}
Arrays.sort(aa);
//System.out.println(Arrays.toString(aa));
for( int i = N - 1, min = N - M, j = 0 ; i >= min; i--, j++){
dish[j] += aa[i];
}
for( int i = N - M - 1, j = M - 1; i >= 0 ; i--, j-- ){
dish[j] += aa[i];
}
for( int i = 0 ; i < M; i++){
long a = dish[i];
ans += a*a;
}
System.out.print(ans);
buff.close();
}catch( IOException e){
System.out.println(e);
}
}
} | ConDefects/ConDefects/Code/arc167_a/Java/46634830 |
condefects-java_data_155 | import java.util.Scanner;
public class Main{
public static void main(String []args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
int p = (x + (n - 1) / n);
System.out.println((char) ('A' + (p - 1)));
}
}
import java.util.Scanner;
public class Main{
public static void main(String []args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
int p = (x + (n - 1)) / n;
System.out.println((char) ('A' + (p - 1)));
}
} | ConDefects/ConDefects/Code/abc257_a/Java/40532983 |
condefects-java_data_156 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
sc.close();
int index = x/n-1;
System.out.println((char)('A'+index));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
sc.close();
int index = (x-1)/n;
System.out.println((char)('A'+index));
}
} | ConDefects/ConDefects/Code/abc257_a/Java/36879488 |
condefects-java_data_157 | import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int c = sc.nextInt();
int n = sc.nextInt();
String a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if(n % c == 0){
System.out.println(a.charAt(n / c - 1) + "");
}else {
System.out.println(a.charAt(n / c + 2) + "");
}
}
}
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int c = sc.nextInt();
int n = sc.nextInt();
String a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if(n % c == 0){
System.out.println(a.charAt(n / c - 1) + "");
}else {
System.out.println(a.charAt(n / c) + "");
}
}
} | ConDefects/ConDefects/Code/abc257_a/Java/42234047 |
condefects-java_data_158 | import java.util.*;
public class Main {
public static void main(String[] args) {
// 入力読み込み
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
int v = X/N-1;
char a = 'A';
for (int i = 0; i < v; i++) {
a++;
}
System.out.println(a);
sc.close();
}
}
// Set<Long> list = new HashSet<>();
import java.util.*;
public class Main {
public static void main(String[] args) {
// 入力読み込み
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
int v = ((X+N-1)/N)-1;
char a = 'A';
for (int i = 0; i < v; i++) {
a++;
}
System.out.println(a);
sc.close();
}
}
// Set<Long> list = new HashSet<>(); | ConDefects/ConDefects/Code/abc257_a/Java/36031432 |
condefects-java_data_159 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int repeat = sc.nextInt();
int target = sc.nextInt();
char[] alph = new char[26];
char c = 'a';
for(int i = 0; i < 26; i++)
alph[i] = c++;
char[] output = new char[26*repeat];
int num = 0;
for(int j = 0; j < 26; j++)
for(int k = 0; k < repeat; k++)
output[num++] = alph[j];
String out = new String(output);
System.out.println(out.substring(target - 1, target));
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int repeat = sc.nextInt();
int target = sc.nextInt();
char[] alph = new char[26];
char c = 'A';
for(int i = 0; i < 26; i++)
alph[i] = c++;
char[] output = new char[26*repeat];
int num = 0;
for(int j = 0; j < 26; j++)
for(int k = 0; k < repeat; k++)
output[num++] = alph[j];
String out = new String(output);
System.out.println(out.substring(target - 1, target));
}
} | ConDefects/ConDefects/Code/abc257_a/Java/35934171 |
condefects-java_data_160 | import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
//
int n = sc.nextInt();
int x = sc.nextInt();
System.out.println((char)(64+(x+1)/n));
}
}
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
//
int n = sc.nextInt();
int x = sc.nextInt();
System.out.println((char)(65+(x-1)/n));
}
}
| ConDefects/ConDefects/Code/abc257_a/Java/46158021 |
condefects-java_data_161 | import static java.lang.System.out;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.*;
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
out.println(solve());
}
private static Object solve() {
sc.next();
var s = sc.next();
boolean hasM = false;
for (int i = 0; i < s.length(); i++) if (s.charAt(i) == '-') {
hasM = true;
break;
}
if (!hasM) return -1;
int ans = 0, cur = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == 'o') ans = max(ans, ++cur);
else cur = 0;
}
return ans;
}
}
import static java.lang.System.out;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.*;
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
out.println(solve());
}
private static Object solve() {
sc.next();
var s = sc.next();
boolean hasM = false;
for (int i = 0; i < s.length(); i++) if (s.charAt(i) == '-') {
hasM = true;
break;
}
if (!hasM) return -1;
int ans = 0, cur = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == 'o') ans = max(ans, ++cur);
else cur = 0;
}
return ans == 0 ? -1 : ans;
}
}
| ConDefects/ConDefects/Code/abc299_c/Java/44876567 |
condefects-java_data_162 | import java.util.Scanner;
import static java.lang.Math.max;
public class Main {public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String s=sc.next();
int a=s.indexOf('-');
int res=-1;
for(int i=0;i<s.length();i++){
if(s.charAt(i)=='o'){
int j=i;
int ans=0;
while(j<s.length()&&s.charAt(j)=='o') {
ans++;
j++;
}
if(j!=s.length())res=max(res,ans);
if(j!=0)res=max(res,ans);
i=j-1;
}
}
System.out.println(res);
}
}
import java.util.Scanner;
import static java.lang.Math.max;
public class Main {public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String s=sc.next();
int a=s.indexOf('-');
int res=-1;
for(int i=0;i<s.length();i++){
if(s.charAt(i)=='o'){
int j=i;
int ans=0;
while(j<s.length()&&s.charAt(j)=='o') {
ans++;
j++;
}
if(j!=s.length())res=max(res,ans);
if(i!=0)res=max(res,ans);
i=j-1;
}
}
System.out.println(res);
}
}
| ConDefects/ConDefects/Code/abc299_c/Java/41291066 |
condefects-java_data_163 | //package com.example.practice.codeforces.below2000;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.StringTokenizer;
//atcoder: D - M<=ab
public class Main {
public static void main(String [] args) throws IOException {
// Use BufferedReader rather than RandomAccessFile; it's much faster
final BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
final PrintWriter out = new PrintWriter(System.out);
// input file name goes above
int Q = 1;//Integer.parseInt(input.readLine());
while (Q > 0) {
StringTokenizer st = new StringTokenizer(input.readLine());
final long n = Long.parseLong(st.nextToken()), m = Long.parseLong(st.nextToken());
out.println(calc(n, m));
Q--;
}
out.close(); // close the output file
}
private static long calc(final long n, final long m) {
if (m <= n)return m;
if (m/n > n || (m/n == n && m%n > 0)){
return -1;
}
final long d = (long) Math.sqrt(m);
long res = -1;
for (int i=2;i<=d && i<=n;++i){
if (m%i == 0){
if (m/i <= n){
return m;
}
}else {
long k = m/i;
if (k < n){
if (res==-1 || res > i*(k+1)){
res = i * (k+1);
}
}
}
}
return res;
}
private static void printArray(long[] ns, final PrintWriter out){
for (int i=0;i<ns.length;++i){
out.print(ns[i]);
if (i+1<ns.length)out.print(" ");
else out.println();
}
}
private static void printArrayInt(int[] ns, final PrintWriter out){
for (int i=0;i<ns.length;++i){
out.print(ns[i]);
if (i+1<ns.length)out.print(" ");
else out.println();
}
}
private static void printArrayVertical(long[] ns, final PrintWriter out){
for (long a : ns){
out.println(a);
}
}
private static void printArrayVerticalInt(int[] ns, final PrintWriter out){
for (int a : ns){
out.println(a);
}
}
private static void printArray2D(long[][] ns, final int len, final PrintWriter out){
int cnt = 0;
for (long[] kk : ns){
cnt++;
if (cnt > len)break;
for (int i=0;i<kk.length;++i){
out.print(kk[i]);
if (i+1<kk.length)out.print(" ");
else out.println();
}
}
}
private static void printArray2DInt(int[][] ns, final int len, final PrintWriter out){
int cnt = 0;
for (int[] kk : ns){
cnt++;
if (cnt > len)break;
for (int i=0;i<kk.length;++i){
out.print(kk[i]);
if (i+1<kk.length)out.print(" ");
else out.println();
}
}
}
private static long[] readArray(final int n, final BufferedReader input) throws IOException{
long[] ns = new long[n];
StringTokenizer st = new StringTokenizer(input.readLine());
for (int i=0;i<n;++i){
ns[i] = Long.parseLong(st.nextToken());
}
return ns;
}
private static int[] readArrayInt(final int n, final BufferedReader input) throws IOException{
int[] ns = new int[n];
StringTokenizer st = new StringTokenizer(input.readLine());
for (int i=0;i<n;++i){
ns[i] = Integer.parseInt(st.nextToken());
}
return ns;
}
private static long[] readArrayVertical(final int n, final BufferedReader input) throws IOException{
long[] ns = new long[n];
for (int i=0;i<n;++i){
ns[i] = Long.parseLong(input.readLine());
}
return ns;
}
private static int[] readArrayVerticalInt(final int n, final BufferedReader input) throws IOException{
int[] ns = new int[n];
for (int i=0;i<n;++i){
ns[i] = Integer.parseInt(input.readLine());
}
return ns;
}
private static long[][] readArray2D(final int n, final int len, final BufferedReader input) throws IOException{
long[][] ns = new long[len][];
for (int i=0;i<n;++i){
StringTokenizer st = new StringTokenizer(input.readLine());
ArrayList<Long> al = new ArrayList<>();
while (st.hasMoreTokens()){
al.add(Long.parseLong(st.nextToken()));
}
long[] kk = new long[al.size()];
for (int j=0;j<kk.length;++j){
kk[j] = al.get(j);
}
ns[i] = kk;
}
return ns;
}
private static int[][] readArray2DInt(final int n, final int len, final BufferedReader input) throws IOException{
int[][] ns = new int[len][];
for (int i=0;i<n;++i){
StringTokenizer st = new StringTokenizer(input.readLine());
ArrayList<Integer> al = new ArrayList<>();
while (st.hasMoreTokens()){
al.add(Integer.parseInt(st.nextToken()));
}
int[] kk = new int[al.size()];
for (int j=0;j<kk.length;++j){
kk[j] = al.get(j);
}
ns[i] = kk;
}
return ns;
}
private static int GCD(int x, int y){
if (x > y)return GCD(y, x);
if (x==0)return y;
return GCD(y%x, x);
}
private static long GCD(long x, long y){
if (x > y)return GCD(y, x);
if (x==0)return y;
return GCD(y%x, x);
}
private static ArrayList<int[]>[] convertToGraphUnDirectWithWeight(final int n, final int[][] es){
ArrayList<int[]>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(new int[]{e[1], e[2]});
als[e[1]].add(new int[]{e[0], e[2]});
}
return als;
}
private static ArrayList<int[]>[] convertToGraphDirectWithWeight(final int n, final int[][] es){
ArrayList<int[]>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(new int[]{e[1], e[2]});
}
return als;
}
private static ArrayList<Integer>[] convertToGraphUnDirect(final int n, final int[][] es){
ArrayList<Integer>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(e[1]);
als[e[1]].add(e[0]);
}
return als;
}
private static ArrayList<Integer>[] convertToGraphDirect(final int n, final int[][] es){
ArrayList<Integer>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(e[1]);
}
return als;
}
private static int find(final int[] rd, int idx){
while (idx != rd[idx]){
rd[idx] = rd[rd[idx]];
idx = rd[idx];
}
return idx;
}
}
//package com.example.practice.codeforces.below2000;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.StringTokenizer;
//atcoder: D - M<=ab
public class Main {
public static void main(String [] args) throws IOException {
// Use BufferedReader rather than RandomAccessFile; it's much faster
final BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
final PrintWriter out = new PrintWriter(System.out);
// input file name goes above
int Q = 1;//Integer.parseInt(input.readLine());
while (Q > 0) {
StringTokenizer st = new StringTokenizer(input.readLine());
final long n = Long.parseLong(st.nextToken()), m = Long.parseLong(st.nextToken());
out.println(calc(n, m));
Q--;
}
out.close(); // close the output file
}
private static long calc(final long n, final long m) {
if (m <= n)return m;
if (m/n > n || (m/n == n && m%n > 0)){
return -1;
}
final long d = (long) Math.sqrt(m);
long res = -1;
for (int i=2;i<=d+1 && i<=n;++i){
if (m%i == 0){
if (m/i <= n){
return m;
}
}else {
long k = m/i;
if (k < n){
if (res==-1 || res > i*(k+1)){
res = i * (k+1);
}
}
}
}
return res;
}
private static void printArray(long[] ns, final PrintWriter out){
for (int i=0;i<ns.length;++i){
out.print(ns[i]);
if (i+1<ns.length)out.print(" ");
else out.println();
}
}
private static void printArrayInt(int[] ns, final PrintWriter out){
for (int i=0;i<ns.length;++i){
out.print(ns[i]);
if (i+1<ns.length)out.print(" ");
else out.println();
}
}
private static void printArrayVertical(long[] ns, final PrintWriter out){
for (long a : ns){
out.println(a);
}
}
private static void printArrayVerticalInt(int[] ns, final PrintWriter out){
for (int a : ns){
out.println(a);
}
}
private static void printArray2D(long[][] ns, final int len, final PrintWriter out){
int cnt = 0;
for (long[] kk : ns){
cnt++;
if (cnt > len)break;
for (int i=0;i<kk.length;++i){
out.print(kk[i]);
if (i+1<kk.length)out.print(" ");
else out.println();
}
}
}
private static void printArray2DInt(int[][] ns, final int len, final PrintWriter out){
int cnt = 0;
for (int[] kk : ns){
cnt++;
if (cnt > len)break;
for (int i=0;i<kk.length;++i){
out.print(kk[i]);
if (i+1<kk.length)out.print(" ");
else out.println();
}
}
}
private static long[] readArray(final int n, final BufferedReader input) throws IOException{
long[] ns = new long[n];
StringTokenizer st = new StringTokenizer(input.readLine());
for (int i=0;i<n;++i){
ns[i] = Long.parseLong(st.nextToken());
}
return ns;
}
private static int[] readArrayInt(final int n, final BufferedReader input) throws IOException{
int[] ns = new int[n];
StringTokenizer st = new StringTokenizer(input.readLine());
for (int i=0;i<n;++i){
ns[i] = Integer.parseInt(st.nextToken());
}
return ns;
}
private static long[] readArrayVertical(final int n, final BufferedReader input) throws IOException{
long[] ns = new long[n];
for (int i=0;i<n;++i){
ns[i] = Long.parseLong(input.readLine());
}
return ns;
}
private static int[] readArrayVerticalInt(final int n, final BufferedReader input) throws IOException{
int[] ns = new int[n];
for (int i=0;i<n;++i){
ns[i] = Integer.parseInt(input.readLine());
}
return ns;
}
private static long[][] readArray2D(final int n, final int len, final BufferedReader input) throws IOException{
long[][] ns = new long[len][];
for (int i=0;i<n;++i){
StringTokenizer st = new StringTokenizer(input.readLine());
ArrayList<Long> al = new ArrayList<>();
while (st.hasMoreTokens()){
al.add(Long.parseLong(st.nextToken()));
}
long[] kk = new long[al.size()];
for (int j=0;j<kk.length;++j){
kk[j] = al.get(j);
}
ns[i] = kk;
}
return ns;
}
private static int[][] readArray2DInt(final int n, final int len, final BufferedReader input) throws IOException{
int[][] ns = new int[len][];
for (int i=0;i<n;++i){
StringTokenizer st = new StringTokenizer(input.readLine());
ArrayList<Integer> al = new ArrayList<>();
while (st.hasMoreTokens()){
al.add(Integer.parseInt(st.nextToken()));
}
int[] kk = new int[al.size()];
for (int j=0;j<kk.length;++j){
kk[j] = al.get(j);
}
ns[i] = kk;
}
return ns;
}
private static int GCD(int x, int y){
if (x > y)return GCD(y, x);
if (x==0)return y;
return GCD(y%x, x);
}
private static long GCD(long x, long y){
if (x > y)return GCD(y, x);
if (x==0)return y;
return GCD(y%x, x);
}
private static ArrayList<int[]>[] convertToGraphUnDirectWithWeight(final int n, final int[][] es){
ArrayList<int[]>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(new int[]{e[1], e[2]});
als[e[1]].add(new int[]{e[0], e[2]});
}
return als;
}
private static ArrayList<int[]>[] convertToGraphDirectWithWeight(final int n, final int[][] es){
ArrayList<int[]>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(new int[]{e[1], e[2]});
}
return als;
}
private static ArrayList<Integer>[] convertToGraphUnDirect(final int n, final int[][] es){
ArrayList<Integer>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(e[1]);
als[e[1]].add(e[0]);
}
return als;
}
private static ArrayList<Integer>[] convertToGraphDirect(final int n, final int[][] es){
ArrayList<Integer>[] als = new ArrayList[n+1];
for (int i=0;i<=n;++i){
als[i] = new ArrayList<>();
}
for (int[] e : es){
als[e[0]].add(e[1]);
}
return als;
}
private static int find(final int[] rd, int idx){
while (idx != rd[idx]){
rd[idx] = rd[rd[idx]];
idx = rd[idx];
}
return idx;
}
} | ConDefects/ConDefects/Code/abc296_d/Java/44835223 |
condefects-java_data_164 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
long n = io.nextLong();
long m = io.nextLong();
if (n * n > 0 && n * n < m) {
io.println(-1);
} else if (m <= n) {
io.println(m);
} else {
long ans = Long.MAX_VALUE;
long l = (m + n - 1) / n;
double end = Math.sqrt(m);
while (l <= end) {
long k = m % l;
if (k == 0) {
ans = m;
break;
} else if (ans > m + l - k) {
ans = m + l - k;
}
l++;
}
io.println(ans);
}
io.flush();
}
public static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// 标准 IO
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// 文件 IO
public Kattio(String intput, String output) throws IOException {
super(output);
r = new BufferedReader(new FileReader(intput));
}
// 在没有其他输入时返回 null
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) {
}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
long n = io.nextLong();
long m = io.nextLong();
if (n * n > 0 && n * n < m) {
io.println(-1);
} else if (m <= n) {
io.println(m);
} else {
long ans = Long.MAX_VALUE;
long l = (m + n - 1) / n;
double end = Math.sqrt(m + n);
while (l <= end) {
long k = m % l;
if (k == 0) {
ans = m;
break;
} else if (ans > m + l - k) {
ans = m + l - k;
}
l++;
}
io.println(ans);
}
io.flush();
}
public static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// 标准 IO
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// 文件 IO
public Kattio(String intput, String output) throws IOException {
super(output);
r = new BufferedReader(new FileReader(intput));
}
// 在没有其他输入时返回 null
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) {
}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
| ConDefects/ConDefects/Code/abc296_d/Java/44835457 |
condefects-java_data_165 | import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
FastScanner scan = new FastScanner();
long N = scan.nextLong();
long M = scan.nextLong();
long answer = Long.MAX_VALUE;
for (long a = 1; a <= Math.ceil(Math.sqrt(M)); a++) {
long b = (long) Math.ceil((double) M / (double) a);
if (b <= N) answer = min(answer, a * b);
}
print(answer == Long.MAX_VALUE ? -1 : answer);
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max){
factorial.ensureCapacity(max+1);
if(factorial.size()==0) factorial.add(1);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), i));
}
}
}
public ModInt factorial(int i){
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (usesMontgomery) {
return maMontgomery.reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1) return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a; a = b; b = tmp1;
u -= t * v;
long tmp2 = u; u = v; v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1) r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {return 1;}
int remainder(long value) {return 0;}
int add(int a, int b) {return 0;}
int sub(int a, int b) {return 0;}
int mul(int a, int b) {return 0;}
int pow(int a, long b) {return 0;}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {return 2;}
int remainder(long value) {return (int) (value & 1);}
int add(int a, int b) {return a ^ b;}
int sub(int a, int b) {return a ^ b;}
int mul(int a, int b) {return a & b;}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod)
* 2^64 = p*mod + q, 2^32 = a*mod + b
* => (a*mod + b)^2 = p*mod + q
* => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from; this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException(
"Graph hasn't been built."
);
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j --> 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids) counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, n)
);
}
}
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N) return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
FastScanner scan = new FastScanner();
long N = scan.nextLong();
long M = scan.nextLong();
long answer = Long.MAX_VALUE;
for (long a = 1; a <= Math.ceil(Math.sqrt(M)); a++) {
long b = (long) Math.ceil((double) M / (double) a);
if (a <= N && b <= N) answer = min(answer, a * b);
}
print(answer == Long.MAX_VALUE ? -1 : answer);
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max){
factorial.ensureCapacity(max+1);
if(factorial.size()==0) factorial.add(1);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), i));
}
}
}
public ModInt factorial(int i){
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (usesMontgomery) {
return maMontgomery.reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1) return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a; a = b; b = tmp1;
u -= t * v;
long tmp2 = u; u = v; v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1) r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {return 1;}
int remainder(long value) {return 0;}
int add(int a, int b) {return 0;}
int sub(int a, int b) {return 0;}
int mul(int a, int b) {return 0;}
int pow(int a, long b) {return 0;}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {return 2;}
int remainder(long value) {return (int) (value & 1);}
int add(int a, int b) {return a ^ b;}
int sub(int a, int b) {return a ^ b;}
int mul(int a, int b) {return a & b;}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod)
* 2^64 = p*mod + q, 2^32 = a*mod + b
* => (a*mod + b)^2 = p*mod + q
* => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from; this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException(
"Graph hasn't been built."
);
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j --> 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids) counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, n)
);
}
}
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N) return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
} | ConDefects/ConDefects/Code/abc296_d/Java/43988859 |
condefects-java_data_166 | import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long n = in.nextLong() , m = in.nextLong();
long min = Lnf;
for(long a = 1 ; a * a <= m ; a ++ ) {
long l = 1 , r = n ;
while(l <= r) {
long mid = (l + r)/2;
if(a * mid < m) l = mid + 1;
else r = mid - 1;
}
if(a > n || l > n) continue;
min = Math.min(a * l , min);
}
out.println(min == Lnf ? -1 : min);
}
/* Library */
/* ------- */
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
final long MOD7 = 1000000007; final long MOD9 = 998244353 ;
final int [] X4 = {0,1,0,-1}; final int [] Y4 = {-1,0,1,0};
final int [] X8 = {-1,-1,0,1,1,1,0,-1}; final int [] Y8 = {0,1,1,1,0,-1,-1,-1};
final int Inf = (int)1e9; final long Lnf = (long)1e18;
final String yes = "Yes"; final String no = "No";
}
/* Class */
/* ----- */
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return first * 31 + second;
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long n = in.nextLong() , m = in.nextLong();
long min = Lnf;
for(long a = 1 ; a * a - a <= m ; a ++ ) {
long l = 1 , r = n ;
while(l <= r) {
long mid = (l + r)/2;
if(a * mid < m) l = mid + 1;
else r = mid - 1;
}
if(a > n || l > n) continue;
min = Math.min(a * l , min);
}
out.println(min == Lnf ? -1 : min);
}
/* Library */
/* ------- */
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
final long MOD7 = 1000000007; final long MOD9 = 998244353 ;
final int [] X4 = {0,1,0,-1}; final int [] Y4 = {-1,0,1,0};
final int [] X8 = {-1,-1,0,1,1,1,0,-1}; final int [] Y8 = {0,1,1,1,0,-1,-1,-1};
final int Inf = (int)1e9; final long Lnf = (long)1e18;
final String yes = "Yes"; final String no = "No";
}
/* Class */
/* ----- */
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return first * 31 + second;
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
| ConDefects/ConDefects/Code/abc296_d/Java/42030870 |
condefects-java_data_167 | import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long n = in.nextLong() , m = in.nextLong();
long min = Lnf;
for(long a = 1 ; a * a <= m ; a ++ ) {
long b = (m + a - 1) / a ;
if(a <= n && b <= n) {
min = Math.min(min,a*b);
}
}
out.println(min == Lnf ? -1 : min);
}
/* Library */
/* ------- */
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
final long MOD7 = 1000000007; final long MOD9 = 998244353 ;
final int [] X4 = {0,1,0,-1}; final int [] Y4 = {-1,0,1,0};
final int [] X8 = {-1,-1,0,1,1,1,0,-1}; final int [] Y8 = {0,1,1,1,0,-1,-1,-1};
final int Inf = (int)1e9; final long Lnf = (long)1e18;
final String yes = "Yes"; final String no = "No";
}
/* Class */
/* ----- */
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return first * 31 + second;
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long n = in.nextLong() , m = in.nextLong();
long min = Lnf;
for(long a = 1 ; a * a - a< m ; a ++ ) {
long b = (m + a - 1) / a ;
if(a <= n && b <= n) {
min = Math.min(min,a*b);
}
}
out.println(min == Lnf ? -1 : min);
}
/* Library */
/* ------- */
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
final long MOD7 = 1000000007; final long MOD9 = 998244353 ;
final int [] X4 = {0,1,0,-1}; final int [] Y4 = {-1,0,1,0};
final int [] X8 = {-1,-1,0,1,1,1,0,-1}; final int [] Y8 = {0,1,1,1,0,-1,-1,-1};
final int Inf = (int)1e9; final long Lnf = (long)1e18;
final String yes = "Yes"; final String no = "No";
}
/* Class */
/* ----- */
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return first * 31 + second;
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
| ConDefects/ConDefects/Code/abc296_d/Java/42030787 |
condefects-java_data_168 | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.util.Comparator.*;
class Solver{
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
long N = in.lg();
long M = in.lg();
Object solve(){
long ans = -1;
for (long a = 1;a <= N && a *a <= M;a++) {
long b = ceil(M,a);
if (a <= b && b <= N)
if (ans == -1)
ans = a *b;
else
ans = min(ans,a *b);
}
return ans;
}
long ceil(long a,long b){ return (a +b -1) /b; }
long mod(final long n){ return (n %mod +mod) %mod; }
}
class Edge{
int id;
int u;
int v;
long l;
Edge rev;
Edge(int id,int u,int v){
this.id = id;
this.u = u;
this.v = v;
}
void rev(Edge rev){ rev.l = l; }
}
class Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
static long[][] trans(long[]... T){ return arr(new long[T[0].length][],i -> arrL(T.length,j -> T[j][i])); }
static double[][] trans(double[]... T){ return arr(new double[T[0].length][],i -> arrD(T.length,j -> T[j][i])); }
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return Math.toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
Edge[] e(int N,int M){ return e(N,M,e -> e.l = 1); }
Edge[] e(int N,int M,Consumer<Edge> f){
return Util.arr(new Edge[M],i -> {
Edge e = new Edge(i,idx(),idx());
f.accept(e);
return e;
});
}
Edge[][] g(int N,int M,boolean b){ return g(N,b,e(N,M)); }
Edge[][] g(int N,int M,boolean b,Consumer<Edge> f){ return g(N,b,e(N,M,f)); }
Edge[][] g(int N,boolean b,Edge[] E){
int[] c = new int[N];
for (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge rev = new Edge(e.id,e.v,e.u);
e.rev(rev);
g[e.v][--c[e.v]] = e.rev = rev;
}
}
return g;
}
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
boolean ln = false;
if (0 < l) {
Object a = Array.get(obj,0);
ln = !(a instanceof char[]) && a.getClass().isArray();
}
for (int i = 0;i +1 < l;i++) {
print(Array.get(obj,i));
write((byte) (ln ? '\n' : ' '));
}
print(Array.get(obj,l -1));
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
print(obj);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.util.elapsed());
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.util.Comparator.*;
class Solver{
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
long N = in.lg();
long M = in.lg();
Object solve(){
long ans = -1;
for (long a = 1;a <= N && (a -1) *(a -1) <= M;a++) {
long b = ceil(M,a);
if (a <= b && b <= N)
if (ans == -1)
ans = a *b;
else
ans = min(ans,a *b);
}
return ans;
}
long ceil(long a,long b){ return (a +b -1) /b; }
long mod(final long n){ return (n %mod +mod) %mod; }
}
class Edge{
int id;
int u;
int v;
long l;
Edge rev;
Edge(int id,int u,int v){
this.id = id;
this.u = u;
this.v = v;
}
void rev(Edge rev){ rev.l = l; }
}
class Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
static long[][] trans(long[]... T){ return arr(new long[T[0].length][],i -> arrL(T.length,j -> T[j][i])); }
static double[][] trans(double[]... T){ return arr(new double[T[0].length][],i -> arrD(T.length,j -> T[j][i])); }
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return Math.toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
Edge[] e(int N,int M){ return e(N,M,e -> e.l = 1); }
Edge[] e(int N,int M,Consumer<Edge> f){
return Util.arr(new Edge[M],i -> {
Edge e = new Edge(i,idx(),idx());
f.accept(e);
return e;
});
}
Edge[][] g(int N,int M,boolean b){ return g(N,b,e(N,M)); }
Edge[][] g(int N,int M,boolean b,Consumer<Edge> f){ return g(N,b,e(N,M,f)); }
Edge[][] g(int N,boolean b,Edge[] E){
int[] c = new int[N];
for (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge rev = new Edge(e.id,e.v,e.u);
e.rev(rev);
g[e.v][--c[e.v]] = e.rev = rev;
}
}
return g;
}
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
boolean ln = false;
if (0 < l) {
Object a = Array.get(obj,0);
ln = !(a instanceof char[]) && a.getClass().isArray();
}
for (int i = 0;i +1 < l;i++) {
print(Array.get(obj,i));
write((byte) (ln ? '\n' : ' '));
}
print(Array.get(obj,l -1));
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
print(obj);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.util.elapsed());
}
} | ConDefects/ConDefects/Code/abc296_d/Java/42008502 |
condefects-java_data_169 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
// solve01();
solve02();
// solve03();
// solve04();
// solve05();
pw.flush();
}
private static void solve02() throws IOException {
String[] s=br.readLine().split(" ");
long n=Long.parseLong(s[0]);
long m=Long.parseLong(s[1]);
// System.out.println(n*n);
if((m+n-1)/n>n) {
pw.println(-1);
return;
}
// System.out.println(Math.sqrt(m));
long ans=Long.MAX_VALUE;
for(long i=1;i<=Math.min(n, Math.sqrt(m));i++) {
long r=(m+i-1)/i;
if(r<=n) {
ans=Math.min(i*r, ans);
}
}
pw.println(ans);
}
private static void solve01() throws IOException {
String[] s=br.readLine().split(" ");
int n=Integer.parseInt(s[0]);
int x=Integer.parseInt(s[1]);
long[] nums=new long[n];
s=br.readLine().split(" ");
Set<Long> st=new HashSet<Long>();
for(int i=0;i<n;i++) {
nums[i]=Integer.parseInt(s[i]);
st.add(nums[i]);
}
for(int i=0;i<n;i++) {
long t=x+nums[i];
if(st.contains(t)) {
pw.println("Yes");
return;
}
t=nums[i]-x;
if(st.contains(t)) {
pw.println("Yes");
return;
}
}
pw.println("No");
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
// solve01();
solve02();
// solve03();
// solve04();
// solve05();
pw.flush();
}
private static void solve02() throws IOException {
String[] s=br.readLine().split(" ");
long n=Long.parseLong(s[0]);
long m=Long.parseLong(s[1]);
// System.out.println(n*n);
if((m+n-1)/n>n) {
pw.println(-1);
return;
}
// System.out.println(Math.sqrt(m));
long ans=Long.MAX_VALUE;
for(long i=1;i<=Math.min(n, 10000000);i++) {
long r=(m+i-1)/i;
if(r<=n) {
ans=Math.min(i*r, ans);
}
}
pw.println(ans);
}
private static void solve01() throws IOException {
String[] s=br.readLine().split(" ");
int n=Integer.parseInt(s[0]);
int x=Integer.parseInt(s[1]);
long[] nums=new long[n];
s=br.readLine().split(" ");
Set<Long> st=new HashSet<Long>();
for(int i=0;i<n;i++) {
nums[i]=Integer.parseInt(s[i]);
st.add(nums[i]);
}
for(int i=0;i<n;i++) {
long t=x+nums[i];
if(st.contains(t)) {
pw.println("Yes");
return;
}
t=nums[i]-x;
if(st.contains(t)) {
pw.println("Yes");
return;
}
}
pw.println("No");
}
}
| ConDefects/ConDefects/Code/abc296_d/Java/41701694 |
condefects-java_data_170 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double X = sc.nextDouble();
int K = sc.nextInt();
for(int i = 0; i <= K; i++) {
X = (Math.round(X / Math.pow(10, i))) * Math.pow(10, i);
}
System.out.println((int)X);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double X = sc.nextDouble();
int K = sc.nextInt();
for(int i = 0; i <= K; i++) {
X = (Math.round(X / Math.pow(10, i))) * Math.pow(10, i);
}
System.out.println((long)X);
}
}
| ConDefects/ConDefects/Code/abc273_b/Java/39147511 |
condefects-java_data_171 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double x = sc.nextLong();
double k = sc.nextLong();
double result = 0;
for(int i=0;i<k;i++){
double j = Math.pow(10, i+1);
if(result == 0){
result = (Math.round(x/j))*j;
}else{
result = (Math.round(result/j))*j;
}
}
System.out.println((int)result);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double x = sc.nextLong();
double k = sc.nextLong();
double result = 0;
for(int i=0;i<k;i++){
double j = Math.pow(10, i+1);
if(result == 0){
result = (Math.round(x/j))*j;
}else{
result = (Math.round(result/j))*j;
}
}
System.out.println((long)result);
}
} | ConDefects/ConDefects/Code/abc273_b/Java/37103600 |
condefects-java_data_172 | import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
long X = in.nextLong();
long K = in.nextLong();
long tmpNum = 0;
String tmp;
for(int i = 0 ; i < K ; i++ ){
tmp = String.valueOf(X);
tmpNum = Long.valueOf(tmp.charAt(tmp.length() - i - 1) - 48);
if(tmpNum > 4){
X += Math.pow(10, i + 1) - tmpNum * Math.pow(10, i);
} else {
X -= tmpNum * Math.pow(10, i);
}
if(X < Math.pow(10, K)){
System.out.println(0);
return;
}
}
System.out.println(X);
}
}
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
long X = in.nextLong();
long K = in.nextLong();
long tmpNum = 0;
String tmp;
for(int i = 0 ; i < K ; i++ ){
tmp = String.valueOf(X);
tmpNum = Long.valueOf(tmp.charAt(tmp.length() - i - 1) - 48);
if(tmpNum > 4){
X += Math.pow(10, i + 1) - tmpNum * Math.pow(10, i);
} else {
X -= tmpNum * Math.pow(10, i);
}
if(X < Math.pow(10, i)){
System.out.println(0);
return;
}
}
System.out.println(X);
}
} | ConDefects/ConDefects/Code/abc273_b/Java/40911175 |
condefects-java_data_173 | import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
class Main {
static void solve () {
int n = nextInt();
String s = next();
s = s.replace("A", "B");
while (true) {
if (s.contains("BB") == true) {
s = s.replace("BB", "A");
}
else {
break;
}
}
println(s);
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
}
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
class Main {
static void solve () {
int n = nextInt();
String s = next();
s = s.replace("A", "BB");
while (true) {
if (s.contains("BB") == true) {
s = s.replace("BB", "A");
}
else {
break;
}
}
println(s);
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
}
| ConDefects/ConDefects/Code/arc136_a/Java/37921308 |
condefects-java_data_174 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int n, i=1;
String s;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
s = sc.next();
StringBuilder sb = new StringBuilder(s);
while (i < sb.length()) {
if (sb.charAt(i) == 'A' && sb.charAt(i-1) == 'B') {
sb = sb.replace(i-1, i+1, "AB");
}
if (sb.charAt(i) == 'B' && sb.charAt(i-1) == 'B') {
sb = sb.replace(i-1, i+1, "A");
}
i += 1;
}
System.out.print(s);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int n, i=1;
String s;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
s = sc.next();
StringBuilder sb = new StringBuilder(s);
while (i < sb.length()) {
if (sb.charAt(i) == 'A' && sb.charAt(i-1) == 'B') {
sb = sb.replace(i-1, i+1, "AB");
}
if (sb.charAt(i) == 'B' && sb.charAt(i-1) == 'B') {
sb = sb.replace(i-1, i+1, "A");
}
i += 1;
}
System.out.print(sb);
}
} | ConDefects/ConDefects/Code/arc136_a/Java/29749248 |
condefects-java_data_175 | import java.util.Scanner;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
StringBuilder sb = new StringBuilder();
sb.append(s);
char now;
if(n > 1){
now = s.charAt(1);
}else{
now = s.charAt(0);
}
char before = s.charAt(0);
for(int i=1;i<n;i++){
//System.out.println(i);
//System.out.println("before:"+before);
//System.out.println("now:"+now);
if(before == 'B'){
if(now == 'A'){
sb.replace(i-1, i+1, "AB");
before = 'B';
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}else if(now == 'B'){
sb.replace(i-1, i+1, "A");
before = 'A';
if(i < sb.length()){
now = sb.charAt(i);
i--;
}
}else{
before = 'C';
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}
}else{
//System.out.println("im else now");
before = now;
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}
//System.out.println("now:"+now);
//System.out.println(sb.toString());
if(i > sb.length() - 1){
break;
}
}
System.out.println(sb.toString());
}
}
import java.util.Scanner;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
StringBuilder sb = new StringBuilder();
sb.append(s);
char now;
if(n > 1){
now = s.charAt(1);
}else{
now = s.charAt(0);
}
char before = s.charAt(0);
for(int i=1;i<n;i++){
//System.out.println(i);
//System.out.println("before:"+before);
//System.out.println("now:"+now);
if(before == 'B'){
if(now == 'A'){
sb.replace(i-1, i+1, "AB");
before = 'B';
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}else if(now == 'B'){
sb.replace(i-1, i+1, "A");
before = 'A';
if(i < sb.length()){
now = sb.charAt(i);
i--;
}
}else{
before = 'C';
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}
}else{
//System.out.println("im else now");
before = now;
if(i < sb.length()-1){
now = sb.charAt(i+1);
}
}
//System.out.println("now:"+now);
//System.out.println(sb.toString());
if(i > sb.length() - 2){
break;
}
}
System.out.println(sb.toString());
}
} | ConDefects/ConDefects/Code/arc136_a/Java/29752268 |
condefects-java_data_176 | import java.util.*;
import java.io.*;
import java.math.*;
//An apple a day
public class Main{
static int maxn = 400005,n,m;
static long INF = (long)1e18,ans = 0,mod = (int)1e9+7;
static Scanner sc = new Scanner (System.in);
static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer st =new StreamTokenizer(bf);
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[]args) throws IOException{
int T = 1;
//T = I();
while(T-->0) solve();
pw.flush();
}
static final int I() throws IOException {
st.nextToken();
return (int)st.nval;
}
static String S() throws IOException{
String res = bf.readLine();
while(res.equals("")) res = bf.readLine();
return res;
}
static void solve() throws IOException{
n = I();m = I();int d = I();
long dp[][][] = new long[n+1][n+1][d];
for (long [][]a:dp)
for (long []b:a) Arrays.fill(b, -INF);
for (int i = 0 ; i <=n ; i++) dp[i][0][0] = 0;
for (int i = 1 ; i <=n ; i++) {
int x = I();
for (int j = 1 ; j <=Math.min(i, m) ; j++)
for (int k = 0 ; k <d ; k++) {
dp[i][j][k] = Math.max(dp[i-1][j][k],dp[i-1][j-1][((d-x)%d+d)%d] + x);
}
}
pw.println(dp[n][m][0] < 0?-1:dp[n][m][0]);
}
}
import java.util.*;
import java.io.*;
import java.math.*;
//An apple a day
public class Main{
static int maxn = 400005,n,m;
static long INF = (long)1e18,ans = 0,mod = (int)1e9+7;
static Scanner sc = new Scanner (System.in);
static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer st =new StreamTokenizer(bf);
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[]args) throws IOException{
int T = 1;
//T = I();
while(T-->0) solve();
pw.flush();
}
static final int I() throws IOException {
st.nextToken();
return (int)st.nval;
}
static String S() throws IOException{
String res = bf.readLine();
while(res.equals("")) res = bf.readLine();
return res;
}
static void solve() throws IOException{
n = I();m = I();int d = I();
long dp[][][] = new long[n+1][n+1][d];
for (long [][]a:dp)
for (long []b:a) Arrays.fill(b, -INF);
for (int i = 0 ; i <=n ; i++) dp[i][0][0] = 0;
for (int i = 1 ; i <=n ; i++) {
int x = I();
for (int j = 1 ; j <=Math.min(i, m) ; j++)
for (int k = 0 ; k <d ; k++) {
dp[i][j][k] = Math.max(dp[i-1][j][k],dp[i-1][j-1][((k-x)%d+d)%d] + x);
}
}
pw.println(dp[n][m][0] < 0?-1:dp[n][m][0]);
}
}
| ConDefects/ConDefects/Code/abc281_d/Java/39537670 |
condefects-java_data_177 |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
InputStreamReader inr = new InputStreamReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
BufferedReader br = new BufferedReader(inr);
StringTokenizer st = new StringTokenizer("");
int H;
int W;
int[][] numD;
void solve() {
try {
H = ni();
W = ni();
boolean[] bl = new boolean[5];
numD = new int[H][];
for(int i=0;i<H;i++) {
numD[i] = new int[W];
String a = next();
for(int j=0;j<H;j++) {
String aa = a.substring(0, 1);
if(aa.equals(".")) {
numD[i][j] =-1;
}else {
numD[i][j]=Integer.parseInt(aa)-1;
}
a = a.substring(1);
}
}
br.close();
for(int i=0;i<H;i++) {
for(int j=0;j<W;j++) {
if(numD[i][j]==-1) {
bl = new boolean[5];
allset(i,j,bl);
for(int k=0;k<5;k++) {
if(!bl[k]) {
numD[i][j]=k;
break;
}
}
}
}
}
for(int i=0;i<H;i++) {
for(int j=0;j<W;j++) {
pw.print(numD[i][j]+1);
}
pw.println();
}
pw.flush();
pw.close();
}catch(Exception err) {
System.out.println("err(solve())= "+err);
}
}
boolean check(int i,int j) {
if(0<=i && i<H && 0<=j && j<W) {
return true;
}else {
return false;
}
}
void allset(int i,int j,boolean[] bl) {
set(i-1,j,bl);
set(i,j-1,bl);
set(i+1,j,bl);
set(i,j+1,bl);
}
void set(int i,int j,boolean[] bl) {
if(check(i,j) && numD[i][j]!=-1) {
bl[numD[i][j]] = true;
}
}
public static void main(String[] args) {
try {
new Main().solve();
}catch(Exception err) {
System.out.println("err(main)= "+err);
}
}
String next() {
try {
if(st.hasMoreTokens()) {
}else {
st = new StringTokenizer(br.readLine());
}
}catch(Exception err) {
System.out.println("err(next())= "+err);
}
return st.nextToken();
}
int ni() {
try {
return Integer.parseInt(next());
}catch(Exception err) {
System.out.println("err(ni())= "+err);
}
return 0;
}
long nl() {
try {
return Long.parseLong(next());
}catch(Exception err) {
System.out.println("err(nl())= "+err);
}
return 0L;
}
int[] ii(int len) {
int[] numS = new int[len];
try {
for(int i=0;i<len;i++) {
numS[i]= ni();
}
}catch(Exception err) {
System.out.println("err(ii("+len+"))= "+err);
}
return numS;
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
InputStreamReader inr = new InputStreamReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
BufferedReader br = new BufferedReader(inr);
StringTokenizer st = new StringTokenizer("");
int H;
int W;
int[][] numD;
void solve() {
try {
H = ni();
W = ni();
boolean[] bl = new boolean[5];
numD = new int[H][];
for(int i=0;i<H;i++) {
numD[i] = new int[W];
String a = next();
for(int j=0;j<W;j++) {
String aa = a.substring(0, 1);
if(aa.equals(".")) {
numD[i][j] =-1;
}else {
numD[i][j]=Integer.parseInt(aa)-1;
}
a = a.substring(1);
}
}
br.close();
for(int i=0;i<H;i++) {
for(int j=0;j<W;j++) {
if(numD[i][j]==-1) {
bl = new boolean[5];
allset(i,j,bl);
for(int k=0;k<5;k++) {
if(!bl[k]) {
numD[i][j]=k;
break;
}
}
}
}
}
for(int i=0;i<H;i++) {
for(int j=0;j<W;j++) {
pw.print(numD[i][j]+1);
}
pw.println();
}
pw.flush();
pw.close();
}catch(Exception err) {
System.out.println("err(solve())= "+err);
}
}
boolean check(int i,int j) {
if(0<=i && i<H && 0<=j && j<W) {
return true;
}else {
return false;
}
}
void allset(int i,int j,boolean[] bl) {
set(i-1,j,bl);
set(i,j-1,bl);
set(i+1,j,bl);
set(i,j+1,bl);
}
void set(int i,int j,boolean[] bl) {
if(check(i,j) && numD[i][j]!=-1) {
bl[numD[i][j]] = true;
}
}
public static void main(String[] args) {
try {
new Main().solve();
}catch(Exception err) {
System.out.println("err(main)= "+err);
}
}
String next() {
try {
if(st.hasMoreTokens()) {
}else {
st = new StringTokenizer(br.readLine());
}
}catch(Exception err) {
System.out.println("err(next())= "+err);
}
return st.nextToken();
}
int ni() {
try {
return Integer.parseInt(next());
}catch(Exception err) {
System.out.println("err(ni())= "+err);
}
return 0;
}
long nl() {
try {
return Long.parseLong(next());
}catch(Exception err) {
System.out.println("err(nl())= "+err);
}
return 0L;
}
int[] ii(int len) {
int[] numS = new int[len];
try {
for(int i=0;i<len;i++) {
numS[i]= ni();
}
}catch(Exception err) {
System.out.println("err(ii("+len+"))= "+err);
}
return numS;
}
} | ConDefects/ConDefects/Code/arc131_b/Java/27719150 |
condefects-java_data_178 |
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
// Your code here!
Scanner sc = new Scanner(System.in);
int H = Integer.parseInt(sc.next());
int W = Integer.parseInt(sc.next());
int[][] canpas = new int[H][W];
int[][] blankCanpas = new int[H*W][2];
int blankCanpasIndex = 0;
for (int i=0; i<H; i++) {
String str = sc.next();
for (int j=0; j<W; j++) {
if (str.charAt(j) == '.') {
canpas[i][j] = 0;
blankCanpas[blankCanpasIndex] = new int[]{i,j};
blankCanpasIndex++;
} else {
canpas[i][j] = Character.getNumericValue(str.charAt(j));
}
}
}
// 色塗り作業
boolean paintable = false;
int tryColor = 1;
for (int scanIndex=0; scanIndex<blankCanpas.length; scanIndex++) {
int paintColor = 0;
// 1~5を走査
for (int i=tryColor; i<=5; i++) {
if (blankCanpas[scanIndex][0]-1 > -1 && canpas[blankCanpas[scanIndex][0]-1][blankCanpas[scanIndex][1]] == i) {
continue;
}
if (blankCanpas[scanIndex][0]+1 < H && canpas[blankCanpas[scanIndex][0]+1][blankCanpas[scanIndex][1]] == i) {
continue;
}
if (blankCanpas[scanIndex][1]-1 > -1 && canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]-1] == i) {
continue;
}
if (blankCanpas[scanIndex][1]+1 < W && canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]+1] == i) {
continue;
}
paintable = true;
paintColor = i;
break;
}
if (!paintable) {
tryColor = canpas[blankCanpas[scanIndex-1][0]][blankCanpas[scanIndex-1][1]] + 1;
scanIndex--;
} else {
canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]] = paintColor;
tryColor = 1;
}
paintable = false;
}
for (int[] line : canpas) {
for (int math : line) {
System.out.print(math);
}
System.out.println();
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
// Your code here!
Scanner sc = new Scanner(System.in);
int H = Integer.parseInt(sc.next());
int W = Integer.parseInt(sc.next());
int[][] canpas = new int[H][W];
int[][] blankCanpas = new int[H*W][2];
int blankCanpasIndex = 0;
for (int i=0; i<H; i++) {
String str = sc.next();
for (int j=0; j<W; j++) {
if (str.charAt(j) == '.') {
canpas[i][j] = 0;
blankCanpas[blankCanpasIndex] = new int[]{i,j};
blankCanpasIndex++;
} else {
canpas[i][j] = Character.getNumericValue(str.charAt(j));
}
}
}
// 色塗り作業
boolean paintable = false;
int tryColor = 1;
for (int scanIndex=0; scanIndex<blankCanpasIndex; scanIndex++) {
int paintColor = 0;
// 1~5を走査
for (int i=tryColor; i<=5; i++) {
if (blankCanpas[scanIndex][0]-1 > -1 && canpas[blankCanpas[scanIndex][0]-1][blankCanpas[scanIndex][1]] == i) {
continue;
}
if (blankCanpas[scanIndex][0]+1 < H && canpas[blankCanpas[scanIndex][0]+1][blankCanpas[scanIndex][1]] == i) {
continue;
}
if (blankCanpas[scanIndex][1]-1 > -1 && canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]-1] == i) {
continue;
}
if (blankCanpas[scanIndex][1]+1 < W && canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]+1] == i) {
continue;
}
paintable = true;
paintColor = i;
break;
}
if (!paintable) {
tryColor = canpas[blankCanpas[scanIndex-1][0]][blankCanpas[scanIndex-1][1]] + 1;
scanIndex--;
} else {
canpas[blankCanpas[scanIndex][0]][blankCanpas[scanIndex][1]] = paintColor;
tryColor = 1;
}
paintable = false;
}
for (int[] line : canpas) {
for (int math : line) {
System.out.print(math);
}
System.out.println();
}
}
} | ConDefects/ConDefects/Code/arc131_b/Java/27722709 |
condefects-java_data_179 | import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.TreeMap;
class VvyLw extends Utility {
protected static final MyScanner sc = new MyScanner();
protected static final MyPrinter o = new MyPrinter(System.out, false);
protected static final MyPrinter e = new MyPrinter(System.err, true);
static final int[] dx = {0, -1, 1, 0, 0, -1, -1, 1, 1};
static final int[] dy = {0, 0, 0, -1, 1, -1, 1, -1, 1};
static final int inf = 1 << 30;
static final long linf = (1L << 61) - 1;
static final int mod998 = 998244353;
static final int mod107 = (int)1e9 + 7;
static final double eps = 1e-18;
protected static final void solve() {
final int n = sc.ni(), k = sc.ni();
final int[] p = Arrays.stream(sc.ni(n)).map(i -> i - 1).toArray();
if(k == 1) {
o.ende(Arrays.stream(p).map(i -> i + 1).toArray());
}
var m = new TreeMap<Integer, ArrayList<Integer>>();
int[] ans = new int[n];
Arrays.fill(ans, -1);
for(int i = 0; i < n; ++i) {
final var ky = m.ceilingKey(p[i]);
if(ky != null) {
m.put(p[i], m.get(ky));
m.remove(ky);
}
m.computeIfAbsent(p[i], x -> new ArrayList<>()).add(p[i]);
final var nm = m.get(p[i]);
if(nm.size() == k) {
for(final var id: nm) {
ans[id] = i + 1;
}
m.remove(p[i]);
}
}
o.outl(ans);
}
}
final class Main extends VvyLw {
public static void main(final String[] args) {
int t = 1;
//t = sc.ni();
while(t-- > 0) {
solve();
}
o.flush();
sc.close();
o.close();
e.close();
}
}
class Utility {
protected static final String yes(final boolean ok){ return ok ? "Yes" : "No"; }
protected static final String no(final boolean ok){ return yes(!ok); }
protected static final long sqr(final long x){ return x * x; }
protected static final int mod(final long n, final int m){ return (int) ((n + m) % m); }
protected static final long intCeil(long a, long b){ return (long) Math.ceil((double)a / b); }
protected static final long intPow(long a, int b) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
protected static final long intPow(long a, long b, final int m) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
res = mod(res, m);
}
a *= a;
a = mod(a, m);
b >>= 1;
}
return res;
}
protected static final ArrayList<Long> div(final long n) {
ArrayList<Long> d = new ArrayList<>();
for(long i = 1; i * i <= n; ++i) {
if(n % i == 0) {
d.add(i);
if(i * i != n) {
d.add(n / i);
}
}
}
Collections.sort(d);
return d;
}
protected static final ArrayList<Pair<Long, Integer>> primeFactor(long n) {
ArrayList<Pair<Long, Integer>> pf = new ArrayList<>();
for(long i = 2; i * i <= n; ++i) {
if(n % i != 0) {
continue;
}
int cnt = 0;
while(n % i == 0) {
cnt++;
n /= i;
}
pf.add(Pair.of(i, cnt));
}
if(n != 1) {
pf.add(Pair.of(n, 1));
}
return pf;
}
protected static final long binom(int a, final int b) {
long res = 1;
for(int i = 1; i <= b; ++i) {
res *= a--;
res /= i;
}
return res;
}
protected static final boolean isInt(final double n){ long r = (long) Math.floor(n); return r == n; }
protected static final boolean isSqr(final long n){ return isInt(Math.sqrt(n)); }
protected static final boolean isPrime(final long n) {
if(n == 1) return false;
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) return false;
}
return true;
}
protected static final boolean scope(final int l, final int x, final int r){ return l <= x && x <= r; }
protected static final boolean nextPerm(ArrayList<? extends Number> a) {
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).longValue() < a.get(i).longValue()) {
final int j = find(a.get(i - 1).longValue(), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), (x, y) -> Long.compare(x.longValue(), y.longValue()));
return true;
}
}
return false;
}
protected static final String nextPerm(final String s) {
var a = s.chars().mapToObj(i -> (char)i).collect(Collectors.toList());
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).compareTo(a.get(i)) < 0) {
final int j = find(a.get(i - 1), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()));
return a.stream().map(String::valueOf).collect(Collectors.joining());
}
}
return null;
}
protected static final boolean prevPerm(ArrayList<? extends Number> a) {
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).longValue() > a.get(i).longValue()) {
final int j = findRev(a.get(i - 1).longValue(), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), Collections.reverseOrder());
return true;
}
}
return false;
}
protected static final String prevPerm(final String s) {
var a = s.chars().mapToObj(i -> (char)i).collect(Collectors.toList());
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).compareTo(a.get(i)) > 0) {
final int j = findRev(a.get(i - 1), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), Collections.reverseOrder());
return a.stream().map(String::valueOf).collect(Collectors.joining());
}
}
return null;
}
private static final int find(final long dest, final List<? extends Number> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).longValue() <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final char dest, final List<Character> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).compareTo(dest) <= 0 ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int findRev(final long dest, final List<? extends Number> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).longValue() > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final char dest, final List<Character> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).compareTo(dest) > 0 ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
protected static final boolean binarySearch(final int[] a, final int x) {
return Arrays.binarySearch(a, x) >= 0;
}
protected static final boolean binarySearch(final long[] a, final long x) {
return Arrays.binarySearch(a, x) >= 0;
}
protected static final boolean binarySearch(final Object[] a, final Object x) {
return binarySearch(Arrays.stream(a).collect(Collectors.toList()), x);
}
protected static final int lowerBound(final int[] a, final int x) {
return lowerBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final int lowerBound(final long[] a, final long x) {
return lowerBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T x) {
return lowerBound(Arrays.asList(a), x);
}
protected static final int upperBound(final int[] a, final int x) {
return upperBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final int upperBound(final long[] a, final long x) {
return upperBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T x) {
return upperBound(Arrays.asList(a), x);
}
protected static final <T> boolean binarySearch(final List<T> a, final T x) {
return Collections.binarySearch(a, x, null) >= 0;
}
protected static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T x) {
return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) >= 0 ? 1 : -1);
}
protected static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T x) {
return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) > 0 ? 1 : -1);
}
protected static final int[] reverse(final int[] a) {
final int n = a.length;
int[] b = new int[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final long[] reverse(final long[] a) {
final int n = a.length;
long[] b = new long[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final double[] reverse(final double[] a) {
final int n = a.length;
double[] b = new double[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final Object[] reverse(final Object[] a) {
final int n = a.length;
Object[] b = new Object[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final int[] rotate(final int[] a, final int id) {
ArrayList<Integer> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
int[] res = new int[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final long[] rotate(final long[] a, final int id) {
ArrayList<Long> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
long[] res = new long[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final double[] rotate(final double[] a, final int id) {
ArrayList<Double> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
double[] res = new double[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final String rotate(final String s, final int id) {
ArrayList<Character> t = new ArrayList<>();
for(final char c: s.toCharArray()) {
t.add(c);
}
Collections.rotate(t, id);
StringBuilder sb = new StringBuilder();
for(final var c: t) {
sb.append(c);
}
return sb.toString();
}
protected static final int[][] rotate(final int[][] a) {
final int h = a.length, w = a[0].length;
int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final long[][] rotate(final long[][] a) {
final int h = a.length, w = a[0].length;
long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final double[][] rotate(final double[][] a) {
final int h = a.length, w = a[0].length;
double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final String[] rotate(final String[] s) {
final int h = s.length, w = s[0].length();
char[][] t = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> t[j][i] = s[i].charAt(j));
});
IntStream.range(0, w).forEach(i -> t[i] = new StringBuilder(new String(t[i])).reverse().toString().toCharArray());
String[] res = new String[w];
IntStream.range(0, w).forEach(i -> res[i] = new String(t[i]));
return res;
}
protected static final long lcm(final long a, final long b){ return a * b / gcd(a, b); }
protected static final long gcd(final long a, final long b){ return b > 0 ? gcd(b, a % b) : a; }
protected static final long lcm(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> lcm(x, y)); }
protected static final long gcd(final long... a){ return Arrays.stream(a).reduce(0, (x, y) -> gcd(x, y)); }
protected static final long min(final long... a){ return Arrays.stream(a).reduce(Long.MAX_VALUE, (x, y) -> Math.min(x, y)); }
protected static final long max(final long... a){ return Arrays.stream(a).reduce(Long.MIN_VALUE, (x, y) -> Math.max(x, y)); }
protected static final <F, S> ArrayList<F> first(final List<Pair<F, S>> p) {
ArrayList<F> f = new ArrayList<>();
for(final var el: p) {
f.add(el.first);
}
return f;
}
protected static final <F, S> ArrayList<S> second(final List<Pair<F, S>> p) {
ArrayList<S> s = new ArrayList<>();
for(final var el: p) {
s.add(el.second);
}
return s;
}
protected static final int[] iota(final int n){ return IntStream.range(0, n).toArray(); }
protected static final int[] iota(final int n, final int init){ return IntStream.range(0 + init, n + init).toArray(); }
protected static final long bins(long ok, long ng, final Predicate<Long> fn) {
while(Math.abs(ok - ng) > 1) {
final long mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final double bins(double ok, double ng, final Predicate<Double> fn) {
while(Math.abs(ok - ng) > VvyLw.eps) {
final double mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final ArrayList<Integer> press(final ArrayList<Long> a) {
ArrayList<Integer> res = new ArrayList<>();
final var cp = a.stream().sorted().distinct().collect(Collectors.toList());
for(final var el: a) {
res.add(lowerBound(cp, el));
}
return res;
}
protected static final int[] zAlgorithm(final String s) {
final int n = s.length();
int j = 0;
int[] pre = new int[n];
for(int i = 0; ++i < n;) {
if(i + pre[i - j] < j + pre[j]) {
pre[i] = pre[i - j];
}
else {
int k = Math.max(0, j + pre[j] - i);
while(i + k < n && s.charAt(k) == s.charAt(i + k)) {
++k;
}
pre[i] = k;
j = i;
}
}
pre[0] = n;
return pre;
}
protected static final int[] manacher(final String s_, final boolean calcEven) {
int n = s_.length();
char[] s;
if(calcEven) {
s = new char[2 * n - 1];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
for(int i = n; --i >= 0;) {
s[2 * i] = s_.charAt(i);
}
final var d = Collections.min(s_.chars().mapToObj(c -> (char) c).collect(Collectors.toList()));
for(int i = 0; i < n - 1; ++i) {
s[2 * i + 1] = d;
}
} else {
s = new char[n];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
}
n = s.length;
int[] rad = new int[n];
for(int i = 0, j = 0; i < n;) {
while(i - j >= 0 && i + j < n && s[i - j] == s[i + j]) {
++j;
}
rad[i] = j;
int k = 1;
while(i - k >= 0 && i + k < n && k + rad[i - k] < j) {
rad[i + k] = rad[i - k];
++k;
}
i += k;
j -= k;
}
if(calcEven) {
for(int i = 0; i < n; ++i) {
if(((i ^ rad[i]) & 1) == 0) {
rad[i]--;
}
}
} else {
for(var x: rad) {
x = 2 * x - 1;
}
}
return rad;
}
protected static final long kthRoot(final long n, final int k) {
if(k == 1) {
return n;
}
final Predicate<Long> chk = (x) -> {
long mul = 1;
for(int j = 0; j < k; ++j) {
try {
mul = Math.multiplyExact(mul, x);
} catch(ArithmeticException e) {
return false;
}
}
return mul <= n;
};
long ret = 0;
for(int i = 32; --i >= 0;) {
if(chk.test(ret | (1L << i))) {
ret |= 1L << i;
}
}
return ret;
}
}
final class MyScanner {
private final Scanner sc = new Scanner(System.in);
final int ni(){ return sc.nextInt(); }
final long nl(){ return sc.nextLong(); }
final double nd(){ return sc.nextDouble(); }
final String ns(){ return sc.next(); }
final int[] ni(final int n){
int[] a = new int[n];
IntStream.range(0, n).forEach(i -> a[i] = ni());
return a;
}
final long[] nl(final int n){
long[] a = new long[n];
IntStream.range(0, n).forEach(i -> a[i] = nl());
return a;
}
final double[] nd(final int n){
double[] a = new double[n];
IntStream.range(0, n).forEach(i -> a[i] = nd());
return a;
}
final String[] ns(final int n){
String[] a = new String[n];
IntStream.range(0, n).forEach(i -> a[i] = ns());
return a;
}
final ArrayList<Integer> nia(final int n) {
var a = new ArrayList<Integer>(n);
IntStream.range(0, n).forEach(i -> a.add(i, ni()));
return a;
}
final ArrayList<Long> nla(final int n) {
var a = new ArrayList<Long>(n);
IntStream.range(0, n).forEach(i -> a.add(i, nl()));
return a;
}
final ArrayList<Double> nda(final int n) {
var a = new ArrayList<Double>(n);
IntStream.range(0, n).forEach(i -> a.add(i, nd()));
return a;
}
final ArrayList<String> nsa(final int n) {
var a = new ArrayList<String>(n);
IntStream.range(0, n).forEach(i -> a.add(i, ns()));
return a;
}
final void close(){ sc.close(); }
}
final class MyPrinter {
private final PrintWriter pw;
MyPrinter(final OutputStream os, final boolean flush){ pw = new PrintWriter(os, flush); }
final void print(final Object arg){ pw.print(arg); }
final void out(){ pw.println(); }
final void out(final Object head, final Object... tail) {
pw.print(head);
for(final var el: tail) {
pw.print(" " + el);
}
out();
}
final <F, S> void out(final Pair<F, S> arg){ pw.println(arg.first + " " + arg.second); }
final void out(final int[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final long[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final double[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final boolean[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final char[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final Object[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final <T> void out(final List<T> args){ IntStream.range(0, args.size()).forEach(i -> pw.print(args.get(i) + (i + 1 < args.size() ? " " : "\n"))); }
final void outl(final Object head, final Object... tail) {
out(head);
Arrays.stream(tail).forEach(pw::println);
}
final void outl(final int[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final int[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final long[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final long[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final double[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final double[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final boolean[] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final char[] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final Object[] args){ Arrays.stream(args).forEach(pw::println); }
final <E> void outl(final Collection<E> args){ args.stream().forEach(pw::println); }
final void fin(final Object head, final Object... tail) {
out(head, tail);
flush();
System.exit(0);
}
final void fin(final int[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final long[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final double[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final boolean[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final char[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final Object[] args) {
out(args);
flush();
System.exit(0);
}
final <T> void fin(final List<T> args) {
out(args);
flush();
System.exit(0);
}
final void ende(final int[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final long[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final double[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final boolean[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final char[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final Object[] args) {
outl(args);
flush();
System.exit(0);
}
final <E> void ende(final Collection<E> args) {
outl(args);
flush();
System.exit(0);
}
final void flush(){ pw.flush(); }
final void close(){ pw.close(); }
}
class Pair<F, S> {
protected final F first;
protected final S second;
Pair(final F first, final S second) {
this.first = first;
this.second = second;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> p = (Pair<?, ?>) o;
if(!first.equals(p.first)) {
return false;
}
return second.equals(p.second);
}
@Override
public final int hashCode(){ return 31 * first.hashCode() + second.hashCode(); }
@Override
public final String toString(){ return "(" + first + ", " + second + ")"; }
public static final <F, S> Pair<F, S> of(final F a, final S b){ return new Pair<>(a, b); }
final Pair<S, F> swap(){ return Pair.of(second, first); }
}
final class NumPair extends Pair<Number, Number> implements Comparable<NumPair> {
NumPair(final Number first, final Number second){ super(first, second); }
final NumPair rotate(){ return new NumPair(-second.doubleValue(), first.doubleValue()); }
final NumPair rotate(final int ang) {
final double rad = Math.toRadians(Utility.mod(ang, 360));
return new NumPair(first.doubleValue() * Math.cos(rad) - second.doubleValue() * Math.sin(rad),
first.doubleValue() * Math.sin(rad) + second.doubleValue() * Math.cos(rad));
}
final long dot(final NumPair p){ return first.longValue() * p.first.longValue() + second.longValue() + p.second.longValue(); }
final double dotf(final NumPair p){ return first.doubleValue() * p.first.doubleValue() + second.doubleValue() + p.second.doubleValue(); }
final long cross(final NumPair p){ return this.rotate().dot(p); }
final double crossf(final NumPair p){ return this.rotate().dotf(p); }
final long sqr(){ return this.dot(this); }
final double sqrf(){ return this.dotf(this); }
final double grad() {
try {
return second.doubleValue() / first.doubleValue();
} catch(ArithmeticException e) {
e.printStackTrace();
}
return Double.NaN;
}
final double abs(){ return Math.hypot(first.doubleValue(), second.doubleValue()); }
final long lcm(){ return Utility.lcm(first.longValue(), second.longValue()); }
final long gcd(){ return Utility.gcd(first.longValue(), second.longValue()); }
final NumPair extgcd() {
long x = 1, y = 0, t1 = 0, t2 = 0, t3 = 1, a = first.longValue(), b = second.longValue();
while(b > 0) {
t1 = a / b;
a -= t1 * b;
a ^= b;
b ^= a;
a ^= b;
x -= t1 * t2;
x ^= t2;
t2 ^= x;
x ^= t2;
y -= t1 * t3;
y ^= t3;
t3 ^= y;
y ^= t3;
}
return new NumPair(x, y);
}
@Override
final public int compareTo(final NumPair o) {
if(first.doubleValue() == o.first.doubleValue()) {
return Double.compare(second.doubleValue(), o.second.doubleValue());
}
return Double.compare(first.doubleValue(), o.first.doubleValue());
}
}
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.TreeMap;
class VvyLw extends Utility {
protected static final MyScanner sc = new MyScanner();
protected static final MyPrinter o = new MyPrinter(System.out, false);
protected static final MyPrinter e = new MyPrinter(System.err, true);
static final int[] dx = {0, -1, 1, 0, 0, -1, -1, 1, 1};
static final int[] dy = {0, 0, 0, -1, 1, -1, 1, -1, 1};
static final int inf = 1 << 30;
static final long linf = (1L << 61) - 1;
static final int mod998 = 998244353;
static final int mod107 = (int)1e9 + 7;
static final double eps = 1e-18;
protected static final void solve() {
final int n = sc.ni(), k = sc.ni();
final int[] p = Arrays.stream(sc.ni(n)).map(i -> i - 1).toArray();
if(k == 1) {
o.ende(Arrays.stream(iota(n)).boxed().sorted((i, j) -> Integer.compare(p[i], p[j])).map(i -> i + 1).toArray());
}
var m = new TreeMap<Integer, ArrayList<Integer>>();
int[] ans = new int[n];
Arrays.fill(ans, -1);
for(int i = 0; i < n; ++i) {
final var ky = m.ceilingKey(p[i]);
if(ky != null) {
m.put(p[i], m.get(ky));
m.remove(ky);
}
m.computeIfAbsent(p[i], x -> new ArrayList<>()).add(p[i]);
final var nm = m.get(p[i]);
if(nm.size() == k) {
for(final var id: nm) {
ans[id] = i + 1;
}
m.remove(p[i]);
}
}
o.outl(ans);
}
}
final class Main extends VvyLw {
public static void main(final String[] args) {
int t = 1;
//t = sc.ni();
while(t-- > 0) {
solve();
}
o.flush();
sc.close();
o.close();
e.close();
}
}
class Utility {
protected static final String yes(final boolean ok){ return ok ? "Yes" : "No"; }
protected static final String no(final boolean ok){ return yes(!ok); }
protected static final long sqr(final long x){ return x * x; }
protected static final int mod(final long n, final int m){ return (int) ((n + m) % m); }
protected static final long intCeil(long a, long b){ return (long) Math.ceil((double)a / b); }
protected static final long intPow(long a, int b) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
protected static final long intPow(long a, long b, final int m) {
long res = 1;
while(b > 0) {
if(b % 2 == 1) {
res *= a;
res = mod(res, m);
}
a *= a;
a = mod(a, m);
b >>= 1;
}
return res;
}
protected static final ArrayList<Long> div(final long n) {
ArrayList<Long> d = new ArrayList<>();
for(long i = 1; i * i <= n; ++i) {
if(n % i == 0) {
d.add(i);
if(i * i != n) {
d.add(n / i);
}
}
}
Collections.sort(d);
return d;
}
protected static final ArrayList<Pair<Long, Integer>> primeFactor(long n) {
ArrayList<Pair<Long, Integer>> pf = new ArrayList<>();
for(long i = 2; i * i <= n; ++i) {
if(n % i != 0) {
continue;
}
int cnt = 0;
while(n % i == 0) {
cnt++;
n /= i;
}
pf.add(Pair.of(i, cnt));
}
if(n != 1) {
pf.add(Pair.of(n, 1));
}
return pf;
}
protected static final long binom(int a, final int b) {
long res = 1;
for(int i = 1; i <= b; ++i) {
res *= a--;
res /= i;
}
return res;
}
protected static final boolean isInt(final double n){ long r = (long) Math.floor(n); return r == n; }
protected static final boolean isSqr(final long n){ return isInt(Math.sqrt(n)); }
protected static final boolean isPrime(final long n) {
if(n == 1) return false;
for(long i = 2; i * i <= n; ++i) {
if(n % i == 0) return false;
}
return true;
}
protected static final boolean scope(final int l, final int x, final int r){ return l <= x && x <= r; }
protected static final boolean nextPerm(ArrayList<? extends Number> a) {
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).longValue() < a.get(i).longValue()) {
final int j = find(a.get(i - 1).longValue(), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), (x, y) -> Long.compare(x.longValue(), y.longValue()));
return true;
}
}
return false;
}
protected static final String nextPerm(final String s) {
var a = s.chars().mapToObj(i -> (char)i).collect(Collectors.toList());
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).compareTo(a.get(i)) < 0) {
final int j = find(a.get(i - 1), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()));
return a.stream().map(String::valueOf).collect(Collectors.joining());
}
}
return null;
}
protected static final boolean prevPerm(ArrayList<? extends Number> a) {
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).longValue() > a.get(i).longValue()) {
final int j = findRev(a.get(i - 1).longValue(), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), Collections.reverseOrder());
return true;
}
}
return false;
}
protected static final String prevPerm(final String s) {
var a = s.chars().mapToObj(i -> (char)i).collect(Collectors.toList());
for(int i = a.size() - 1; i > 0; i--) {
if(a.get(i - 1).compareTo(a.get(i)) > 0) {
final int j = findRev(a.get(i - 1), a, i, a.size() - 1);
Collections.swap(a, i - 1, j);
Collections.sort(a.subList(i, a.size()), Collections.reverseOrder());
return a.stream().map(String::valueOf).collect(Collectors.joining());
}
}
return null;
}
private static final int find(final long dest, final List<? extends Number> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).longValue() <= dest ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int find(final char dest, final List<Character> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).compareTo(dest) <= 0 ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
private static final int findRev(final long dest, final List<? extends Number> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).longValue() > dest ? findRev(dest, a, s, m - 1) : findRev(dest, a, m, e);
}
private static final int findRev(final char dest, final List<Character> a, final int s, final int e) {
if(s == e) {
return s;
}
final int m = (s + e + 1) / 2;
return a.get(m).compareTo(dest) > 0 ? find(dest, a, s, m - 1) : find(dest, a, m, e);
}
protected static final boolean binarySearch(final int[] a, final int x) {
return Arrays.binarySearch(a, x) >= 0;
}
protected static final boolean binarySearch(final long[] a, final long x) {
return Arrays.binarySearch(a, x) >= 0;
}
protected static final boolean binarySearch(final Object[] a, final Object x) {
return binarySearch(Arrays.stream(a).collect(Collectors.toList()), x);
}
protected static final int lowerBound(final int[] a, final int x) {
return lowerBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final int lowerBound(final long[] a, final long x) {
return lowerBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T x) {
return lowerBound(Arrays.asList(a), x);
}
protected static final int upperBound(final int[] a, final int x) {
return upperBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final int upperBound(final long[] a, final long x) {
return upperBound(Arrays.stream(a).boxed().collect(Collectors.toList()), x);
}
protected static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T x) {
return upperBound(Arrays.asList(a), x);
}
protected static final <T> boolean binarySearch(final List<T> a, final T x) {
return Collections.binarySearch(a, x, null) >= 0;
}
protected static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T x) {
return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) >= 0 ? 1 : -1);
}
protected static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T x) {
return ~Collections.binarySearch(a, x, (p, q) -> p.compareTo(q) > 0 ? 1 : -1);
}
protected static final int[] reverse(final int[] a) {
final int n = a.length;
int[] b = new int[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final long[] reverse(final long[] a) {
final int n = a.length;
long[] b = new long[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final double[] reverse(final double[] a) {
final int n = a.length;
double[] b = new double[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final Object[] reverse(final Object[] a) {
final int n = a.length;
Object[] b = new Object[n];
for(int i = 0; i <= n / 2; ++i) {
b[i] = a[n - 1 - i];
b[n - 1 - i] = a[i];
}
return b;
}
protected static final int[] rotate(final int[] a, final int id) {
ArrayList<Integer> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
int[] res = new int[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final long[] rotate(final long[] a, final int id) {
ArrayList<Long> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
long[] res = new long[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final double[] rotate(final double[] a, final int id) {
ArrayList<Double> t = new ArrayList<>(a.length);
for(final var el: a) {
t.add(el);
}
Collections.rotate(t, id);
double[] res = new double[t.size()];
for(int i = 0; i < t.size(); ++i) {
res[i] = t.get(i);
}
return res;
}
protected static final String rotate(final String s, final int id) {
ArrayList<Character> t = new ArrayList<>();
for(final char c: s.toCharArray()) {
t.add(c);
}
Collections.rotate(t, id);
StringBuilder sb = new StringBuilder();
for(final var c: t) {
sb.append(c);
}
return sb.toString();
}
protected static final int[][] rotate(final int[][] a) {
final int h = a.length, w = a[0].length;
int[][] b = new int[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final long[][] rotate(final long[][] a) {
final int h = a.length, w = a[0].length;
long[][] b = new long[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final double[][] rotate(final double[][] a) {
final int h = a.length, w = a[0].length;
double[][] b = new double[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> b[j][i] = a[i][j]);
});
IntStream.range(0, w).forEach(i -> b[i] = reverse(b[i]));
return b;
}
protected static final String[] rotate(final String[] s) {
final int h = s.length, w = s[0].length();
char[][] t = new char[w][h];
IntStream.range(0, h).forEach(i -> {
IntStream.range(0, w).forEach(j -> t[j][i] = s[i].charAt(j));
});
IntStream.range(0, w).forEach(i -> t[i] = new StringBuilder(new String(t[i])).reverse().toString().toCharArray());
String[] res = new String[w];
IntStream.range(0, w).forEach(i -> res[i] = new String(t[i]));
return res;
}
protected static final long lcm(final long a, final long b){ return a * b / gcd(a, b); }
protected static final long gcd(final long a, final long b){ return b > 0 ? gcd(b, a % b) : a; }
protected static final long lcm(final long... a){ return Arrays.stream(a).reduce(1, (x, y) -> lcm(x, y)); }
protected static final long gcd(final long... a){ return Arrays.stream(a).reduce(0, (x, y) -> gcd(x, y)); }
protected static final long min(final long... a){ return Arrays.stream(a).reduce(Long.MAX_VALUE, (x, y) -> Math.min(x, y)); }
protected static final long max(final long... a){ return Arrays.stream(a).reduce(Long.MIN_VALUE, (x, y) -> Math.max(x, y)); }
protected static final <F, S> ArrayList<F> first(final List<Pair<F, S>> p) {
ArrayList<F> f = new ArrayList<>();
for(final var el: p) {
f.add(el.first);
}
return f;
}
protected static final <F, S> ArrayList<S> second(final List<Pair<F, S>> p) {
ArrayList<S> s = new ArrayList<>();
for(final var el: p) {
s.add(el.second);
}
return s;
}
protected static final int[] iota(final int n){ return IntStream.range(0, n).toArray(); }
protected static final int[] iota(final int n, final int init){ return IntStream.range(0 + init, n + init).toArray(); }
protected static final long bins(long ok, long ng, final Predicate<Long> fn) {
while(Math.abs(ok - ng) > 1) {
final long mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final double bins(double ok, double ng, final Predicate<Double> fn) {
while(Math.abs(ok - ng) > VvyLw.eps) {
final double mid = (ok + ng) / 2;
if(fn.test(mid)) {
ok = mid;
}
else {
ng = mid;
}
}
return ok;
}
protected static final ArrayList<Integer> press(final ArrayList<Long> a) {
ArrayList<Integer> res = new ArrayList<>();
final var cp = a.stream().sorted().distinct().collect(Collectors.toList());
for(final var el: a) {
res.add(lowerBound(cp, el));
}
return res;
}
protected static final int[] zAlgorithm(final String s) {
final int n = s.length();
int j = 0;
int[] pre = new int[n];
for(int i = 0; ++i < n;) {
if(i + pre[i - j] < j + pre[j]) {
pre[i] = pre[i - j];
}
else {
int k = Math.max(0, j + pre[j] - i);
while(i + k < n && s.charAt(k) == s.charAt(i + k)) {
++k;
}
pre[i] = k;
j = i;
}
}
pre[0] = n;
return pre;
}
protected static final int[] manacher(final String s_, final boolean calcEven) {
int n = s_.length();
char[] s;
if(calcEven) {
s = new char[2 * n - 1];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
for(int i = n; --i >= 0;) {
s[2 * i] = s_.charAt(i);
}
final var d = Collections.min(s_.chars().mapToObj(c -> (char) c).collect(Collectors.toList()));
for(int i = 0; i < n - 1; ++i) {
s[2 * i + 1] = d;
}
} else {
s = new char[n];
IntStream.range(0, n).forEach(i -> s[i] = s_.charAt(i));
}
n = s.length;
int[] rad = new int[n];
for(int i = 0, j = 0; i < n;) {
while(i - j >= 0 && i + j < n && s[i - j] == s[i + j]) {
++j;
}
rad[i] = j;
int k = 1;
while(i - k >= 0 && i + k < n && k + rad[i - k] < j) {
rad[i + k] = rad[i - k];
++k;
}
i += k;
j -= k;
}
if(calcEven) {
for(int i = 0; i < n; ++i) {
if(((i ^ rad[i]) & 1) == 0) {
rad[i]--;
}
}
} else {
for(var x: rad) {
x = 2 * x - 1;
}
}
return rad;
}
protected static final long kthRoot(final long n, final int k) {
if(k == 1) {
return n;
}
final Predicate<Long> chk = (x) -> {
long mul = 1;
for(int j = 0; j < k; ++j) {
try {
mul = Math.multiplyExact(mul, x);
} catch(ArithmeticException e) {
return false;
}
}
return mul <= n;
};
long ret = 0;
for(int i = 32; --i >= 0;) {
if(chk.test(ret | (1L << i))) {
ret |= 1L << i;
}
}
return ret;
}
}
final class MyScanner {
private final Scanner sc = new Scanner(System.in);
final int ni(){ return sc.nextInt(); }
final long nl(){ return sc.nextLong(); }
final double nd(){ return sc.nextDouble(); }
final String ns(){ return sc.next(); }
final int[] ni(final int n){
int[] a = new int[n];
IntStream.range(0, n).forEach(i -> a[i] = ni());
return a;
}
final long[] nl(final int n){
long[] a = new long[n];
IntStream.range(0, n).forEach(i -> a[i] = nl());
return a;
}
final double[] nd(final int n){
double[] a = new double[n];
IntStream.range(0, n).forEach(i -> a[i] = nd());
return a;
}
final String[] ns(final int n){
String[] a = new String[n];
IntStream.range(0, n).forEach(i -> a[i] = ns());
return a;
}
final ArrayList<Integer> nia(final int n) {
var a = new ArrayList<Integer>(n);
IntStream.range(0, n).forEach(i -> a.add(i, ni()));
return a;
}
final ArrayList<Long> nla(final int n) {
var a = new ArrayList<Long>(n);
IntStream.range(0, n).forEach(i -> a.add(i, nl()));
return a;
}
final ArrayList<Double> nda(final int n) {
var a = new ArrayList<Double>(n);
IntStream.range(0, n).forEach(i -> a.add(i, nd()));
return a;
}
final ArrayList<String> nsa(final int n) {
var a = new ArrayList<String>(n);
IntStream.range(0, n).forEach(i -> a.add(i, ns()));
return a;
}
final void close(){ sc.close(); }
}
final class MyPrinter {
private final PrintWriter pw;
MyPrinter(final OutputStream os, final boolean flush){ pw = new PrintWriter(os, flush); }
final void print(final Object arg){ pw.print(arg); }
final void out(){ pw.println(); }
final void out(final Object head, final Object... tail) {
pw.print(head);
for(final var el: tail) {
pw.print(" " + el);
}
out();
}
final <F, S> void out(final Pair<F, S> arg){ pw.println(arg.first + " " + arg.second); }
final void out(final int[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final long[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final double[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final boolean[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final char[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final void out(final Object[] args){ IntStream.range(0, args.length).forEach(i -> pw.print(args[i] + (i + 1 < args.length ? " " : "\n"))); }
final <T> void out(final List<T> args){ IntStream.range(0, args.size()).forEach(i -> pw.print(args.get(i) + (i + 1 < args.size() ? " " : "\n"))); }
final void outl(final Object head, final Object... tail) {
out(head);
Arrays.stream(tail).forEach(pw::println);
}
final void outl(final int[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final int[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final long[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final long[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final double[] args){ Arrays.stream(args).forEach(pw::println); }
final void outl(final double[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final boolean[] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final boolean[][] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final char[] args){ IntStream.range(0, args.length).forEach(i -> out(args[i])); }
final void outl(final Object[] args){ Arrays.stream(args).forEach(pw::println); }
final <E> void outl(final Collection<E> args){ args.stream().forEach(pw::println); }
final void fin(final Object head, final Object... tail) {
out(head, tail);
flush();
System.exit(0);
}
final void fin(final int[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final long[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final double[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final boolean[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final char[] args) {
out(args);
flush();
System.exit(0);
}
final void fin(final Object[] args) {
out(args);
flush();
System.exit(0);
}
final <T> void fin(final List<T> args) {
out(args);
flush();
System.exit(0);
}
final void ende(final int[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final long[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final double[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final boolean[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final char[] args) {
outl(args);
flush();
System.exit(0);
}
final void ende(final Object[] args) {
outl(args);
flush();
System.exit(0);
}
final <E> void ende(final Collection<E> args) {
outl(args);
flush();
System.exit(0);
}
final void flush(){ pw.flush(); }
final void close(){ pw.close(); }
}
class Pair<F, S> {
protected final F first;
protected final S second;
Pair(final F first, final S second) {
this.first = first;
this.second = second;
}
@Override
public final boolean equals(final Object o) {
if(this == o) {
return true;
}
if(o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> p = (Pair<?, ?>) o;
if(!first.equals(p.first)) {
return false;
}
return second.equals(p.second);
}
@Override
public final int hashCode(){ return 31 * first.hashCode() + second.hashCode(); }
@Override
public final String toString(){ return "(" + first + ", " + second + ")"; }
public static final <F, S> Pair<F, S> of(final F a, final S b){ return new Pair<>(a, b); }
final Pair<S, F> swap(){ return Pair.of(second, first); }
}
final class NumPair extends Pair<Number, Number> implements Comparable<NumPair> {
NumPair(final Number first, final Number second){ super(first, second); }
final NumPair rotate(){ return new NumPair(-second.doubleValue(), first.doubleValue()); }
final NumPair rotate(final int ang) {
final double rad = Math.toRadians(Utility.mod(ang, 360));
return new NumPair(first.doubleValue() * Math.cos(rad) - second.doubleValue() * Math.sin(rad),
first.doubleValue() * Math.sin(rad) + second.doubleValue() * Math.cos(rad));
}
final long dot(final NumPair p){ return first.longValue() * p.first.longValue() + second.longValue() + p.second.longValue(); }
final double dotf(final NumPair p){ return first.doubleValue() * p.first.doubleValue() + second.doubleValue() + p.second.doubleValue(); }
final long cross(final NumPair p){ return this.rotate().dot(p); }
final double crossf(final NumPair p){ return this.rotate().dotf(p); }
final long sqr(){ return this.dot(this); }
final double sqrf(){ return this.dotf(this); }
final double grad() {
try {
return second.doubleValue() / first.doubleValue();
} catch(ArithmeticException e) {
e.printStackTrace();
}
return Double.NaN;
}
final double abs(){ return Math.hypot(first.doubleValue(), second.doubleValue()); }
final long lcm(){ return Utility.lcm(first.longValue(), second.longValue()); }
final long gcd(){ return Utility.gcd(first.longValue(), second.longValue()); }
final NumPair extgcd() {
long x = 1, y = 0, t1 = 0, t2 = 0, t3 = 1, a = first.longValue(), b = second.longValue();
while(b > 0) {
t1 = a / b;
a -= t1 * b;
a ^= b;
b ^= a;
a ^= b;
x -= t1 * t2;
x ^= t2;
t2 ^= x;
x ^= t2;
y -= t1 * t3;
y ^= t3;
t3 ^= y;
y ^= t3;
}
return new NumPair(x, y);
}
@Override
final public int compareTo(final NumPair o) {
if(first.doubleValue() == o.first.doubleValue()) {
return Double.compare(second.doubleValue(), o.second.doubleValue());
}
return Double.compare(first.doubleValue(), o.first.doubleValue());
}
} | ConDefects/ConDefects/Code/abc260_d/Java/48245740 |
condefects-java_data_180 |
import java.util.Arrays;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Vector;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int p[] = new int[n];
for(int i = 0; i < n; i++) {
p[i] = sc.nextInt();
}
int time[] = new int[n];
if(k == 1) {
for(int i = 0; i < n; i++) {
time[p[i] - 1] = i + 1;
}
for(int i = 0; i < n; i++) {
System.out.println(i + 1);
}
return;
}
Arrays.fill(time, -1);
TreeSet<MyQueue> set = new TreeSet<>();
for(int i = 0; i < n; i++) {
// System.out.println("add "+p[i]);
if(set.size() == 0 || p[i] > set.last().last()) {
// System.out.println("add to tail");
MyQueue tmpQue = new MyQueue(k);
tmpQue.vec.add(p[i]);
set.add(tmpQue);
}
else {
MyQueue tmpQue = new MyQueue(1);
tmpQue.vec.add(p[i]);
SortedSet<MyQueue> view = set.tailSet(tmpQue);
MyQueue minimum = view.first();
minimum.vec.add(p[i]);
set.remove(minimum);
if(minimum.vec.size() < k) {
// System.out.println("top "+p[i] + " size "+ minimum.vec.size());
set.add(minimum);
}
else {
Vector<Integer> vec = minimum.vec;
for(int j = 0; j < vec.size(); j++) {
int tmp = vec.get(j);
// System.out.println("time "+ (i + 1));
time[tmp - 1] = i + 1;
}
}
}
}
for(int i = 0; i < n; i++) {
System.out.println(time[i]);
}
}
}
class MyQueue implements Comparable<MyQueue> {
Vector<Integer> vec;
int cap;
MyQueue(int cap){
this.vec = new Vector<Integer>();
this.cap = cap;
}
@Override
public int compareTo(MyQueue q1) {
// TODO Auto-generated method stub
return this.vec.lastElement() - q1.vec.lastElement();
}
int last () {
return vec.lastElement();
}
}
import java.util.Arrays;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.Vector;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int p[] = new int[n];
for(int i = 0; i < n; i++) {
p[i] = sc.nextInt();
}
int time[] = new int[n];
if(k == 1) {
for(int i = 0; i < n; i++) {
time[p[i] - 1] = i + 1;
}
for(int i = 0; i < n; i++) {
System.out.println(time[i]);
}
return;
}
Arrays.fill(time, -1);
TreeSet<MyQueue> set = new TreeSet<>();
for(int i = 0; i < n; i++) {
// System.out.println("add "+p[i]);
if(set.size() == 0 || p[i] > set.last().last()) {
// System.out.println("add to tail");
MyQueue tmpQue = new MyQueue(k);
tmpQue.vec.add(p[i]);
set.add(tmpQue);
}
else {
MyQueue tmpQue = new MyQueue(1);
tmpQue.vec.add(p[i]);
SortedSet<MyQueue> view = set.tailSet(tmpQue);
MyQueue minimum = view.first();
minimum.vec.add(p[i]);
set.remove(minimum);
if(minimum.vec.size() < k) {
// System.out.println("top "+p[i] + " size "+ minimum.vec.size());
set.add(minimum);
}
else {
Vector<Integer> vec = minimum.vec;
for(int j = 0; j < vec.size(); j++) {
int tmp = vec.get(j);
// System.out.println("time "+ (i + 1));
time[tmp - 1] = i + 1;
}
}
}
}
for(int i = 0; i < n; i++) {
System.out.println(time[i]);
}
}
}
class MyQueue implements Comparable<MyQueue> {
Vector<Integer> vec;
int cap;
MyQueue(int cap){
this.vec = new Vector<Integer>();
this.cap = cap;
}
@Override
public int compareTo(MyQueue q1) {
// TODO Auto-generated method stub
return this.vec.lastElement() - q1.vec.lastElement();
}
int last () {
return vec.lastElement();
}
} | ConDefects/ConDefects/Code/abc260_d/Java/33586407 |
condefects-java_data_181 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
public static void main( String[] args) {
Scanner scn = new Scanner( System.in);
int N = scn.nextInt();
int K = scn.nextInt();
int[] array = new int[N];
for ( int i = 0; i < N; i++) {
array[i] = scn.nextInt();
}
int[] brray = Arrays.copyOf( array, N);
Arrays.sort( brray);
List<Set<Integer>> listA = new ArrayList<>();
List<Set<Integer>> listB = new ArrayList<>();
if ( K == 1) {
System.out.println( "Yes");
return;
}
else if ( N / 2 >= K) {
for ( int h = 0; h < K; h++) {
listA.add( new TreeSet<>());
listB.add( new TreeSet<>());
}
for ( int i = 0; i < N; i++) {
listA.get( i % K).add( array[i]);
listB.get( i % K).add( brray[i]);
}
for ( int l = 0; l < K; l++) {
if ( !listA.get( l).equals( listB.get( l))) {
System.out.println( "No");
return;
}
}
System.out.println( "Yes");
}
else {
List<Integer> arrayA = new ArrayList<>();
List<Integer> arrayB = new ArrayList<>();
for ( int h = 0; h < N - K; h++) {
listA.add( new TreeSet<>());
listB.add( new TreeSet<>());
}
for ( int i = 0; i < N; i++) {
if ( i + K < N) {
listA.get( i % K).add( array[i]);
listB.get( i % K).add( brray[i]);
}
else {
arrayA.add( array[i]);
arrayB.add( brray[i]);
}
}
if ( !arrayA.equals( arrayB)) {
System.out.println( "No");
return;
}
for ( int l = 0; l < N - K; l++) {
if ( !listA.get( l).equals( listB.get( l))) {
System.out.println( "No");
return;
}
}
System.out.println( "Yes");
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main {
public static void main( String[] args) {
Scanner scn = new Scanner( System.in);
int N = scn.nextInt();
int K = scn.nextInt();
int[] array = new int[N];
for ( int i = 0; i < N; i++) {
array[i] = scn.nextInt();
}
int[] brray = Arrays.copyOf( array, N);
Arrays.sort( brray);
List<Set<Integer>> listA = new ArrayList<>();
List<Set<Integer>> listB = new ArrayList<>();
if ( K == 1) {
System.out.println( "Yes");
return;
}
else if ( N / 2 >= K) {
for ( int h = 0; h < K; h++) {
listA.add( new TreeSet<>());
listB.add( new TreeSet<>());
}
for ( int i = 0; i < N; i++) {
listA.get( i % K).add( array[i]);
listB.get( i % K).add( brray[i]);
}
for ( int l = 0; l < K; l++) {
if ( !listA.get( l).equals( listB.get( l))) {
System.out.println( "No");
return;
}
}
System.out.println( "Yes");
}
else {
List<Integer> arrayA = new ArrayList<>();
List<Integer> arrayB = new ArrayList<>();
for ( int h = 0; h < N - K; h++) {
listA.add( new TreeSet<>());
listB.add( new TreeSet<>());
}
for ( int i = 0; i < N; i++) {
if ( N - i > K || K <= i) {
listA.get( i % K).add( array[i]);
listB.get( i % K).add( brray[i]);
}
else {
arrayA.add( array[i]);
arrayB.add( brray[i]);
}
}
if ( !arrayA.equals( arrayB)) {
System.out.println( "No");
return;
}
for ( int l = 0; l < N - K; l++) {
if ( !listA.get( l).equals( listB.get( l))) {
System.out.println( "No");
return;
}
}
System.out.println( "Yes");
}
}
} | ConDefects/ConDefects/Code/abc254_c/Java/36897168 |
condefects-java_data_182 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String S = sc.nextLine();
String T = sc.nextLine();
boolean hantei = false;
for(int i = 0; i < n; i++) {
if(S.charAt(i) == T.charAt(i) || (S.charAt(i) == 'l' && T.charAt(i) == '1') || (S.charAt(i) == 'l' && T.charAt(i) == '1') || (S.charAt(i) == 'o' && T.charAt(i) == '0') || (S.charAt(i) == '0' && T.charAt(i) == 'o')) {
continue;
}
else {
hantei = true;
}
}
if(hantei) System.out.println("No\n");
else System.out.println("Yes\n");
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String S = sc.nextLine();
String T = sc.nextLine();
boolean hantei = false;
for(int i = 0; i < n; i++) {
if(S.charAt(i) == T.charAt(i) || (S.charAt(i) == 'l' && T.charAt(i) == '1') || (S.charAt(i) == '1' && T.charAt(i) == 'l') || (S.charAt(i) == 'o' && T.charAt(i) == '0') || (S.charAt(i) == '0' && T.charAt(i) == 'o')) {
continue;
}
else {
hantei = true;
}
}
if(hantei) System.out.println("No\n");
else System.out.println("Yes\n");
}
} | ConDefects/ConDefects/Code/abc303_a/Java/42064695 |
condefects-java_data_183 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int length = scanner.nextInt();
String input1 = scanner.next();
;
String input2 = scanner.next();
if (input2.length() != length || input1.length() != length) {
System.out.println("No");
return;
}
for (int i = 0; i < length; i++) {
if (((input1.charAt(i) == 'l' && input1.charAt(i) == '1') || (input1.charAt(i) == '1' && input1.charAt(i) == 'l')) || ((input1.charAt(i) == 'o' && input1.charAt(i) == '0') || (input1.charAt(i) == '0' && input1.charAt(i) == 'o')) || input1.charAt(i) == input2.charAt(i)) {
} else {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int length = scanner.nextInt();
String input1 = scanner.next();
;
String input2 = scanner.next();
if (input2.length() != length || input1.length() != length) {
System.out.println("No");
return;
}
for (int i = 0; i < length; i++) {
if (((input1.charAt(i) == 'l' && input2.charAt(i) == '1') || (input1.charAt(i) == '1' && input2.charAt(i) == 'l')) || ((input1.charAt(i) == 'o' && input2.charAt(i) == '0') || (input1.charAt(i) == '0' && input2.charAt(i) == 'o')) || input1.charAt(i) == input2.charAt(i)) {
} else {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
} | ConDefects/ConDefects/Code/abc303_a/Java/43050431 |
condefects-java_data_184 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
String S = input.next();
String T = input.next();
String Answer = "Yes";
for (int i = 0; i < N; i++) {
if (S.charAt(i) != T.charAt(i)) {
if ((S.charAt(i) == 'l' && T.charAt(i) == '1') || (S.charAt(i) == '1' && T.charAt(i) == 'l')) {
continue;
}
else if ((S.charAt(i) == '0' && T.charAt(i) == 'o') || (S.charAt(i) == '0' && T.charAt(i) == 'o')) {
continue;
} else {
Answer = "No";
break;
}
}
}
System.out.println(Answer);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
String S = input.next();
String T = input.next();
String Answer = "Yes";
for (int i = 0; i < N; i++) {
if (S.charAt(i) != T.charAt(i)) {
if ((S.charAt(i) == 'l' && T.charAt(i) == '1') || (S.charAt(i) == '1' && T.charAt(i) == 'l')) {
continue;
}
else if ((S.charAt(i) == '0' && T.charAt(i) == 'o') || (S.charAt(i) == 'o' && T.charAt(i) == '0')) {
continue;
} else {
Answer = "No";
break;
}
}
}
System.out.println(Answer);
}
} | ConDefects/ConDefects/Code/abc303_a/Java/45309715 |
condefects-java_data_185 | import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
int num = scn.nextInt();
String str1 = scn.next();
String str2 = scn.next();
str1 = str1.replace("0", "o").replace("1","l");
str2 = str2.replace("0", "o").replace("1","l");
if(str1==str2) {
System.out.println("Yes");
}else {
System.out.println("No");
}
scn.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
int num = scn.nextInt();
String str1 = scn.next();
String str2 = scn.next();
str1 = str1.replace("0", "o").replace("1","l");
str2 = str2.replace("0", "o").replace("1","l");
if(str1.equals(str2)) {
System.out.println("Yes");
}else {
System.out.println("No");
}
scn.close();
}
}
| ConDefects/ConDefects/Code/abc303_a/Java/43314239 |
condefects-java_data_186 |
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int days = sc.nextInt(); // N
int T_M = sc.nextInt(); // M
String S = sc.next(); // S
// ロゴ入りTシャツ必要枚数算出
int needLogoT = 0;
int needLogoT_tmp = 0;
for (int i=0; i < S.length(); i++) {
char c = S.charAt(i);
switch(c) {
case '0': // 洗濯
needLogoT_tmp = 0;
continue;
case '2': // コンペ
needLogoT_tmp++;
break;
}
if(needLogoT_tmp > needLogoT) {
needLogoT = needLogoT_tmp;
}
}
// System.out.println("needLogoT: "+needLogoT);
// Tシャツ（無地+ロゴ入り）必要枚数算出
int needT = 0;
int needT_tmp = 0;
for (int i=0; i < S.length(); i++) {
char c = S.charAt(i);
switch(c) {
case '0':
needT_tmp = 0;
continue;
case '1':
needT_tmp++;
break;
case '2':
needT_tmp++;
break;
}
if(needT_tmp > needT) {
needT = needT_tmp;
}
}
// System.out.println("needT: "+needT);
int ans = 0;
// ロゴ入りTシャツが足りないパターン
if(needT + T_M >= needT) {
ans = needLogoT;
}
else { // 全Tシャツが足りないパターン
ans = needT - T_M;
}
System.out.println(ans);
}
}
class FastScanner
{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte()
{
if (ptr < buflen)
{
return true;
}
else
{
ptr = 0;
try
{
buflen = in.read(buffer);
}
catch(IOException e)
{
e.printStackTrace();
}
if (buflen <= 0)
{
return false;
}
}
return true;
}
private int readByte()
{
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c)
{
return 33 <= c && c <= 126;
}
public boolean hasNext()
{
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next()
{
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b))
{
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong()
{
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-')
{
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
{
throw new NumberFormatException();
}
while (true)
{
if ('0' <= b && b <= '9')
{
n *= 10;
n += b - '0';
}
else if (b == -1 || !isPrintableChar(b))
{
return minus ? -n : n;
}
else
{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt()
{
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble()
{
return Double.parseDouble(next());
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int days = sc.nextInt(); // N
int T_M = sc.nextInt(); // M
String S = sc.next(); // S
// ロゴ入りTシャツ必要枚数算出
int needLogoT = 0;
int needLogoT_tmp = 0;
for (int i=0; i < S.length(); i++) {
char c = S.charAt(i);
switch(c) {
case '0': // 洗濯
needLogoT_tmp = 0;
continue;
case '2': // コンペ
needLogoT_tmp++;
break;
}
if(needLogoT_tmp > needLogoT) {
needLogoT = needLogoT_tmp;
}
}
// System.out.println("needLogoT: "+needLogoT);
// Tシャツ（無地+ロゴ入り）必要枚数算出
int needT = 0;
int needT_tmp = 0;
for (int i=0; i < S.length(); i++) {
char c = S.charAt(i);
switch(c) {
case '0':
needT_tmp = 0;
continue;
case '1':
needT_tmp++;
break;
case '2':
needT_tmp++;
break;
}
if(needT_tmp > needT) {
needT = needT_tmp;
}
}
// System.out.println("needT: "+needT);
int ans = 0;
// ロゴ入りTシャツが足りないパターン
if(needLogoT + T_M >= needT) {
ans = needLogoT;
}
else { // 全Tシャツが足りないパターン
ans = needT - T_M;
}
System.out.println(ans);
}
}
class FastScanner
{
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte()
{
if (ptr < buflen)
{
return true;
}
else
{
ptr = 0;
try
{
buflen = in.read(buffer);
}
catch(IOException e)
{
e.printStackTrace();
}
if (buflen <= 0)
{
return false;
}
}
return true;
}
private int readByte()
{
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c)
{
return 33 <= c && c <= 126;
}
public boolean hasNext()
{
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next()
{
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b))
{
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong()
{
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-')
{
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
{
throw new NumberFormatException();
}
while (true)
{
if ('0' <= b && b <= '9')
{
n *= 10;
n += b - '0';
}
else if (b == -1 || !isPrintableChar(b))
{
return minus ? -n : n;
}
else
{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt()
{
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble()
{
return Double.parseDouble(next());
}
}
| ConDefects/ConDefects/Code/abc332_c/Java/49245666 |
condefects-java_data_187 | // Source: https://usaco.guide/general/io
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(r.readLine());
int n = Integer.parseInt(st.nextToken());
int maxM = Integer.parseInt(st.nextToken());
String s = r.readLine();
int m = maxM;
int maxLogo = 0;
int l = 0;
for (int i = 0; i < n; i++) {
int curNum = Character.getNumericValue(s.charAt(i));
if (curNum == 0) {
m = maxM;
l = maxLogo;
} else if (curNum == 1) {
if (m == 0) {
if (l == 0) {
maxLogo++;
} else {
l--;
}
}
} else {
if (l == 0) {
maxLogo++;
} else {
l--;
}
}
}
System.out.println(maxLogo);
pw.close();
}
}
// Source: https://usaco.guide/general/io
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(r.readLine());
int n = Integer.parseInt(st.nextToken());
int maxM = Integer.parseInt(st.nextToken());
String s = r.readLine();
int m = maxM;
int maxLogo = 0;
int l = 0;
for (int i = 0; i < n; i++) {
int curNum = Character.getNumericValue(s.charAt(i));
if (curNum == 0) {
m = maxM;
l = maxLogo;
} else if (curNum == 1) {
if (m == 0) {
if (l == 0) {
maxLogo++;
} else {
l--;
}
} else {
m--;
}
} else {
if (l == 0) {
maxLogo++;
} else {
l--;
}
}
}
System.out.println(maxLogo);
pw.close();
}
}
| ConDefects/ConDefects/Code/abc332_c/Java/50108452 |
condefects-java_data_188 | import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
// Round-Robin Tournament
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] s = new String[n];
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int i = 0; i < s.length; i++) {
s[i] = sc.next();
int win = s[i].length() - s[i].replace("o", "").length();
map.put(-win*10+(i+1),i+1);
}
List<Entry<Integer, Integer>>list_entries = new ArrayList<Entry<Integer, Integer>>(map.entrySet());
int i=0;
for(Entry<Integer, Integer>entry:list_entries) {
System.out.print(entry.getValue());
i++;
if(i==map.size()) {
System.out.println();
} else {
System.out.print(" ");
}
}
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
// Round-Robin Tournament
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] s = new String[n];
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int i = 0; i < s.length; i++) {
s[i] = sc.next();
int win = s[i].length() - s[i].replace("o", "").length();
map.put(-win*1000+(i+1),i+1);
}
List<Entry<Integer, Integer>>list_entries = new ArrayList<Entry<Integer, Integer>>(map.entrySet());
int i=0;
for(Entry<Integer, Integer>entry:list_entries) {
System.out.print(entry.getValue());
i++;
if(i==map.size()) {
System.out.println();
} else {
System.out.print(" ");
}
}
}
} | ConDefects/ConDefects/Code/abc323_b/Java/46441904 |
condefects-java_data_189 | import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String[] s=new String[n];
int[] cnt=new int[n];
for(int i=0; i<n; i++){
s[i]=sc.next();
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(s[i].charAt(j)=='o'){
cnt[i]++;
}
}
}
for(int k=100; k>=0; k--){
for(int i=0; i<n; i++){
if(cnt[i]==k){
System.out.print(i+" ");
}
}
}
}
}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String[] s=new String[n];
int[] cnt=new int[n];
for(int i=0; i<n; i++){
s[i]=sc.next();
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(s[i].charAt(j)=='o'){
cnt[i]++;
}
}
}
for(int k=100; k>=0; k--){
for(int i=0; i<n; i++){
if(cnt[i]==k){
System.out.print(i+1+" ");
}
}
}
}
} | ConDefects/ConDefects/Code/abc323_b/Java/50965215 |
condefects-java_data_190 | import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
String S[] = new String[N];
for(int i=0; i<N; i++) S[i] = sc.next();
int win[] = new int[N];
Integer place[] = new Integer[N];
for(int i=0; i<N; i++) place[i] = i+1;
for(int i=0; i<N; i++) {
for(int j=0; j<N; j++) if(S[i].charAt(j)=='o') win[i]++;
}
Arrays.sort(place, new Comparator<Integer>() {
@Override
public int compare(Integer x, Integer y) {
return win[x-1] > win[y-1] ? -1 : 1;
}
});
for(int v : place) System.out.print(v + " ");
System.out.println();
}
}
class MyScanner {
public Scanner sc = new Scanner(System.in);
public int nextInt() {
return Integer.parseInt(sc.next());
}
public long nextLong() {
return Long.parseLong(sc.next());
}
public double nextDouble() {
return Double.parseDouble(sc.next());
}
public String next() {
return sc.next();
}
}
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
String S[] = new String[N];
for(int i=0; i<N; i++) S[i] = sc.next();
int win[] = new int[N];
Integer place[] = new Integer[N];
for(int i=0; i<N; i++) place[i] = i+1;
for(int i=0; i<N; i++) {
for(int j=0; j<N; j++) if(S[i].charAt(j)=='o') win[i]++;
}
Arrays.sort(place, new Comparator<Integer>() {
@Override
public int compare(Integer x, Integer y) {
return win[x-1] == win[y-1] ? 0 : win[x-1] > win[y-1] ? -1 : 1;
}
});
for(int v : place) System.out.print(v + " ");
System.out.println();
}
}
class MyScanner {
public Scanner sc = new Scanner(System.in);
public int nextInt() {
return Integer.parseInt(sc.next());
}
public long nextLong() {
return Long.parseLong(sc.next());
}
public double nextDouble() {
return Double.parseDouble(sc.next());
}
public String next() {
return sc.next();
}
} | ConDefects/ConDefects/Code/abc323_b/Java/54216048 |
condefects-java_data_191 | import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
long a = sc.nextLong();
long b = sc.nextLong();
long c = sc.nextLong();
long d = sc.nextLong();
c = Math.abs(c - a);
a = 0L;
d = Math.abs(d - b);
b = 0L;
long ans = 0L;
if(d%2L == 1L && c%2L == 0L) c = Math.abs(c - 1L);
if(d%2L == 0L && c%2L == 1L) c = Math.abs(c - 1L);
if(d > c) {
ans = d;
} else {
ans = d;
ans += (c - d) / 2L;
}
System.out.println(ans);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
long a = sc.nextLong();
long b = sc.nextLong();
long c = sc.nextLong();
long d = sc.nextLong();
a = (a + b) % 2L == 0L ? a: a -1L;
c = (c + d) % 2L == 0L ? c: c -1L;
c = Math.abs(c - a);
a = 0L;
d = Math.abs(d - b);
b = 0L;
long ans = 0L;
if(d%2L == 1L && c%2L == 0L) c = Math.abs(c - 1L);
if(d%2L == 0L && c%2L == 1L) c = Math.abs(c - 1L);
if(d > c) {
ans = d;
} else {
ans = d;
ans += (c - d) / 2L;
}
System.out.println(ans);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
} | ConDefects/ConDefects/Code/abc359_c/Java/54936044 |
condefects-java_data_192 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
long Sx= scanner.nextLong();
long Sy= scanner.nextLong();
long Tx= scanner.nextLong();
long Ty= scanner.nextLong();
long cornerSx = (Sx>=0)? (Sx-Sy%2)/2*2+Sy%2 : ((Sx-1)-Sy%2)/2*2+Sy%2;
long cornerTx = (Ty>=0)? (Tx-Ty%2)/2*2+Ty%2 : ((Tx-1)-Ty%2)/2*2+Ty%2;
long num = Math.abs(cornerTx-cornerSx);
long h =Math.abs(Sy-Ty);
if(num<=h) {
System.out.println(h);
}else {
System.out.println(2*num-h);
}
scanner.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
long Sx= scanner.nextLong();
long Sy= scanner.nextLong();
long Tx= scanner.nextLong();
long Ty= scanner.nextLong();
long cornerSx = (Sx>=0)? (Sx-Sy%2)/2*2+Sy%2 : ((Sx-1)-Sy%2)/2*2+Sy%2;
long cornerTx = (Ty>=0)? (Tx-Ty%2)/2*2+Ty%2 : ((Tx-1)-Ty%2)/2*2+Ty%2;
long num = Math.abs(cornerTx-cornerSx);
long h =Math.abs(Sy-Ty);
if(num<=h) {
System.out.println(h);
}else {
System.out.println((h+num)/2);
}
scanner.close();
}
}
| ConDefects/ConDefects/Code/abc359_c/Java/54932246 |
condefects-java_data_193 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long sx = sc.nextLong();
long sy = sc.nextLong();
long tx = sc.nextLong();
long ty = sc.nextLong();
if((sx+ty)%2 == 1) {
sx--;
}
if((tx+ty)%2 == 1) {
tx--;
}
long x = Math.abs(tx-sx);
long y = Math.abs(ty-sy);
if(x < y) {
System.out.println(y);
} else {
System.out.println((x+y)/2);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long sx = sc.nextLong();
long sy = sc.nextLong();
long tx = sc.nextLong();
long ty = sc.nextLong();
if((sx+sy)%2 == 1) {
sx--;
}
if((tx+ty)%2 == 1) {
tx--;
}
long x = Math.abs(tx-sx);
long y = Math.abs(ty-sy);
if(x < y) {
System.out.println(y);
} else {
System.out.println((x+y)/2);
}
}
} | ConDefects/ConDefects/Code/abc359_c/Java/55012581 |
condefects-java_data_194 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
long Sx = sc.nextLong();
long Sy = sc.nextLong();
long Tx = sc.nextLong();
long Ty = sc.nextLong();
long result = 0;
long xReduction = 0;
xReduction += Math.abs(Ty - Sy);
result += Math.abs(Ty - Sy);
if (Tx - Sx >= 0) {
if ((Sx + Sy) % 2 == 0 ) {
xReduction++;
}
if ((Tx + Ty) % 2 == 1) {
xReduction++;
}
} else {
if ((Sx + Sy) % 2 == 1 ) {
xReduction++;
}
if ((Tx + Ty) % 2 == 0) {
xReduction++;
}
}
if (xReduction < Math.abs(Tx - Sx)) {
result += (Math.abs(Tx - Sx) - xReduction) / 2;
}
System.out.println(result);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
long Sx = sc.nextLong();
long Sy = sc.nextLong();
long Tx = sc.nextLong();
long Ty = sc.nextLong();
long result = 0;
long xReduction = 0;
xReduction += Math.abs(Ty - Sy);
result += Math.abs(Ty - Sy);
if (Tx - Sx >= 0) {
if ((Sx + Sy) % 2 == 0 ) {
xReduction++;
}
if ((Tx + Ty) % 2 == 1) {
xReduction++;
}
} else {
if ((Sx + Sy) % 2 == 1 ) {
xReduction++;
}
if ((Tx + Ty) % 2 == 0) {
xReduction++;
}
}
if (xReduction < Math.abs(Tx - Sx)) {
result += (Math.abs(Tx - Sx) - xReduction) / 2 + (Math.abs(Tx - Sx) - xReduction) % 2;
}
System.out.println(result);
}
}
} | ConDefects/ConDefects/Code/abc359_c/Java/54940335 |
condefects-java_data_195 | import java.util.*;
public class Main {
public static void main(String[] args) {
int t = getInt();
for(int i = 0;i < t;i++){
long n = getInt();
long a = getInt();
long b = getInt();
long tmp = (n-a);
if(a > n){
No();
} else if(a < n/2 && b > tmp*(a+(n-a)/2+(n-a)%2) || a >= n/2 && b > tmp*tmp) {
No();
}else{
Yes();
}
}
}
static int sqrtI(long n){
return toInt(Math.sqrt(n));
}
static long toLong(double v) {
return Double.valueOf(v).longValue();
}
static int toInt(double v) {
return Double.valueOf(v).intValue();
}
static String[] createTiles(int w, int h, String out){
String[] s = new String[h + 2];
s[0] = s[h + 1] = out.repeat(w + 2);
for (int i = 1; i <= h; i++) {
s[i] = out + getString() + out;
}
return s;
}
static void outH(List<?> o){
int nl = o.size()-1;
for (int i = 0; i < o.size(); i++) {
System.out.print(o.get(i)+(i != nl ? " ":"\n"));
}
out();
}
static void out(List<?> o){
for (Object oo: o) {
System.out.println(oo);
}
}
static void outH(Object[] o){
int nl = o.length-1;
for (int i = 0; i < o.length; i++) {
System.out.print(o[i]+(i != nl ? " ":""));
}
out();
}
static void outH(char[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(double[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(int[] in){
int nl = in.length-1;
for (int i = 0; i < in.length; i++) {
System.out.print(in[i]+(i != nl ? " ":""));
}
out();
}
static void outH(long[] l){
int nl = l.length-1;
for (int i = 0; i < l.length; i++) {
System.out.print(l[i]+(i != nl ? " ":""));
}
out();
}
static void outH(String[] s){
int nl = s.length-1;
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+(i != nl ? " ":""));
}
out();
}
static void out(){
System.out.println();
}
static void out(Object[] o){
for (Object oo : o) {
System.out.println(oo);
}
}
static String sortString(String s) {
char[] a = s.toCharArray();
Arrays.sort(a);
return new String(a);
}
static String sortStringDesc(String s) {
return new StringBuilder(sortString(s)).reverse().toString();
}
static void out(char[] c){
for (Character aChar : c) {
System.out.println(aChar);
}
}
static void out(double[] d){
for (Double aDouble : d) {
System.out.println(aDouble);
}
}
static void out(int[] i){
for (Integer iInteger: i) {
System.out.println(iInteger);
}
}
static void out(long[] l){
for (Long lLong: l) {
System.out.println(lLong);
}
}
static void out(String[] s){
for (String sString: s) {
System.out.println(sString);
}
}
static void out(Double d){
System.out.println(d);
}
static void out(Integer i){
System.out.println(i);
}
static void out(Long l){
System.out.println(l);
}
static void out(String s){
System.out.println(s);
}
static void YesOrNo(boolean b){
System.out.println(b ? "Yes" : "No");
}
static void YesOrNo(boolean b, String yes, String no){
System.out.println(b ? yes : no);
}
static void Yes(){
System.out.println("Yes");
}
static void No(){
System.out.println("No");
}
/*
static StringTokenizer st;
static InputStreamReader isr = new InputStreamReader(System.in);
static BufferedReader br = new BufferedReader(isr);
static String getString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine().trim());
} catch (IOException e) {
System.exit(0);
}
}
return st.nextToken();
}
static long getLong() {
return Long.parseLong(getString());
}
static int getInt() {
return Integer.parseInt(getString());
}
static Double getDouble() {
return parseDouble(getString());
}
*/
private static final java.io.InputStream in = System.in;
private static final byte[] buffer = new byte[1024];
private static int ptr = 0;
private static int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
static boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
static int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
static boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
static String getString() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
static long getLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit)
);
}
n = n * 10 + digit;
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
static public int getInt() {
long nl = getLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
static public double getDouble() {
return Double.parseDouble(getString());
}
static public long[] getLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = getLong();
return array;
}
static public long[] getLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(getLong());
return array;
}
static public int[] getIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = getInt();
return array;
}
static public int[] getIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(getInt());
return array;
}
static public double[] getDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = getDouble();
return array;
}
static public double[] getDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(getDouble());
return array;
}
static public long[][] getLongMatrix(int height, int width){
long[][] mat = new long[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getLong();
}
return mat;
}
static int[][] getIntMatrix(int height, int width){
int[][] mat = new int[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getInt();
}
return mat;
}
static public double[][] getDoubleMatrix(int height, int width){
double[][] mat = new double[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getDouble();
}
return mat;
}
static public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = getString();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
public static long mod1097 = 1000000007L;
public static long mod9982 = 998244353L;
}
import java.util.*;
public class Main {
public static void main(String[] args) {
int t = getInt();
for(int i = 0;i < t;i++){
long n = getInt();
long a = getInt();
long b = getInt();
long tmp = (n-a);
if(a > n){
No();
} else if(a*2 < n && b > tmp*(n/2+(n)%2) || a*2 >= n && b > tmp*tmp) {
No();
}else{
Yes();
}
}
}
static int sqrtI(long n){
return toInt(Math.sqrt(n));
}
static long toLong(double v) {
return Double.valueOf(v).longValue();
}
static int toInt(double v) {
return Double.valueOf(v).intValue();
}
static String[] createTiles(int w, int h, String out){
String[] s = new String[h + 2];
s[0] = s[h + 1] = out.repeat(w + 2);
for (int i = 1; i <= h; i++) {
s[i] = out + getString() + out;
}
return s;
}
static void outH(List<?> o){
int nl = o.size()-1;
for (int i = 0; i < o.size(); i++) {
System.out.print(o.get(i)+(i != nl ? " ":"\n"));
}
out();
}
static void out(List<?> o){
for (Object oo: o) {
System.out.println(oo);
}
}
static void outH(Object[] o){
int nl = o.length-1;
for (int i = 0; i < o.length; i++) {
System.out.print(o[i]+(i != nl ? " ":""));
}
out();
}
static void outH(char[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(double[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(int[] in){
int nl = in.length-1;
for (int i = 0; i < in.length; i++) {
System.out.print(in[i]+(i != nl ? " ":""));
}
out();
}
static void outH(long[] l){
int nl = l.length-1;
for (int i = 0; i < l.length; i++) {
System.out.print(l[i]+(i != nl ? " ":""));
}
out();
}
static void outH(String[] s){
int nl = s.length-1;
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+(i != nl ? " ":""));
}
out();
}
static void out(){
System.out.println();
}
static void out(Object[] o){
for (Object oo : o) {
System.out.println(oo);
}
}
static String sortString(String s) {
char[] a = s.toCharArray();
Arrays.sort(a);
return new String(a);
}
static String sortStringDesc(String s) {
return new StringBuilder(sortString(s)).reverse().toString();
}
static void out(char[] c){
for (Character aChar : c) {
System.out.println(aChar);
}
}
static void out(double[] d){
for (Double aDouble : d) {
System.out.println(aDouble);
}
}
static void out(int[] i){
for (Integer iInteger: i) {
System.out.println(iInteger);
}
}
static void out(long[] l){
for (Long lLong: l) {
System.out.println(lLong);
}
}
static void out(String[] s){
for (String sString: s) {
System.out.println(sString);
}
}
static void out(Double d){
System.out.println(d);
}
static void out(Integer i){
System.out.println(i);
}
static void out(Long l){
System.out.println(l);
}
static void out(String s){
System.out.println(s);
}
static void YesOrNo(boolean b){
System.out.println(b ? "Yes" : "No");
}
static void YesOrNo(boolean b, String yes, String no){
System.out.println(b ? yes : no);
}
static void Yes(){
System.out.println("Yes");
}
static void No(){
System.out.println("No");
}
/*
static StringTokenizer st;
static InputStreamReader isr = new InputStreamReader(System.in);
static BufferedReader br = new BufferedReader(isr);
static String getString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine().trim());
} catch (IOException e) {
System.exit(0);
}
}
return st.nextToken();
}
static long getLong() {
return Long.parseLong(getString());
}
static int getInt() {
return Integer.parseInt(getString());
}
static Double getDouble() {
return parseDouble(getString());
}
*/
private static final java.io.InputStream in = System.in;
private static final byte[] buffer = new byte[1024];
private static int ptr = 0;
private static int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
static boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
static int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
static boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
static String getString() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
static long getLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b))
);
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit)
);
}
n = n * 10 + digit;
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
static public int getInt() {
long nl = getLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
static public double getDouble() {
return Double.parseDouble(getString());
}
static public long[] getLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = getLong();
return array;
}
static public long[] getLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(getLong());
return array;
}
static public int[] getIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = getInt();
return array;
}
static public int[] getIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(getInt());
return array;
}
static public double[] getDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = getDouble();
return array;
}
static public double[] getDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(getDouble());
return array;
}
static public long[][] getLongMatrix(int height, int width){
long[][] mat = new long[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getLong();
}
return mat;
}
static int[][] getIntMatrix(int height, int width){
int[][] mat = new int[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getInt();
}
return mat;
}
static public double[][] getDoubleMatrix(int height, int width){
double[][] mat = new double[height][width];
for(int h=0; h<height; h++) for(int w=0; w<width; w++){
mat[h][w] = getDouble();
}
return mat;
}
static public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = getString();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
public static long mod1097 = 1000000007L;
public static long mod9982 = 998244353L;
} | ConDefects/ConDefects/Code/arc171_a/Java/50012906 |
condefects-java_data_196 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int q = scan.nextInt();
int[] circumstance = new int[n];
for (int i = 0; i < n; i++) {
circumstance[i] = 0;
}
for (int k = 0; k < q; k++) {
int query1 = scan.nextInt();
int query2 = scan.nextInt();
if (query1 == 1 || query1 == 2) {
circumstance[query2-1] = circumstance[query2-1] + query1;
} else {
if (circumstance[query2-1] == 2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
scan.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int q = scan.nextInt();
int[] circumstance = new int[n];
for (int i = 0; i < n; i++) {
circumstance[i] = 0;
}
for (int k = 0; k < q; k++) {
int query1 = scan.nextInt();
int query2 = scan.nextInt();
if (query1 == 1 || query1 == 2) {
circumstance[query2-1] = circumstance[query2-1] + query1;
} else {
if (circumstance[query2-1] >= 2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
scan.close();
}
} | ConDefects/ConDefects/Code/abc292_b/Java/40350527 |
condefects-java_data_197 | import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int M = in.it();
int Q = in.it();
Object solve(){
UnionFindPotential uf = new UnionFindPotential(N);
Set<Integer> infs = new HashSet<>();
for (int i = 0;i < M;i++) {
int a = in.idx();
int b = in.idx();
long c = in.lg();
if (!uf.valid(a,b,c))
infs.add(uf.root(a));
else
uf.unite(a,b,c);
}
for (var i:new ArrayList<>(infs))
infs.add(uf.root(i));
while (Q-- > 0) {
int x = in.idx();
int y = in.idx();
if (!uf.same(x,y))
out.println("nan");
else if (infs.contains(uf.root(x)))
out.println("inf");
else
out.println(uf.dist(y) -uf.dist(x));
}
return null;
}
}
class UnionFind{
int num;
int[] par;
int[] size;
public UnionFind(int n){
par = new int[n];
Arrays.setAll(par,i -> i);
size = new int[n];
Arrays.fill(size,1);
num = n;
}
int root(int x){ return x == par[x] ? x : (par[x] = root(par[x])); }
boolean same(int u,int v){ return root(u) == root(v); }
boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (size[u] < size[v]) {
u ^= v;
v ^= u;
u ^= v;
}
sub(u,v);
par[v] = u;
size[u] += size[v];
num--;
return true;
}
protected void sub(int u,int v){}
int size(int x){ return size[root(x)]; }
}
class UnionFindGroup extends UnionFind{
List<Set<Integer>> group;
UnionFindGroup(int n){
super(n);
group = new ArrayList<>();
for (int i = 0;i < n;i++) {
Set<Integer> set = new HashSet<>();
set.add(i);
group.add(set);
}
}
Set<Integer> getGroup(int i){ return group.get(root(i)); }
@Override
protected void sub(int u,int v){ group.get(u).addAll(group.get(v)); }
}
class UnionFindPotential extends UnionFind{
long[] dist;
UnionFindPotential(int n){
super(n);
dist = new long[n];
}
long sum(long a,long b){ return a +b; }
long sub(long a,long b){ return a -b; }
@Override
int root(int x){
if (x == par[x])
return x;
int r = root(par[x]);
dist[x] = sum(dist[x],dist[par[x]]);
return par[x] = r;
}
@Override
boolean unite(int u,int v){ return unite(u,v,0); }
boolean valid(int u,int v,long c){ return !same(u,v) || sub(dist(v),dist(u)) == c; }
boolean unite(int u,int v,long c){
assert valid(u,v,c);
if ((u = root(u)) == (v = root(v)))
return false;
c = sum(c,sub(dist(u),dist(v)));
if (size[u] < size[v]) {
u ^= v;
v ^= u;
u ^= v;
c = sub(0,c);
}
par[v] = u;
dist[v] = c;
size[u] += size[v];
num--;
return true;
}
long dist(int x){
root(x);
return dist[x];
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (var e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int M = in.it();
int Q = in.it();
Object solve(){
UnionFindPotential uf = new UnionFindPotential(N);
Set<Integer> infs = new HashSet<>();
for (int i = 0;i < M;i++) {
int a = in.idx();
int b = in.idx();
long c = in.lg();
if (!uf.valid(a,b,c))
infs.add(uf.root(a));
else
uf.unite(a,b,c);
}
for (var i:new ArrayList<>(infs))
infs.add(uf.root(i));
while (Q-- > 0) {
int x = in.idx();
int y = in.idx();
if (!uf.same(x,y))
out.println("nan");
else if (infs.contains(uf.root(x)))
out.println("inf");
else
out.println(uf.dist(y) -uf.dist(x));
}
return null;
}
}
class UnionFind{
int num;
int[] par;
int[] size;
public UnionFind(int n){
par = new int[n];
Arrays.setAll(par,i -> i);
size = new int[n];
Arrays.fill(size,1);
num = n;
}
int root(int x){ return x == par[x] ? x : (par[x] = root(par[x])); }
boolean same(int u,int v){ return root(u) == root(v); }
boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (size[u] < size[v]) {
u ^= v;
v ^= u;
u ^= v;
}
sub(u,v);
par[v] = u;
size[u] += size[v];
num--;
return true;
}
protected void sub(int u,int v){}
int size(int x){ return size[root(x)]; }
}
class UnionFindGroup extends UnionFind{
List<Set<Integer>> group;
UnionFindGroup(int n){
super(n);
group = new ArrayList<>();
for (int i = 0;i < n;i++) {
Set<Integer> set = new HashSet<>();
set.add(i);
group.add(set);
}
}
Set<Integer> getGroup(int i){ return group.get(root(i)); }
@Override
protected void sub(int u,int v){ group.get(u).addAll(group.get(v)); }
}
class UnionFindPotential extends UnionFind{
long[] dist;
UnionFindPotential(int n){
super(n);
dist = new long[n];
}
long sum(long a,long b){ return a +b; }
long sub(long a,long b){ return a -b; }
@Override
int root(int x){
if (x == par[x])
return x;
int r = root(par[x]);
dist[x] = sum(dist[x],dist[par[x]]);
return par[x] = r;
}
@Override
boolean unite(int u,int v){ return unite(u,v,0); }
boolean valid(int u,int v,long c){ return !same(u,v) || sub(dist(v),dist(u)) == c; }
boolean unite(int u,int v,long c){
assert valid(u,v,c);
c = sum(c,sub(dist(u),dist(v)));
if ((u = root(u)) == (v = root(v)))
return false;
if (size[u] < size[v]) {
u ^= v;
v ^= u;
u ^= v;
c = sub(0,c);
}
par[v] = u;
dist[v] = c;
size[u] += size[v];
num--;
return true;
}
long dist(int x){
root(x);
return dist[x];
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (var e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
} | ConDefects/ConDefects/Code/abc280_f/Java/42792826 |
condefects-java_data_198 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int q = sc.nextInt();
char[] s = sc.next().toCharArray();
int[] ss = new int[n+1];
ss[0] = 0;
ss[1] = 0;
for (int i = 1; i < n; i++) {
if(s[i]==s[i-1]) {
ss[i+1] = ss[i]+1;
}else {
ss[i+1] = ss[i];
}
}
for (int i = 0; i < q; i++) {
int l = sc.nextInt()-1;
int r = sc.nextInt()-1;
int ans = ss[r+1] - ss[l];
if(l>1) {
if(s[l]==s[l-1])ans--;
}
System.out.println(ans);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int q = sc.nextInt();
char[] s = sc.next().toCharArray();
int[] ss = new int[n+1];
ss[0] = 0;
ss[1] = 0;
for (int i = 1; i < n; i++) {
if(s[i]==s[i-1]) {
ss[i+1] = ss[i]+1;
}else {
ss[i+1] = ss[i];
}
}
for (int i = 0; i < q; i++) {
int l = sc.nextInt()-1;
int r = sc.nextInt()-1;
int ans = ss[r+1] - ss[l];
if(l>0) {
if(s[l]==s[l-1])ans--;
}
System.out.println(ans);
}
}
}
| ConDefects/ConDefects/Code/abc328_c/Java/51779851 |
condefects-java_data_199 | import java.util.Scanner;
public class Main {
public static void main(String args[]) {
int n = 0;
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int ans = 0;
boolean[][] g = new boolean[100][100];
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for (int k = 0; k < n; k++) {
a = sc.nextInt();
b = sc.nextInt();
c = sc.nextInt();
d = sc.nextInt();
for (int i = a; i < b; i++) {
for (int j = c; j < d; j++) {
g[i][j] = true;
}
}
}
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
if (g[i][j] = true) {
ans++;
}
}
}
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
int n = 0;
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int ans = 0;
boolean[][] g = new boolean[100][100];
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for (int k = 0; k < n; k++) {
a = sc.nextInt();
b = sc.nextInt();
c = sc.nextInt();
d = sc.nextInt();
for (int i = a; i < b; i++) {
for (int j = c; j < d; j++) {
g[i][j] = true;
}
}
}
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
if (g[i][j] == true) {
ans++;
}
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc318_b/Java/46480127 |
condefects-java_data_200 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
class Main {
public static void solve(Read br, Write out) {
int n = br.readI();
int a[] = br.readIs(n);
HashMap<Integer, Integer> map = new HashMap<>();
int xor = 0;
for (int i = 0; i < n; i++) {
xor = xor ^ a[i];
if (map.containsKey(a[i])) {
map.put(a[i], map.get(a[i]) + 1);
} else {
map.put(a[i], 1);
}
}
if (xor != 0) {
out.pl(-1);
return;
}
int max = 0;
for (Map.Entry<Integer, Integer> e : map.entrySet()) {
if (e.getValue() % 2 != 0 && e.getKey() > max) {
max = e.getKey();
}
}
out.pl(max - 1);
}
public static void main(String args[]) {
Read br = new Read();
Write out = new Write();
solve(br, out);
out.flush();
}
static class KDtree {
Node root;
int k;
public KDtree(int a[][], int k) {
this.k = k;
root = construct(a, 0);
}
private Node construct(int a[][], int depth) {
int axis = depth % k;
sortA(a, axis);
int m = a.length / 2;
Node node = new Node(a[m], axis);
if (m > 0) {
node.left = construct(Arrays.copyOfRange(a, 0, m), depth + 1);
node.left.parent = node;
}
if (m + 1 < a.length) {
node.right = construct(Arrays.copyOfRange(a, m + 1, a.length), depth + 1);
node.right.parent = node;
}
return node;
}
public int[] search(int coord[]) {
Node node = neighborhood(coord, root);
double dist = distance(coord, node.coord);
ArrayList<Node> list = new ArrayList<>();
list.add(node);
while (node.parent != null) {
node = node.parent;
if (Math.abs(coord[node.axis] - node.coord[node.axis]) < dist) {
neighborhood(coord, node);
list.add(node);
}
}
return node.coord;
}
public double distance(int a[], int b[]) {
double d = 0;
for (int i = 0; i < k; i++) {
int t = a[i] - b[i];
d += t * t;
}
return Math.sqrt(d);
}
private Node neighborhood(int coord[], Node n) {
int axis = n.axis;
if (coord[axis] < n.coord[axis]) {
if (n.left != null) {
return neighborhood(coord, n.left);
} else {
return n;
}
} else {
if (n.right != null) {
return neighborhood(coord, n.right);
} else {
return n;
}
}
}
class Node {
int coord[];
int axis;
Node left, right, parent;
public Node(int c[], int axis) {
this.coord = c;
this.axis = axis;
}
}
}
static class Tree {
int n;
int root;
int parent[];
int height[];
int maxh;
ArrayList<ArrayList<Integer>> child;
int lca[][];
public Tree(int nn, int r) {
n = nn;
root = r;
parent = new int[n];
height = new int[n];
child = new ArrayList<>();
for (int i = 0; i < n; i++) {
child.add(new ArrayList<>());
}
}
public Tree(int par[], int r) {
n = par.length;
root = r;
parent = new int[n];
height = new int[n];
child = new ArrayList<>();
for (int i = 0; i < n; i++) {
child.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
parent[i] = par[i];
if (parent[i] != -1) {
child.get(parent[i]).add(i);
}
}
ArrayDeque<Integer> q = new ArrayDeque<>();
q.add(root);
while (q.size() > 0) {
int v = q.poll();
for (int u : child.get(v)) {
height[u] = height[v] + 1;
if (height[u] > maxh) {
maxh = height[u];
}
q.add(u);
}
}
}
public Tree(Graph g, int r) {
this(g.n, r);
construct(g);
}
public void construct(Graph g) {
constructdfs(g, root, -1, 0, new boolean[n]);
}
public void constructdfs(Graph g, int now, int before, int h, boolean flg[]) {
flg[now] = true;
parent[now] = before;
height[now] = h;
if (h > maxh) {
maxh = h;
}
for (Graph.Edge e : g.g.get(now)) {
if (e.v != before) {
constructdfs(g, e.v, now, h + 1, flg);
child.get(now).add(e.v);
}
}
}
public void const_lowest_common_ancestor() {
int k = 1;
while ((1 << k) <= maxh) {
k++;
}
lca = new int[k][n];
for (int i = 0; i < n; i++) {
lca[0][i] = parent[i];
if (lca[0][i] == -1) {
lca[0][i] = i;
}
}
for (int i = 1; i < k; i++) {
for (int v = 0; v < n; v++) {
lca[i][v] = lca[i - 1][lca[i - 1][v]];
}
}
}
public int get_anscestor(int u, int d) {
int k = lca.length;
for (int i = 0; i < k; i++) {
if ((d >> i) % 2 > 0) {
u = lca[i][u];
}
}
return u;
}
public int query_lowest_common_ancestor(int u, int v) {
if (height[u] < height[v]) {
return query_lowest_common_ancestor(v, u);
}
int k = lca.length;
u = get_anscestor(u, height[u] - height[v]);
if (u == v) {
return u;
}
for (int i = k - 1; i >= 0; i--) {
if (lca[i][u] != lca[i][v]) {
u = lca[i][u];
v = lca[i][v];
}
}
return lca[0][u];
}
}
public static int comp(long a, long b) {
return a > b ? 1 : a < b ? -1 : 0;
}
public static long fact(int i) {
if (i == 1 || i == 0) {
return 1L;
}
return i * fact(i - 1);
}
public static long gcd(long a, long b) {
if (a < b) {
return gcd(b, a);
}
long c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static int gcd(int a, int b) {
if (a < b) {
return gcd(b, a);
}
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
public static int lcm(int a, int b) {
return a / gcd(a, b) * b;
}
public static void sortA(int n[]) {
Arrays.sort(n);
}
public static void sortA(long n[]) {
Arrays.sort(n);
}
public static void sortD(int n[]) {
Arrays.sort(n);
rev(n);
}
public static void rev(int n[]) {
int l = n.length;
for (int i = 0; i < l / 2; i++) {
int t = n[i];
n[i] = n[l - i - 1];
n[l - i - 1] = t;
}
}
public static void sortA(ArrayList<Integer> n) {
Collections.sort(n);
}
public static void sortD(ArrayList<Integer> n) {
Collections.sort(n, Collections.reverseOrder());
}
public static void sortA(int n[][], int k) {
Arrays.sort(n, (a, b) -> Integer.compare(a[k], b[k]));
}
public static void sortD(int n[][], int k) {
Arrays.sort(n, (a, b) -> Integer.compare(b[k], a[k]));
}
public static void mysort(int n[][], int k) {
Arrays.sort(n, new Comparator<int[]>() {
public int compare(int[] x, int[] y) {
if (x[k] == y[k]) {
return x[1] - y[1];
}
return x[k] - y[k];
}
});
}
static class ModFunc {
int n;
long mod;
long fact[], invfact[];
public ModFunc(int n, long mod) {
this.n = n;
this.mod = mod;
fact = new long[n + 1];
invfact = new long[n + 1];
modfact();
modinvfact();
}
public static long modfact(int n, long mod) {
long k = 1;
for (int i = 1; i <= n; i++) {
k = k * i % mod;
}
return k;
}
public static long modinvfact(int n, long mod) {
return modinv(modfact(n, mod), mod);
}
public static long modinv(long a, long mod) {
long x1 = 1, x2 = 0;
long p = a, q = mod, t;
while (q != 0) {
t = p / q;
t = x1 - t * x2;
x1 = x2;
x2 = t;
t = p % q;
p = q;
q = t;
}
return x1 < 0 ? x1 + mod : x1;
}
private void modfact() {
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i % mod;
}
}
private void modinvfact() {
invfact[n] = modinv(fact[n], mod);
for (int i = n - 1; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1) % mod;
}
}
public long modConv(int n, int k) {
return ((fact[n] * invfact[n - k]) % mod) * invfact[k] % mod;
}
public static long modpow(long x, long n, long pow) {
long r = 1;
while (n >= 1) {
if (1 == (n & 1)) {
r = r * x % pow;
}
x = x * x % pow;
n /= 2;
}
return r;
}
}
static class Permu {
int n;
public int a[];
boolean flg;
public Permu(int n) {
this.n = n;
flg = true;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = i;
}
}
public Permu(int k[]) {
this.n = k.length;
flg = true;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = k[i];
}
}
public boolean next() {
for (int i = n - 2; i >= 0; i--) {
if (a[i] >= a[i + 1]) {
continue;
}
for (int j = n - 1;; j--) {
if (a[i] >= a[j]) {
continue;
}
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
for (j = n - 1; i < j; i++, j--) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
return true;
}
}
flg = false;
return false;
}
public boolean before() {
for (int i = n - 2; i >= 0; i--) {
if (a[i] <= a[i + 1]) {
continue;
}
for (int j = n - 1;; j--) {
if (a[i] <= a[j]) {
continue;
}
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
for (j = n - 1; i < j; i++, j--) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
return true;
}
}
flg = false;
return false;
}
}
static class Compress {
ArrayList<Integer> a;
HashMap<Integer, Integer> map;
public Compress(int[] b) {
HashSet<Integer> temp = new HashSet<>();
for (int i : b) {
temp.add(i);
}
a = new ArrayList<Integer>(temp);
setup();
}
public Compress(ArrayList<Integer> b) {
a = new ArrayList<Integer>(new HashSet<Integer>(b));
setup();
}
private void setup() {
map = new HashMap<>();
sortA(a);
for (int i = 0; i < a.size(); i++) {
map.put(a.get(i), i);
}
}
public int get(int i) {
return map.get(i);
}
}
static class UnionFindTree {
int parent[];
int size;
int vol[];
public UnionFindTree(int s) {
size = s;
parent = new int[size];
vol = new int[size];
for (int i = 0; i < size; i++) {
parent[i] = i;
vol[i] = 1;
}
}
public int root(int n) {
if (parent[n] == n) {
return n;
}
parent[n] = root(parent[n]);
return parent[n];
}
public void unite(int a, int b) {
int ra = root(a), rb = root(b);
if (ra == rb) {
return;
}
if (vol[ra] < vol[rb]) {
a = ra;
ra = rb;
rb = a;
}
parent[rb] = ra;
vol[ra] += vol[rb];
}
public boolean same(int a, int b) {
return root(a) == root(b);
}
}
static class WeightUnionFindTree {
int parent[];
int size;
int vol[];
int diff[];
public WeightUnionFindTree(int s) {
size = s;
parent = new int[size];
vol = new int[size];
diff = new int[size];
for (int i = 0; i < size; i++) {
parent[i] = i;
vol[i] = 1;
diff[i] = 0;
}
}
public int root(int n) {
if (parent[n] == n) {
return n;
}
int r = root(parent[n]);
diff[n] += diff[parent[n]];
parent[n] = r;
return parent[n];
}
public int weight(int n) {
root(n);
return diff[n];
}
public void unite(int a, int b, int w) {
int ra = root(a), rb = root(b);
if (ra == rb) {
return;
}
w += weight(a);
w -= weight(b);
if (vol[ra] < vol[rb]) {
a = ra;
ra = rb;
rb = a;
w = -w;
}
parent[rb] = ra;
vol[ra] += vol[rb];
diff[rb] = w;
}
public int differ(int a, int b) {
return weight(a) - weight(b);
}
public boolean same(int a, int b) {
return root(a) == root(b);
}
}
static abstract class SegmentTree {
int n, leafN;
int ar[];
int lazy[];
int temp;
public SegmentTree(int x, int temp) {
leafN = x;
this.temp = temp;
n = twon(leafN);
ar = new int[2 * n - 1];
lazy = new int[2 * n - 1];
for (int i = 0; i < n * 2 - 1; i++) {
ar[i] = temp;
lazy[i] = temp;
}
}
public abstract int func(int a, int b);
public void eval(int k) {
if (lazy[k] == temp) {
return;
}
if (k < n - 1) {
lazy[k * 2 + 1] = lazy[k];
lazy[k * 2 + 2] = lazy[k];
}
ar[k] = lazy[k];
lazy[k] = temp;
}
public void update(int i, int x) {
int now = i + n - 1;
ar[now] = x;
while (now > 0) {
now = (now - 1) / 2;
ar[now] = func(ar[now * 2 + 1], ar[now * 2 + 2]);
}
}
public void add(int i, int x) {
update(i, ar[i + n - 1] + x);
}
public void update(int a, int b, int x) {
update(a, b, x, 0, 0, n);
}
public void update(int a, int b, int x, int k, int l, int r) {
eval(k);
if (r <= a || b <= l) {
return;
} else if (a <= l && r <= b) {
lazy[k] = x;
eval(k);
}
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
ar[k] = func(ar[k * 2 + 1], ar[k * 2 + 2]);
}
public int get(int i) {
return ar[i + n - 1];
}
public int query(int a, int b) {
return query(a, b, 0, 0, n);
}
public int query(int a, int b, int k, int l, int r) {
eval(k);
if (r <= a || b <= l) {
return temp;
} else if (a <= l && r <= b) {
return ar[k];
}
int t1 = query(a, b, k * 2 + 1, l, (l + r) / 2), t2 = query(a, b, k * 2 + 2, (l + r) / 2, r);
return func(t1, t2);
}
private int twon(int x) {
int i = 1;
while (i < x) {
i *= 2;
}
return i;
}
}
static class SegmentTreeE extends SegmentTree {
public SegmentTreeE(int x) {
super(x, 0);
}
public int func(int a, int b) {
return a ^ b;
}
}
static class SegmentTreeMin extends SegmentTree {
public SegmentTreeMin(int x) {
super(x, Integer.MAX_VALUE);
}
public int func(int a, int b) {
return Math.min(a, b);
}
}
static class SegmentTreeMax extends SegmentTree {
public SegmentTreeMax(int x) {
super(x, Integer.MIN_VALUE);
}
public int func(int a, int b) {
return Math.max(a, b);
}
public int leftmax(int a) {
if (ar[0] < a) {
return -1;
}
return leftmax(a, 0);
}
private int leftmax(int a, int i) {
eval(i);
if (i >= n - 1) {
return i - n + 1;
}
int next = i * 2 + 1;
if (ar[next] < a) {
return leftmax(a, next + 1);
}
return leftmax(a, next);
}
}
static class SegmentTreeS extends SegmentTree {
public SegmentTreeS(int x) {
super(x, 0);
}
public int func(int a, int b) {
return a + b;
}
}
static class BIT {
int n;
int ar[];
public BIT(int x) {
n = x + 1;
ar = new int[n];
for (int i = 0; i < n; i++) {
ar[i] = 0;
}
}
public void update(int i, int x) {
i++;
for (int ii = i; ii < n; ii += (ii & -ii)) {
ar[ii] += x;
}
}
public int sum(int i) {
int k = 0;
for (int ii = i; ii > 0; ii -= (ii & -ii)) {
k += ar[ii];
}
return k;
}
}
static class Graph {
int n;
ArrayList<ArrayList<Edge>> g;
public Graph(int nn) {
n = nn;
g = new ArrayList<ArrayList<Edge>>();
for (int i = 0; i < n; i++) {
g.add(new ArrayList<Edge>());
}
}
public void add(int a, int b, int d) {
g.get(a).add(new Edge(b, d));
g.get(b).add(new Edge(a, d));
}
public void addY(int a, int b, int d) {
g.get(a).add(new Edge(b, d));
}
public void add(int a, int b) {
g.get(a).add(new Edge(b, 1));
g.get(b).add(new Edge(a, 1));
}
public void addY(int a, int b) {
g.get(a).add(new Edge(b, 1));
}
public int len(int a) {
return g.get(a).size();
}
public long[][] dijkstra(int s) {
long dist[][] = new long[n][2];
for (int i = 0; i < n; i++) {
dist[i][0] = Long.MAX_VALUE;
dist[i][1] = -1;
}
dist[s][0] = 0;
dist[s][1] = -1;
PriorityQueue<long[]> q = new PriorityQueue<long[]>(new Comparator<long[]>() {
public int compare(long[] x, long[] y) {
return Long.compare(x[1], y[1]);
}
});
q.add(new long[] { s, 0L });
while (q.size() > 0) {
long[] p = q.poll();
if (dist[(int) p[0]][0] != p[1]) {
continue;
}
for (Edge e : g.get((int) p[0])) {
if (dist[e.v][0] > dist[(int) p[0]][0] + e.d) {
dist[e.v][0] = dist[(int) p[0]][0] + e.d;
dist[e.v][1] = (int) p[0];
q.add(new long[] { e.v, dist[e.v][0] });
}
}
}
return dist;
}
public static long[][] floydwarshall(int g[][]) {
int n = g.length;
long dist[][] = new long[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = g[i][j];
if (dist[i][j] == 0) {
dist[i][j] = Long.MAX_VALUE;
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dist[i][k] == Long.MAX_VALUE || dist[k][j] == Long.MAX_VALUE) {
continue;
}
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
return dist;
}
public void dfs(int v) {
ArrayDeque<Integer> q = new ArrayDeque<>();
boolean flg[] = new boolean[n];
q.addLast(v);
flg[v] = true;
while (q.size() > 0) {
int now = q.pollLast();
for (Edge e : g.get(now)) {
if (!flg[e.v]) {
flg[e.v] = true;
q.addLast(e.v);
}
}
}
}
public void bfs(int s) {
boolean flg[] = new boolean[n];
Queue<Integer> q = new ArrayDeque<Integer>();
q.add(s);
while (q.size() > 0) {
int v = q.poll();
flg[v] = true;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
q.add(e.v);
flg[e.v] = true;
}
}
}
}
public int minspantree() {
PriorityQueue<Edge> q = new PriorityQueue<Edge>(new Comparator<Edge>() {
public int compare(Edge a, Edge b) {
return a.d - b.d;
}
});
boolean flg[] = new boolean[n];
int c = 1, sum = 0;
for (Edge e : g.get(0)) {
q.add(e);
}
flg[0] = true;
while (c < n) {
Edge e = q.poll();
if (flg[e.v]) {
continue;
}
flg[e.v] = true;
sum += e.d;
c++;
for (Edge i : g.get(e.v)) {
if (!flg[i.v]) {
q.add(i);
}
}
}
return sum;
}
public int[] scc1_1() {
Graph g2 = new Graph(n);
for (int i = 0; i < n; i++) {
for (Edge e : g.get(i)) {
g2.addY(e.v, i);
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
boolean flg[] = new boolean[n];
boolean end[] = new boolean[n];
ArrayDeque<Integer> q = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (flg[i]) {
continue;
}
q.addLast(-i - 1);
q.addLast(i + 1);
while (q.size() > 0) {
int v = q.pollLast();
if (v < 0) {
v = -v - 1;
if (end[v]) {
continue;
}
end[v] = true;
list.add(v);
continue;
}
v--;
if (flg[v]) {
continue;
}
flg[v] = true;
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
q.addLast(-e.v - 1);
q.addLast(e.v + 1);
}
}
}
return g2.scc1_2(list);
}
public int[] scc1_2(ArrayList<Integer> list) {
boolean flg[] = new boolean[n];
int ren[] = new int[n];
ArrayDeque<Integer> q = new ArrayDeque<>();
int num = 0;
for (int i = n - 1; i >= 0; i--) {
int now = list.get(i);
if (flg[now]) {
continue;
}
q.add(now);
flg[now] = true;
while (q.size() > 0) {
int v = q.poll();
ren[v] = num;
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
flg[e.v] = true;
q.add(e.v);
}
}
num++;
}
return ren;
}
public int[] scc() {
Graph g2 = new Graph(n);
for (int i = 0; i < n; i++) {
for (Edge e : g.get(i)) {
g2.addY(e.v, i);
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
boolean flg[] = new boolean[n];
for (int i = 0; i < n; i++) {
if (!flg[i]) {
dfs_scc(i, flg, list);
}
}
return g2.scc2(list);
}
public int[] scc2(ArrayList<Integer> list) {
boolean flg[] = new boolean[n];
int ren[] = new int[n];
int num = 0;
for (int i = n - 1; i >= 0; i--) {
int now = list.get(i);
if (!flg[now]) {
dfs_scc2(now, flg, ren, num);
num++;
}
}
return ren;
}
private void dfs_scc(int v, boolean flg[], ArrayList<Integer> list) {
flg[v] = true;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
dfs_scc(e.v, flg, list);
}
}
list.add(v);
}
private void dfs_scc2(int v, boolean flg[], int num[], int now) {
flg[v] = true;
num[v] = now;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
dfs_scc2(e.v, flg, num, now);
}
}
}
public ArrayList<ArrayList<Integer>> two_Edge_connected() {
int ord[] = new int[n], low[] = new int[n];
boolean flg[] = new boolean[n];
for (int i = 0; i < n; i++) {
if (!flg[i]) {
tecDfs(i, flg, ord, low, -1);
}
}
flg = new boolean[n];
ArrayList<ArrayList<Integer>> list = new ArrayList<>();
int now = 0;
for (int i = 0; i < n; i++) {
if (!flg[i]) {
list.add(new ArrayList<>());
tecDfs2(i, flg, ord, low, list.get(now));
now++;
}
}
return list;
}
public void tecDfs(int v, boolean flg[], int ord[], int low[], int before) {
flg[v] = true;
if (before != -1) {
ord[v] = ord[before] + 1;
} else {
ord[v] = 0;
}
low[v] = ord[v];
for (Edge e : g.get(v)) {
if (e.v == before) {
before = -1;
continue;
}
if (flg[e.v]) {
low[v] = Math.min(low[v], ord[e.v]);
} else {
tecDfs(e.v, flg, ord, low, v);
low[v] = Math.min(low[v], low[e.v]);
}
}
}
public void tecDfs2(int v, boolean flg[], int ord[], int low[], ArrayList<Integer> list) {
flg[v] = true;
list.add(v);
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
if (ord[v] < low[e.v] || ord[e.v] < low[v]) {
continue;
}
tecDfs2(e.v, flg, ord, low, list);
}
}
static class Edge {
int v, d;
public Edge(int v, int d) {
this.v = v;
this.d = d;
}
}
}
static class Read {
BufferedReader br;
public Read() {
br = new BufferedReader(new InputStreamReader(System.in));
}
private boolean canprint(int a) {
return 33 <= a && a <= 126;
}
private int skipread() {
int a = readC();
while (a != -1 && !canprint(a)) {
a = readC();
}
return a;
}
public char readC() {
try {
return (char) br.read();
} catch (IOException e) {
e.printStackTrace();
return (char) -1;
}
}
public String readLine() {
try {
return br.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
public String readS() {
StringBuilder sb = new StringBuilder();
int k = skipread();
while (true) {
if (!canprint(k)) {
break;
}
sb.append((char) k);
k = readC();
}
return sb.toString();
}
public int readI() {
int r = 0;
int k = skipread();
int flg = 1;
if (k == '-') {
flg = -1;
k = readC();
}
while (true) {
if (!canprint(k)) {
break;
}
r = r * 10 + (k - '0');
k = readC();
}
return flg * r;
}
public long readL() {
long r = 0;
int k = skipread();
int flg = 1;
if (k == '-') {
flg = -1;
k = readC();
}
while (true) {
if (!canprint(k)) {
break;
}
r = r * 10 + (k - '0');
k = readC();
}
return flg * r;
}
public String[] readSs(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++) {
a[i] = readS();
}
return a;
}
public int[] readIs(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = readI();
}
return a;
}
public long[] readLs(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = readL();
}
return a;
}
}
static class Write {
PrintWriter out;
boolean debug;
public Write() {
out = new PrintWriter(System.out);
debug = false;
}
public <T> void pr(T str) {
out.print(str);
}
public <T> void pl(T str) {
out.println(str);
}
public void pr(int[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(int[][] a) {
for (int i[] : a) {
pr(i);
}
}
public void pr(long[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(long[][] a) {
for (long i[] : a) {
pr(i);
}
}
public void pr(String[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(String[][] a) {
for (String i[] : a) {
pr(i);
}
}
public void yes() {
pl("Yes");
}
public void no() {
pl("No");
}
public void yn(boolean flg) {
if (flg) {
yes();
} else {
no();
}
}
public void flush() {
out.flush();
}
public static <T> void prA(T str) {
System.out.print(str);
}
public static <T> void plA(T str) {
System.out.println(str);
}
public static void prA(int[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(int[][] a) {
for (int i[] : a) {
prA(i);
}
}
public static void prA(long[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(long[][] a) {
for (long i[] : a) {
prA(i);
}
}
public static void prA(String[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(String[][] a) {
for (String i[] : a) {
prA(i);
}
}
public <T> void debugP(T str) {
if (debug) {
pl(str);
}
}
}
public static long stol(String s) {
return Long.parseLong(s);
}
public static int stoi(String s) {
return Integer.parseInt(s);
}
public static int[] stoi(String s[]) {
int a[] = new int[s.length];
for (int i = 0; i < s.length; i++) {
a[i] = stoi(s[i]);
}
return a;
}
public static String itos(int i) {
return String.valueOf(i);
}
public static String[] itos(int[] a) {
String s[] = new String[a.length];
for (int i = 0; i < a.length; i++) {
s[i] = itos(a[i]);
}
return s;
}
public static String ctos(char c) {
return String.valueOf(c);
}
public static String cstos(char[] c) {
return new String(c);
}
public static char stoc(String s) {
return s.charAt(0);
}
public static char stoc(String s, int i) {
return s.charAt(i);
}
public static char[] stocs(String s) {
return s.toCharArray();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
class Main {
public static void solve(Read br, Write out) {
int n = br.readI();
int a[] = br.readIs(n);
HashMap<Integer, Integer> map = new HashMap<>();
int xor = 0;
for (int i = 0; i < n; i++) {
xor = xor ^ a[i];
if (map.containsKey(a[i])) {
map.put(a[i], map.get(a[i]) + 1);
} else {
map.put(a[i], 1);
}
}
if (xor != 0) {
out.pl(-1);
return;
}
int max = 0;
for (Map.Entry<Integer, Integer> e : map.entrySet()) {
if (e.getValue() % 2 != 0 && e.getKey() > max) {
max = e.getKey();
}
}
out.pl(Math.max(0, max - 1));
}
public static void main(String args[]) {
Read br = new Read();
Write out = new Write();
solve(br, out);
out.flush();
}
static class KDtree {
Node root;
int k;
public KDtree(int a[][], int k) {
this.k = k;
root = construct(a, 0);
}
private Node construct(int a[][], int depth) {
int axis = depth % k;
sortA(a, axis);
int m = a.length / 2;
Node node = new Node(a[m], axis);
if (m > 0) {
node.left = construct(Arrays.copyOfRange(a, 0, m), depth + 1);
node.left.parent = node;
}
if (m + 1 < a.length) {
node.right = construct(Arrays.copyOfRange(a, m + 1, a.length), depth + 1);
node.right.parent = node;
}
return node;
}
public int[] search(int coord[]) {
Node node = neighborhood(coord, root);
double dist = distance(coord, node.coord);
ArrayList<Node> list = new ArrayList<>();
list.add(node);
while (node.parent != null) {
node = node.parent;
if (Math.abs(coord[node.axis] - node.coord[node.axis]) < dist) {
neighborhood(coord, node);
list.add(node);
}
}
return node.coord;
}
public double distance(int a[], int b[]) {
double d = 0;
for (int i = 0; i < k; i++) {
int t = a[i] - b[i];
d += t * t;
}
return Math.sqrt(d);
}
private Node neighborhood(int coord[], Node n) {
int axis = n.axis;
if (coord[axis] < n.coord[axis]) {
if (n.left != null) {
return neighborhood(coord, n.left);
} else {
return n;
}
} else {
if (n.right != null) {
return neighborhood(coord, n.right);
} else {
return n;
}
}
}
class Node {
int coord[];
int axis;
Node left, right, parent;
public Node(int c[], int axis) {
this.coord = c;
this.axis = axis;
}
}
}
static class Tree {
int n;
int root;
int parent[];
int height[];
int maxh;
ArrayList<ArrayList<Integer>> child;
int lca[][];
public Tree(int nn, int r) {
n = nn;
root = r;
parent = new int[n];
height = new int[n];
child = new ArrayList<>();
for (int i = 0; i < n; i++) {
child.add(new ArrayList<>());
}
}
public Tree(int par[], int r) {
n = par.length;
root = r;
parent = new int[n];
height = new int[n];
child = new ArrayList<>();
for (int i = 0; i < n; i++) {
child.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
parent[i] = par[i];
if (parent[i] != -1) {
child.get(parent[i]).add(i);
}
}
ArrayDeque<Integer> q = new ArrayDeque<>();
q.add(root);
while (q.size() > 0) {
int v = q.poll();
for (int u : child.get(v)) {
height[u] = height[v] + 1;
if (height[u] > maxh) {
maxh = height[u];
}
q.add(u);
}
}
}
public Tree(Graph g, int r) {
this(g.n, r);
construct(g);
}
public void construct(Graph g) {
constructdfs(g, root, -1, 0, new boolean[n]);
}
public void constructdfs(Graph g, int now, int before, int h, boolean flg[]) {
flg[now] = true;
parent[now] = before;
height[now] = h;
if (h > maxh) {
maxh = h;
}
for (Graph.Edge e : g.g.get(now)) {
if (e.v != before) {
constructdfs(g, e.v, now, h + 1, flg);
child.get(now).add(e.v);
}
}
}
public void const_lowest_common_ancestor() {
int k = 1;
while ((1 << k) <= maxh) {
k++;
}
lca = new int[k][n];
for (int i = 0; i < n; i++) {
lca[0][i] = parent[i];
if (lca[0][i] == -1) {
lca[0][i] = i;
}
}
for (int i = 1; i < k; i++) {
for (int v = 0; v < n; v++) {
lca[i][v] = lca[i - 1][lca[i - 1][v]];
}
}
}
public int get_anscestor(int u, int d) {
int k = lca.length;
for (int i = 0; i < k; i++) {
if ((d >> i) % 2 > 0) {
u = lca[i][u];
}
}
return u;
}
public int query_lowest_common_ancestor(int u, int v) {
if (height[u] < height[v]) {
return query_lowest_common_ancestor(v, u);
}
int k = lca.length;
u = get_anscestor(u, height[u] - height[v]);
if (u == v) {
return u;
}
for (int i = k - 1; i >= 0; i--) {
if (lca[i][u] != lca[i][v]) {
u = lca[i][u];
v = lca[i][v];
}
}
return lca[0][u];
}
}
public static int comp(long a, long b) {
return a > b ? 1 : a < b ? -1 : 0;
}
public static long fact(int i) {
if (i == 1 || i == 0) {
return 1L;
}
return i * fact(i - 1);
}
public static long gcd(long a, long b) {
if (a < b) {
return gcd(b, a);
}
long c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static int gcd(int a, int b) {
if (a < b) {
return gcd(b, a);
}
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
public static int lcm(int a, int b) {
return a / gcd(a, b) * b;
}
public static void sortA(int n[]) {
Arrays.sort(n);
}
public static void sortA(long n[]) {
Arrays.sort(n);
}
public static void sortD(int n[]) {
Arrays.sort(n);
rev(n);
}
public static void rev(int n[]) {
int l = n.length;
for (int i = 0; i < l / 2; i++) {
int t = n[i];
n[i] = n[l - i - 1];
n[l - i - 1] = t;
}
}
public static void sortA(ArrayList<Integer> n) {
Collections.sort(n);
}
public static void sortD(ArrayList<Integer> n) {
Collections.sort(n, Collections.reverseOrder());
}
public static void sortA(int n[][], int k) {
Arrays.sort(n, (a, b) -> Integer.compare(a[k], b[k]));
}
public static void sortD(int n[][], int k) {
Arrays.sort(n, (a, b) -> Integer.compare(b[k], a[k]));
}
public static void mysort(int n[][], int k) {
Arrays.sort(n, new Comparator<int[]>() {
public int compare(int[] x, int[] y) {
if (x[k] == y[k]) {
return x[1] - y[1];
}
return x[k] - y[k];
}
});
}
static class ModFunc {
int n;
long mod;
long fact[], invfact[];
public ModFunc(int n, long mod) {
this.n = n;
this.mod = mod;
fact = new long[n + 1];
invfact = new long[n + 1];
modfact();
modinvfact();
}
public static long modfact(int n, long mod) {
long k = 1;
for (int i = 1; i <= n; i++) {
k = k * i % mod;
}
return k;
}
public static long modinvfact(int n, long mod) {
return modinv(modfact(n, mod), mod);
}
public static long modinv(long a, long mod) {
long x1 = 1, x2 = 0;
long p = a, q = mod, t;
while (q != 0) {
t = p / q;
t = x1 - t * x2;
x1 = x2;
x2 = t;
t = p % q;
p = q;
q = t;
}
return x1 < 0 ? x1 + mod : x1;
}
private void modfact() {
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i % mod;
}
}
private void modinvfact() {
invfact[n] = modinv(fact[n], mod);
for (int i = n - 1; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1) % mod;
}
}
public long modConv(int n, int k) {
return ((fact[n] * invfact[n - k]) % mod) * invfact[k] % mod;
}
public static long modpow(long x, long n, long pow) {
long r = 1;
while (n >= 1) {
if (1 == (n & 1)) {
r = r * x % pow;
}
x = x * x % pow;
n /= 2;
}
return r;
}
}
static class Permu {
int n;
public int a[];
boolean flg;
public Permu(int n) {
this.n = n;
flg = true;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = i;
}
}
public Permu(int k[]) {
this.n = k.length;
flg = true;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = k[i];
}
}
public boolean next() {
for (int i = n - 2; i >= 0; i--) {
if (a[i] >= a[i + 1]) {
continue;
}
for (int j = n - 1;; j--) {
if (a[i] >= a[j]) {
continue;
}
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
for (j = n - 1; i < j; i++, j--) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
return true;
}
}
flg = false;
return false;
}
public boolean before() {
for (int i = n - 2; i >= 0; i--) {
if (a[i] <= a[i + 1]) {
continue;
}
for (int j = n - 1;; j--) {
if (a[i] <= a[j]) {
continue;
}
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
for (j = n - 1; i < j; i++, j--) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
return true;
}
}
flg = false;
return false;
}
}
static class Compress {
ArrayList<Integer> a;
HashMap<Integer, Integer> map;
public Compress(int[] b) {
HashSet<Integer> temp = new HashSet<>();
for (int i : b) {
temp.add(i);
}
a = new ArrayList<Integer>(temp);
setup();
}
public Compress(ArrayList<Integer> b) {
a = new ArrayList<Integer>(new HashSet<Integer>(b));
setup();
}
private void setup() {
map = new HashMap<>();
sortA(a);
for (int i = 0; i < a.size(); i++) {
map.put(a.get(i), i);
}
}
public int get(int i) {
return map.get(i);
}
}
static class UnionFindTree {
int parent[];
int size;
int vol[];
public UnionFindTree(int s) {
size = s;
parent = new int[size];
vol = new int[size];
for (int i = 0; i < size; i++) {
parent[i] = i;
vol[i] = 1;
}
}
public int root(int n) {
if (parent[n] == n) {
return n;
}
parent[n] = root(parent[n]);
return parent[n];
}
public void unite(int a, int b) {
int ra = root(a), rb = root(b);
if (ra == rb) {
return;
}
if (vol[ra] < vol[rb]) {
a = ra;
ra = rb;
rb = a;
}
parent[rb] = ra;
vol[ra] += vol[rb];
}
public boolean same(int a, int b) {
return root(a) == root(b);
}
}
static class WeightUnionFindTree {
int parent[];
int size;
int vol[];
int diff[];
public WeightUnionFindTree(int s) {
size = s;
parent = new int[size];
vol = new int[size];
diff = new int[size];
for (int i = 0; i < size; i++) {
parent[i] = i;
vol[i] = 1;
diff[i] = 0;
}
}
public int root(int n) {
if (parent[n] == n) {
return n;
}
int r = root(parent[n]);
diff[n] += diff[parent[n]];
parent[n] = r;
return parent[n];
}
public int weight(int n) {
root(n);
return diff[n];
}
public void unite(int a, int b, int w) {
int ra = root(a), rb = root(b);
if (ra == rb) {
return;
}
w += weight(a);
w -= weight(b);
if (vol[ra] < vol[rb]) {
a = ra;
ra = rb;
rb = a;
w = -w;
}
parent[rb] = ra;
vol[ra] += vol[rb];
diff[rb] = w;
}
public int differ(int a, int b) {
return weight(a) - weight(b);
}
public boolean same(int a, int b) {
return root(a) == root(b);
}
}
static abstract class SegmentTree {
int n, leafN;
int ar[];
int lazy[];
int temp;
public SegmentTree(int x, int temp) {
leafN = x;
this.temp = temp;
n = twon(leafN);
ar = new int[2 * n - 1];
lazy = new int[2 * n - 1];
for (int i = 0; i < n * 2 - 1; i++) {
ar[i] = temp;
lazy[i] = temp;
}
}
public abstract int func(int a, int b);
public void eval(int k) {
if (lazy[k] == temp) {
return;
}
if (k < n - 1) {
lazy[k * 2 + 1] = lazy[k];
lazy[k * 2 + 2] = lazy[k];
}
ar[k] = lazy[k];
lazy[k] = temp;
}
public void update(int i, int x) {
int now = i + n - 1;
ar[now] = x;
while (now > 0) {
now = (now - 1) / 2;
ar[now] = func(ar[now * 2 + 1], ar[now * 2 + 2]);
}
}
public void add(int i, int x) {
update(i, ar[i + n - 1] + x);
}
public void update(int a, int b, int x) {
update(a, b, x, 0, 0, n);
}
public void update(int a, int b, int x, int k, int l, int r) {
eval(k);
if (r <= a || b <= l) {
return;
} else if (a <= l && r <= b) {
lazy[k] = x;
eval(k);
}
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
ar[k] = func(ar[k * 2 + 1], ar[k * 2 + 2]);
}
public int get(int i) {
return ar[i + n - 1];
}
public int query(int a, int b) {
return query(a, b, 0, 0, n);
}
public int query(int a, int b, int k, int l, int r) {
eval(k);
if (r <= a || b <= l) {
return temp;
} else if (a <= l && r <= b) {
return ar[k];
}
int t1 = query(a, b, k * 2 + 1, l, (l + r) / 2), t2 = query(a, b, k * 2 + 2, (l + r) / 2, r);
return func(t1, t2);
}
private int twon(int x) {
int i = 1;
while (i < x) {
i *= 2;
}
return i;
}
}
static class SegmentTreeE extends SegmentTree {
public SegmentTreeE(int x) {
super(x, 0);
}
public int func(int a, int b) {
return a ^ b;
}
}
static class SegmentTreeMin extends SegmentTree {
public SegmentTreeMin(int x) {
super(x, Integer.MAX_VALUE);
}
public int func(int a, int b) {
return Math.min(a, b);
}
}
static class SegmentTreeMax extends SegmentTree {
public SegmentTreeMax(int x) {
super(x, Integer.MIN_VALUE);
}
public int func(int a, int b) {
return Math.max(a, b);
}
public int leftmax(int a) {
if (ar[0] < a) {
return -1;
}
return leftmax(a, 0);
}
private int leftmax(int a, int i) {
eval(i);
if (i >= n - 1) {
return i - n + 1;
}
int next = i * 2 + 1;
if (ar[next] < a) {
return leftmax(a, next + 1);
}
return leftmax(a, next);
}
}
static class SegmentTreeS extends SegmentTree {
public SegmentTreeS(int x) {
super(x, 0);
}
public int func(int a, int b) {
return a + b;
}
}
static class BIT {
int n;
int ar[];
public BIT(int x) {
n = x + 1;
ar = new int[n];
for (int i = 0; i < n; i++) {
ar[i] = 0;
}
}
public void update(int i, int x) {
i++;
for (int ii = i; ii < n; ii += (ii & -ii)) {
ar[ii] += x;
}
}
public int sum(int i) {
int k = 0;
for (int ii = i; ii > 0; ii -= (ii & -ii)) {
k += ar[ii];
}
return k;
}
}
static class Graph {
int n;
ArrayList<ArrayList<Edge>> g;
public Graph(int nn) {
n = nn;
g = new ArrayList<ArrayList<Edge>>();
for (int i = 0; i < n; i++) {
g.add(new ArrayList<Edge>());
}
}
public void add(int a, int b, int d) {
g.get(a).add(new Edge(b, d));
g.get(b).add(new Edge(a, d));
}
public void addY(int a, int b, int d) {
g.get(a).add(new Edge(b, d));
}
public void add(int a, int b) {
g.get(a).add(new Edge(b, 1));
g.get(b).add(new Edge(a, 1));
}
public void addY(int a, int b) {
g.get(a).add(new Edge(b, 1));
}
public int len(int a) {
return g.get(a).size();
}
public long[][] dijkstra(int s) {
long dist[][] = new long[n][2];
for (int i = 0; i < n; i++) {
dist[i][0] = Long.MAX_VALUE;
dist[i][1] = -1;
}
dist[s][0] = 0;
dist[s][1] = -1;
PriorityQueue<long[]> q = new PriorityQueue<long[]>(new Comparator<long[]>() {
public int compare(long[] x, long[] y) {
return Long.compare(x[1], y[1]);
}
});
q.add(new long[] { s, 0L });
while (q.size() > 0) {
long[] p = q.poll();
if (dist[(int) p[0]][0] != p[1]) {
continue;
}
for (Edge e : g.get((int) p[0])) {
if (dist[e.v][0] > dist[(int) p[0]][0] + e.d) {
dist[e.v][0] = dist[(int) p[0]][0] + e.d;
dist[e.v][1] = (int) p[0];
q.add(new long[] { e.v, dist[e.v][0] });
}
}
}
return dist;
}
public static long[][] floydwarshall(int g[][]) {
int n = g.length;
long dist[][] = new long[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = g[i][j];
if (dist[i][j] == 0) {
dist[i][j] = Long.MAX_VALUE;
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dist[i][k] == Long.MAX_VALUE || dist[k][j] == Long.MAX_VALUE) {
continue;
}
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
return dist;
}
public void dfs(int v) {
ArrayDeque<Integer> q = new ArrayDeque<>();
boolean flg[] = new boolean[n];
q.addLast(v);
flg[v] = true;
while (q.size() > 0) {
int now = q.pollLast();
for (Edge e : g.get(now)) {
if (!flg[e.v]) {
flg[e.v] = true;
q.addLast(e.v);
}
}
}
}
public void bfs(int s) {
boolean flg[] = new boolean[n];
Queue<Integer> q = new ArrayDeque<Integer>();
q.add(s);
while (q.size() > 0) {
int v = q.poll();
flg[v] = true;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
q.add(e.v);
flg[e.v] = true;
}
}
}
}
public int minspantree() {
PriorityQueue<Edge> q = new PriorityQueue<Edge>(new Comparator<Edge>() {
public int compare(Edge a, Edge b) {
return a.d - b.d;
}
});
boolean flg[] = new boolean[n];
int c = 1, sum = 0;
for (Edge e : g.get(0)) {
q.add(e);
}
flg[0] = true;
while (c < n) {
Edge e = q.poll();
if (flg[e.v]) {
continue;
}
flg[e.v] = true;
sum += e.d;
c++;
for (Edge i : g.get(e.v)) {
if (!flg[i.v]) {
q.add(i);
}
}
}
return sum;
}
public int[] scc1_1() {
Graph g2 = new Graph(n);
for (int i = 0; i < n; i++) {
for (Edge e : g.get(i)) {
g2.addY(e.v, i);
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
boolean flg[] = new boolean[n];
boolean end[] = new boolean[n];
ArrayDeque<Integer> q = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (flg[i]) {
continue;
}
q.addLast(-i - 1);
q.addLast(i + 1);
while (q.size() > 0) {
int v = q.pollLast();
if (v < 0) {
v = -v - 1;
if (end[v]) {
continue;
}
end[v] = true;
list.add(v);
continue;
}
v--;
if (flg[v]) {
continue;
}
flg[v] = true;
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
q.addLast(-e.v - 1);
q.addLast(e.v + 1);
}
}
}
return g2.scc1_2(list);
}
public int[] scc1_2(ArrayList<Integer> list) {
boolean flg[] = new boolean[n];
int ren[] = new int[n];
ArrayDeque<Integer> q = new ArrayDeque<>();
int num = 0;
for (int i = n - 1; i >= 0; i--) {
int now = list.get(i);
if (flg[now]) {
continue;
}
q.add(now);
flg[now] = true;
while (q.size() > 0) {
int v = q.poll();
ren[v] = num;
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
flg[e.v] = true;
q.add(e.v);
}
}
num++;
}
return ren;
}
public int[] scc() {
Graph g2 = new Graph(n);
for (int i = 0; i < n; i++) {
for (Edge e : g.get(i)) {
g2.addY(e.v, i);
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
boolean flg[] = new boolean[n];
for (int i = 0; i < n; i++) {
if (!flg[i]) {
dfs_scc(i, flg, list);
}
}
return g2.scc2(list);
}
public int[] scc2(ArrayList<Integer> list) {
boolean flg[] = new boolean[n];
int ren[] = new int[n];
int num = 0;
for (int i = n - 1; i >= 0; i--) {
int now = list.get(i);
if (!flg[now]) {
dfs_scc2(now, flg, ren, num);
num++;
}
}
return ren;
}
private void dfs_scc(int v, boolean flg[], ArrayList<Integer> list) {
flg[v] = true;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
dfs_scc(e.v, flg, list);
}
}
list.add(v);
}
private void dfs_scc2(int v, boolean flg[], int num[], int now) {
flg[v] = true;
num[v] = now;
for (Edge e : g.get(v)) {
if (!flg[e.v]) {
dfs_scc2(e.v, flg, num, now);
}
}
}
public ArrayList<ArrayList<Integer>> two_Edge_connected() {
int ord[] = new int[n], low[] = new int[n];
boolean flg[] = new boolean[n];
for (int i = 0; i < n; i++) {
if (!flg[i]) {
tecDfs(i, flg, ord, low, -1);
}
}
flg = new boolean[n];
ArrayList<ArrayList<Integer>> list = new ArrayList<>();
int now = 0;
for (int i = 0; i < n; i++) {
if (!flg[i]) {
list.add(new ArrayList<>());
tecDfs2(i, flg, ord, low, list.get(now));
now++;
}
}
return list;
}
public void tecDfs(int v, boolean flg[], int ord[], int low[], int before) {
flg[v] = true;
if (before != -1) {
ord[v] = ord[before] + 1;
} else {
ord[v] = 0;
}
low[v] = ord[v];
for (Edge e : g.get(v)) {
if (e.v == before) {
before = -1;
continue;
}
if (flg[e.v]) {
low[v] = Math.min(low[v], ord[e.v]);
} else {
tecDfs(e.v, flg, ord, low, v);
low[v] = Math.min(low[v], low[e.v]);
}
}
}
public void tecDfs2(int v, boolean flg[], int ord[], int low[], ArrayList<Integer> list) {
flg[v] = true;
list.add(v);
for (Edge e : g.get(v)) {
if (flg[e.v]) {
continue;
}
if (ord[v] < low[e.v] || ord[e.v] < low[v]) {
continue;
}
tecDfs2(e.v, flg, ord, low, list);
}
}
static class Edge {
int v, d;
public Edge(int v, int d) {
this.v = v;
this.d = d;
}
}
}
static class Read {
BufferedReader br;
public Read() {
br = new BufferedReader(new InputStreamReader(System.in));
}
private boolean canprint(int a) {
return 33 <= a && a <= 126;
}
private int skipread() {
int a = readC();
while (a != -1 && !canprint(a)) {
a = readC();
}
return a;
}
public char readC() {
try {
return (char) br.read();
} catch (IOException e) {
e.printStackTrace();
return (char) -1;
}
}
public String readLine() {
try {
return br.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
public String readS() {
StringBuilder sb = new StringBuilder();
int k = skipread();
while (true) {
if (!canprint(k)) {
break;
}
sb.append((char) k);
k = readC();
}
return sb.toString();
}
public int readI() {
int r = 0;
int k = skipread();
int flg = 1;
if (k == '-') {
flg = -1;
k = readC();
}
while (true) {
if (!canprint(k)) {
break;
}
r = r * 10 + (k - '0');
k = readC();
}
return flg * r;
}
public long readL() {
long r = 0;
int k = skipread();
int flg = 1;
if (k == '-') {
flg = -1;
k = readC();
}
while (true) {
if (!canprint(k)) {
break;
}
r = r * 10 + (k - '0');
k = readC();
}
return flg * r;
}
public String[] readSs(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++) {
a[i] = readS();
}
return a;
}
public int[] readIs(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = readI();
}
return a;
}
public long[] readLs(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = readL();
}
return a;
}
}
static class Write {
PrintWriter out;
boolean debug;
public Write() {
out = new PrintWriter(System.out);
debug = false;
}
public <T> void pr(T str) {
out.print(str);
}
public <T> void pl(T str) {
out.println(str);
}
public void pr(int[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(int[][] a) {
for (int i[] : a) {
pr(i);
}
}
public void pr(long[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(long[][] a) {
for (long i[] : a) {
pr(i);
}
}
public void pr(String[] a) {
int t = a.length;
if (t > 0) {
pr(a[0]);
}
for (int i = 1; i < t; i++) {
pr(" " + a[i]);
}
pl("");
}
public void pr(String[][] a) {
for (String i[] : a) {
pr(i);
}
}
public void yes() {
pl("Yes");
}
public void no() {
pl("No");
}
public void yn(boolean flg) {
if (flg) {
yes();
} else {
no();
}
}
public void flush() {
out.flush();
}
public static <T> void prA(T str) {
System.out.print(str);
}
public static <T> void plA(T str) {
System.out.println(str);
}
public static void prA(int[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(int[][] a) {
for (int i[] : a) {
prA(i);
}
}
public static void prA(long[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(long[][] a) {
for (long i[] : a) {
prA(i);
}
}
public static void prA(String[] a) {
int t = a.length;
if (t > 0) {
prA(a[0]);
}
for (int i = 1; i < t; i++) {
prA(" " + a[i]);
}
plA("");
}
public static void prA(String[][] a) {
for (String i[] : a) {
prA(i);
}
}
public <T> void debugP(T str) {
if (debug) {
pl(str);
}
}
}
public static long stol(String s) {
return Long.parseLong(s);
}
public static int stoi(String s) {
return Integer.parseInt(s);
}
public static int[] stoi(String s[]) {
int a[] = new int[s.length];
for (int i = 0; i < s.length; i++) {
a[i] = stoi(s[i]);
}
return a;
}
public static String itos(int i) {
return String.valueOf(i);
}
public static String[] itos(int[] a) {
String s[] = new String[a.length];
for (int i = 0; i < a.length; i++) {
s[i] = itos(a[i]);
}
return s;
}
public static String ctos(char c) {
return String.valueOf(c);
}
public static String cstos(char[] c) {
return new String(c);
}
public static char stoc(String s) {
return s.charAt(0);
}
public static char stoc(String s, int i) {
return s.charAt(i);
}
public static char[] stocs(String s) {
return s.toCharArray();
}
}
| ConDefects/ConDefects/Code/arc168_b/Java/47800055 |