The original source code of ek.java (probably)

Protocol.java

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import gnu.trove.map.TIntObjectMap;
import gnu.trove.map.hash.TIntObjectHashMap;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import net.minecraft.server.Packet;

public enum Protocol {
    // el.class
    HANDSHAKING(0) {
        {
            addServerPacket(0, jd.class);
        }
    },
    // em.class
    PLAY(1) {
        {
            addClientPacket(0, gn.class);
            addClientPacket(1, gu.class);
            addClientPacket(2, ga.class);
            addClientPacket(3, hu.class);
            addClientPacket(4, hn.class);
            addClientPacket(5, ht.class);
            addClientPacket(6, hp.class);
            addClientPacket(7, hg.class);
            addClientPacket(8, fl.class);
            addClientPacket(9, hi.class);
            addClientPacket(10, hd.class);
            addClientPacket(11, ft.class);
            addClientPacket(12, fs.class);
            addClientPacket(13, hw.class);
            addClientPacket(14, fn.class);
            addClientPacket(15, fq.class);
            addClientPacket(16, fr.class);
            addClientPacket(17, fo.class);
            addClientPacket(18, hm.class);
            addClientPacket(19, he.class);
            addClientPacket(20, gw.class);
            addClientPacket(21, gx.class);
            addClientPacket(22, gz.class);
            addClientPacket(23, gy.class);
            addClientPacket(24, hx.class);
            addClientPacket(25, hh.class);
            addClientPacket(26, gk.class);
            addClientPacket(27, hl.class);
            addClientPacket(28, hk.class);
            addClientPacket(29, ia.class);
            addClientPacket(30, hf.class);
            addClientPacket(31, ho.class);
            addClientPacket(32, hy.class);
            addClientPacket(33, go.class);
            addClientPacket(34, gb.class);
            addClientPacket(35, fy.class);
            addClientPacket(36, fx.class);
            addClientPacket(37, fv.class);
            addClientPacket(38, gq.class);
            addClientPacket(39, gl.class);
            addClientPacket(40, gr.class);
            addClientPacket(41, gt.class);
            addClientPacket(42, gs.class);
            addClientPacket(43, gm.class);
            addClientPacket(44, fp.class);
            addClientPacket(45, ge.class);
            addClientPacket(46, gd.class);
            addClientPacket(47, gh.class);
            addClientPacket(48, gf.class);
            addClientPacket(49, gg.class);
            addClientPacket(50, gc.class);
            addClientPacket(51, hv.class);
            addClientPacket(52, gv.class);
            addClientPacket(53, fw.class);
            addClientPacket(54, ha.class);
            addClientPacket(55, fu.class);
            addClientPacket(56, hc.class);
            addClientPacket(57, hb.class);
            addClientPacket(58, fz.class);
            addClientPacket(59, hq.class);
            addClientPacket(60, hs.class);
            addClientPacket(61, hj.class);
            addClientPacket(62, hr.class);
            addClientPacket(63, gi.class);
            addClientPacket(64, gj.class);

            addServerPacket(0, iq.class);
            addServerPacket(1, ie.class);
            addServerPacket(2, io.class);
            addServerPacket(3, ir.class);
            addServerPacket(4, is.class);
            addServerPacket(5, iu.class);
            addServerPacket(6, it.class);
            addServerPacket(7, iw.class);
            addServerPacket(8, jc.class);
            addServerPacket(9, iz.class);
            addServerPacket(10, ic.class);
            addServerPacket(11, ix.class);
            addServerPacket(12, iy.class);
            addServerPacket(13, im.class);
            addServerPacket(14, il.class);
            addServerPacket(15, ij.class);
            addServerPacket(16, ja.class);
            addServerPacket(17, ik.class);
            addServerPacket(18, jb.class);
            addServerPacket(19, iv.class);
            addServerPacket(20, id.class);
            addServerPacket(21, ii.class);
            addServerPacket(22, ig.class);
            addServerPacket(23, in.class);
        }
    },
    STATUS(2) {
        {
            addServerPacket(0, jx.class);
            addClientPacket(0, jo.class);
            addServerPacket(1, jw.class);
            addClientPacket(1, jn.class);
        }
    },
    LOGIN(3) {
        {
            addClientPacket(0, ji.class);
            addClientPacket(1, jh.class);
            addClientPacket(2, jg.class);

            addServerPacket(0, jk.class);
            addServerPacket(1, jl.class);
        }
    };

