Problem: There are n boys and m girls studying in the class. They should stand in a line so that boys and girls alternated there as much as possible. Let's assume that positions in the line are indexed from left to right by numbers from 1 to n + m. Then the number of integers i (1 ≤ i < n + m) such that positions with indexes i and i + 1 contain children of different genders (position i has a girl and position i + 1 has a boy or vice versa) must be as large as possible. 

Help the children and tell them how to form the line.

Input

The single line of the input contains two integers n and m (1 ≤ n, m ≤ 100), separated by a space.

Output

Print a line of n + m characters. Print on the i-th position of the line character "B", if the i-th position of your arrangement should have a boy and "G", if it should have a girl. 

Of course, the number of characters "B" should equal n and the number of characters "G" should equal m. If there are multiple optimal solutions, print any of them.

Examples

Input

3 3


Output

GBGBGB


Input

4 2


Output

BGBGBB

Note

In the first sample another possible answer is BGBGBG. 

In the second sample answer BBGBGB is also optimal.

Solution (in JAVA):

Solution:

import java.io.*;
import java.math.*;
import java.util.*;
public class Solution {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("input.txt");
        Scanner sc = new Scanner(new FileInputStream(file));
        PrintWriter out = new PrintWriter(new FileOutputStream("output.txt"));

        int b = sc.nextInt();
        int g = sc.nextInt();

        int min = Math.min(b,g);

        String ptrn1= "BG";
        String ptrn2 = "GB";

        String ans1 = "";
        String ans2 = "";

        for(int i=0;i<min;i++){
            ans1 += ptrn1;
            ans2 += ptrn2;
        }

        if(b>g){
            for(int i=0;i<b-g;i++){
                ans1+="B";
                ans2+= "B";

            }
        }
        else if(g>b){
            for(int i=0;i<g-b;i++){
                ans1+="G";
                ans2+= "G";

            }
        }

        int count1 =0;
        for(int i=0;i<ans1.length()-1;i++){
            if(ans1.charAt(i)!=ans1.charAt(i+1)){
                count1++;
            }
        }

        int count2 =0;
        for(int i=0;i<ans2.length()-1;i++){
            if(ans2.charAt(i)!=ans2.charAt(i+1)){
                count2++;
            }
        }

        if(count1>count2){
            out.println(ans1);
        }
        else if(count2>count1){
            out.println(ans2);
        }
        else {
            out.println(ans1);
        }

        out.close();
    }

     public 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 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() {
                 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);
                 }
             }
         }
      public static class InputReader {
              private boolean finished = false;

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

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

              public int read() {
                  if (numChars == -1) {
                      throw new InputMismatchException();
                  }
                  if (curChar >= numChars) {
                      curChar = 0;
                      try {
                          numChars = stream.read(buf);
                      } 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 {
                          numChars = stream.read(buf);
                      } catch (IOException e) {
                          return -1;
                      }
                      if (numChars <= 0) {
                          return -1;
                      }
                  }
                  return buf[curChar];
              }

              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 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 String nextString() {
                  int c = read();
                  while (isSpaceChar(c)) {
                      c = read();
                  }
                  StringBuilder res = new StringBuilder();
                  do {
                      if (Character.isValidCodePoint(c)) {
                          res.appendCodePoint(c);
                      }
                      c = read();
                  } 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;
              }

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

              public String readLine() {
                  String s = readLine0();
                  while (s.trim().length() == 0) {
                      s = readLine0();
                  }
                  return s;
              }

              public String readLine(boolean ignoreEmptyLines) {
                  if (ignoreEmptyLines) {
                      return readLine();
                  } else {
                      return readLine0();
                  }
              }

              public BigInteger readBigInteger() {
                  try {
                      return new BigInteger(nextString());
                  } catch (NumberFormatException e) {
                      throw new InputMismatchException();
                  }
              }

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

              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 boolean isExhausted() {
                  int value;
                  while (isSpaceChar(value = peek()) && value != -1) {
                      read();
                  }
                  return value == -1;
              }

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

              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 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;
              }
          }

}