/************************************************
Algorithmen und Problemloesungen mit C++,
http://www.algorithmen-und-problemloesungen.de
Copyright @2007 by Doina Logofatu
************************************************/

#include <fstream>
#include <set>
#include <vector>
#include <bitset>

using namespace std;

typedef unsigned long long ULLINT;
typedef set<short> TSet;
typedef vector<TSet> TSetsVector;

vector<short> a;
bitset<30> x;

void addSet(int k, TSetsVector& b) {
  int i, t=1; 
  TSet auxSet;
  for(i=1; i<k; i++)
    if(x[i]) 
      auxSet.insert(a[i-1]);
  b.push_back(auxSet);
}

void back(ULLINT n, int k, TSetsVector& b){
  int i, j;
  long int p = 1;
  int aSiz = (int)a.size();
  for(j=1; j<k; j++) if(x[j]) p*=a[j-1];
  if(p == n) {
    addSet(k, b); 
  }
  else 
    if(k <= aSiz)
      for(i=0; i<2; i++){
        x[k] = 0==i ? false:true;
        if(!i) back(n, k+1, b);
        else 
          if(0==(n/p)%a[k-1]){		  
            x[k]=true;
            if(1==(n/p)/a[k-1] || (n/p)/a[k-1]>a[k-1]) 
              back(n, k+1, b);
          }
      }
}

void divVect(ULLINT n, vector<short>& a){
  a.clear();
  for(int i=2; i<=100; i++)
    if(0==n%i)
      a.push_back(i);
}

void buildSetsVector(ULLINT n, TSetsVector& b){
  divVect(n, a);  
  b.clear(); x.reset();
  back(n, 1, b);
}

bool isACommonElement(TSet A, TSet B){
  bool flag = false;
  set<short>::const_iterator itA;
  for (itA = A.begin(); !flag && itA != A.end(); itA++)   
    if (B.find(*itA) != B.end()){     
      flag = true;
    }
  return flag;
}

bool isADisjointCombination(TSetsVector b, TSetsVector c){
  bool flag = false;
  short bSiz = (short) b.size(), cSiz = (short)c.size();
  for(short i=0; !flag && i<bSiz; i++)
    for(short j=0; !flag && j<cSiz; j++)
      if(!isACommonElement(b[i], c[j])) flag=true;
  return flag;
}

void makeDecision(ULLINT n1, ULLINT n2, 
                  TSetsVector b, TSetsVector c,
                  ofstream &fout){
  
    if(!b.size() && !c.size()) 
      fout << "Beide luegen! Unentschieden!" << endl;                
    else if(!b.size())
      fout << "Der Erste luegt! Der Zweite gewinnt!" << endl;
    else if(!c.size()) 	
      fout << "Der Zweite luegt! Der Erste gewinnt!" << endl;
    else   
      if(n1<n2)
        if(isADisjointCombination(b, c)) 		
          fout << "Der zweite Spieler gewinnt!" << endl;
        else 
          fout << "Der erste Spieler gewinnt!" << endl;
      else
        if (isADisjointCombination(b, c))
          fout << "Der erste Spieler gewinnt!" << endl;
        else 		
          fout << "Der zweite Spieler gewinnt!" << endl;
}

int main(){
  ULLINT n1, n2;
  TSetsVector b, c;
  ifstream fin("oliven.in");
  ofstream fout("oliven.out");
  while(fin && !fin.eof() && fin>>n1>>n2){
    buildSetsVector(n1, b);  
    buildSetsVector(n2, c);   
    makeDecision(n1, n2, b, c, fout);
  };  
  fin.close(); fout.close();
}