    private static final TIntObjectMap<Protocol> ID_LOOKUP = new TIntObjectHashMap<Protocol>();
    private static final Map<Class<?>, Protocol> CLASS_LOOKUP = Maps.newHashMap();

    private final int g;
    private final BiMap<Integer, Class<?>> serverPacket = HashBiMap.create();
    private final BiMap<Integer, Class<?>> clientPacket = HashBiMap.create();

    static {
        for (Protocol protocol : values()) {
            ID_LOOKUP.put(protocol.c(), protocol);

            for (Class<?> localClass : Iterables.concat(protocol.clientPackets().values(), protocol
                    .serverPackets().values())) {
                if ((CLASS_LOOKUP.containsKey(localClass))
                        && (CLASS_LOOKUP.get(localClass) != protocol)) {
                    throw new Error("Packet " + localClass + " is already assigned to protocol "
                            + CLASS_LOOKUP.get(localClass) + " - can't reassign to " + protocol);
                }

                CLASS_LOOKUP.put(localClass, protocol);
            }
        }
    }

    private Protocol(int arg3) {
        this.g = arg3;
    }

    protected Protocol addServerPacket(int paramInt, Class<? extends Packet> paramClass) {
        String str;
        if (this.serverPacket.containsKey(Integer.valueOf(paramInt))) {
            str = "Serverbound packet ID " + paramInt + " is already assigned to "
                    + this.serverPacket.get(Integer.valueOf(paramInt)) + "; cannot re-assign to "
                    + paramClass;
            LogManager.getLogger().fatal(str);
            throw new IllegalArgumentException(str);
        }
        if (this.serverPacket.containsValue(paramClass)) {
            str = "Serverbound packet " + paramClass + " is already assigned to ID "
                    + this.serverPacket.inverse().get(paramClass) + "; cannot re-assign to "
                    + paramInt;
            LogManager.getLogger().fatal(str);
            throw new IllegalArgumentException(str);
        }
        this.serverPacket.put(Integer.valueOf(paramInt), paramClass);
        return this;
    }

    protected Protocol addClientPacket(int paramInt, Class<? extends Packet> paramClass) {
        String str;
        if (this.clientPacket.containsKey(Integer.valueOf(paramInt))) {
            str = "Clientbound packet ID " + paramInt + " is already assigned to "
                    + this.clientPacket.get(Integer.valueOf(paramInt)) + "; cannot re-assign to "
                    + paramClass;
            LogManager.getLogger().fatal(str);
            throw new IllegalArgumentException(str);
        }
        if (this.clientPacket.containsValue(paramClass)) {
            str = "Clientbound packet " + paramClass + " is already assigned to ID "
                    + this.clientPacket.inverse().get(paramClass) + "; cannot re-assign to "
                    + paramInt;
            LogManager.getLogger().fatal(str);
            throw new IllegalArgumentException(str);
        }
        this.clientPacket.put(Integer.valueOf(paramInt), paramClass);
        return this;
    }

    public BiMap<Integer, Class<?>> serverPackets() {
        return this.serverPacket;
    }

    public BiMap<Integer, Class<?>> clientPackets() {
        return this.clientPacket;
    }

    public BiMap<Integer, Class<?>> a(boolean paramBoolean) {
        return paramBoolean ? clientPackets() : serverPackets();
    }

    public BiMap<Integer, Class<?>> b(boolean paramBoolean) {
        return paramBoolean ? serverPackets() : clientPackets();
    }

    public int c() {
        return this.g;
    }

    public static Protocol a(int paramInt) {
        return (Protocol) ID_LOOKUP.get(paramInt);
    }

    public static Protocol a(Packet paramfk) {
        return (Protocol) CLASS_LOOKUP.get(paramfk.getClass());
    }
}