package d8;
public final class f extends e8.o implements b8.c {
    public final kotlinx.coroutines.flow.StateFlow A;
    public final f8.a q;
    public final kotlinx.coroutines.flow.MutableStateFlow r;
    public final kotlinx.coroutines.flow.StateFlow s;
    public final kotlinx.coroutines.flow.MutableStateFlow t;
    public final kotlinx.coroutines.flow.StateFlow u;
    public final kotlinx.coroutines.flow.MutableStateFlow v;
    public final kotlinx.coroutines.flow.StateFlow w;
    public final kotlinx.coroutines.flow.MutableStateFlow x;
    public final kotlinx.coroutines.flow.StateFlow y;
    public final kotlinx.coroutines.flow.MutableStateFlow z;

    public f(String p2, qbsg.top.ble.data.BleSessionFacade p3, kotlinx.coroutines.flow.SharedFlow p4, f8.a p5)
    {
        kotlin.jvm.internal.s.f(p2, "macAddress");
        kotlin.jvm.internal.s.f(p3, "session");
        super(p2, p3, p4);
        super.q = p5;
        kotlinx.coroutines.flow.StateFlow v2_14 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow("");
        super.r = v2_14;
        super.s = kotlinx.coroutines.flow.FlowKt.asStateFlow(v2_14);
        kotlinx.coroutines.flow.StateFlow v2_4 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(new e8.a());
        super.t = v2_4;
        super.u = kotlinx.coroutines.flow.FlowKt.asStateFlow(v2_4);
        kotlinx.coroutines.flow.StateFlow v2_8 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(new e8.a());
        super.v = v2_8;
        super.w = kotlinx.coroutines.flow.FlowKt.asStateFlow(v2_8);
        kotlinx.coroutines.flow.StateFlow v3_1 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(0);
        super.x = v3_1;
        super.y = kotlinx.coroutines.flow.FlowKt.asStateFlow(v3_1);
        kotlinx.coroutines.flow.StateFlow v2_11 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(0);
        super.z = v2_11;
        super.A = kotlinx.coroutines.flow.FlowKt.asStateFlow(v2_11);
        return;
    }

    public static final byte[] o(d8.f p9, Object p10, boolean p11)
    {
        int v6;
        int v5_0;
        kotlin.jvm.internal.s.f(p10, "bitmap");
        int v0 = ((android.graphics.Bitmap) p10).getWidth();
        int v9_6 = ((android.graphics.Bitmap) p10).getHeight();
        byte[] v10_2 = g8.f.c(p10);
        java.util.ArrayList v1_1 = new java.util.ArrayList();
        int v4 = 0;
        if ((v0 == 212) || ((v0 == 250) || (v0 == 296))) {
            int v2_3 = (v0 - 1);
            v5_0 = 0;
            v6 = 0;
            while (-1 < v2_3) {
                int v7_1 = 0;
                while (v7_1 < v9_6) {
                    v5_0 = ((v5_0 << 1) | d8.f.r(v10_2, v0, p11, v2_3, v7_1));
                    v6++;
                    if (v6 == 8) {
                        v1_1.add(Integer.valueOf(v5_0));
                        v5_0 = 0;
                        v6 = 0;
                    }
                    v7_1++;
                }
                v2_3--;
            }
        } else {
            int v2_4 = 0;
            v5_0 = 0;
            v6 = 0;
            while (v2_4 < v9_6) {
                int v7_2 = 0;
                while (v7_2 < v0) {
                    v5_0 = ((v5_0 << 1) | d8.f.r(v10_2, v0, p11, v7_2, v2_4));
                    v6++;
                    if (v6 == 8) {
                        v1_1.add(Integer.valueOf(v5_0));
                        v5_0 = 0;
                        v6 = 0;
                    }
                    v7_2++;
                }
                v2_4++;
            }
        }
        if (v6 > 0) {
            v1_1.add(Integer.valueOf((v5_0 << (8 - v6))));
        }
        int v9_5 = v1_1.size();
        byte[] v10_1 = new byte[v9_5];
        while (v4 < v9_5) {
            v10_1[v4] = ((byte) ((Number) v1_1.get(v4)).intValue());
            v4++;
        }
        return v10_1;
    }

    public static final byte[] p(d8.f p4, String p5)
    {
        IllegalArgumentException v4_2 = i7.p.j0(p5, " ", "");
        if ((v4_2.length() % 2) != 0) {
            throw new IllegalArgumentException("Failed requirement.");
        } else {
            String v5_2 = (v4_2.length() / 2);
            byte[] v0_1 = new byte[v5_2];
            int v1 = 0;
            while (v1 < v5_2) {
                byte v2_0 = (v1 * 2);
                byte v2_1 = v4_2.substring(v2_0, (v2_0 + 2));
                kotlin.jvm.internal.s.e(v2_1, "substring(...)");
                c7.a.l(16);
                v0_1[v1] = ((byte) Integer.parseInt(v2_1, 16));
                v1++;
            }
            return v0_1;
        }
    }

    public static final int r(int[] p0, int p1, boolean p2, int p3, int p4)
    {
        int v0_3 = p0[((p4 * p1) + p3)];
        int v1_2 = ((v0_3 >> 16) & 255);
        if (p2) {
            if ((v1_2 > 0) && ((((v0_3 >> 8) & 255) == 0) && ((v0_3 & 255) == 0))) {
                return 1;
            }
        } else {
            if (v1_2 > 0) {
                return 1;
            }
        }
        return 0;
    }

    public static String s(int p2)
    {
        if (p2 == null) {
            return "e102";
        } else {
            if (p2 == 1) {
                return "e101";
            } else {
                if (p2 != 2) {
                    throw new IllegalArgumentException(a1.a.j(p2, "Unknown row: "));
                } else {
                    return "e100";
                }
            }
        }
    }

