package com.thoughtworks.xstream.converters.reflection;

import com.ijm.dataencryption.de.DataDecryptTool;
import com.thoughtworks.xstream.converters.ConversionException;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
import com.thoughtworks.xstream.core.ClassLoaderReference;
import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.mapper.Mapper;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.CallbackFilter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.NoOp;

/* loaded from: classes.dex */
public class CGLIBEnhancedConverter extends SerializableConverter {
    private static String CALLBACK_MARKER = "CGLIB$CALLBACK_";
    private static String DEFAULT_NAMING_MARKER = "$$EnhancerByCGLIB$$";
    static /* synthetic */ Class class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter;
    static /* synthetic */ Class class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker;
    static /* synthetic */ Class class$java$lang$Class;
    static /* synthetic */ Class class$java$lang$String;
    static /* synthetic */ Class class$java$util$HashMap;
    static /* synthetic */ Class class$net$sf$cglib$proxy$Callback;
    static /* synthetic */ Class class$net$sf$cglib$proxy$Factory;
    static /* synthetic */ Class class$net$sf$cglib$proxy$MethodInterceptor;
    static /* synthetic */ Class class$net$sf$cglib$proxy$NoOp;
    private transient Map fieldCache;

    private static class CGLIBFilteringReflectionProvider extends ReflectionProviderWrapper {
        public CGLIBFilteringReflectionProvider(ReflectionProvider reflectionProvider) {
            super(reflectionProvider);
        }

