import java.math.*;
import javax.imageio.*;
import java.awt.image.*;
import java.awt.event.*;
import java.awt.*;
import java.security.spec.*;
import java.security.*;
import java.lang.management.*;
import java.lang.ref.*;
import java.lang.reflect.*;
import java.net.*;
import java.io.*;
import javax.swing.table.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.regex.*;
import java.util.List;
import java.util.zip.*;
import java.util.*;

public class main {
  public static void main(String[] args) throws Exception {
    List<String> tok = javaTok(loadMainJava());
    for (List<String> c : allClasses(tok)) {
      print("Double stuff remover: Processing class " + getClassDeclarationName(c));
      Set<String> vars = new TreeSet<String>();
      Set<String> classes = new TreeSet<String>();
      
      for (List<String> ic : innerClasses(c)) {
        String name = getClassDeclarationName(ic);
        print("Found inner class " + name);
        if (classes.contains(name)) {
          print("Removing duplicate inner class " + name);
          clearAllTokens(ic);
          ic.set(ic.size()-1, "\n"); // generous line break :)
        } else
          classes.add(name);
      }
      
      List<String> c2 = javaTok(join(c)); // retokenize
      
      //print(join(c));
      
      try {
        for (List<String> v : allVariableDeclarations(c2)) {
          String name = getVarDeclarationName(v);
          print("Found var " + name);
          if (vars.contains(name)) {
            print("Removing duplicate variable " + name);
            clearAllTokens(v);
            v.set(v.size()-1, "\n"); // generous line break :)
          } else
            vars.add(name);
        }
      } catch (Exception e) {
        printStackTrace(e);
      }
      
      clearAllTokens(c);
      c.set(0, join(c2));
    }
    print("done");
    saveMainJava(join(tok));
  }

static void printStackTrace(Throwable e) {
  // we go to system.out now - system.err is nonsense
  print(getStackTrace(e));
}

static List<List<String>> innerClasses(List<String> tok) {
  int i = 1;
  while (i < tok.size() && !tok.get(i).equals("{"))
    i += 2;
  return allClasses(tok.subList(i+1, tok.size()));
}

  static String getClassDeclarationName(List<String> c) {
    for (int i = 1; i+2 < c.size(); i += 2)
      if (c.get(i).equals("class"))
        return c.get(i+2);
    return null;
  }
  


 static String getVarDeclarationName(List<String> tok) {
    int j = 1;
    List<String> special = litlist("=", "{", ";");
    while (j < tok.size() && !special.contains(tok.get(j)))
      j += 2;
    j -= 2;
    while (j > 1 && litlist("[", "]").contains(tok.get(j)))
      j -= 2;
    return tok.get(j);
  }

// tok = CNC of the class
static List<List<String>> allVariableDeclarations(List<String> tok) {
  List<List<String>> l = new ArrayList<List<String>>();
  int i = 1;
  while (!tok.get(i).equals("{")) i += 2;
  i += 2;
  
  // Now we're inside the class.
  
  while (i < tok.size() && !tok.get(i).equals("}")) {
    //print("i=" + i);
    // parse a declaration (constructor/method/variable/inner class)
    int j = i;
    List<String> special = litlist("=", "{", ";");
    while (j < tok.size() && !special.contains(tok.get(j)))
      j += 2;
      
    if (tok.get(j).equals("{"))
      // method or class declaration - skip
      j = findEndOfBlock(tok, j)+1;
    else {
      // variable declaration
      if (tok.get(j).equals("="))
        j = allVariableDeclarations_findEndOfInitializer(tok, j)+1;
      else
        j += 2; // skip ";"
      l.add(tok.subList(i-1, j));
    }
    
    i = j;
  }
  return l;
}

