Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/l1/C0436a.java

@@ -0,0 +1,57 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetRelationStationsFavoritesUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* renamed from: l1.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0436a extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7314a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetRelationStationsFavoritesUseCase f7315b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public C0436a(GetRelationStationsFavoritesUseCase getRelationStationsFavoritesUseCase, Continuation continuation) {
+        super(2, continuation);
+        this.f7315b = getRelationStationsFavoritesUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new C0436a(this.f7315b, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0436a) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7314a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        favoritesRepository = this.f7315b.favoritesRepository;
+        this.f7314a = 1;
+        Object fetchAllFavoritesStations = favoritesRepository.fetchAllFavoritesStations(this);
+        return fetchAllFavoritesStations == coroutine_suspended ? coroutine_suspended : fetchAllFavoritesStations;
+    }
+}

apk_decompiled/sources/l1/b.java

@@ -0,0 +1,77 @@
+package l1;
+
+import com.adif.elcanomovil.domain.entities.DataType;
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetStationIsFavoriteUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.Boxing;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class b extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7316a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetStationIsFavoriteUseCase f7317b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7318c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7319d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ DataType f7320e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ boolean f7321f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(GetStationIsFavoriteUseCase getStationIsFavoriteUseCase, String str, String str2, DataType dataType, boolean z3, Continuation continuation) {
+        super(2, continuation);
+        this.f7317b = getStationIsFavoriteUseCase;
+        this.f7318c = str;
+        this.f7319d = str2;
+        this.f7320e = dataType;
+        this.f7321f = z3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new b(this.f7317b, this.f7318c, this.f7319d, this.f7320e, this.f7321f, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((b) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7316a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7317b.favoritesRepository;
+            this.f7316a = 1;
+            obj = favoritesRepository.fetchFavouriteTimetable(this.f7318c, this.f7319d, this.f7320e, this.f7321f, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Boxing.boxBoolean(obj != null);
+    }
+}

apk_decompiled/sources/l1/c.java

@@ -0,0 +1,64 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetStationIsFavoriteUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.Boxing;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class c extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7322a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetStationIsFavoriteUseCase f7323b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7324c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public c(GetStationIsFavoriteUseCase getStationIsFavoriteUseCase, String str, Continuation continuation) {
+        super(2, continuation);
+        this.f7323b = getStationIsFavoriteUseCase;
+        this.f7324c = str;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new c(this.f7323b, this.f7324c, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((c) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7322a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7323b.favoritesRepository;
+            this.f7322a = 1;
+            obj = favoritesRepository.fetchFavouriteStation(this.f7324c, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Boxing.boxBoolean(obj != null);
+    }
+}

apk_decompiled/sources/l1/d.java

@@ -0,0 +1,56 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetStationsFavoritesUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class d extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7325a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetStationsFavoritesUseCase f7326b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public d(GetStationsFavoritesUseCase getStationsFavoritesUseCase, Continuation continuation) {
+        super(2, continuation);
+        this.f7326b = getStationsFavoritesUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new d(this.f7326b, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((d) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7325a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        favoritesRepository = this.f7326b.favoritesRepository;
+        this.f7325a = 1;
+        Object fetchAllStations = favoritesRepository.fetchAllStations(this);
+        return fetchAllStations == coroutine_suspended ? coroutine_suspended : fetchAllStations;
+    }
+}

apk_decompiled/sources/l1/e.java

@@ -0,0 +1,68 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetTrainIsFavoriteUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class e extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7327a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetTrainIsFavoriteUseCase f7328b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7329c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7330d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7331e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public e(GetTrainIsFavoriteUseCase getTrainIsFavoriteUseCase, String str, String str2, String str3, Continuation continuation) {
+        super(2, continuation);
+        this.f7328b = getTrainIsFavoriteUseCase;
+        this.f7329c = str;
+        this.f7330d = str2;
+        this.f7331e = str3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new e(this.f7328b, this.f7329c, this.f7330d, this.f7331e, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((e) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7327a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        favoritesRepository = this.f7328b.favoritesRepository;
+        this.f7327a = 1;
+        Object isFavouriteTrain = favoritesRepository.isFavouriteTrain(this.f7329c, this.f7330d, this.f7331e, this);
+        return isFavouriteTrain == coroutine_suspended ? coroutine_suspended : isFavouriteTrain;
+    }
+}

apk_decompiled/sources/l1/f.java

@@ -0,0 +1,56 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetTrainsFavoritesUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class f extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7332a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetTrainsFavoritesUseCase f7333b;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public f(GetTrainsFavoritesUseCase getTrainsFavoritesUseCase, Continuation continuation) {
+        super(2, continuation);
+        this.f7333b = getTrainsFavoritesUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new f(this.f7333b, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((f) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7332a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        favoritesRepository = this.f7333b.favoritesRepository;
+        this.f7332a = 1;
+        Object fetchAllTrains = favoritesRepository.fetchAllTrains(this);
+        return fetchAllTrains == coroutine_suspended ? coroutine_suspended : fetchAllTrains;
+    }
+}

apk_decompiled/sources/l1/g.java

@@ -0,0 +1,75 @@
+package l1;
+
+import com.adif.elcanomovil.domain.entities.DataType;
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.RemoveFavoriteStationUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class g extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7334a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ RemoveFavoriteStationUseCase f7335b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7336c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ DataType f7337d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7338e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Boolean f7339f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public g(RemoveFavoriteStationUseCase removeFavoriteStationUseCase, String str, DataType dataType, String str2, Boolean bool, Continuation continuation) {
+        super(2, continuation);
+        this.f7335b = removeFavoriteStationUseCase;
+        this.f7336c = str;
+        this.f7337d = dataType;
+        this.f7338e = str2;
+        this.f7339f = bool;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new g(this.f7335b, this.f7336c, this.f7337d, this.f7338e, this.f7339f, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((g) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7334a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7335b.favoritesRepository;
+            this.f7334a = 1;
+            if (favoritesRepository.deleteStation(this.f7336c, this.f7337d, this.f7338e, this.f7339f, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/l1/h.java

@@ -0,0 +1,70 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.RemoveFavoriteTrainUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class h extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7340a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ RemoveFavoriteTrainUseCase f7341b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7342c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7343d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7344e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public h(RemoveFavoriteTrainUseCase removeFavoriteTrainUseCase, String str, String str2, String str3, Continuation continuation) {
+        super(2, continuation);
+        this.f7341b = removeFavoriteTrainUseCase;
+        this.f7342c = str;
+        this.f7343d = str2;
+        this.f7344e = str3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new h(this.f7341b, this.f7342c, this.f7343d, this.f7344e, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((h) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7340a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7341b.favoritesRepository;
+            this.f7340a = 1;
+            if (favoritesRepository.deleteFavouriteTrain(this.f7342c, this.f7343d, this.f7344e, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/l1/i.java

@@ -0,0 +1,83 @@
+package l1;
+
+import com.adif.elcanomovil.domain.entities.DataType;
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.SaveFavoriteStationUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class i extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7345a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ SaveFavoriteStationUseCase f7346b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7347c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7348d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ DataType f7349e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ String f7350f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ String f7351g;
+    public final /* synthetic */ Boolean h;
+    public final /* synthetic */ Boolean i;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public i(SaveFavoriteStationUseCase saveFavoriteStationUseCase, String str, String str2, DataType dataType, String str3, String str4, Boolean bool, Boolean bool2, Continuation continuation) {
+        super(2, continuation);
+        this.f7346b = saveFavoriteStationUseCase;
+        this.f7347c = str;
+        this.f7348d = str2;
+        this.f7349e = dataType;
+        this.f7350f = str3;
+        this.f7351g = str4;
+        this.h = bool;
+        this.i = bool2;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new i(this.f7346b, this.f7347c, this.f7348d, this.f7349e, this.f7350f, this.f7351g, this.h, this.i, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((i) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7345a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7346b.favoritesRepository;
+            this.f7345a = 1;
+            if (favoritesRepository.insertStation(this.f7347c, this.f7348d, this.f7349e, this.f7350f, this.f7351g, this.h, this.i, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/l1/j.java

@@ -0,0 +1,86 @@
+package l1;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.SaveFavoriteTrainUseCase;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class j extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7352a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ SaveFavoriteTrainUseCase f7353b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7354c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7355d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7356e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Long f7357f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ String f7358g;
+    public final /* synthetic */ String h;
+    public final /* synthetic */ String i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public final /* synthetic */ String f7359j;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public j(SaveFavoriteTrainUseCase saveFavoriteTrainUseCase, String str, String str2, String str3, Long l4, String str4, String str5, String str6, String str7, Continuation continuation) {
+        super(2, continuation);
+        this.f7353b = saveFavoriteTrainUseCase;
+        this.f7354c = str;
+        this.f7355d = str2;
+        this.f7356e = str3;
+        this.f7357f = l4;
+        this.f7358g = str4;
+        this.h = str5;
+        this.i = str6;
+        this.f7359j = str7;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new j(this.f7353b, this.f7354c, this.f7355d, this.f7356e, this.f7357f, this.f7358g, this.h, this.i, this.f7359j, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((j) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        FavoritesRepository favoritesRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7352a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            favoritesRepository = this.f7353b.favoritesRepository;
+            this.f7352a = 1;
+            if (favoritesRepository.insertFavouriteTrain(this.f7354c, this.f7355d, this.f7356e, this.f7357f, this.f7358g, this.h, this.i, this.f7359j, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}