        @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProviderWrapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider
        public void visitSerializableFields(Object obj, final ReflectionProvider.Visitor visitor) {
            this.wrapped.visitSerializableFields(obj, new ReflectionProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.CGLIBFilteringReflectionProvider.1
                @Override // com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor
                public void visit(String str, Class cls, Class cls2, Object obj2) {
                    if (str.startsWith("CGLIB$")) {
                        return;
                    }
                    visitor.visit(str, cls, cls2, obj2);
                }
            });
        }
    }

    private static class ReverseEngineeredCallbackFilter implements CallbackFilter {
        private final Map callbackIndexMap;

        public ReverseEngineeredCallbackFilter(Map map) {
            this.callbackIndexMap = map;
        }

        public int accept(Method method) {
            if (this.callbackIndexMap.containsKey(method)) {
                return ((Integer) this.callbackIndexMap.get(method)).intValue();
            }
            ConversionException conversionException = new ConversionException("CGLIB callback not detected in reverse engineering");
            conversionException.add("CGLIB-callback", method.toString());
            throw conversionException;
        }
    }

    private static final class ReverseEngineeringInvocationHandler implements InvocationHandler {
        private final Integer index;
        private final Map indexMap;

        public ReverseEngineeringInvocationHandler(int i, Map map) {
            this.indexMap = map;
            this.index = new Integer(i);
        }

        @Override // java.lang.reflect.InvocationHandler
        public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
            Map map = this.indexMap;
            map.put(map.get(null), this.index);
            return null;
        }
    }

    public CGLIBEnhancedConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
        super(mapper, new CGLIBFilteringReflectionProvider(reflectionProvider), classLoaderReference);
        this.fieldCache = new HashMap();
    }

    static /* synthetic */ Class class$(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            throw new NoClassDefFoundError().initCause(e);
        }
    }

    private Object create(Enhancer enhancer, List list, boolean z) {
        Object create = enhancer.create();
        if (z) {
            ((Factory) create).setCallbacks((Callback[]) list.toArray(new Callback[list.size()]));
        }
        return create;
    }

    private Map createCallbackIndexMap(Factory factory) {
        Class cls;
        Method method;
        Callback[] callbacks = factory.getCallbacks();
        Callback[] callbackArr = new Callback[callbacks.length];
        Map hashMap = new HashMap();
        int i = -1;
        for (int i2 = 0; i2 < callbacks.length; i2++) {
            Callback callback = callbacks[i2];
            if (callback == null) {
                callbackArr[i2] = null;
            } else {
                Class cls2 = class$net$sf$cglib$proxy$NoOp;
                if (cls2 == null) {
                    cls2 = class$("net.sf.cglib.proxy.NoOp");
                    class$net$sf$cglib$proxy$NoOp = cls2;
                }
                if (cls2.isAssignableFrom(callback.getClass())) {
                    callbackArr[i2] = NoOp.INSTANCE;
                    i = i2;
                } else {
                    callbackArr[i2] = createReverseEngineeredCallbackOfProperType(callback, i2, hashMap);
                }
            }
        }
        try {
            factory.setCallbacks(callbackArr);
            HashSet<Class<?>> hashSet = new HashSet();
            HashSet hashSet2 = new HashSet();
            r6 = factory.getClass();
            do {
                hashSet2.addAll(Arrays.asList(r6.getDeclaredMethods()));
                hashSet2.addAll(Arrays.asList(r6.getMethods()));
                hashSet.addAll(Arrays.asList(r6.getInterfaces()));
                r6 = r6.getSuperclass();
            } while (r6 != null);
            for (Class<?> cls3 : hashSet) {
                hashSet2.addAll(Arrays.asList(cls3.getDeclaredMethods()));
            }
            Iterator it = hashSet2.iterator();
            while (it.hasNext()) {
                Method method2 = (Method) it.next();
                if (!method2.isAccessible()) {
                    method2.setAccessible(true);
                }
                if (class$net$sf$cglib$proxy$Factory == null) {
                    cls = class$("net.sf.cglib.proxy.Factory");
                    class$net$sf$cglib$proxy$Factory = cls;
                } else {
                    cls = class$net$sf$cglib$proxy$Factory;
                }
                if (!cls.isAssignableFrom(method2.getDeclaringClass()) && (method2.getModifiers() & 24) <= 0) {
                    Class[] parameterTypes = method2.getParameterTypes();
                    try {
                        try {
                            method = (method2.getModifiers() & DataDecryptTool.DECRYPT_SP_FILE) > 0 ? factory.getClass().getMethod(method2.getName(), method2.getParameterTypes()) : method2;
                        } catch (NoSuchMethodException unused) {
                            ConversionException conversionException = new ConversionException("CGLIB enhanced proxies wit abstract nethod that has not been implemented");
                            conversionException.add("proxy-superclass", cls3.getSuperclass().getName());
                            conversionException.add("method", method2.toString());
                            throw conversionException;
                        } catch (InvocationTargetException unused2) {
                        }
                    } catch (IllegalAccessException e) {
                        e = e;
                    }
                    try {
                        hashMap.put(null, method2);
                        method.invoke(factory, parameterTypes == null ? null : createNullArguments(parameterTypes));
                        if (hashMap.containsKey(method2)) {
                            it.remove();
                        }
                    } catch (IllegalAccessException e2) {
                        e = e2;
                        method2 = method;
                        ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access method", e);
                        objectAccessException.add("method", method2.toString());
                        throw objectAccessException;
                    }
                }
                it.remove();
            }
            if (i >= 0) {
                Integer num = new Integer(i);
                Iterator it2 = hashSet2.iterator();
                while (it2.hasNext()) {
                    hashMap.put(it2.next(), num);
                }
            }
            factory.setCallbacks(callbacks);
            hashMap.remove(null);
            return hashMap;
        } catch (Throwable th) {
            factory.setCallbacks(callbacks);
            throw th;
        }
    }

    private Object[] createNullArguments(Class[] clsArr) {
        Object[] objArr = new Object[clsArr.length];
        for (int i = 0; i < objArr.length; i++) {
            Class cls = clsArr[i];
            if (cls.isPrimitive()) {
                if (cls == Byte.TYPE) {
                    objArr[i] = new Byte((byte) 0);
                } else if (cls == Short.TYPE) {
                    objArr[i] = new Short((short) 0);
                } else if (cls == Integer.TYPE) {
                    objArr[i] = new Integer(0);
                } else if (cls == Long.TYPE) {
                    objArr[i] = new Long(0L);
                } else if (cls == Float.TYPE) {
                    objArr[i] = new Float(0.0f);
                } else if (cls == Double.TYPE) {
                    objArr[i] = new Double(0.0d);
                } else if (cls == Character.TYPE) {
                    objArr[i] = new Character((char) 0);
                } else {
                    objArr[i] = Boolean.FALSE;
                }
            }
        }
        return objArr;
    }

    private Callback createReverseEngineeredCallbackOfProperType(Callback callback, int i, Map map) {
        Class<?> cls = null;
        Class<?>[] interfaces = callback.getClass().getInterfaces();
        int i2 = 0;
        while (i2 < interfaces.length) {
            Class cls2 = class$net$sf$cglib$proxy$Callback;
            if (cls2 == null) {
                cls2 = class$("net.sf.cglib.proxy.Callback");
                class$net$sf$cglib$proxy$Callback = cls2;
            }
            if (cls2.isAssignableFrom(interfaces[i2])) {
                cls = interfaces[i2];
                Class<?> cls3 = class$net$sf$cglib$proxy$Callback;
                if (cls3 == null) {
                    cls3 = class$("net.sf.cglib.proxy.Callback");
                    class$net$sf$cglib$proxy$Callback = cls3;
                }
                if (cls == cls3) {
                    ConversionException conversionException = new ConversionException("Cannot handle CGLIB callback");
                    conversionException.add("CGLIB-callback-type", callback.getClass().getName());
                    throw conversionException;
                }
                Class<?>[] interfaces2 = cls.getInterfaces();
                List asList = Arrays.asList(interfaces2);
                Class cls4 = class$net$sf$cglib$proxy$Callback;
                if (cls4 == null) {
                    cls4 = class$("net.sf.cglib.proxy.Callback");
                    class$net$sf$cglib$proxy$Callback = cls4;
                }
                if (asList.contains(cls4)) {
                    break;
                }
                interfaces = interfaces2;
                i2 = -1;
            }
            i2++;
        }
        return (Callback) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new ReverseEngineeringInvocationHandler(i, map));
    }

    private Callback[] getCallbacks(Object obj) {
        Class<?> cls = obj.getClass();
        List list = (List) this.fieldCache.get(cls.getName());
        if (list == null) {
            list = new ArrayList();
            this.fieldCache.put(cls.getName(), list);
            int i = 0;
            while (true) {
                try {
                    StringBuffer stringBuffer = new StringBuffer();
                    stringBuffer.append(CALLBACK_MARKER);
                    stringBuffer.append(i);
                    Field declaredField = cls.getDeclaredField(stringBuffer.toString());
                    if (!declaredField.isAccessible()) {
                        declaredField.setAccessible(true);
                    }
                    list.add(declaredField);
                    i++;
                } catch (NoSuchFieldException unused) {
                }
            }
        }
        ArrayList arrayList = new ArrayList();
        for (int i2 = 0; i2 < list.size(); i2++) {
            try {
                arrayList.add(((Field) list.get(i2)).get(obj));
            } catch (IllegalAccessException e) {
                ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access field", e);
                StringBuffer stringBuffer2 = new StringBuffer();
                stringBuffer2.append(cls.getName());
                stringBuffer2.append(".");
                stringBuffer2.append(CALLBACK_MARKER);
                stringBuffer2.append(i2);
                objectAccessException.add("field", stringBuffer2.toString());
                throw objectAccessException;
            }
        }
        return (Callback[]) arrayList.toArray(new Callback[arrayList.size()]);
    }

    private void readCallback(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext, List list, List list2) {
        Callback callback = (Callback) unmarshallingContext.convertAnother(null, this.mapper.realClass(hierarchicalStreamReader.getNodeName()));
        list2.add(callback);
        if (callback == null) {
            list.add(NoOp.INSTANCE);
        } else {
            list.add(callback);
        }
    }

    @Override // com.thoughtworks.xstream.converters.reflection.SerializableConverter, com.thoughtworks.xstream.converters.ConverterMatcher
    public boolean canConvert(Class cls) {
        if (cls == null || !Enhancer.isEnhanced(cls) || cls.getName().indexOf(DEFAULT_NAMING_MARKER) <= 0) {
            Class cls2 = class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker;
            if (cls2 == null) {
                cls2 = class$("com.thoughtworks.xstream.mapper.CGLIBMapper$Marker");
                class$com$thoughtworks$xstream$mapper$CGLIBMapper$Marker = cls2;
            }
            if (cls != cls2) {
                return false;
            }
        }
        return true;
    }

    @Override // com.thoughtworks.xstream.converters.reflection.SerializableConverter
    protected List hierarchyFor(Class cls) {
        List hierarchyFor = super.hierarchyFor(cls);
        hierarchyFor.remove(hierarchyFor.size() - 1);
        return hierarchyFor;
    }

    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter, com.thoughtworks.xstream.converters.Converter
    public void marshal(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
        Class cls;
        Class<?> cls2 = obj.getClass();
        Class cls3 = class$net$sf$cglib$proxy$Factory;
        if (cls3 == null) {
            cls3 = class$("net.sf.cglib.proxy.Factory");
            class$net$sf$cglib$proxy$Factory = cls3;
        }
        boolean isAssignableFrom = cls3.isAssignableFrom(cls2);
        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "type", cls2);
        marshallingContext.convertAnother(cls2.getSuperclass());
        hierarchicalStreamWriter.endNode();
        hierarchicalStreamWriter.startNode("interfaces");
        Class<?>[] interfaces = cls2.getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            Class<?> cls4 = interfaces[i];
            Class<?> cls5 = class$net$sf$cglib$proxy$Factory;
            if (cls5 == null) {
                cls5 = class$("net.sf.cglib.proxy.Factory");
                class$net$sf$cglib$proxy$Factory = cls5;
            }
            if (cls4 != cls5) {
                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(interfaces[i].getClass()), interfaces[i].getClass());
                marshallingContext.convertAnother(interfaces[i]);
                hierarchicalStreamWriter.endNode();
            }
        }
        hierarchicalStreamWriter.endNode();
        hierarchicalStreamWriter.startNode("hasFactory");
        hierarchicalStreamWriter.setValue(String.valueOf(isAssignableFrom));
        hierarchicalStreamWriter.endNode();
        Callback[] callbacks = isAssignableFrom ? ((Factory) obj).getCallbacks() : getCallbacks(obj);
        if (callbacks.length > 1) {
            if (!isAssignableFrom) {
                ConversionException conversionException = new ConversionException("Cannot handle CGLIB enhanced proxies without factory that have multiple callbacks");
                conversionException.add("proxy-superclass", cls2.getSuperclass().getName());
                conversionException.add("number-of-callbacks", String.valueOf(callbacks.length));
                throw conversionException;
            }
            Map createCallbackIndexMap = createCallbackIndexMap((Factory) obj);
            hierarchicalStreamWriter.startNode("callbacks");
            hierarchicalStreamWriter.startNode("mapping");
            marshallingContext.convertAnother(createCallbackIndexMap);
            hierarchicalStreamWriter.endNode();
        }
        boolean z = false;
        for (Callback callback : callbacks) {
            if (callback == null) {
                hierarchicalStreamWriter.startNode(this.mapper.serializedClass(null));
                hierarchicalStreamWriter.endNode();
            } else {
                if (!z) {
                    Class cls6 = class$net$sf$cglib$proxy$MethodInterceptor;
                    if (cls6 == null) {
                        cls6 = class$("net.sf.cglib.proxy.MethodInterceptor");
                        class$net$sf$cglib$proxy$MethodInterceptor = cls6;
                    }
                    if (!cls6.isAssignableFrom(callback.getClass())) {
                        z = false;
                        ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(callback.getClass()), callback.getClass());
                        marshallingContext.convertAnother(callback);
                        hierarchicalStreamWriter.endNode();
                    }
                }
                z = true;
                ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, this.mapper.serializedClass(callback.getClass()), callback.getClass());
                marshallingContext.convertAnother(callback);
                hierarchicalStreamWriter.endNode();
            }
        }
        if (callbacks.length > 1) {
            hierarchicalStreamWriter.endNode();
        }
        try {
            Field declaredField = cls2.getDeclaredField("serialVersionUID");
            if (!declaredField.isAccessible()) {
                declaredField.setAccessible(true);
            }
            long j = declaredField.getLong(null);
            if (class$java$lang$String == null) {
                cls = class$("java.lang.String");
                class$java$lang$String = cls;
            } else {
                cls = class$java$lang$String;
            }
            ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, "serialVersionUID", cls);
            hierarchicalStreamWriter.setValue(String.valueOf(j));
            hierarchicalStreamWriter.endNode();
        } catch (IllegalAccessException e) {
            ObjectAccessException objectAccessException = new ObjectAccessException("Cannot access field", e);
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append(cls2.getName());
            stringBuffer.append(".serialVersionUID");
            objectAccessException.add("field", stringBuffer.toString());
            throw objectAccessException;
        } catch (NoSuchFieldException unused) {
        }
        if (z) {
            hierarchicalStreamWriter.startNode("instance");
            super.doMarshalConditionally(obj, hierarchicalStreamWriter, marshallingContext);
            hierarchicalStreamWriter.endNode();
        }
    }

    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
    protected Object readResolve() {
        super.readResolve();
        this.fieldCache = new HashMap();
        return this;
    }

    @Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter, com.thoughtworks.xstream.converters.Converter
    public Object unmarshal(HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
        Map map;
        Enhancer enhancer = new Enhancer();
        hierarchicalStreamReader.moveDown();
        Class cls = class$java$lang$Class;
        if (cls == null) {
            cls = class$("java.lang.Class");
            class$java$lang$Class = cls;
        }
        Object obj = null;
        enhancer.setSuperclass((Class) unmarshallingContext.convertAnother(null, cls));
        hierarchicalStreamReader.moveUp();
        hierarchicalStreamReader.moveDown();
        ArrayList arrayList = new ArrayList();
        while (hierarchicalStreamReader.hasMoreChildren()) {
            hierarchicalStreamReader.moveDown();
            arrayList.add(unmarshallingContext.convertAnother(null, this.mapper.realClass(hierarchicalStreamReader.getNodeName())));
            hierarchicalStreamReader.moveUp();
        }
        enhancer.setInterfaces((Class[]) arrayList.toArray(new Class[arrayList.size()]));
        hierarchicalStreamReader.moveUp();
        hierarchicalStreamReader.moveDown();
        boolean booleanValue = Boolean.valueOf(hierarchicalStreamReader.getValue()).booleanValue();
        enhancer.setUseFactory(booleanValue);
        hierarchicalStreamReader.moveUp();
        ArrayList arrayList2 = new ArrayList();
        ArrayList arrayList3 = new ArrayList();
        hierarchicalStreamReader.moveDown();
        if ("callbacks".equals(hierarchicalStreamReader.getNodeName())) {
            hierarchicalStreamReader.moveDown();
            Class cls2 = class$java$util$HashMap;
            if (cls2 == null) {
                cls2 = class$("java.util.HashMap");
                class$java$util$HashMap = cls2;
            }
            map = (Map) unmarshallingContext.convertAnother(null, cls2);
            hierarchicalStreamReader.moveUp();
            while (hierarchicalStreamReader.hasMoreChildren()) {
                hierarchicalStreamReader.moveDown();
                readCallback(hierarchicalStreamReader, unmarshallingContext, arrayList2, arrayList3);
                hierarchicalStreamReader.moveUp();
            }
        } else {
            readCallback(hierarchicalStreamReader, unmarshallingContext, arrayList2, arrayList3);
            map = null;
        }
        enhancer.setCallbacks((Callback[]) arrayList2.toArray(new Callback[arrayList2.size()]));
        if (map != null) {
            enhancer.setCallbackFilter(new ReverseEngineeredCallbackFilter(map));
        }
        hierarchicalStreamReader.moveUp();
        while (hierarchicalStreamReader.hasMoreChildren()) {
            hierarchicalStreamReader.moveDown();
            if (hierarchicalStreamReader.getNodeName().equals("serialVersionUID")) {
                enhancer.setSerialVersionUID(Long.valueOf(hierarchicalStreamReader.getValue()));
            } else if (hierarchicalStreamReader.getNodeName().equals("instance")) {
                obj = create(enhancer, arrayList3, booleanValue);
                super.doUnmarshalConditionally(obj, hierarchicalStreamReader, unmarshallingContext);
            }
            hierarchicalStreamReader.moveUp();
        }
        if (obj == null) {
            obj = create(enhancer, arrayList3, booleanValue);
        }
        return this.serializationMembers.callReadResolve(obj);
    }

    public CGLIBEnhancedConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoader classLoader) {
        super(mapper, new CGLIBFilteringReflectionProvider(reflectionProvider), classLoader);
        this.fieldCache = new HashMap();
    }

    /* JADX WARN: Illegal instructions before constructor call */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public CGLIBEnhancedConverter(com.thoughtworks.xstream.mapper.Mapper r2, com.thoughtworks.xstream.converters.reflection.ReflectionProvider r3) {
        /*
            r1 = this;
            com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter$CGLIBFilteringReflectionProvider r0 = new com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter$CGLIBFilteringReflectionProvider
            r0.<init>(r3)
            java.lang.Class r3 = com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter
            if (r3 != 0) goto L11
            java.lang.String r3 = "com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter"
            java.lang.Class r3 = class$(r3)
            com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.class$com$thoughtworks$xstream$converters$reflection$CGLIBEnhancedConverter = r3
        L11:
            java.lang.ClassLoader r3 = r3.getClassLoader()
            r1.<init>(r2, r0, r3)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter.<init>(com.thoughtworks.xstream.mapper.Mapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider):void");
    }
}