  // i is a code token pointing at the "="
  // as usual, returns index of last code token + 1
  static int allVariableDeclarations_findEndOfInitializer(List<String> tok, int i) {
    while (i < tok.size() && !tok.get(i).equals(";") && !tok.get(i).equals(",")) {
      if ("{<(".indexOf(tok.get(i)) >= 0)
        i = findEndOfBracketPart(tok, i)+1;
      else
        i += 2;
    }
    return i+1;
  }


  static void clearAllTokens(List<String> tok) {
    for (int i = 0; i < tok.size(); i++)
      tok.set(i, "");
  }
  
  static void clearAllTokens(List<String> tok, int i, int j) {
    for (; i < j; i++)
      tok.set(i, "");
  }

// lists returned are actual CNC (N/C/N/.../C/N) - and connected to
// original list
static List<List<String>> allClasses(List<String> tok) {
  List<List<String>> l = new ArrayList();
  for (int i = 1; i < tok.size(); i += 2) {
    if (tok.get(i).equals("class") && (i == 1 || !tok.get(i-2).equals("."))) {
      int j = i;
      while (j < tok.size() && !tok.get(j).equals("{"))
        j += 2;
      j = findEndOfBlock(tok, j)+1;
      i = leftScanModifiers(tok, i);
      l.add(tok.subList(i-1, Math.min(tok.size(), j)));
      i = j-2;
    }
  }
  return l;
}

static List<List<String>> allClasses(String text) {
  return allClasses(javaTok(text));
}

static int leftScanModifiers(List<String> tok, int i) {
  List<String> mod = getJavaModifiers();
  while (i > 1 && mod.contains(tok.get(i-2)))
    i -= 2;
  return i;
}


static <A> ArrayList<A> litlist(A... a) {
  return new ArrayList<A>(Arrays.asList(a));
}

// i must point at the opening bracket ("{")
// index returned is index of closing bracket + 1
static int findEndOfBlock(List<String> cnc, int i) {
  int j = i+2, level = 1;
  while (j < cnc.size()) {
    if (cnc.get(j).equals("{")) ++level;
    else if (cnc.get(j).equals("}")) --level;
    if (level == 0)
      return j+1;
    ++j;
  }
  return cnc.size();
}

// replacement for class JavaTok
// maybe incomplete, might want to add floating point numbers
// todo also: extended multi-line strings

static List<String> javaTok(String s) {
  List<String> tok = new ArrayList<String>();
  int l = s.length();
  
  int i = 0;
  while (i < l) {
    int j = i;
    char c; String cc;
    
    // scan for whitespace
    while (j < l) {
      c = s.charAt(j);
      cc = s.substring(j, Math.min(j+2, l));
      if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
        ++j;
      else if (cc.equals("/*")) {
        do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
        j = Math.min(j+2, l);
      } else if (cc.equals("//")) {
        do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
      } else
        break;
    }
    
    tok.add(s.substring(i, j));
    i = j;
    if (i >= l) break;
    c = s.charAt(i); // cc is not needed in rest of loop body
    cc = s.substring(i, Math.min(i+2, l));

    // scan for non-whitespace
    if (c == '\'' || c == '"') {
      char opener = c;
      ++j;
      while (j < l) {
        if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
          ++j;
          break;
        } else if (s.charAt(j) == '\\' && j+1 < l)
          j += 2;
        else
          ++j;
      }
    } else if (Character.isJavaIdentifierStart(c))
      do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); // for stuff like "don't"
    else if (Character.isDigit(c)) {
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
      if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
    } else if (cc.equals("[[")) {
      do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
      j = Math.min(j+2, l);
    } else
      ++j;

    tok.add(s.substring(i, j));
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}

static List<String> javaTok(List<String> tok) {
  return javaTok(join(tok));
}

static StringBuffer print_log;

static void print() {
  print("");
}

static void print(Object o) {
  String s = String.valueOf(o) + "\n";
  synchronized(StringBuffer.class) {
    if (print_log == null) print_log = new StringBuffer();
  }
  print_log.append(s);
  System.out.print(s);
}

