Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/facebook/appevents/ml/MTensor.java

@@ -0,0 +1,73 @@
+package com.facebook.appevents.ml;
+
+import kotlin.collections.ArraysKt___ArraysKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class MTensor {
+    public static final Companion Companion = new Companion(null);
+    private int capacity;
+    private float[] data;
+    private int[] shape;
+
+    public final float[] getData() {
+        return this.data;
+    }
+
+    public MTensor(int[] shape) {
+        Intrinsics.checkNotNullParameter(shape, "shape");
+        this.shape = shape;
+        int capacity = Companion.getCapacity(shape);
+        this.capacity = capacity;
+        this.data = new float[capacity];
+    }
+
+    public final int getShapeSize() {
+        return this.shape.length;
+    }
+
+    public final int getShape(int i) {
+        return this.shape[i];
+    }
+
+    public final void reshape(int[] shape) {
+        Intrinsics.checkNotNullParameter(shape, "shape");
+        this.shape = shape;
+        int capacity = Companion.getCapacity(shape);
+        float[] fArr = new float[capacity];
+        System.arraycopy(this.data, 0, fArr, 0, Math.min(this.capacity, capacity));
+        this.data = fArr;
+        this.capacity = capacity;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final int getCapacity(int[] iArr) {
+            int lastIndex;
+            if (iArr.length == 0) {
+                throw new UnsupportedOperationException("Empty array can't be reduced.");
+            }
+            int i = iArr[0];
+            lastIndex = ArraysKt___ArraysKt.getLastIndex(iArr);
+            int i2 = 1;
+            if (1 <= lastIndex) {
+                while (true) {
+                    i *= iArr[i2];
+                    if (i2 == lastIndex) {
+                        break;
+                    }
+                    i2++;
+                }
+            }
+            return i;
+        }
+    }
+}

decompiled/sources/com/facebook/appevents/ml/Model.java

