diff --git a/src/OEnumEnchantmentType.java b/src/OEnumEnchantmentType.java
new file mode 100644
index 00000000..97cda678
--- /dev/null
+++ b/src/OEnumEnchantmentType.java
@@ -0,0 +1,24 @@
+public enum OEnumEnchantmentType {
+
+    a("all", 0), b("armor", 1), c("armor_feet", 2), d("armor_legs", 3), e("armor_torso", 4), f("armor_head", 5), g("weapon", 6), h("digger", 7), i("bow", 8);
+
+    private static final OEnumEnchantmentType[] j = new OEnumEnchantmentType[] { a, b, c, d, e, f, g, h, i};
+
+    private OEnumEnchantmentType(String s, int i) {}
+
+    public boolean a(OItem oitem) {
+        if (this == a) {
+            return true;
+        } else if (oitem instanceof OItemArmor) {
+            if (this == b) {
+                return true;
+            } else {
+                OItemArmor oitemarmor = (OItemArmor) oitem;
+
+                return oitemarmor.a == 0 ? this == f : (oitemarmor.a == 2 ? this == d : (oitemarmor.a == 1 ? this == e : (oitemarmor.a == 3 ? this == c : false)));
+            }
+        } else {
+            return oitem instanceof OItemSword ? this == g : (oitem instanceof OItemTool ? this == h : (oitem instanceof OItemBow ? this == i : false));
+        }
+    }
+}
diff --git a/src/OFlatGeneratorInfo.java b/src/OFlatGeneratorInfo.java
new file mode 100644
index 00000000..0be7d402
--- /dev/null
+++ b/src/OFlatGeneratorInfo.java
@@ -0,0 +1,248 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class OFlatGeneratorInfo {
+
+    private final List a = new ArrayList();
+    private final Map b = new HashMap();
+    private int c = 0;
+
+    public OFlatGeneratorInfo() {}
+
+    public int a() {
+        return this.c;
+    }
+
+    public void a(int i) {
+        this.c = i;
+    }
+
+    public Map b() {
+        return this.b;
+    }
+
+    public List c() {
+        return this.a;
+    }
+
+    public void d() {
+        int i = 0;
+
+        OFlatLayerInfo oflatlayerinfo;
+
+        for (Iterator iterator = this.a.iterator(); iterator.hasNext(); i += oflatlayerinfo.a()) {
+            oflatlayerinfo = (OFlatLayerInfo) iterator.next();
+            oflatlayerinfo.d(i);
+        }
+    }
+
+    public String toString() {
+        StringBuilder stringbuilder = new StringBuilder();
+
+        stringbuilder.append(2);
+        stringbuilder.append(";");
+
+        int i;
+
+        for (i = 0; i < this.a.size(); ++i) {
+            if (i > 0) {
+                stringbuilder.append(",");
+            }
+
+            stringbuilder.append(((OFlatLayerInfo) this.a.get(i)).toString());
+        }
+
+        stringbuilder.append(";");
+        stringbuilder.append(this.c);
+        if (!this.b.isEmpty()) {
+            stringbuilder.append(";");
+            i = 0;
+            Iterator iterator = this.b.entrySet().iterator();
+
+            while (iterator.hasNext()) {
+                Entry entry = (Entry) iterator.next();
+
+                if (i++ > 0) {
+                    stringbuilder.append(",");
+                }
+
+                stringbuilder.append(((String) entry.getKey()).toLowerCase());
+                Map map = (Map) entry.getValue();
+
+                if (!map.isEmpty()) {
+                    stringbuilder.append("(");
+                    int j = 0;
+                    Iterator iterator1 = map.entrySet().iterator();
+
+                    while (iterator1.hasNext()) {
+                        Entry entry1 = (Entry) iterator1.next();
+
+                        if (j++ > 0) {
+                            stringbuilder.append(" ");
+                        }
+
+                        stringbuilder.append((String) entry1.getKey());
+                        stringbuilder.append("=");
+                        stringbuilder.append((String) entry1.getValue());
+                    }
+
+                    stringbuilder.append(")");
+                }
+            }
+        }
+
+        return stringbuilder.toString();
+    }
+
+    private static OFlatLayerInfo a(String s, int i) {
+        String[] astring = s.split("x", 2);
+        int j = 1;
+        int k = 0;
+
+        if (astring.length == 2) {
+            try {
+                j = Integer.parseInt(astring[0]);
+                if (i + j >= 256) {
+                    j = 256 - i;
+                }
+
+                if (j < 0) {
+                    j = 0;
+                }
+            } catch (Throwable throwable) {
+                return null;
+            }
+        }
+
+        int l;
+
+        try {
+            String s1 = astring[astring.length - 1];
+
+            astring = s1.split(":", 2);
+            l = Integer.parseInt(astring[0]);
+            if (astring.length > 1) {
+                k = Integer.parseInt(astring[1]);
+            }
+
+            if (OBlock.p[l] == null) {
+                l = 0;
+                k = 0;
+            }
+
+            if (k < 0 || k > 15) {
+                k = 0;
+            }
+        } catch (Throwable throwable1) {
+            return null;
+        }
+
+        OFlatLayerInfo oflatlayerinfo = new OFlatLayerInfo(j, l, k);
+
+        oflatlayerinfo.d(i);
+        return oflatlayerinfo;
+    }
+
+    private static List b(String s) {
+        if (s != null && s.length() >= 1) {
+            ArrayList arraylist = new ArrayList();
+            String[] astring = s.split(",");
+            int i = 0;
+            String[] astring1 = astring;
+            int j = astring.length;
+
+            for (int k = 0; k < j; ++k) {
+                String s1 = astring1[k];
+                OFlatLayerInfo oflatlayerinfo = a(s1, i);
+
+                if (oflatlayerinfo == null) {
+                    return null;
+                }
+
+                arraylist.add(oflatlayerinfo);
+                i += oflatlayerinfo.a();
+            }
+
+            return arraylist;
+        } else {
+            return null;
+        }
+    }
+
+    public static OFlatGeneratorInfo a(String s) {
+        if (s == null) {
+            return e();
+        } else {
+            String[] astring = s.split(";", -1);
+            int i = astring.length == 1 ? 0 : OMathHelper.a(astring[0], 0);
+
+            if (i >= 0 && i <= 2) {
+                OFlatGeneratorInfo oflatgeneratorinfo = new OFlatGeneratorInfo();
+                int j = astring.length == 1 ? 0 : 1;
+                List list = b(astring[j++]);
+
+                if (list != null && !list.isEmpty()) {
+                    oflatgeneratorinfo.c().addAll(list);
+                    oflatgeneratorinfo.d();
+                    int k = OBiomeGenBase.c.N;
+
+                    if (i > 0 && astring.length > j) {
+                        k = OMathHelper.a(astring[j++], k);
+                    }
+
+                    oflatgeneratorinfo.a(k);
+                    if (i > 0 && astring.length > j) {
+                        String[] astring1 = astring[j++].toLowerCase().split(",");
+                        String[] astring2 = astring1;
+                        int l = astring1.length;
+
+                        for (int i1 = 0; i1 < l; ++i1) {
+                            String s1 = astring2[i1];
+                            String[] astring3 = s1.split("\\(", 2);
+                            HashMap hashmap = new HashMap();
+
+                            if (astring3[0].length() > 0) {
+                                oflatgeneratorinfo.b().put(astring3[0], hashmap);
+                                if (astring3.length > 1 && astring3[1].endsWith(")") && astring3[1].length() > 1) {
+                                    String[] astring4 = astring3[1].substring(0, astring3[1].length() - 1).split(" ");
+
+                                    for (int j1 = 0; j1 < astring4.length; ++j1) {
+                                        String[] astring5 = astring4[j1].split("=", 2);
+
+                                        if (astring5.length == 2) {
+                                            hashmap.put(astring5[0], astring5[1]);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        oflatgeneratorinfo.b().put("village", new HashMap());
+                    }
+
+                    return oflatgeneratorinfo;
+                } else {
+                    return e();
+                }
+            } else {
+                return e();
+            }
+        }
+    }
+
+    public static OFlatGeneratorInfo e() {
+        OFlatGeneratorInfo oflatgeneratorinfo = new OFlatGeneratorInfo();
+
+        oflatgeneratorinfo.a(OBiomeGenBase.c.N);
+        oflatgeneratorinfo.c().add(new OFlatLayerInfo(1, OBlock.C.cm));
+        oflatgeneratorinfo.c().add(new OFlatLayerInfo(2, OBlock.y.cm));
+        oflatgeneratorinfo.c().add(new OFlatLayerInfo(1, OBlock.x.cm));
+        oflatgeneratorinfo.d();
+        oflatgeneratorinfo.b().put("village", new HashMap());
+        return oflatgeneratorinfo;
+    }
+}
diff --git a/src/OFlatLayerInfo.java b/src/OFlatLayerInfo.java
new file mode 100644
index 00000000..b22e755c
--- /dev/null
+++ b/src/OFlatLayerInfo.java
@@ -0,0 +1,55 @@
+public class OFlatLayerInfo {
+
+    private int a;
+    private int b;
+    private int c;
+    private int d;
+
+    public OFlatLayerInfo(int i, int j) {
+        this.a = 1;
+        this.b = 0;
+        this.c = 0;
+        this.d = 0;
+        this.a = i;
+        this.b = j;
+    }
+
+    public OFlatLayerInfo(int i, int j, int k) {
+        this(i, j);
+        this.c = k;
+    }
+
+    public int a() {
+        return this.a;
+    }
+
+    public int b() {
+        return this.b;
+    }
+
+    public int c() {
+        return this.c;
+    }
+
+    public int d() {
+        return this.d;
+    }
+
+    public void d(int i) {
+        this.d = i;
+    }
+
+    public String toString() {
+        String s = Integer.toString(this.b);
+
+        if (this.a > 1) {
+            s = this.a + "x" + s;
+        }
+
+        if (this.c > 0) {
+            s = s + ":" + this.c;
+        }
+
+        return s;
+    }
+}
diff --git a/src/OPlayerSelector.java b/src/OPlayerSelector.java
new file mode 100644
index 00000000..e9822aba
--- /dev/null
+++ b/src/OPlayerSelector.java
@@ -0,0 +1,207 @@
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class OPlayerSelector {
+
+    private static final Pattern a = Pattern.compile("^@([parf])(?:\\[([\\w=,-]*)\\])?$");
+    private static final Pattern b = Pattern.compile("\\G(-?\\w*)(?:$|,)");
+    private static final Pattern c = Pattern.compile("\\G(\\w{1,2})=(-?\\w+)(?:$|,)");
+
+    public static OEntityPlayerMP a(OICommandSender oicommandsender, String s) {
+        OEntityPlayerMP[] aoentityplayermp = c(oicommandsender, s);
+
+        return aoentityplayermp != null && aoentityplayermp.length == 1 ? aoentityplayermp[0] : null;
+    }
+
+    public static String b(OICommandSender oicommandsender, String s) {
+        OEntityPlayerMP[] aoentityplayermp = c(oicommandsender, s);
+
+        if (aoentityplayermp != null && aoentityplayermp.length != 0) {
+            String[] astring = new String[aoentityplayermp.length];
+
+            for (int i = 0; i < astring.length; ++i) {
+                astring[i] = aoentityplayermp[i].an();
+            }
+
+            return OCommandBase.a((Object[]) astring);
+        } else {
+            return null;
+        }
+    }
+
+    public static OEntityPlayerMP[] c(OICommandSender oicommandsender, String s) {
+        Matcher matcher = a.matcher(s);
+
+        if (matcher.matches()) {
+            Map map = h(matcher.group(2));
+            String s1 = matcher.group(1);
+            int i = c(s1);
+            int j = d(s1);
+            int k = f(s1);
+            int l = e(s1);
+            int i1 = g(s1);
+            int j1 = OEnumGameType.a.a();
+            OChunkCoordinates ochunkcoordinates = oicommandsender.b();
+
+            if (map.containsKey("rm")) {
+                i = OMathHelper.a((String) map.get("rm"), i);
+            }
+
+            if (map.containsKey("r")) {
+                j = OMathHelper.a((String) map.get("r"), j);
+            }
+
+            if (map.containsKey("lm")) {
+                k = OMathHelper.a((String) map.get("lm"), k);
+            }
+
+            if (map.containsKey("l")) {
+                l = OMathHelper.a((String) map.get("l"), l);
+            }
+
+            if (map.containsKey("x")) {
+                ochunkcoordinates.a = OMathHelper.a((String) map.get("x"), ochunkcoordinates.a);
+            }
+
+            if (map.containsKey("y")) {
+                ochunkcoordinates.b = OMathHelper.a((String) map.get("y"), ochunkcoordinates.b);
+            }
+
+            if (map.containsKey("z")) {
+                ochunkcoordinates.c = OMathHelper.a((String) map.get("z"), ochunkcoordinates.c);
+            }
+
+            if (map.containsKey("m")) {
+                j1 = OMathHelper.a((String) map.get("m"), j1);
+            }
+
+            if (map.containsKey("c")) {
+                i1 = OMathHelper.a((String) map.get("c"), i1);
+            }
+
+            List list;
+
+            if (!s1.equals("p") && !s1.equals("a")) {
+                if (!s1.equals("p")) {
+                    return null;
+                } else {
+                    list = OMinecraftServer.D().ad().a(ochunkcoordinates, i, j, 0, j1, k, l);
+                    Collections.shuffle(list);
+                    list = list.subList(0, Math.min(i1, list.size()));
+                    return list != null && !list.isEmpty() ? (OEntityPlayerMP[]) list.toArray(new OEntityPlayerMP[0]) : new OEntityPlayerMP[0];
+                }
+            } else {
+                list = OMinecraftServer.D().ad().a(ochunkcoordinates, i, j, i1, j1, k, l);
+                return list != null && !list.isEmpty() ? (OEntityPlayerMP[]) list.toArray(new OEntityPlayerMP[0]) : new OEntityPlayerMP[0];
+            }
+        } else {
+            return null;
+        }
+    }
+
+    public static boolean a(String s) {
+        Matcher matcher = a.matcher(s);
+
+        if (matcher.matches()) {
+            Map map = h(matcher.group(2));
+            String s1 = matcher.group(1);
+            int i = g(s1);
+
+            if (map.containsKey("c")) {
+                i = OMathHelper.a((String) map.get("c"), i);
+            }
+
+            return i != 1;
+        } else {
+            return false;
+        }
+    }
+
+    public static boolean a(String s, String s1) {
+        Matcher matcher = a.matcher(s);
+
+        if (!matcher.matches()) {
+            return false;
+        } else {
+            String s2 = matcher.group(1);
+
+            return s1 == null || s1.equals(s2);
+        }
+    }
+
+    public static boolean b(String s) {
+        return a(s, (String) null);
+    }
+
+    private static final int c(String s) {
+        return 0;
+    }
+
+    private static final int d(String s) {
+        return 0;
+    }
+
+    private static final int e(String s) {
+        return Integer.MAX_VALUE;
+    }
+
+    private static final int f(String s) {
+        return 0;
+    }
+
+    private static final int g(String s) {
+        return s.equals("a") ? 0 : 1;
+    }
+
+    private static Map h(String s) {
+        HashMap hashmap = new HashMap();
+
+        if (s == null) {
+            return hashmap;
+        } else {
+            Matcher matcher = b.matcher(s);
+            int i = 0;
+
+            int j;
+
+            for (j = -1; matcher.find(); j = matcher.end()) {
+                String s1 = null;
+
+                switch (i++) {
+                case 0:
+                    s1 = "x";
+                    break;
+
+                case 1:
+                    s1 = "y";
+                    break;
+
+                case 2:
+                    s1 = "z";
+                    break;
+
+                case 3:
+                    s1 = "r";
+                }
+
+                if (s1 != null && matcher.group(1).length() > 0) {
+                    hashmap.put(s1, matcher.group(1));
+                }
+            }
+
+            if (j < s.length()) {
+                matcher = c.matcher(j == -1 ? s : s.substring(j));
+
+                while (matcher.find()) {
+                    hashmap.put(matcher.group(1), matcher.group(2));
+                }
+            }
+
+            return hashmap;
+        }
+    }
+}