Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/x0/C0656a.java

@@ -0,0 +1,41 @@
+package x0;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteCursor;
+import android.database.sqlite.SQLiteCursorDriver;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQuery;
+import kotlin.jvm.internal.Intrinsics;
+import w0.InterfaceC0648d;
+
+/* renamed from: x0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final /* synthetic */ class C0656a implements SQLiteDatabase.CursorFactory {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f8852a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ Object f8853b;
+
+    public /* synthetic */ C0656a(Object obj, int i) {
+        this.f8852a = i;
+        this.f8853b = obj;
+    }
+
+    @Override // android.database.sqlite.SQLiteDatabase.CursorFactory
+    public final Cursor newCursor(SQLiteDatabase sQLiteDatabase, SQLiteCursorDriver sQLiteCursorDriver, String str, SQLiteQuery sQLiteQuery) {
+        switch (this.f8852a) {
+            case 0:
+                InterfaceC0648d query = (InterfaceC0648d) this.f8853b;
+                Intrinsics.checkNotNullParameter(query, "$query");
+                Intrinsics.checkNotNull(sQLiteQuery);
+                query.s(new j(sQLiteQuery));
+                return new SQLiteCursor(sQLiteCursorDriver, str, sQLiteQuery);
+            default:
+                b tmp0 = (b) this.f8853b;
+                Intrinsics.checkNotNullParameter(tmp0, "$tmp0");
+                return (Cursor) tmp0.invoke(sQLiteDatabase, sQLiteCursorDriver, str, sQLiteQuery);
+        }
+    }
+}

apk_decompiled/sources/x0/b.java

@@ -0,0 +1,30 @@
+package x0;
+
+import android.database.sqlite.SQLiteCursor;
+import android.database.sqlite.SQLiteCursorDriver;
+import android.database.sqlite.SQLiteQuery;
+import kotlin.jvm.functions.Function4;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import w0.InterfaceC0648d;
+
+/* loaded from: classes.dex */
+public final class b extends Lambda implements Function4 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ InterfaceC0648d f8854a;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(InterfaceC0648d interfaceC0648d) {
+        super(4);
+        this.f8854a = interfaceC0648d;
+    }
+
+    @Override // kotlin.jvm.functions.Function4
+    public final Object invoke(Object obj, Object obj2, Object obj3, Object obj4) {
+        SQLiteQuery sQLiteQuery = (SQLiteQuery) obj4;
+        Intrinsics.checkNotNull(sQLiteQuery);
+        this.f8854a.s(new j(sQLiteQuery));
+        return new SQLiteCursor((SQLiteCursorDriver) obj2, (String) obj3, sQLiteQuery);
+    }
+}

apk_decompiled/sources/x0/c.java

