Vitaly is a diligent student who never missed a lesson in his five years of studying in the university. He always does his homework on time and passes his exams in time. 

During the last lesson the teacher has provided two strings s and t to Vitaly. The strings have the same length, they consist of lowercase English letters, string s is lexicographically smaller than string t. Vitaly wondered if there is such string that is lexicographically larger than string s and at the same is lexicographically smaller than string t. This string should also consist of lowercase English letters and have the length equal to the lengths of strings s and t. 

Let's help Vitaly solve this easy problem!

Input

The first line contains string s (1 ≤ |s| ≤ 100), consisting of lowercase English letters. Here, |s| denotes the length of the string.

The second line contains string t (|t| = |s|), consisting of lowercase English letters.

It is guaranteed that the lengths of strings s and t are the same and string s is lexicographically less than string t.

Output

If the string that meets the given requirements doesn't exist, print a single string "No such string" (without the quotes).

If such string exists, print it. If there are multiple valid strings, you may print any of them.

Examples

Input

a
c


Output

b


Input

aaa
zzz


Output

kkk


Input

abcdefg
abcdefh


Output

No such string

Note

String s = s1s2... sn is said to be lexicographically smaller than t = t1t2... tn, if there exists such i, that s1 = t1, s2 = t2, ... si - 1 = ti - 1, si < ti.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.Writer;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author MaxHeap
 */
public class Main {

  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    AVitalyAndStrings solver = new AVitalyAndStrings();
    solver.solve(1, in, out);
    out.close();
  }

  static class AVitalyAndStrings {

    public void solve(int testNumber, InputReader in, OutputWriter out) {
      char[] s = in.nextCharArray();
      char[] t = in.nextCharArray();
      int n = s.length;
      int at = -1;
      for (int i = 0; i < n; ++i) {
        if (s[i] != t[i]) {
          at = i;
          break;
        }
      }
      if (at == -1) {
        out.println("No such string");
        return;
      }
      if ((s[at] + 1) == t[at]) {
        int p = at + 1;
        while (p < n) {
          if (s[p] != 'z') {
            break;
          }
          ++p;
        }
        if (p == n) {
          p = at + 1;
          while (p < n) {
            if (t[p] != 'a') {
              break;
            }
            ++p;
          }
          if (p == n) {
            out.println("No such string");
          } else {
            s[at] = (char) (s[at] + 1);
            for (int i = at + 1; i < n; ++i) {
              s[i] = 'a';
            }
            out.println(new String(s));
          }
        } else {
          s[p] = (char) (s[p] + 1);
          out.println(new String(s));
        }
        return;
      }
      s[at] = (char) (s[at] + 1);
      out.println(new String(s));
    }

  }

  static class OutputWriter extends PrintWriter {

    public OutputWriter(OutputStream out) {
      super(out);
    }

    public OutputWriter(Writer out) {
      super(out);
    }

    public OutputWriter(File file) throws FileNotFoundException {
      super(file);
    }

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

  }

  static class InputReader {

    private InputStream stream;
    private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
    private static final int EOF = -1;
    private byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (this.numChars == EOF) {
        throw new UnknownError();
      } else {
        if (this.curChar >= this.numChars) {
          this.curChar = 0;

          try {
            this.numChars = this.stream.read(this.buf);
          } catch (IOException ex) {
            throw new InputMismatchException();
          }

          if (this.numChars <= 0) {
            return EOF;
          }
        }

        return this.buf[this.curChar++];
      }
    }

    public String next() {
      int c;
      while (isSpaceChar(c = this.read())) {
      }

      StringBuilder result = new StringBuilder();
      result.appendCodePoint(c);

      while (!isSpaceChar(c = this.read())) {
        result.appendCodePoint(c);
      }

      return result.toString();
    }

    public static boolean isSpaceChar(int c) {
      return c == 32 || c == 10 || c == 13 || c == 9 || c == EOF;
    }

    public char[] nextCharArray() {
      return next().toCharArray();
    }

  }
}

