# RE(NZEC) in fence

What does RE(NZEC) error means? I am getting it for fence.

code:

``````import java.io.Writer;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;

class Codechef{
static int check(int[][] grid, int i, int j){
int count=0;
//check up
if(grid[i-1][j]==-1 || grid[i-1][j]==0) count++;
//check left
if(grid[i][j-1]==-1 || grid[i][j-1]==0) count++;
//check down
if(grid[i+1][j]==-1 || grid[i+1][j]==0) count++;
//check right
if(grid[i][j+1]==-1 || grid[i][j+1]==0) count++;
// System.out.println("x: "+i+" y: "+j+"  --> "+"( "+grid[i][j]+" )"+" count: "+count);
return count;
}
static class ProblemSolver{
public void solveTheProblem(InputReader in,OutputWriter out, NumberTheory nt){
int test=in.nextInt();
while(test-- >0){
int n=in.nextInt();
int m=in.nextInt();
int k=in.nextInt();
int grid[][]= new int[n+2][m+2];
for(int i=0;i<n+2;i++){
grid[i][0]=-1;
}
for(int i=0;i<m+2;i++){
grid[0][i]=-1;
}
for(int i=0;i<n+2;i++){
grid[i][m+1]=-1;
}
for(int i=0;i<m+2;i++){
grid[n+1][i]=-1;
}
for(int i=0;i<k;i++){
grid[in.nextInt()][in.nextInt()]=1;
}
// out.print(grid);
long len=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(grid[i][j]==0) continue;
len=Math.max(len, check(grid, i, j));
}
}
System.out.println(len);
}
}
}

public static void main(String[] args){
InputStream inputStream=System.in;
OutputStream outputStream=System.out;
OutputWriter out=new OutputWriter(outputStream);
NumberTheory nt= new NumberTheory();
ProblemSolver problemSolver=new ProblemSolver();
problemSolver.solveTheProblem(in,out, nt);
out.flush();
out.close();
}

private boolean finished = false;

private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;

this.stream = stream;
}

if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}

public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}

public int nextInt() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public long nextLong() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public String nextLine() {
while (isSpaceChar(c)) {
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
} while (!isSpaceChar(c));
return res.toString();
}

public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}

public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

StringBuilder buf = new StringBuilder();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
}
return buf.toString();
}

while (s.trim().length() == 0) {
}
return s;
}

if (ignoreEmptyLines) {
} else {
}
}

try {
return new BigInteger(nextLine());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}

public char nextCharacter() {
while (isSpaceChar(c)) {
}
return (char) c;
}

public double nextDouble() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
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';
}
if (c == '.') {
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;
}
}
return res * sgn;
}

public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
}
return value == -1;
}

public String next() {
return nextLine();
}

public SpaceCharFilter getFilter() {
return filter;
}

public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}

public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] nextIntArray(int n){
int[] array=new int[n];
for(int i=0;i<n;++i)array[i]=nextInt();
return array;
}
public int[] nextSortedIntArray(int n){
int array[]=nextIntArray(n);
Arrays.sort(array);
return array;
}
public ArrayList<Integer> nextIntArrayList(int n){
ArrayList<Integer> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}
public ArrayList<Long> nextLongArrayList(int n){
ArrayList<Long> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}