    public final kotlinx.coroutines.flow.StateFlow a()
    {
        return this.s;
    }

    public final void b(int p4)
    {
        this.i(q6.n.Y(new String[] {d8.f.s(p4), "TIME", "e2"})), new c0.j0(this, p4, 2));
        return;
    }

    public final kotlinx.coroutines.flow.StateFlow c()
    {
        return this.y;
    }

    public final void d(String p5)
    {
        kotlin.jvm.internal.s.f(p5, "number");
        java.util.List v0_9 = java.util.regex.Pattern.compile("^[0-9]{11}$");
        kotlin.jvm.internal.s.e(v0_9, "compile(...)");
        if (!v0_9.matcher(p5).matches()) {
            throw new e8.p("\u7535\u8bdd\u53f7\u7801\u5fc5\u987b\u662f11\u4f4d\u7eaf\u6570\u5b57");
        } else {
            java.util.List v0_4 = new StringBuilder("ef");
            a0.f2 v1_1 = 0;
            while (v1_1 < p5.length()) {
                int v2_2 = p5.charAt(v1_1);
                c7.a.l(16);
                int v2_3 = Integer.toString(v2_2, 16);
                kotlin.jvm.internal.s.e(v2_3, "toString(...)");
                v0_4.append(v2_3);
                v1_1++;
            }
            this.i(q6.n.Y(new String[] {v0_4.toString(), "e2"})), new a0.f2(11, this, p5));
            return;
        }
    }

    public final void e(java.util.List p3)
    {
        this.i(p3, new a5.a(14));
        return;
    }

    public final void f(int p8, int p9, boolean p10)
    {
        String v2_0 = 1;
        if (p10 == null) {
            d8.d v10_14 = ((Integer) this.x.getValue());
            Integer v3_1 = ((Integer) this.z.getValue());
            java.util.ArrayList v4_1 = new java.util.ArrayList();
            int v5 = 0;
            if ((v10_14 == null) || ((v10_14.intValue() != p8) || ((v3_1 == null) || (p9 <= v3_1.intValue())))) {
                if ((v10_14 == null) || (v10_14.intValue() == p8)) {
                    if (p8 != 0) {
                        v2_0 = 0;
                    }
                    v4_1.add(d8.f.s(v2_0));
                    d8.d v10_6 = (p9 + 1);
                    while (v5 < v10_6) {
                        v4_1.add(d8.f.s(p8));
                        v5++;
                    }
                } else {
                    d8.d v10_7 = (p9 + 1);
                    while (v5 < v10_7) {
                        v4_1.add(d8.f.s(p8));
                        v5++;
                    }
                }
            } else {
                d8.d v10_2 = (p9 - v3_1.intValue());
                while (v5 < v10_2) {
                    v4_1.add(d8.f.s(p8));
                    v5++;
                }
            }
            v4_1.add("TIME");
            v4_1.add("e2");
            this.i(v4_1, new d8.d(this, p8, p9, 1));
            return;
        } else {
            d8.d v10_12;
            if (p8 == 0) {
                v10_12 = a1.a.j((p9 + 1), "e1020");
            } else {
                if (p8 == 1) {
                    v10_12 = a1.a.j((p9 + 3), "e1010");
                } else {
                    v10_12 = "e10000";
                }
            }
            this.i(q6.n.Y(new String[] {v10_12, "TIME", "e2"})), new d8.d(this, p8, p9, 0));
            return;
        }
    }

    public final kotlinx.coroutines.flow.StateFlow g()
    {
        return this.A;
    }

    public final String j()
    {
        return "\u8f7b\u821e/\u65f6\u5149";
    }

    public final void n(Object p8, g8.d p9, a7.a p10)
    {
        kotlin.jvm.internal.s.f(p8, "processedBitmap");
        kotlin.jvm.internal.s.f(p9, "config");
        this.f = kotlinx.coroutines.BuildersKt.launch$default(this.e, 0, 0, new d8.e(this, p8, p9, p10, 0), 3, 0);
        return;
    }

    public final void q(e8.a p10, int p11)
    {
        a9.v1 v1_2;
        java.util.ArrayList v0_0 = p10.a;
        if (p11 != 16) {
            v1_2 = 4;
        } else {
            v1_2 = 8;
        }
        int v2_0 = p10.f;
        int v3 = p10.e;
        int v4 = p10.d;
        if ((v0_0.length() == 0) || (v0_0.length() > v1_2)) {
            throw new e8.q(a1.a.k("\u5b57\u6570\u5fc5\u987b\u57281~", v1_2, " \u4e4b\u95f4"));
        } else {
            if (a.b.l(v4, v3, v2_0) <= a.b.M()) {
                throw new e8.p("\u76ee\u6807\u65e5\u671f\u5fc5\u987b\u665a\u4e8e\u4eca\u5929");
            } else {
                f8.a v6 = this.q;
                java.util.ArrayList v0_3 = q6.o.H0(v6.c(v0_0, p11, p10.b, p10.c));
                if (v0_3.isEmpty()) {
                    throw new e8.r("\u672a\u80fd\u751f\u6210\u5012\u8ba1\u65f6\u6587\u5b57\uff0c\u8bf7\u68c0\u67e5\u5b57\u4f53\u6216\u5185\u5bb9");
                } else {
                    v0_3.add(v6.b(p11, v4, v3, v2_0));
                    this.i(q6.o.y0(v0_3, "e2"), new a9.v1(p11, this, p10, 2));
                    return;
                }
            }
        }
    }
}