@@ -0,0 +1,213 @@
+package com.facebook.appevents.ml;
+
+import androidx.annotation.RestrictTo;
+import com.facebook.appevents.ml.ModelManager;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import kotlin.TuplesKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes2.dex */
+public final class Model {
+    public static final Companion Companion = new Companion(null);
+    private static final int SEQ_LEN = 128;
+    private static final Map<String, String> mapping;
+    private final MTensor convs0Bias;
+    private final MTensor convs0Weight;
+    private final MTensor convs1Bias;
+    private final MTensor convs1Weight;
+    private final MTensor convs2Bias;
+    private final MTensor convs2Weight;
+    private final MTensor embedding;
+    private final MTensor fc1Bias;
+    private final MTensor fc1Weight;
+    private final MTensor fc2Bias;
+    private final MTensor fc2Weight;
+    private final Map<String, MTensor> finalWeights;
+
+    public /* synthetic */ Model(Map map, DefaultConstructorMarker defaultConstructorMarker) {
+        this(map);
+    }
+
+    private Model(Map<String, MTensor> map) {
+        Set<String> of;
+        MTensor mTensor = map.get("embed.weight");
+        if (mTensor == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.embedding = mTensor;
+        Operator operator = Operator.INSTANCE;
+        MTensor mTensor2 = map.get("convs.0.weight");
+        if (mTensor2 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs0Weight = Operator.transpose3D(mTensor2);
+        MTensor mTensor3 = map.get("convs.1.weight");
+        if (mTensor3 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs1Weight = Operator.transpose3D(mTensor3);
+        MTensor mTensor4 = map.get("convs.2.weight");
+        if (mTensor4 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs2Weight = Operator.transpose3D(mTensor4);
+        MTensor mTensor5 = map.get("convs.0.bias");
+        if (mTensor5 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs0Bias = mTensor5;
+        MTensor mTensor6 = map.get("convs.1.bias");
+        if (mTensor6 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs1Bias = mTensor6;
+        MTensor mTensor7 = map.get("convs.2.bias");
+        if (mTensor7 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.convs2Bias = mTensor7;
+        MTensor mTensor8 = map.get("fc1.weight");
+        if (mTensor8 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.fc1Weight = Operator.transpose2D(mTensor8);
+        MTensor mTensor9 = map.get("fc2.weight");
+        if (mTensor9 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.fc2Weight = Operator.transpose2D(mTensor9);
+        MTensor mTensor10 = map.get("fc1.bias");
+        if (mTensor10 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.fc1Bias = mTensor10;
+        MTensor mTensor11 = map.get("fc2.bias");
+        if (mTensor11 == null) {
+            throw new IllegalStateException("Required value was null.".toString());
+        }
+        this.fc2Bias = mTensor11;
+        this.finalWeights = new HashMap();
+        of = SetsKt__SetsKt.setOf((Object[]) new String[]{ModelManager.Task.MTML_INTEGRITY_DETECT.toKey(), ModelManager.Task.MTML_APP_EVENT_PREDICTION.toKey()});
+        for (String str : of) {
+            String stringPlus = Intrinsics.stringPlus(str, ".weight");
+            String stringPlus2 = Intrinsics.stringPlus(str, ".bias");
+            MTensor mTensor12 = map.get(stringPlus);
+            MTensor mTensor13 = map.get(stringPlus2);
+            if (mTensor12 != null) {
+                this.finalWeights.put(stringPlus, Operator.transpose2D(mTensor12));
+            }
+            if (mTensor13 != null) {
+                this.finalWeights.put(stringPlus2, mTensor13);
+            }
+        }
+    }
+
+    public static final /* synthetic */ Map access$getMapping$cp() {
+        if (CrashShieldHandler.isObjectCrashing(Model.class)) {
+            return null;
+        }
+        try {
+            return mapping;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Model.class);
+            return null;
+        }
+    }
+
+    public final MTensor predictOnMTML(MTensor dense, String[] texts, String task) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(dense, "dense");
+            Intrinsics.checkNotNullParameter(texts, "texts");
+            Intrinsics.checkNotNullParameter(task, "task");
+            Operator operator = Operator.INSTANCE;
+            MTensor conv1D = Operator.conv1D(Operator.embedding(texts, 128, this.embedding), this.convs0Weight);
+            Operator.addmv(conv1D, this.convs0Bias);
+            Operator.relu(conv1D);
+            MTensor conv1D2 = Operator.conv1D(conv1D, this.convs1Weight);
+            Operator.addmv(conv1D2, this.convs1Bias);
+            Operator.relu(conv1D2);
+            MTensor maxPool1D = Operator.maxPool1D(conv1D2, 2);
+            MTensor conv1D3 = Operator.conv1D(maxPool1D, this.convs2Weight);
+            Operator.addmv(conv1D3, this.convs2Bias);
+            Operator.relu(conv1D3);
+            MTensor maxPool1D2 = Operator.maxPool1D(conv1D, conv1D.getShape(1));
+            MTensor maxPool1D3 = Operator.maxPool1D(maxPool1D, maxPool1D.getShape(1));
+            MTensor maxPool1D4 = Operator.maxPool1D(conv1D3, conv1D3.getShape(1));
+            Operator.flatten(maxPool1D2, 1);
+            Operator.flatten(maxPool1D3, 1);
+            Operator.flatten(maxPool1D4, 1);
+            MTensor dense2 = Operator.dense(Operator.concatenate(new MTensor[]{maxPool1D2, maxPool1D3, maxPool1D4, dense}), this.fc1Weight, this.fc1Bias);
+            Operator.relu(dense2);
+            MTensor dense3 = Operator.dense(dense2, this.fc2Weight, this.fc2Bias);
+            Operator.relu(dense3);
+            MTensor mTensor = this.finalWeights.get(Intrinsics.stringPlus(task, ".weight"));
+            MTensor mTensor2 = this.finalWeights.get(Intrinsics.stringPlus(task, ".bias"));
+            if (mTensor != null && mTensor2 != null) {
+                MTensor dense4 = Operator.dense(dense3, mTensor, mTensor2);
+                Operator.softmax(dense4);
+                return dense4;
+            }
+            return null;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final Model build(File file) {
+            Intrinsics.checkNotNullParameter(file, "file");
+            Map<String, MTensor> parse = parse(file);
+            DefaultConstructorMarker defaultConstructorMarker = null;
+            if (parse == null) {
+                return null;
+            }
+            try {
+                return new Model(parse, defaultConstructorMarker);
+            } catch (Exception unused) {
+                return null;
+            }
+        }
+
+        private final Map<String, MTensor> parse(File file) {
+            Map<String, MTensor> parseModelWeights = Utils.parseModelWeights(file);
+            if (parseModelWeights == null) {
+                return null;
+            }
+            HashMap hashMap = new HashMap();
+            Map access$getMapping$cp = Model.access$getMapping$cp();
+            for (Map.Entry<String, MTensor> entry : parseModelWeights.entrySet()) {
+                String key = entry.getKey();
+                if (access$getMapping$cp.containsKey(entry.getKey()) && (key = (String) access$getMapping$cp.get(entry.getKey())) == null) {
+                    return null;
+                }
+                hashMap.put(key, entry.getValue());
+            }
+            return hashMap;
+        }
+    }
+
+    static {
+        HashMap hashMapOf;
+        hashMapOf = MapsKt__MapsKt.hashMapOf(TuplesKt.to("embedding.weight", "embed.weight"), TuplesKt.to("dense1.weight", "fc1.weight"), TuplesKt.to("dense2.weight", "fc2.weight"), TuplesKt.to("dense3.weight", "fc3.weight"), TuplesKt.to("dense1.bias", "fc1.bias"), TuplesKt.to("dense2.bias", "fc2.bias"), TuplesKt.to("dense3.bias", "fc3.bias"));
+        mapping = hashMapOf;
+    }
+}

decompiled/sources/com/facebook/appevents/ml/ModelManager.java

@@ -0,0 +1,784 @@
+package com.facebook.appevents.ml;
+
+import android.os.Bundle;
+import android.text.TextUtils;
+import androidx.annotation.RestrictTo;
+import com.facebook.GraphRequest;
+import com.facebook.appevents.AppEventsConstants;
+import com.facebook.appevents.integrity.IntegrityManager;
+import com.facebook.appevents.internal.FileDownloadTask;
+import com.facebook.appevents.ml.ModelManager;
+import com.facebook.appevents.suggestedevents.SuggestedEventsManager;
+import com.facebook.internal.FeatureManager;
+import com.facebook.internal.Utility;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.collections.IntIterator;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY})
+/* loaded from: classes2.dex */
+public final class ModelManager {
+    private static final String ASSET_URI_KEY = "asset_uri";
+    private static final String CACHE_KEY_MODELS = "models";
+    private static final String CACHE_KEY_REQUEST_TIMESTAMP = "model_request_timestamp";
+    private static final String MODEL_ASSERT_STORE = "com.facebook.internal.MODEL_STORE";
+    public static final int MODEL_REQUEST_INTERVAL_MILLISECONDS = 259200000;
+    private static final List<String> MTML_INTEGRITY_DETECT_PREDICTION;
+    private static final List<String> MTML_SUGGESTED_EVENTS_PREDICTION;
+    private static final String MTML_USE_CASE = "MTML";
+    private static final String RULES_URI_KEY = "rules_uri";
+    private static final String THRESHOLD_KEY = "thresholds";
+    private static final String USE_CASE_KEY = "use_case";
+    private static final String VERSION_ID_KEY = "version_id";
+    public static final ModelManager INSTANCE = new ModelManager();
+    private static final Map<String, TaskHandler> taskHandlers = new ConcurrentHashMap();
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+        static {
+            int[] iArr = new int[Task.valuesCustom().length];
+            iArr[Task.MTML_APP_EVENT_PREDICTION.ordinal()] = 1;
+            iArr[Task.MTML_INTEGRITY_DETECT.ordinal()] = 2;
+            $EnumSwitchMapping$0 = iArr;
+        }
+    }
+
+    private ModelManager() {
+    }
+
+    public static final /* synthetic */ float[] access$parseJsonArray(ModelManager modelManager, JSONArray jSONArray) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            return modelManager.parseJsonArray(jSONArray);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    public enum Task {
+        MTML_INTEGRITY_DETECT,
+        MTML_APP_EVENT_PREDICTION;
+
+        public /* synthetic */ class WhenMappings {
+            public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+            static {
+                int[] iArr = new int[Task.valuesCustom().length];
+                iArr[Task.MTML_INTEGRITY_DETECT.ordinal()] = 1;
+                iArr[Task.MTML_APP_EVENT_PREDICTION.ordinal()] = 2;
+                $EnumSwitchMapping$0 = iArr;
+            }
+        }
+
+        public final String toKey() {
+            int i = WhenMappings.$EnumSwitchMapping$0[ordinal()];
+            if (i == 1) {
+                return "integrity_detect";
+            }
+            if (i == 2) {
+                return "app_event_pred";
+            }
+            throw new NoWhenBranchMatchedException();
+        }
+
+        public final String toUseCase() {
+            int i = WhenMappings.$EnumSwitchMapping$0[ordinal()];
+            if (i == 1) {
+                return "MTML_INTEGRITY_DETECT";
+            }
+            if (i == 2) {
+                return "MTML_APP_EVENT_PRED";
+            }
+            throw new NoWhenBranchMatchedException();
+        }
+
+        /* renamed from: values, reason: to resolve conflict with enum method */
+        public static Task[] valuesCustom() {
+            Task[] valuesCustom = values();
+            return (Task[]) Arrays.copyOf(valuesCustom, valuesCustom.length);
+        }
+    }
+
+    static {
+        List<String> listOf;
+        List<String> listOf2;
+        listOf = CollectionsKt__CollectionsKt.listOf((Object[]) new String[]{"other", AppEventsConstants.EVENT_NAME_COMPLETED_REGISTRATION, AppEventsConstants.EVENT_NAME_ADDED_TO_CART, AppEventsConstants.EVENT_NAME_PURCHASED, AppEventsConstants.EVENT_NAME_INITIATED_CHECKOUT});
+        MTML_SUGGESTED_EVENTS_PREDICTION = listOf;
+        listOf2 = CollectionsKt__CollectionsKt.listOf((Object[]) new String[]{"none", IntegrityManager.INTEGRITY_TYPE_ADDRESS, IntegrityManager.INTEGRITY_TYPE_HEALTH});
+        MTML_INTEGRITY_DETECT_PREDICTION = listOf2;
+    }
+
+    public static final void enable() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            Utility utility = Utility.INSTANCE;
+            Utility.runOnNonUiThread(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ModelManager.m513enable$lambda0();
+                }
+            });
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x0059 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x005a A[Catch: all -> 0x002c, Exception -> 0x007d, TryCatch #2 {Exception -> 0x007d, all -> 0x002c, blocks: (B:6:0x000d, B:8:0x001f, B:11:0x0026, B:12:0x0033, B:14:0x0043, B:16:0x0049, B:18:0x0071, B:21:0x0051, B:24:0x005a, B:25:0x002e), top: B:5:0x000d }] */
+    /* renamed from: enable$lambda-0, reason: not valid java name */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final void m513enable$lambda0() {
+        /*
+            java.lang.String r0 = "model_request_timestamp"
+            java.lang.String r1 = "models"
+            java.lang.Class<com.facebook.appevents.ml.ModelManager> r2 = com.facebook.appevents.ml.ModelManager.class
+            boolean r3 = com.facebook.internal.instrument.crashshield.CrashShieldHandler.isObjectCrashing(r2)
+            if (r3 == 0) goto Ld
+            return
+        Ld:
+            android.content.Context r3 = com.facebook.FacebookSdk.getApplicationContext()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            java.lang.String r4 = "com.facebook.internal.MODEL_STORE"
+            r5 = 0
+            android.content.SharedPreferences r3 = r3.getSharedPreferences(r4, r5)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r4 = 0
+            java.lang.String r4 = r3.getString(r1, r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L2e
+            int r5 = r4.length()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r5 != 0) goto L26
+            goto L2e
+        L26:
+            org.json.JSONObject r5 = new org.json.JSONObject     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r5.<init>(r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            goto L33
+        L2c:
+            r0 = move-exception
+            goto L7a
+        L2e:
+            org.json.JSONObject r5 = new org.json.JSONObject     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r5.<init>()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+        L33:
+            r6 = 0
+            long r6 = r3.getLong(r0, r6)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            com.facebook.internal.FeatureManager r4 = com.facebook.internal.FeatureManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            com.facebook.internal.FeatureManager$Feature r4 = com.facebook.internal.FeatureManager.Feature.ModelRequest     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            boolean r4 = com.facebook.internal.FeatureManager.isEnabled(r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L51
+            int r4 = r5.length()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 == 0) goto L51
+            com.facebook.appevents.ml.ModelManager r4 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            boolean r4 = r4.isValidTimestamp(r6)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r4 != 0) goto L71
+        L51:
+            com.facebook.appevents.ml.ModelManager r4 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            org.json.JSONObject r5 = r4.fetchModels()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            if (r5 != 0) goto L5a
+            return
+        L5a:
+            android.content.SharedPreferences$Editor r3 = r3.edit()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            java.lang.String r4 = r5.toString()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            android.content.SharedPreferences$Editor r1 = r3.putString(r1, r4)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            long r3 = java.lang.System.currentTimeMillis()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            android.content.SharedPreferences$Editor r0 = r1.putLong(r0, r3)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.apply()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+        L71:
+            com.facebook.appevents.ml.ModelManager r0 = com.facebook.appevents.ml.ModelManager.INSTANCE     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.addModels(r5)     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            r0.enableMTML()     // Catch: java.lang.Throwable -> L2c java.lang.Exception -> L7d
+            goto L7d
+        L7a:
+            com.facebook.internal.instrument.crashshield.CrashShieldHandler.handleThrowable(r0, r2)
+        L7d:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.facebook.appevents.ml.ModelManager.m513enable$lambda0():void");
+    }
+
+    private final boolean isValidTimestamp(long j) {
+        if (CrashShieldHandler.isObjectCrashing(this) || j == 0) {
+            return false;
+        }
+        try {
+            return System.currentTimeMillis() - j < 259200000;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return false;
+        }
+    }
+
+    private final void addModels(JSONObject jSONObject) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                try {
+                    TaskHandler build = TaskHandler.Companion.build(jSONObject.getJSONObject(keys.next()));
+                    if (build != null) {
+                        taskHandlers.put(build.getUseCase(), build);
+                    }
+                } catch (JSONException unused) {
+                    return;
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    private final JSONObject parseRawJsonObject(JSONObject jSONObject) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            JSONObject jSONObject2 = new JSONObject();
+            try {
+                JSONArray jSONArray = jSONObject.getJSONArray("data");
+                int length = jSONArray.length();
+                if (length <= 0) {
+                    return jSONObject2;
+                }
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    JSONObject jSONObject3 = jSONArray.getJSONObject(i);
+                    JSONObject jSONObject4 = new JSONObject();
+                    jSONObject4.put(VERSION_ID_KEY, jSONObject3.getString(VERSION_ID_KEY));
+                    jSONObject4.put(USE_CASE_KEY, jSONObject3.getString(USE_CASE_KEY));
+                    jSONObject4.put(THRESHOLD_KEY, jSONObject3.getJSONArray(THRESHOLD_KEY));
+                    jSONObject4.put(ASSET_URI_KEY, jSONObject3.getString(ASSET_URI_KEY));
+                    if (jSONObject3.has(RULES_URI_KEY)) {
+                        jSONObject4.put(RULES_URI_KEY, jSONObject3.getString(RULES_URI_KEY));
+                    }
+                    jSONObject2.put(jSONObject3.getString(USE_CASE_KEY), jSONObject4);
+                    if (i2 >= length) {
+                        return jSONObject2;
+                    }
+                    i = i2;
+                }
+            } catch (JSONException unused) {
+                return new JSONObject();
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final JSONObject fetchModels() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            String[] strArr = {USE_CASE_KEY, VERSION_ID_KEY, ASSET_URI_KEY, RULES_URI_KEY, THRESHOLD_KEY};
+            Bundle bundle = new Bundle();
+            bundle.putString(GraphRequest.FIELDS_PARAM, TextUtils.join(",", strArr));
+            GraphRequest newGraphPathRequest = GraphRequest.Companion.newGraphPathRequest(null, "app/model_asset", null);
+            newGraphPathRequest.setParameters(bundle);
+            JSONObject jSONObject = newGraphPathRequest.executeAndWait().getJSONObject();
+            if (jSONObject == null) {
+                return null;
+            }
+            return parseRawJsonObject(jSONObject);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final void enableMTML() {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return;
+        }
+        try {
+            ArrayList arrayList = new ArrayList();
+            String str = null;
+            int i = 0;
+            for (Map.Entry<String, TaskHandler> entry : taskHandlers.entrySet()) {
+                String key = entry.getKey();
+                TaskHandler value = entry.getValue();
+                if (Intrinsics.areEqual(key, Task.MTML_APP_EVENT_PREDICTION.toUseCase())) {
+                    String assetUri = value.getAssetUri();
+                    int max = Math.max(i, value.getVersionId());
+                    FeatureManager featureManager = FeatureManager.INSTANCE;
+                    if (FeatureManager.isEnabled(FeatureManager.Feature.SuggestedEvents) && isLocaleEnglish()) {
+                        arrayList.add(value.setOnPostExecute(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda1
+                            @Override // java.lang.Runnable
+                            public final void run() {
+                                ModelManager.m514enableMTML$lambda1();
+                            }
+                        }));
+                    }
+                    str = assetUri;
+                    i = max;
+                }
+                if (Intrinsics.areEqual(key, Task.MTML_INTEGRITY_DETECT.toUseCase())) {
+                    str = value.getAssetUri();
+                    i = Math.max(i, value.getVersionId());
+                    FeatureManager featureManager2 = FeatureManager.INSTANCE;
+                    if (FeatureManager.isEnabled(FeatureManager.Feature.IntelligentIntegrity)) {
+                        arrayList.add(value.setOnPostExecute(new Runnable() { // from class: com.facebook.appevents.ml.ModelManager$$ExternalSyntheticLambda2
+                            @Override // java.lang.Runnable
+                            public final void run() {
+                                ModelManager.m515enableMTML$lambda2();
+                            }
+                        }));
+                    }
+                }
+            }
+            if (str == null || i <= 0 || arrayList.isEmpty()) {
+                return;
+            }
+            TaskHandler.Companion.execute(new TaskHandler(MTML_USE_CASE, str, null, i, null), arrayList);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: enableMTML$lambda-1, reason: not valid java name */
+    public static final void m514enableMTML$lambda1() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            SuggestedEventsManager.enable();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: enableMTML$lambda-2, reason: not valid java name */
+    public static final void m515enableMTML$lambda2() {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return;
+        }
+        try {
+            IntegrityManager.enable();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+        }
+    }
+
+    private final boolean isLocaleEnglish() {
+        boolean contains$default;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return false;
+        }
+        try {
+            Locale resourceLocale = Utility.getResourceLocale();
+            if (resourceLocale != null) {
+                String language = resourceLocale.getLanguage();
+                Intrinsics.checkNotNullExpressionValue(language, "locale.language");
+                contains$default = StringsKt__StringsKt.contains$default(language, "en", false, 2, null);
+                if (!contains$default) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return false;
+        }
+    }
+
+    private final float[] parseJsonArray(JSONArray jSONArray) {
+        if (CrashShieldHandler.isObjectCrashing(this) || jSONArray == null) {
+            return null;
+        }
+        try {
+            float[] fArr = new float[jSONArray.length()];
+            int length = jSONArray.length();
+            if (length > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    try {
+                        String string = jSONArray.getString(i);
+                        Intrinsics.checkNotNullExpressionValue(string, "jsonArray.getString(i)");
+                        fArr[i] = Float.parseFloat(string);
+                    } catch (JSONException unused) {
+                    }
+                    if (i2 >= length) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            return fArr;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final File getRuleFile(Task task) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(task, "task");
+            TaskHandler taskHandler = taskHandlers.get(task.toUseCase());
+            if (taskHandler == null) {
+                return null;
+            }
+            return taskHandler.getRuleFile();
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    public static final String[] predict(Task task, float[][] denses, String[] texts) {
+        if (CrashShieldHandler.isObjectCrashing(ModelManager.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(task, "task");
+            Intrinsics.checkNotNullParameter(denses, "denses");
+            Intrinsics.checkNotNullParameter(texts, "texts");
+            TaskHandler taskHandler = taskHandlers.get(task.toUseCase());
+            Model model = taskHandler == null ? null : taskHandler.getModel();
+            if (model == null) {
+                return null;
+            }
+            float[] thresholds = taskHandler.getThresholds();
+            int length = texts.length;
+            int length2 = denses[0].length;
+            MTensor mTensor = new MTensor(new int[]{length, length2});
+            if (length > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    System.arraycopy(denses[i], 0, mTensor.getData(), i * length2, length2);
+                    if (i2 >= length) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            MTensor predictOnMTML = model.predictOnMTML(mTensor, texts, task.toKey());
+            if (predictOnMTML != null && thresholds != null && predictOnMTML.getData().length != 0 && thresholds.length != 0) {
+                int i3 = WhenMappings.$EnumSwitchMapping$0[task.ordinal()];
+                if (i3 == 1) {
+                    return INSTANCE.processSuggestedEventResult(predictOnMTML, thresholds);
+                }
+                if (i3 == 2) {
+                    return INSTANCE.processIntegrityDetectionResult(predictOnMTML, thresholds);
+                }
+                throw new NoWhenBranchMatchedException();
+            }
+            return null;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, ModelManager.class);
+            return null;
+        }
+    }
+
+    private final String[] processSuggestedEventResult(MTensor mTensor, float[] fArr) {
+        IntRange until;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            int shape = mTensor.getShape(0);
+            int shape2 = mTensor.getShape(1);
+            float[] data = mTensor.getData();
+            if (shape2 != fArr.length) {
+                return null;
+            }
+            until = RangesKt___RangesKt.until(0, shape);
+            ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(until, 10));
+            Iterator it = until.iterator();
+            while (it.hasNext()) {
+                int nextInt = ((IntIterator) it).nextInt();
+                String str = "other";
+                int length = fArr.length;
+                int i = 0;
+                int i2 = 0;
+                while (i < length) {
+                    int i3 = i2 + 1;
+                    if (data[(nextInt * shape2) + i2] >= fArr[i]) {
+                        str = MTML_SUGGESTED_EVENTS_PREDICTION.get(i2);
+                    }
+                    i++;
+                    i2 = i3;
+                }
+                arrayList.add(str);
+            }
+            Object[] array = arrayList.toArray(new String[0]);
+            if (array != null) {
+                return (String[]) array;
+            }
+            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    private final String[] processIntegrityDetectionResult(MTensor mTensor, float[] fArr) {
+        IntRange until;
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            int shape = mTensor.getShape(0);
+            int shape2 = mTensor.getShape(1);
+            float[] data = mTensor.getData();
+            if (shape2 != fArr.length) {
+                return null;
+            }
+            until = RangesKt___RangesKt.until(0, shape);
+            ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(until, 10));
+            Iterator it = until.iterator();
+            while (it.hasNext()) {
+                int nextInt = ((IntIterator) it).nextInt();
+                String str = "none";
+                int length = fArr.length;
+                int i = 0;
+                int i2 = 0;
+                while (i < length) {
+                    int i3 = i2 + 1;
+                    if (data[(nextInt * shape2) + i2] >= fArr[i]) {
+                        str = MTML_INTEGRITY_DETECT_PREDICTION.get(i2);
+                    }
+                    i++;
+                    i2 = i3;
+                }
+                arrayList.add(str);
+            }
+            Object[] array = arrayList.toArray(new String[0]);
+            if (array != null) {
+                return (String[]) array;
+            }
+            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final class TaskHandler {
+        public static final Companion Companion = new Companion(null);
+        private String assetUri;
+        private Model model;
+        private Runnable onPostExecute;
+        private File ruleFile;
+        private String ruleUri;
+        private float[] thresholds;
+        private String useCase;
+        private int versionId;
+
+        public final String getAssetUri() {
+            return this.assetUri;
+        }
+
+        public final Model getModel() {
+            return this.model;
+        }
+
+        public final File getRuleFile() {
+            return this.ruleFile;
+        }
+
+        public final String getRuleUri() {
+            return this.ruleUri;
+        }
+
+        public final float[] getThresholds() {
+            return this.thresholds;
+        }
+
+        public final String getUseCase() {
+            return this.useCase;
+        }
+
+        public final int getVersionId() {
+            return this.versionId;
+        }
+
+        public final void setAssetUri(String str) {
+            Intrinsics.checkNotNullParameter(str, "<set-?>");
+            this.assetUri = str;
+        }
+
+        public final void setModel(Model model) {
+            this.model = model;
+        }
+
+        public final TaskHandler setOnPostExecute(Runnable runnable) {
+            this.onPostExecute = runnable;
+            return this;
+        }
+
+        public final void setRuleFile(File file) {
+            this.ruleFile = file;
+        }
+
+        public final void setRuleUri(String str) {
+            this.ruleUri = str;
+        }
+
+        public final void setThresholds(float[] fArr) {
+            this.thresholds = fArr;
+        }
+
+        public final void setUseCase(String str) {
+            Intrinsics.checkNotNullParameter(str, "<set-?>");
+            this.useCase = str;
+        }
+
+        public final void setVersionId(int i) {
+            this.versionId = i;
+        }
+
+        public TaskHandler(String useCase, String assetUri, String str, int i, float[] fArr) {
+            Intrinsics.checkNotNullParameter(useCase, "useCase");
+            Intrinsics.checkNotNullParameter(assetUri, "assetUri");
+            this.useCase = useCase;
+            this.assetUri = assetUri;
+            this.ruleUri = str;
+            this.versionId = i;
+            this.thresholds = fArr;
+        }
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+
+            public final TaskHandler build(JSONObject jSONObject) {
+                if (jSONObject == null) {
+                    return null;
+                }
+                try {
+                    String useCase = jSONObject.getString(ModelManager.USE_CASE_KEY);
+                    String assetUri = jSONObject.getString(ModelManager.ASSET_URI_KEY);
+                    String optString = jSONObject.optString(ModelManager.RULES_URI_KEY, null);
+                    int i = jSONObject.getInt(ModelManager.VERSION_ID_KEY);
+                    float[] access$parseJsonArray = ModelManager.access$parseJsonArray(ModelManager.INSTANCE, jSONObject.getJSONArray(ModelManager.THRESHOLD_KEY));
+                    Intrinsics.checkNotNullExpressionValue(useCase, "useCase");
+                    Intrinsics.checkNotNullExpressionValue(assetUri, "assetUri");
+                    return new TaskHandler(useCase, assetUri, optString, i, access$parseJsonArray);
+                } catch (Exception unused) {
+                    return null;
+                }
+            }
+
+            public final void execute(TaskHandler handler) {
+                Intrinsics.checkNotNullParameter(handler, "handler");
+                execute(handler, CollectionsKt__CollectionsJVMKt.listOf(handler));
+            }
+
+            public final void execute(TaskHandler master, final List<TaskHandler> slaves) {
+                Intrinsics.checkNotNullParameter(master, "master");
+                Intrinsics.checkNotNullParameter(slaves, "slaves");
+                deleteOldFiles(master.getUseCase(), master.getVersionId());
+                download(master.getAssetUri(), master.getUseCase() + '_' + master.getVersionId(), new FileDownloadTask.Callback() { // from class: com.facebook.appevents.ml.ModelManager$TaskHandler$Companion$$ExternalSyntheticLambda0
+                    @Override // com.facebook.appevents.internal.FileDownloadTask.Callback
+                    public final void onComplete(File file) {
+                        ModelManager.TaskHandler.Companion.m517execute$lambda1(slaves, file);
+                    }
+                });
+            }
+
+            /* JADX INFO: Access modifiers changed from: private */
+            /* renamed from: execute$lambda-1, reason: not valid java name */
+            public static final void m517execute$lambda1(List slaves, File file) {
+                Intrinsics.checkNotNullParameter(slaves, "$slaves");
+                Intrinsics.checkNotNullParameter(file, "file");
+                final Model build = Model.Companion.build(file);
+                if (build != null) {
+                    Iterator it = slaves.iterator();
+                    while (it.hasNext()) {
+                        final TaskHandler taskHandler = (TaskHandler) it.next();
+                        TaskHandler.Companion.download(taskHandler.getRuleUri(), taskHandler.getUseCase() + '_' + taskHandler.getVersionId() + "_rule", new FileDownloadTask.Callback() { // from class: com.facebook.appevents.ml.ModelManager$TaskHandler$Companion$$ExternalSyntheticLambda1
+                            @Override // com.facebook.appevents.internal.FileDownloadTask.Callback
+                            public final void onComplete(File file2) {
+                                ModelManager.TaskHandler.Companion.m518execute$lambda1$lambda0(ModelManager.TaskHandler.this, build, file2);
+                            }
+                        });
+                    }
+                }
+            }
+
+            /* JADX INFO: Access modifiers changed from: private */
+            /* renamed from: execute$lambda-1$lambda-0, reason: not valid java name */
+            public static final void m518execute$lambda1$lambda0(TaskHandler slave, Model model, File file) {
+                Intrinsics.checkNotNullParameter(slave, "$slave");
+                Intrinsics.checkNotNullParameter(file, "file");
+                slave.setModel(model);
+                slave.setRuleFile(file);
+                Runnable runnable = slave.onPostExecute;
+                if (runnable == null) {
+                    return;
+                }
+                runnable.run();
+            }
+
+            private final void deleteOldFiles(String str, int i) {
+                File[] listFiles;
+                File mlDir = Utils.getMlDir();
+                if (mlDir == null || (listFiles = mlDir.listFiles()) == null || listFiles.length == 0) {
+                    return;
+                }
+                String str2 = str + '_' + i;
+                int length = listFiles.length;
+                int i2 = 0;
+                while (i2 < length) {
+                    File file = listFiles[i2];
+                    i2++;
+                    String name = file.getName();
+                    Intrinsics.checkNotNullExpressionValue(name, "name");
+                    if (StringsKt__StringsJVMKt.startsWith$default(name, str, false, 2, null) && !StringsKt__StringsJVMKt.startsWith$default(name, str2, false, 2, null)) {
+                        file.delete();
+                    }
+                }
+            }
+
+            private final void download(String str, String str2, FileDownloadTask.Callback callback) {
+                File file = new File(Utils.getMlDir(), str2);
+                if (str == null || file.exists()) {
+                    callback.onComplete(file);
+                } else {
+                    new FileDownloadTask(str, file, callback).execute(new String[0]);
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/facebook/appevents/ml/Operator.java

@@ -0,0 +1,685 @@
+package com.facebook.appevents.ml;
+
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes2.dex */
+public final class Operator {
+    public static final Operator INSTANCE = new Operator();
+
+    private Operator() {
+    }
+
+    public static final void addmv(MTensor x, MTensor b) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            Intrinsics.checkNotNullParameter(b, "b");
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            int shape3 = x.getShape(2);
+            float[] data = x.getData();
+            float[] data2 = b.getData();
+            if (shape <= 0) {
+                return;
+            }
+            int i = 0;
+            while (true) {
+                int i2 = i + 1;
+                if (shape2 > 0) {
+                    int i3 = 0;
+                    while (true) {
+                        int i4 = i3 + 1;
+                        if (shape3 > 0) {
+                            int i5 = 0;
+                            while (true) {
+                                int i6 = i5 + 1;
+                                int i7 = (i * shape2 * shape3) + (i3 * shape3) + i5;
+                                data[i7] = data[i7] + data2[i5];
+                                if (i6 >= shape3) {
+                                    break;
+                                } else {
+                                    i5 = i6;
+                                }
+                            }
+                        }
+                        if (i4 >= shape2) {
+                            break;
+                        } else {
+                            i3 = i4;
+                        }
+                    }
+                }
+                if (i2 >= shape) {
+                    return;
+                } else {
+                    i = i2;
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+        }
+    }
+
+    public static final MTensor mul(MTensor x, MTensor w) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            Intrinsics.checkNotNullParameter(w, "w");
+            int i = 0;
+            int shape = x.getShape(0);
+            int shape2 = w.getShape(0);
+            int shape3 = w.getShape(1);
+            MTensor mTensor = new MTensor(new int[]{shape, shape3});
+            float[] data = x.getData();
+            float[] data2 = w.getData();
+            float[] data3 = mTensor.getData();
+            if (shape > 0) {
+                int i2 = 0;
+                while (true) {
+                    int i3 = i2 + 1;
+                    if (shape3 > 0) {
+                        int i4 = i;
+                        while (true) {
+                            int i5 = i4 + 1;
+                            int i6 = (i2 * shape3) + i4;
+                            data3[i6] = 0.0f;
+                            if (shape2 > 0) {
+                                int i7 = i;
+                                while (true) {
+                                    int i8 = i7 + 1;
+                                    data3[i6] = data3[i6] + (data[(i2 * shape2) + i7] * data2[(i7 * shape3) + i4]);
+                                    if (i8 >= shape2) {
+                                        break;
+                                    }
+                                    i7 = i8;
+                                }
+                            }
+                            if (i5 >= shape3) {
+                                break;
+                            }
+                            i4 = i5;
+                            i = 0;
+                        }
+                    }
+                    if (i3 >= shape) {
+                        break;
+                    }
+                    i2 = i3;
+                    i = 0;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final void relu(MTensor x) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            float[] data = x.getData();
+            int length = data.length - 1;
+            if (length < 0) {
+                return;
+            }
+            int i = 0;
+            while (true) {
+                int i2 = i + 1;
+                if (data[i] < 0.0f) {
+                    data[i] = 0.0f;
+                }
+                if (i2 > length) {
+                    return;
+                } else {
+                    i = i2;
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+        }
+    }
+
+    public static final void flatten(MTensor x, int i) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            if (i >= x.getShapeSize()) {
+                return;
+            }
+            int shapeSize = x.getShapeSize();
+            int i2 = 1;
+            if (i < shapeSize) {
+                int i3 = i;
+                while (true) {
+                    int i4 = i3 + 1;
+                    i2 *= x.getShape(i3);
+                    if (i4 >= shapeSize) {
+                        break;
+                    } else {
+                        i3 = i4;
+                    }
+                }
+            }
+            int[] iArr = new int[i + 1];
+            if (i > 0) {
+                int i5 = 0;
+                while (true) {
+                    int i6 = i5 + 1;
+                    iArr[i5] = x.getShape(i5);
+                    if (i6 >= i) {
+                        break;
+                    } else {
+                        i5 = i6;
+                    }
+                }
+            }
+            iArr[i] = i2;
+            x.reshape(iArr);
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+        }
+    }
+
+    public static final MTensor concatenate(MTensor[] tensors) {
+        int i;
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(tensors, "tensors");
+            int i2 = 0;
+            int shape = tensors[0].getShape(0);
+            int length = tensors.length - 1;
+            if (length >= 0) {
+                int i3 = 0;
+                i = 0;
+                while (true) {
+                    int i4 = i3 + 1;
+                    i += tensors[i3].getShape(1);
+                    if (i4 > length) {
+                        break;
+                    }
+                    i3 = i4;
+                }
+            } else {
+                i = 0;
+            }
+            MTensor mTensor = new MTensor(new int[]{shape, i});
+            float[] data = mTensor.getData();
+            if (shape > 0) {
+                int i5 = 0;
+                while (true) {
+                    int i6 = i5 + 1;
+                    int i7 = i5 * i;
+                    int length2 = tensors.length - 1;
+                    if (length2 >= 0) {
+                        int i8 = i2;
+                        while (true) {
+                            int i9 = i8 + 1;
+                            float[] data2 = tensors[i8].getData();
+                            int shape2 = tensors[i8].getShape(1);
+                            System.arraycopy(data2, i5 * shape2, data, i7, shape2);
+                            i7 += shape2;
+                            if (i9 > length2) {
+                                break;
+                            }
+                            i8 = i9;
+                        }
+                    }
+                    if (i6 >= shape) {
+                        break;
+                    }
+                    i5 = i6;
+                    i2 = 0;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final void softmax(MTensor x) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            int i = 0;
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            float[] data = x.getData();
+            if (shape <= 0) {
+                return;
+            }
+            while (true) {
+                int i2 = i + 1;
+                int i3 = i * shape2;
+                int i4 = i3 + shape2;
+                float f = Float.MIN_VALUE;
+                if (i3 < i4) {
+                    int i5 = i3;
+                    while (true) {
+                        int i6 = i5 + 1;
+                        float f2 = data[i5];
+                        if (f2 > f) {
+                            f = f2;
+                        }
+                        if (i6 >= i4) {
+                            break;
+                        } else {
+                            i5 = i6;
+                        }
+                    }
+                }
+                float f3 = 0.0f;
+                if (i3 < i4) {
+                    int i7 = i3;
+                    while (true) {
+                        int i8 = i7 + 1;
+                        float exp = (float) Math.exp(data[i7] - f);
+                        data[i7] = exp;
+                        f3 += exp;
+                        if (i8 >= i4) {
+                            break;
+                        } else {
+                            i7 = i8;
+                        }
+                    }
+                }
+                if (i3 < i4) {
+                    while (true) {
+                        int i9 = i3 + 1;
+                        data[i3] = data[i3] / f3;
+                        if (i9 >= i4) {
+                            break;
+                        } else {
+                            i3 = i9;
+                        }
+                    }
+                }
+                if (i2 >= shape) {
+                    return;
+                } else {
+                    i = i2;
+                }
+            }
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+        }
+    }
+
+    public static final MTensor dense(MTensor x, MTensor w, MTensor b) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            Intrinsics.checkNotNullParameter(w, "w");
+            Intrinsics.checkNotNullParameter(b, "b");
+            int shape = x.getShape(0);
+            int shape2 = b.getShape(0);
+            MTensor mul = mul(x, w);
+            float[] data = b.getData();
+            float[] data2 = mul.getData();
+            if (shape > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    if (shape2 > 0) {
+                        int i3 = 0;
+                        while (true) {
+                            int i4 = i3 + 1;
+                            int i5 = (i * shape2) + i3;
+                            data2[i5] = data2[i5] + data[i3];
+                            if (i4 >= shape2) {
+                                break;
+                            }
+                            i3 = i4;
+                        }
+                    }
+                    if (i2 >= shape) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            return mul;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final MTensor embedding(String[] texts, int i, MTensor w) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(texts, "texts");
+            Intrinsics.checkNotNullParameter(w, "w");
+            int length = texts.length;
+            int shape = w.getShape(1);
+            MTensor mTensor = new MTensor(new int[]{length, i, shape});
+            float[] data = mTensor.getData();
+            float[] data2 = w.getData();
+            if (length > 0) {
+                int i2 = 0;
+                while (true) {
+                    int i3 = i2 + 1;
+                    int[] vectorize = Utils.INSTANCE.vectorize(texts[i2], i);
+                    if (i > 0) {
+                        int i4 = 0;
+                        while (true) {
+                            int i5 = i4 + 1;
+                            System.arraycopy(data2, vectorize[i4] * shape, data, (shape * i * i2) + (i4 * shape), shape);
+                            if (i5 >= i) {
+                                break;
+                            }
+                            i4 = i5;
+                        }
+                    }
+                    if (i3 >= length) {
+                        break;
+                    }
+                    i2 = i3;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final MTensor transpose2D(MTensor x) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            MTensor mTensor = new MTensor(new int[]{shape2, shape});
+            float[] data = x.getData();
+            float[] data2 = mTensor.getData();
+            if (shape > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    if (shape2 > 0) {
+                        int i3 = 0;
+                        while (true) {
+                            int i4 = i3 + 1;
+                            data2[(i3 * shape) + i] = data[(i * shape2) + i3];
+                            if (i4 >= shape2) {
+                                break;
+                            }
+                            i3 = i4;
+                        }
+                    }
+                    if (i2 >= shape) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final MTensor transpose3D(MTensor x) {
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            int shape3 = x.getShape(2);
+            MTensor mTensor = new MTensor(new int[]{shape3, shape2, shape});
+            float[] data = x.getData();
+            float[] data2 = mTensor.getData();
+            if (shape > 0) {
+                int i = 0;
+                while (true) {
+                    int i2 = i + 1;
+                    if (shape2 > 0) {
+                        int i3 = 0;
+                        while (true) {
+                            int i4 = i3 + 1;
+                            if (shape3 > 0) {
+                                int i5 = 0;
+                                while (true) {
+                                    int i6 = i5 + 1;
+                                    data2[(i5 * shape * shape2) + (i3 * shape) + i] = data[(i * shape2 * shape3) + (i3 * shape3) + i5];
+                                    if (i6 >= shape3) {
+                                        break;
+                                    }
+                                    i5 = i6;
+                                }
+                            }
+                            if (i4 >= shape2) {
+                                break;
+                            }
+                            i3 = i4;
+                        }
+                    }
+                    if (i2 >= shape) {
+                        break;
+                    }
+                    i = i2;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+
+    public static final MTensor conv1D(MTensor x, MTensor w) {
+        Class<Operator> cls;
+        MTensor mTensor;
+        Class<Operator> cls2 = Operator.class;
+        if (CrashShieldHandler.isObjectCrashing(cls2)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            Intrinsics.checkNotNullParameter(w, "w");
+            int i = 0;
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            int shape3 = x.getShape(2);
+            int shape4 = w.getShape(0);
+            int i2 = (shape2 - shape4) + 1;
+            int shape5 = w.getShape(2);
+            MTensor mTensor2 = new MTensor(new int[]{shape, i2, shape5});
+            float[] data = x.getData();
+            float[] data2 = mTensor2.getData();
+            float[] data3 = w.getData();
+            if (shape <= 0) {
+                return mTensor2;
+            }
+            int i3 = 0;
+            while (true) {
+                int i4 = i3 + 1;
+                if (shape5 > 0) {
+                    int i5 = i;
+                    while (true) {
+                        int i6 = i5 + 1;
+                        if (i2 > 0) {
+                            int i7 = 0;
+                            while (true) {
+                                int i8 = i7 + 1;
+                                float f = 0.0f;
+                                if (shape4 > 0) {
+                                    int i9 = 0;
+                                    while (true) {
+                                        cls = cls2;
+                                        int i10 = i9 + 1;
+                                        if (shape3 > 0) {
+                                            int i11 = 0;
+                                            while (true) {
+                                                mTensor = mTensor2;
+                                                int i12 = i11 + 1;
+                                                try {
+                                                    f += data[(shape2 * shape3 * i3) + ((i9 + i7) * shape3) + i11] * data3[(((i9 * shape3) + i11) * shape5) + i5];
+                                                    if (i12 >= shape3) {
+                                                        break;
+                                                    }
+                                                    i11 = i12;
+                                                    mTensor2 = mTensor;
+                                                } catch (Throwable th) {
+                                                    th = th;
+                                                    CrashShieldHandler.handleThrowable(th, cls);
+                                                    return null;
+                                                }
+                                            }
+                                        } else {
+                                            mTensor = mTensor2;
+                                        }
+                                        if (i10 >= shape4) {
+                                            break;
+                                        }
+                                        i9 = i10;
+                                        cls2 = cls;
+                                        mTensor2 = mTensor;
+                                    }
+                                } else {
+                                    cls = cls2;
+                                    mTensor = mTensor2;
+                                }
+                                data2[(i2 * shape5 * i3) + (i7 * shape5) + i5] = f;
+                                if (i8 >= i2) {
+                                    break;
+                                }
+                                i7 = i8;
+                                cls2 = cls;
+                                mTensor2 = mTensor;
+                            }
+                        } else {
+                            cls = cls2;
+                            mTensor = mTensor2;
+                        }
+                        if (i6 >= shape5) {
+                            break;
+                        }
+                        i5 = i6;
+                        cls2 = cls;
+                        mTensor2 = mTensor;
+                    }
+                } else {
+                    cls = cls2;
+                    mTensor = mTensor2;
+                }
+                if (i4 >= shape) {
+                    return mTensor;
+                }
+                i3 = i4;
+                cls2 = cls;
+                mTensor2 = mTensor;
+                i = 0;
+            }
+        } catch (Throwable th2) {
+            th = th2;
+            cls = cls2;
+        }
+    }
+
+    public static final MTensor maxPool1D(MTensor x, int i) {
+        int i2;
+        if (CrashShieldHandler.isObjectCrashing(Operator.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(x, "x");
+            int i3 = 0;
+            int shape = x.getShape(0);
+            int shape2 = x.getShape(1);
+            int shape3 = x.getShape(2);
+            int i4 = (shape2 - i) + 1;
+            MTensor mTensor = new MTensor(new int[]{shape, i4, shape3});
+            float[] data = x.getData();
+            float[] data2 = mTensor.getData();
+            if (shape > 0) {
+                int i5 = 0;
+                while (true) {
+                    int i6 = i5 + 1;
+                    if (shape3 > 0) {
+                        int i7 = i3;
+                        while (true) {
+                            int i8 = i7 + 1;
+                            if (i4 > 0) {
+                                int i9 = i3;
+                                while (true) {
+                                    int i10 = i9 + 1;
+                                    int i11 = i9 * shape3;
+                                    int i12 = (i5 * i4 * shape3) + i11 + i7;
+                                    int i13 = (i5 * shape2 * shape3) + i11 + i7;
+                                    data2[i12] = Float.MIN_VALUE;
+                                    if (i > 0) {
+                                        int i14 = 0;
+                                        while (true) {
+                                            int i15 = i14 + 1;
+                                            i2 = shape2;
+                                            data2[i12] = Math.max(data2[i12], data[i13 + (i14 * shape3)]);
+                                            if (i15 >= i) {
+                                                break;
+                                            }
+                                            i14 = i15;
+                                            shape2 = i2;
+                                        }
+                                    } else {
+                                        i2 = shape2;
+                                    }
+                                    if (i10 >= i4) {
+                                        break;
+                                    }
+                                    i9 = i10;
+                                    shape2 = i2;
+                                }
+                            } else {
+                                i2 = shape2;
+                            }
+                            if (i8 >= shape3) {
+                                break;
+                            }
+                            i7 = i8;
+                            shape2 = i2;
+                            i3 = 0;
+                        }
+                    } else {
+                        i2 = shape2;
+                    }
+                    if (i6 >= shape) {
+                        break;
+                    }
+                    i5 = i6;
+                    shape2 = i2;
+                    i3 = 0;
+                }
+            }
+            return mTensor;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Operator.class);
+            return null;
+        }
+    }
+}

decompiled/sources/com/facebook/appevents/ml/Utils.java

@@ -0,0 +1,222 @@
+package com.facebook.appevents.ml;
+
+import android.text.TextUtils;
+import androidx.annotation.RestrictTo;
+import com.facebook.FacebookSdk;
+import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+import kotlin.collections.ArraysKt___ArraysJvmKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Charsets;
+import kotlin.text.Regex;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes2.dex */
+public final class Utils {
+    private static final String DIR_NAME = "facebook_ml/";
+    public static final Utils INSTANCE = new Utils();
+
+    private Utils() {
+    }
+
+    public final int[] vectorize(String texts, int i) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(texts, "texts");
+            int[] iArr = new int[i];
+            String normalizeString = normalizeString(texts);
+            Charset forName = Charset.forName("UTF-8");
+            Intrinsics.checkNotNullExpressionValue(forName, "forName(\"UTF-8\")");
+            if (normalizeString == null) {
+                throw new NullPointerException("null cannot be cast to non-null type java.lang.String");
+            }
+            byte[] bytes = normalizeString.getBytes(forName);
+            Intrinsics.checkNotNullExpressionValue(bytes, "(this as java.lang.String).getBytes(charset)");
+            if (i > 0) {
+                int i2 = 0;
+                while (true) {
+                    int i3 = i2 + 1;
+                    if (i2 < bytes.length) {
+                        iArr[i2] = bytes[i2] & 255;
+                    } else {
+                        iArr[i2] = 0;
+                    }
+                    if (i3 >= i) {
+                        break;
+                    }
+                    i2 = i3;
+                }
+            }
+            return iArr;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+
+    public static final File getMlDir() {
+        if (CrashShieldHandler.isObjectCrashing(Utils.class)) {
+            return null;
+        }
+        try {
+            File file = new File(FacebookSdk.getApplicationContext().getFilesDir(), DIR_NAME);
+            if (!file.exists()) {
+                if (!file.mkdirs()) {
+                    return null;
+                }
+            }
+            return file;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, Utils.class);
+            return null;
+        }
+    }
+
+    public static final Map<String, MTensor> parseModelWeights(File file) {
+        Map<String, MTensor> map;
+        Map<String, MTensor> map2 = null;
+        if (CrashShieldHandler.isObjectCrashing(Utils.class)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(file, "file");
+        } catch (Throwable th) {
+            th = th;
+            map = null;
+        }
+        try {
+            try {
+                FileInputStream fileInputStream = new FileInputStream(file);
+                int available = fileInputStream.available();
+                DataInputStream dataInputStream = new DataInputStream(fileInputStream);
+                byte[] bArr = new byte[available];
+                dataInputStream.readFully(bArr);
+                dataInputStream.close();
+                if (available < 4) {
+                    return null;
+                }
+                int i = 0;
+                ByteBuffer wrap = ByteBuffer.wrap(bArr, 0, 4);
+                wrap.order(ByteOrder.LITTLE_ENDIAN);
+                int i2 = wrap.getInt();
+                int i3 = i2 + 4;
+                if (available < i3) {
+                    return null;
+                }
+                JSONObject jSONObject = new JSONObject(new String(bArr, 4, i2, Charsets.UTF_8));
+                JSONArray names = jSONObject.names();
+                int length = names.length();
+                String[] strArr = new String[length];
+                int i4 = length - 1;
+                if (i4 >= 0) {
+                    int i5 = 0;
+                    while (true) {
+                        int i6 = i5 + 1;
+                        strArr[i5] = names.getString(i5);
+                        if (i6 > i4) {
+                            break;
+                        }
+                        i5 = i6;
+                    }
+                }
+                ArraysKt___ArraysJvmKt.sort(strArr);
+                HashMap hashMap = new HashMap();
+                int i7 = 0;
+                while (i7 < length) {
+                    String str = strArr[i7];
+                    i7++;
+                    if (str != null) {
+                        JSONArray jSONArray = jSONObject.getJSONArray(str);
+                        int length2 = jSONArray.length();
+                        int[] iArr = new int[length2];
+                        int i8 = length2 - 1;
+                        int i9 = 1;
+                        if (i8 >= 0) {
+                            while (true) {
+                                int i10 = i + 1;
+                                try {
+                                    int i11 = jSONArray.getInt(i);
+                                    iArr[i] = i11;
+                                    i9 *= i11;
+                                    if (i10 > i8) {
+                                        break;
+                                    }
+                                    i = i10;
+                                } catch (Exception unused) {
+                                    return null;
+                                }
+                            }
+                        }
+                        int i12 = i9 * 4;
+                        int i13 = i3 + i12;
+                        if (i13 > available) {
+                            return null;
+                        }
+                        ByteBuffer wrap2 = ByteBuffer.wrap(bArr, i3, i12);
+                        wrap2.order(ByteOrder.LITTLE_ENDIAN);
+                        MTensor mTensor = new MTensor(iArr);
+                        wrap2.asFloatBuffer().get(mTensor.getData(), 0, i9);
+                        hashMap.put(str, mTensor);
+                        i3 = i13;
+                        i = 0;
+                        map2 = null;
+                    }
+                }
+                return hashMap;
+            } catch (Exception unused2) {
+                return map2;
+            }
+        } catch (Throwable th2) {
+            th = th2;
+            map = null;
+            CrashShieldHandler.handleThrowable(th, Utils.class);
+            return map;
+        }
+    }
+
+    public final String normalizeString(String str) {
+        if (CrashShieldHandler.isObjectCrashing(this)) {
+            return null;
+        }
+        try {
+            Intrinsics.checkNotNullParameter(str, "str");
+            int length = str.length() - 1;
+            int i = 0;
+            boolean z = false;
+            while (i <= length) {
+                boolean z2 = Intrinsics.compare((int) str.charAt(!z ? i : length), 32) <= 0;
+                if (z) {
+                    if (!z2) {
+                        break;
+                    }
+                    length--;
+                } else if (z2) {
+                    i++;
+                } else {
+                    z = true;
+                }
+            }
+            Object[] array = new Regex("\\s+").split(str.subSequence(i, length + 1).toString(), 0).toArray(new String[0]);
+            if (array == null) {
+                throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
+            }
+            String join = TextUtils.join(" ", (String[]) array);
+            Intrinsics.checkNotNullExpressionValue(join, "join(\" \", strArray)");
+            return join;
+        } catch (Throwable th) {
+            CrashShieldHandler.handleThrowable(th, this);
+            return null;
+        }
+    }
+}