Problem:
Score : 100 points

Problem Statement

You are given two integers A and B as the input. Output the value of A + B.

However, if A + B is 10 or greater, output error instead.

Constraints

A and B are integers.

1 ≤ A, B ≤ 9

Input

Input is given from Standard Input in the following format:

A B

Output

If A + B is 10 or greater, print the string error (case-sensitive); otherwise, print the value of A + B.

Sample Input 1

6 3

Sample Output 1

9

Sample Input 2

6 4

Sample Output 2

error

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

    import java.io.*;
    import java.util.*;
    import java.math.BigInteger;
    public class Main{
      public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
         int sum=in.nextInt()+in.nextInt();
         if (sum>=10)
            w.println("error");
         else w.println(sum);
        w.close();
      }
      static class InputReader {
     
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;
     
        public InputReader(InputStream stream) {
          this.stream = stream;
        }
     
        public int snext() {
          if (snumChars == -1)
            throw new InputMismatchException();
          if (curChar >= snumChars) {
            curChar = 0;
            try {
              snumChars = stream.read(buf);
            } catch (IOException e) {
              throw new InputMismatchException();
            }
            if (snumChars <= 0)
              return -1;
          }
          return buf[curChar++];
        }
     
        public int nextInt() {
          int c = snext();
          while (isSpaceChar(c)) {
            c = snext();
          }
          int sgn = 1;
          if (c == '-') {
            sgn = -1;
            c = snext();
          }
          int res = 0;
          do {
            if (c < '0' || c > '9')
              throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = snext();
          } while (!isSpaceChar(c));
          return res * sgn;
        }
     
        public long nextLong() {
          int c = snext();
          while (isSpaceChar(c)) {
            c = snext();
          }
          int sgn = 1;
          if (c == '-') {
            sgn = -1;
            c = snext();
          }
          long res = 0;
          do {
            if (c < '0' || c > '9')
              throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = snext();
          } while (!isSpaceChar(c));
          return res * sgn;
        }
     
        public int[] nextIntArray(int n) {
          int a[] = new int[n];
          for (int i = 0; i < n; i++) {
            a[i] = nextInt();
          }
          return a;
        }
     
        public String readString() {
          int c = snext();
          while (isSpaceChar(c)) {
            c = snext();
          }
          StringBuilder res = new StringBuilder();
          do {
            res.appendCodePoint(c);
            c = snext();
          } while (!isSpaceChar(c));
          return res.toString();
        }
     
        public String nextLine() {
          int c = snext();
          while (isSpaceChar(c))
            c = snext();
          StringBuilder res = new StringBuilder();
          do {
            res.appendCodePoint(c);
            c = snext();
          } while (!isEndOfLine(c));
          return res.toString();
        }
     
        public boolean isSpaceChar(int c) {
          if (filter != null)
            return filter.isSpaceChar(c);
          return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
     
        private boolean isEndOfLine(int c) {
          return c == '\n' || c == '\r' || c == -1;
        }
     
        public interface SpaceCharFilter {
          public boolean isSpaceChar(int ch);
        }
      }
    }