Initial import of ADIF API reverse-engineering toolkit

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();
+    }
+}