static void print(long l) {
  print(String.valueOf(l));
}

  static String mainJava;
  
  static String loadMainJava() throws IOException {
    if (mainJava != null) return mainJava;
    return loadTextFile("input/main.java", "");
  }

  static void saveMainJava(String s) throws IOException {
    if (mainJava != null)
      mainJava = s;
    else
      saveTextFile("output/main.java", s);
  }
  
  static void saveMainJava(List<String> tok) throws IOException {
    saveMainJava(join(tok));
  }


  public static String join(String glue, Iterable<String> strings) {
    StringBuilder buf = new StringBuilder();
    Iterator<String> i = strings.iterator();
    if (i.hasNext()) {
      buf.append(i.next());
      while (i.hasNext())
        buf.append(glue).append(i.next());
    }
    return buf.toString();
  }
  
  public static String join(String glue, String[] strings) {
    return join(glue, Arrays.asList(strings));
  }
  
  public static String join(Iterable<String> strings) {
    return join("", strings);
  }
  
  public static String join(String[] strings) {
    return join("", strings);
  }


static String getStackTrace(Throwable throwable) {
  StringWriter writer = new StringWriter();
  throwable.printStackTrace(new PrintWriter(writer));
  return writer.toString();
}

static List<String> getJavaModifiers_list = litlist("static", "abstract", "public", "private", "protected", "final", "native", "volatile", "synchronized", "transient");

static List<String> getJavaModifiers() {
  return getJavaModifiers_list;
}

  // i must point at the opening bracket (any of the 2 types, not type parameters)
  // index returned is index of closing bracket + 1
  static int findEndOfBracketPart(List<String> cnc, int i) {
    int j = i+2, level = 1;
    while (j < cnc.size()) {
      if (litlist("{", "(").contains(cnc.get(j))) ++level;
      else if (litlist("}", ")").contains(cnc.get(j))) --level;
      if (level == 0)
        return j+1;
      ++j;
    }
    return cnc.size();
  }
  

  /** writes safely (to temp file, then rename) */
  public static void saveTextFile(String fileName, String contents) throws IOException {
    File file = new File(fileName);
    File parentFile = file.getParentFile();
    if (parentFile != null)
      parentFile.mkdirs();
    String tempFileName = fileName + "_temp";
    if (contents != null) {
      FileOutputStream fileOutputStream = new FileOutputStream(tempFileName);
      OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
      PrintWriter printWriter = new PrintWriter(outputStreamWriter);
      printWriter.print(contents);
      printWriter.close();
    }
    
    if (file.exists() && !file.delete())
      throw new IOException("Can't delete " + fileName);

    if (contents != null)
      if (!new File(tempFileName).renameTo(file))
        throw new IOException("Can't rename " + tempFileName + " to " + fileName);
  }
  
  public static void saveTextFile(File fileName, String contents) {
    try {
      saveTextFile(fileName.getPath(), contents);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }


  public static String loadTextFile(String fileName) {
    try {
      return loadTextFile(fileName, null);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  
  public static String loadTextFile(String fileName, String defaultContents) throws IOException {
    if (!new File(fileName).exists())
      return defaultContents;

    FileInputStream fileInputStream = new FileInputStream(fileName);
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
    return loadTextFile(inputStreamReader);
  }
  
  public static String loadTextFile(File fileName) {
    try {
      return loadTextFile(fileName, null);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  public static String loadTextFile(File fileName, String defaultContents) throws IOException {
    try {
      return loadTextFile(fileName.getPath(), defaultContents);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  
  public static String loadTextFile(Reader reader) throws IOException {
    StringBuilder builder = new StringBuilder();
    try {
      char[] buffer = new char[1024];
      int n;
      while (-1 != (n = reader.read(buffer)))
        builder.append(buffer, 0, n);
        
    } finally {
      reader.close();
    }
    return builder.toString();
  }
}