class SubWalker {
        byte[] info;

        SubWalker(byte[] attrInfo) {
            info = attrInfo;
        }

        final int targetInfo(int pos, int type) throws Exception {<FILL_FUNCTION_BODY>}

        void typeParameterTarget(int pos, int targetType, int typeParameterIndex)
            throws Exception {}

        void supertypeTarget(int pos, int superTypeIndex) throws Exception {}

        void typeParameterBoundTarget(int pos, int targetType, int typeParameterIndex,
                                      int boundIndex) throws Exception {}

        void emptyTarget(int pos, int targetType) throws Exception {}

        void formalParameterTarget(int pos, int formalParameterIndex) throws Exception {}

        void throwsTarget(int pos, int throwsTypeIndex) throws Exception {}

        int localvarTarget(int pos, int targetType, int tableLength) throws Exception {
            for (int i = 0; i < tableLength; i++) {
                int start = ByteArray.readU16bit(info, pos);
                int length = ByteArray.readU16bit(info, pos + 2);
                int index = ByteArray.readU16bit(info, pos + 4);
                localvarTarget(pos, targetType, start, length, index);
                pos += 6;
            }

            return pos;
        }

        void localvarTarget(int pos, int targetType, int startPc, int length, int index)
            throws Exception {}

        void catchTarget(int pos, int exceptionTableIndex) throws Exception {}

        void offsetTarget(int pos, int targetType, int offset) throws Exception {}

        void typeArgumentTarget(int pos, int targetType, int offset, int typeArgumentIndex)
            throws Exception {}

        final int typePath(int pos) throws Exception {
            int len = info[pos++] & 0xff;
            return typePath(pos, len);
        }

        int typePath(int pos, int pathLength) throws Exception {
            for (int i = 0; i < pathLength; i++) {
                int kind = info[pos] & 0xff;
                int index = info[pos + 1] & 0xff;
                typePath(pos, kind, index);
                pos += 2;
            }

            return pos;
        }

        void typePath(int pos, int typePathKind, int typeArgumentIndex) throws Exception {}
    }

            switch (type) {
            case 0x00:
            case 0x01: {
                int index = info[pos] & 0xff;
                typeParameterTarget(pos, type, index);
                return pos + 1; }
            case 0x10: {
                int index = ByteArray.readU16bit(info, pos);
                supertypeTarget(pos, index);
                return pos + 2; }
            case 0x11:
            case 0x12: {
                int param = info[pos] & 0xff;
                int bound = info[pos + 1] & 0xff;
                typeParameterBoundTarget(pos, type, param, bound);
                return pos + 2; }
            case 0x13:
            case 0x14:
            case 0x15:
                emptyTarget(pos, type);
                return pos;
            case 0x16: {
                int index = info[pos] & 0xff;
                formalParameterTarget(pos, index);
                return pos + 1; }
            case 0x17: {
                int index = ByteArray.readU16bit(info, pos);
                throwsTarget(pos, index);
                return pos + 2; }
            case 0x40:
            case 0x41: {
                int len = ByteArray.readU16bit(info, pos);
                return localvarTarget(pos + 2, type, len); }
            case 0x42: {
                int index = ByteArray.readU16bit(info, pos);
                catchTarget(pos, index);
                return pos + 2; }
            case 0x43:
            case 0x44:
            case 0x45:
            case 0x46: {
                int offset = ByteArray.readU16bit(info, pos);
                offsetTarget(pos, type, offset);
                return pos + 2; }
            case 0x47:
            case 0x48:
            case 0x49:
            case 0x4a:
            case 0x4b: {
                int offset = ByteArray.readU16bit(info, pos);
                int index = info[pos + 2] & 0xff;
                typeArgumentTarget(pos, type, offset, index);
                return pos + 3; }
            default:
                throw new RuntimeException("invalid target type: " + type);
            }
        
<methods>public void <init>(org.hotswap.agent.javassist.bytecode.ConstPool, java.lang.String, byte[]) ,public org.hotswap.agent.javassist.bytecode.AttributeInfo copy(org.hotswap.agent.javassist.bytecode.ConstPool, Map<java.lang.String,java.lang.String>) ,public byte[] get() ,public org.hotswap.agent.javassist.bytecode.ConstPool getConstPool() ,public java.lang.String getName() ,public int length() ,public void set(byte[]) <variables>protected org.hotswap.agent.javassist.bytecode.ConstPool constPool,byte[] info,int name