@@ -0,0 +1,113 @@
+package x0;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.os.CancellationSignal;
+import kotlin.jvm.internal.Intrinsics;
+import w0.InterfaceC0645a;
+import w0.InterfaceC0648d;
+import w0.InterfaceC0649e;
+
+/* loaded from: classes.dex */
+public final class c implements InterfaceC0645a {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final String[] f8855b = new String[0];
+
+    /* renamed from: a, reason: collision with root package name */
+    public final SQLiteDatabase f8856a;
+
+    public c(SQLiteDatabase delegate) {
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f8856a = delegate;
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final boolean B() {
+        return this.f8856a.inTransaction();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final boolean G() {
+        SQLiteDatabase sQLiteDatabase = this.f8856a;
+        Intrinsics.checkNotNullParameter(sQLiteDatabase, "sQLiteDatabase");
+        return sQLiteDatabase.isWriteAheadLoggingEnabled();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final void J() {
+        this.f8856a.setTransactionSuccessful();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final void K() {
+        this.f8856a.beginTransactionNonExclusive();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final Cursor V(String query) {
+        Intrinsics.checkNotNullParameter(query, "query");
+        return p(new F.i(query));
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final void b() {
+        this.f8856a.endTransaction();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final void c() {
+        this.f8856a.beginTransaction();
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        this.f8856a.close();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final void i(String sql) {
+        Intrinsics.checkNotNullParameter(sql, "sql");
+        this.f8856a.execSQL(sql);
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final boolean isOpen() {
+        return this.f8856a.isOpen();
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final Cursor j(InterfaceC0648d query, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(query, "query");
+        String sql = query.x();
+        String[] selectionArgs = f8855b;
+        Intrinsics.checkNotNull(cancellationSignal);
+        C0656a cursorFactory = new C0656a(query, 0);
+        SQLiteDatabase sQLiteDatabase = this.f8856a;
+        Intrinsics.checkNotNullParameter(sQLiteDatabase, "sQLiteDatabase");
+        Intrinsics.checkNotNullParameter(sql, "sql");
+        Intrinsics.checkNotNullParameter(selectionArgs, "selectionArgs");
+        Intrinsics.checkNotNullParameter(cancellationSignal, "cancellationSignal");
+        Intrinsics.checkNotNullParameter(cursorFactory, "cursorFactory");
+        Cursor rawQueryWithFactory = sQLiteDatabase.rawQueryWithFactory(cursorFactory, sql, selectionArgs, null, cancellationSignal);
+        Intrinsics.checkNotNullExpressionValue(rawQueryWithFactory, "sQLiteDatabase.rawQueryW…ationSignal\n            )");
+        return rawQueryWithFactory;
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final Cursor p(InterfaceC0648d query) {
+        Intrinsics.checkNotNullParameter(query, "query");
+        Cursor rawQueryWithFactory = this.f8856a.rawQueryWithFactory(new C0656a(new b(query), 1), query.x(), f8855b, null);
+        Intrinsics.checkNotNullExpressionValue(rawQueryWithFactory, "delegate.rawQueryWithFac…EMPTY_STRING_ARRAY, null)");
+        return rawQueryWithFactory;
+    }
+
+    @Override // w0.InterfaceC0645a
+    public final InterfaceC0649e q(String sql) {
+        Intrinsics.checkNotNullParameter(sql, "sql");
+        SQLiteStatement compileStatement = this.f8856a.compileStatement(sql);
+        Intrinsics.checkNotNullExpressionValue(compileStatement, "delegate.compileStatement(sql)");
+        return new k(compileStatement);
+    }
+}

apk_decompiled/sources/x0/d.java

@@ -0,0 +1,8 @@
+package x0;
+
+/* loaded from: classes.dex */
+public final class d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public c f8857a;
+}

apk_decompiled/sources/x0/f.java

@@ -0,0 +1,27 @@
+package x0;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class f extends RuntimeException {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final g f8860a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Throwable f8861b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public f(g callbackName, Throwable cause) {
+        super(cause);
+        Intrinsics.checkNotNullParameter(callbackName, "callbackName");
+        Intrinsics.checkNotNullParameter(cause, "cause");
+        this.f8860a = callbackName;
+        this.f8861b = cause;
+    }
+
+    @Override // java.lang.Throwable
+    public final Throwable getCause() {
+        return this.f8861b;
+    }
+}

apk_decompiled/sources/x0/g.java

@@ -0,0 +1,52 @@
+package x0;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes.dex */
+public final class g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final g f8862a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final g f8863b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public static final g f8864c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final g f8865d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final g f8866e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final /* synthetic */ g[] f8867f;
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [java.lang.Enum, x0.g] */
+    /* JADX WARN: Type inference failed for: r1v1, types: [java.lang.Enum, x0.g] */
+    /* JADX WARN: Type inference failed for: r2v2, types: [java.lang.Enum, x0.g] */
+    /* JADX WARN: Type inference failed for: r3v2, types: [java.lang.Enum, x0.g] */
+    /* JADX WARN: Type inference failed for: r4v2, types: [java.lang.Enum, x0.g] */
+    static {
+        ?? r02 = new Enum("ON_CONFIGURE", 0);
+        f8862a = r02;
+        ?? r12 = new Enum("ON_CREATE", 1);
+        f8863b = r12;
+        ?? r22 = new Enum("ON_UPGRADE", 2);
+        f8864c = r22;
+        ?? r32 = new Enum("ON_DOWNGRADE", 3);
+        f8865d = r32;
+        ?? r4 = new Enum("ON_OPEN", 4);
+        f8866e = r4;
+        f8867f = new g[]{r02, r12, r22, r32, r4};
+    }
+
+    public static g valueOf(String str) {
+        return (g) Enum.valueOf(g.class, str);
+    }
+
+    public static g[] values() {
+        return (g[]) f8867f.clone();
+    }
+}

apk_decompiled/sources/x0/h.java

@@ -0,0 +1,271 @@
+package x0;
+
+import a.AbstractC0105a;
+import android.content.Context;
+import android.database.DatabaseErrorHandler;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+import android.util.Pair;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+import kotlin.jvm.internal.Intrinsics;
+import q2.AbstractC0562d;
+import w0.InterfaceC0645a;
+
+/* loaded from: classes.dex */
+public final class h extends SQLiteOpenHelper {
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final /* synthetic */ int f8868g = 0;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Context f8869a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final d f8870b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final AbstractC0562d f8871c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public boolean f8872d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final y0.a f8873e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f8874f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public h(Context context, String str, final d dbRef, final AbstractC0562d callback) {
+        super(context, str, null, callback.f8189a, new DatabaseErrorHandler() { // from class: x0.e
+            @Override // android.database.DatabaseErrorHandler
+            public final void onCorruption(SQLiteDatabase dbObj) {
+                AbstractC0562d callback2 = AbstractC0562d.this;
+                Intrinsics.checkNotNullParameter(callback2, "$callback");
+                d dbRef2 = dbRef;
+                Intrinsics.checkNotNullParameter(dbRef2, "$dbRef");
+                int i = h.f8868g;
+                Intrinsics.checkNotNullExpressionValue(dbObj, "dbObj");
+                c db = AbstractC0105a.D(dbRef2, dbObj);
+                callback2.getClass();
+                Intrinsics.checkNotNullParameter(db, "db");
+                Log.e("SupportSQLite", "Corruption reported by sqlite on database: " + db + ".path");
+                SQLiteDatabase sQLiteDatabase = db.f8856a;
+                if (!sQLiteDatabase.isOpen()) {
+                    String path = sQLiteDatabase.getPath();
+                    if (path != null) {
+                        AbstractC0562d.a(path);
+                        return;
+                    }
+                    return;
+                }
+                List<Pair<String, String>> list = null;
+                try {
+                    try {
+                        list = sQLiteDatabase.getAttachedDbs();
+                    } finally {
+                        if (list != null) {
+                            Iterator<T> it = list.iterator();
+                            while (it.hasNext()) {
+                                Object obj = ((Pair) it.next()).second;
+                                Intrinsics.checkNotNullExpressionValue(obj, "p.second");
+                                AbstractC0562d.a((String) obj);
+                            }
+                        } else {
+                            String path2 = sQLiteDatabase.getPath();
+                            if (path2 != null) {
+                                AbstractC0562d.a(path2);
+                            }
+                        }
+                    }
+                } catch (SQLiteException unused) {
+                }
+                try {
+                    db.close();
+                } catch (IOException unused2) {
+                    if (list != null) {
+                        return;
+                    }
+                }
+            }
+        });
+        String str2;
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(dbRef, "dbRef");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        this.f8869a = context;
+        this.f8870b = dbRef;
+        this.f8871c = callback;
+        if (str == null) {
+            str2 = UUID.randomUUID().toString();
+            Intrinsics.checkNotNullExpressionValue(str2, "randomUUID().toString()");
+        } else {
+            str2 = str;
+        }
+        this.f8873e = new y0.a(str2, context.getCacheDir(), false);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper, java.lang.AutoCloseable
+    public final void close() {
+        y0.a aVar = this.f8873e;
+        try {
+            aVar.a(aVar.f8975a);
+            super.close();
+            this.f8870b.f8857a = null;
+            this.f8874f = false;
+        } finally {
+            aVar.b();
+        }
+    }
+
+    public final InterfaceC0645a d(boolean z3) {
+        y0.a aVar = this.f8873e;
+        try {
+            aVar.a((this.f8874f || getDatabaseName() == null) ? false : true);
+            this.f8872d = false;
+            SQLiteDatabase x3 = x(z3);
+            if (!this.f8872d) {
+                c e4 = e(x3);
+                aVar.b();
+                return e4;
+            }
+            close();
+            InterfaceC0645a d4 = d(z3);
+            aVar.b();
+            return d4;
+        } catch (Throwable th) {
+            aVar.b();
+            throw th;
+        }
+    }
+
+    public final c e(SQLiteDatabase sqLiteDatabase) {
+        Intrinsics.checkNotNullParameter(sqLiteDatabase, "sqLiteDatabase");
+        return AbstractC0105a.D(this.f8870b, sqLiteDatabase);
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public final void onConfigure(SQLiteDatabase db) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        boolean z3 = this.f8872d;
+        AbstractC0562d abstractC0562d = this.f8871c;
+        if (!z3 && abstractC0562d.f8189a != db.getVersion()) {
+            db.setMaxSqlCacheSize(1);
+        }
+        try {
+            abstractC0562d.g(e(db));
+        } catch (Throwable th) {
+            throw new f(g.f8862a, th);
+        }
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public final void onCreate(SQLiteDatabase sqLiteDatabase) {
+        Intrinsics.checkNotNullParameter(sqLiteDatabase, "sqLiteDatabase");
+        try {
+            this.f8871c.h(e(sqLiteDatabase));
+        } catch (Throwable th) {
+            throw new f(g.f8863b, th);
+        }
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public final void onDowngrade(SQLiteDatabase db, int i, int i4) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        this.f8872d = true;
+        try {
+            this.f8871c.i(e(db), i, i4);
+        } catch (Throwable th) {
+            throw new f(g.f8865d, th);
+        }
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public final void onOpen(SQLiteDatabase db) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        if (!this.f8872d) {
+            try {
+                this.f8871c.j(e(db));
+            } catch (Throwable th) {
+                throw new f(g.f8866e, th);
+            }
+        }
+        this.f8874f = true;
+    }
+
+    @Override // android.database.sqlite.SQLiteOpenHelper
+    public final void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i4) {
+        Intrinsics.checkNotNullParameter(sqLiteDatabase, "sqLiteDatabase");
+        this.f8872d = true;
+        try {
+            this.f8871c.k(e(sqLiteDatabase), i, i4);
+        } catch (Throwable th) {
+            throw new f(g.f8864c, th);
+        }
+    }
+
+    public final SQLiteDatabase s(boolean z3) {
+        if (z3) {
+            SQLiteDatabase writableDatabase = getWritableDatabase();
+            Intrinsics.checkNotNullExpressionValue(writableDatabase, "{\n                super.…eDatabase()\n            }");
+            return writableDatabase;
+        }
+        SQLiteDatabase readableDatabase = getReadableDatabase();
+        Intrinsics.checkNotNullExpressionValue(readableDatabase, "{\n                super.…eDatabase()\n            }");
+        return readableDatabase;
+    }
+
+    public final SQLiteDatabase x(boolean z3) {
+        File parentFile;
+        String databaseName = getDatabaseName();
+        boolean z4 = this.f8874f;
+        Context context = this.f8869a;
+        if (databaseName != null && !z4 && (parentFile = context.getDatabasePath(databaseName).getParentFile()) != null) {
+            parentFile.mkdirs();
+            if (!parentFile.isDirectory()) {
+                Log.w("SupportSQLite", "Invalid database parent file, not a directory: " + parentFile);
+            }
+        }
+        try {
+            return s(z3);
+        } catch (Throwable unused) {
+            super.close();
+            try {
+                Thread.sleep(500L);
+            } catch (InterruptedException unused2) {
+            }
+            try {
+                return this.s(z3);
+            } catch (Throwable th) {
+                super.close();
+                if (!(th instanceof f)) {
+                    if (th instanceof SQLiteException) {
+                        throw th;
+                    }
+                    throw th;
+                }
+                f fVar = th;
+                int ordinal = fVar.f8860a.ordinal();
+                Throwable th2 = fVar.f8861b;
+                if (ordinal == 0 || ordinal == 1 || ordinal == 2 || ordinal == 3) {
+                    throw th2;
+                }
+                if (!(th2 instanceof SQLiteException)) {
+                    throw th2;
+                }
+                context.deleteDatabase(databaseName);
+                try {
+                    return this.s(z3);
+                } catch (f e4) {
+                    throw e4.f8861b;
+                }
+            }
+        }
+    }
+}

apk_decompiled/sources/x0/i.java

@@ -0,0 +1,61 @@
+package x0;
+
+import android.content.Context;
+import kotlin.Lazy;
+import kotlin.LazyKt;
+import kotlin.jvm.internal.Intrinsics;
+import q2.AbstractC0562d;
+import w0.InterfaceC0645a;
+import w0.InterfaceC0646b;
+
+/* loaded from: classes.dex */
+public final class i implements InterfaceC0646b {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Context f8875a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f8876b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final AbstractC0562d f8877c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Lazy f8878d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f8879e;
+
+    public i(Context context, String str, AbstractC0562d callback) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        this.f8875a = context;
+        this.f8876b = str;
+        this.f8877c = callback;
+        this.f8878d = LazyKt.lazy(new J0.e(this, 13));
+    }
+
+    @Override // w0.InterfaceC0646b
+    public final InterfaceC0645a S() {
+        return ((h) this.f8878d.getValue()).d(true);
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        Lazy lazy = this.f8878d;
+        if (lazy.isInitialized()) {
+            ((h) lazy.getValue()).close();
+        }
+    }
+
+    @Override // w0.InterfaceC0646b
+    public final void setWriteAheadLoggingEnabled(boolean z3) {
+        Lazy lazy = this.f8878d;
+        if (lazy.isInitialized()) {
+            h sQLiteOpenHelper = (h) lazy.getValue();
+            Intrinsics.checkNotNullParameter(sQLiteOpenHelper, "sQLiteOpenHelper");
+            sQLiteOpenHelper.setWriteAheadLoggingEnabled(z3);
+        }
+        this.f8879e = z3;
+    }
+}

apk_decompiled/sources/x0/j.java

@@ -0,0 +1,49 @@
+package x0;
+
+import android.database.sqlite.SQLiteProgram;
+import kotlin.jvm.internal.Intrinsics;
+import w0.InterfaceC0647c;
+
+/* loaded from: classes.dex */
+public class j implements InterfaceC0647c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final SQLiteProgram f8880a;
+
+    public j(SQLiteProgram delegate) {
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f8880a = delegate;
+    }
+
+    @Override // w0.InterfaceC0647c
+    public final void I(int i, long j4) {
+        this.f8880a.bindLong(i, j4);
+    }
+
+    @Override // w0.InterfaceC0647c
+    public final void N(int i, byte[] value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        this.f8880a.bindBlob(i, value);
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        this.f8880a.close();
+    }
+
+    @Override // w0.InterfaceC0647c
+    public final void k(int i, String value) {
+        Intrinsics.checkNotNullParameter(value, "value");
+        this.f8880a.bindString(i, value);
+    }
+
+    @Override // w0.InterfaceC0647c
+    public final void t(int i) {
+        this.f8880a.bindNull(i);
+    }
+
+    @Override // w0.InterfaceC0647c
+    public final void v(int i, double d4) {
+        this.f8880a.bindDouble(i, d4);
+    }
+}

apk_decompiled/sources/x0/k.java

@@ -0,0 +1,29 @@
+package x0;
+
+import android.database.sqlite.SQLiteStatement;
+import kotlin.jvm.internal.Intrinsics;
+import w0.InterfaceC0649e;
+
+/* loaded from: classes.dex */
+public final class k extends j implements InterfaceC0649e {
+
+    /* renamed from: b, reason: collision with root package name */
+    public final SQLiteStatement f8881b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public k(SQLiteStatement delegate) {
+        super(delegate);
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f8881b = delegate;
+    }
+
+    @Override // w0.InterfaceC0649e
+    public final long T() {
+        return this.f8881b.executeInsert();
+    }
+
+    @Override // w0.InterfaceC0649e
+    public final int o() {
+        return this.f8881b.executeUpdateDelete();
+    }
+}