public int[] nextSumIntArray(int n){
int[] array=new int[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextLongArray(int n){
long[] array=new long[n];
for(int i=0;i<n;++i)array[i]=nextLong();
return array;
}
public long[] nextSumLongArray(int n){
long[] array=new long[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextSortedLongArray(int n){
long array[]=nextLongArray(n);
Arrays.sort(array);
return array;
}
public int[][] nextIntMatrix(int n,int m){
int[][] matrix=new int[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextInt();
return matrix;
}

public int[][] nextIntMatrix(int n){
return nextIntMatrix(n,n);
}

public long[][] nextLongMatrix(int n,int m){
long[][] matrix=new long[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextLong();
return matrix;
}

public long[][] nextLongMatrix(int n){
return nextLongMatrix(n,n);
}

public char[][] nextCharMatrix(int n,int m){
char[][] matrix=new char[n][m];
for(int i=0;i<n;++i)
matrix[i]=next().toCharArray();
return matrix;
}

public char[][] nextCharMatrix(int n){
return nextCharMatrix(n,n);
}
}

static class OutputWriter {
private final PrintWriter writer;

public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}

public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}

// public void print(char[] array) {
//     writer.print(array);
// }

public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}

public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(double[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(long[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(char[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(String[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(int[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(double[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(long[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(char[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(String[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void println(int[] array) {
print(array);
writer.println();
}

public void println(double[] array) {
print(array);
writer.println();
}

public void println(long[] array) {
print(array);
writer.println();
}

// public void println(char[] array) {
//     print(array);
//     writer.println();
// }

public void println(String[] array) {
print(array);
writer.println();
}

public void println() {
writer.println();
}

public void println(Object... objects) {
print(objects);
writer.println();
}

public void print(char i) {
writer.print(i);
}

public void println(char i) {
writer.println(i);
}

public void println(char[] array) {
writer.println(array);
}

public void printf(String format, Object... objects) {
writer.printf(format, objects);
}

public void close() {
writer.close();
}

public void flush() {
writer.flush();
}

public void print(long i) {
writer.print(i);
}

public void println(long i) {
writer.println(i);
}

public void print(int i) {
writer.print(i);
}

public void println(int i) {
writer.println(i);
}

public void separateLines(int[] array) {
for (int i : array) {
println(i);
}
}
}
static class NumberTheory{

/**
* Modular Arithmetic:
*  1. (a+b)%c=(a%c+b%c)%c
*  2. (a*b)%c=(a%c*b%c)%c
*  3. (a-b)%c=(a%c-b%c+c)%c
*  4. (a/b)%c=(a%c*(b^-1)%c)%c -- (b^-1 is multiplicative modulo inverse)
*/
public int modularAddition(int a,int b,int MOD){
return (a%MOD+b%MOD)%MOD;
}
public long modularAddition(long a,long b,long MOD){
return (a%MOD+b%MOD)%MOD;
}
//Modular Multiplication
public int modularMultiplication(int a,int b,int MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
public long modularMultiplication(long a,long b,long MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
//Modular Subtraction
public int modularSubtraction(int a,int b,int MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}
public long modularSubtraction(long a,long b,long MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}

/**
* Binary Exponentiation
*/
public int binaryExponentiation(int x,int n){
if(n==0)return 1;
else if(n%2==0)return binaryExponentiation(x*x,n/2);
else return x*binaryExponentiation(x*x,(n-1)/2);
}
public long binaryExponentiation(long x,long n){
long result=1;
while(n>0){
if(n%2==1)result*=x;
x=x*x;
n/=2;
}
return result;
}

/**
* Modular Exponentiation
*/
public int modularExponentiation(int x,int n,int MOD){
if(n==0)return 1%MOD;
else if(n%2==0)return modularExponentiation(modularMultiplication(x,x,MOD),n/2,MOD);
else return modularMultiplication(x,modularExponentiation(modularMultiplication(x,x,MOD),(n-1)/2,MOD),MOD);
}
public long modularExponentiation(long x,long n,long MOD){
long result=1;
while(n>0){
if(n%2==1)result=modularMultiplication(result,x,MOD);
x=modularMultiplication(x,x,MOD);
n/=2;
}
return result;
}

/**
* Factorial of a number
*/
public long factorials(long n){
if(n==0)return 1;
return n*factorials(n-1);
}

/**
* Prime factors of a number
*/
public ArrayList<Integer> distinctPrimeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> distinctPrimeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Integer> primeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> primeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

/**
* Combination: nCr
*/
//Naive version
//(n,r)=(n-1,r-1)+(n-1,r) for r!=0 or r!=n
//(n,0)=(n,n)=1
public int binomialCoefficientRecursive(int n,int k){
if(k==0 || k==n)return 1;//base case
return binomialCoefficientRecursive(n-1,k-1)+binomialCoefficientRecursive(n-1,k);//recursion
}

//Dynamic Programming version(Uses bottom up approach to fill the table)
//Time complexity: O(n*k)
//Space complexity: O(n*k)
public long binomialCoefficientIterative(int n,int k){
long[][] C=new long[n+1][k+1];
for(int i=0;i<=n;++i){
for(int j=0;j<=Math.min(n,k);++j){
if(j==0 || j==i)C[i][j]=1;
else C[i][j]=C[i-1][j-1]+C[i-1][j];
}
}
return C[n][k];
}

//Pascal's Triangle version(Space efficient program)
//Time complexity: O(n*k)
//Space complexity: O(k)
public long nCr(int n,int r){
int[] C=new int[r+1];
C[0]=1;//nC0=1
for(int i=1;i<=n;++i)
for(int j=Math.min(i,r);j>0;--j)
C[j]=C[j]+C[j-1];
return C[r];
}

/**
* Catlan number:
*  - Time complexity: O(n*n)
*  - Auxiliary space: O(n)
*
*  NOTE: Time complexity could be reduced to O(n) but it is
*        possible if and only if n is small or else there is
*        a chance of getting an overflow. To decrease the time
*        complexity to O(n) just remember nCr=nCn-r
*/
public long catlanNumber(int n){
long[] catlan=new long[n+1];
catlan[0]=catlan[1]=1;
for(int i=2;i<=n;++i)
for(int j=0;j<i;++j)
catlan[i]+=catlan[j]*catlan[i-1-j];

return catlan[n];
}

/**
* Greatest Common Divisor(GCD)
*  - It is also known as Highest Common Factor(HCF)
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a %b);
}

public long gcd(long a,long b){
if(b==0)return a;
return gcd(b,a%b);
}

/**
* Extended Euclid's Algorithm:
*  - ax+by=gcd(a,b)
*  - Time complexity:
*  -
*/

/**
* Least Common Multiple(LCM):
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public long lcm(long a,long b){
return (a*b)/gcd(a,b);
}

}
}
``````