How to use the mythril.laser.smt.bool.And function in mythril

(a_nest.raw == b_nest.raw),
                ),
                z3.Or(
                    z3.Not((a_nest.raw == b_nest.raw)),
                    (a_nest.input_ != b_nest.input_).raw,
                ),
            )

    comparision = And(
        Bool(cast(z3.BoolRef, operation(a.raw, b.raw)), annotations=union),
        Bool(condition) if b.nested_functions else Bool(True),
        a.input_ == b.input_ if inputs_equal else a.input_ != b.input_,
    )
    if a.potential_values:
        for i, val in enumerate(a.potential_values):
            comparision = Or(comparision, And(operation(val[0].raw, b.raw), val[1]))

    comparision.simplify()
    return comparision

if not isinstance(b, BitVecFunc):
        paddded_cond = True
        if b.potential_input and b.potential_input.size() >= a.input_.size():
            if b.potential_input.size() > a.input_.size():
                padded_a = z3.Concat(
                    z3.BitVecVal(0, b.potential_input.size() - a.input_.size()),
                    a.input_.raw,
                )
            else:
                padded_a = a.input_.raw
            paddded_cond = And(operation(padded_a, b.potential_input.raw), b.potential_input_cond)
        if a.potential_values:
            condition = False
            for value, cond in a.potential_values:
                if value is not None:
                    condition = Or(condition, And(operation(b.raw, value.value), cond))
            ret = And(condition, operation(a.raw, b.raw), paddded_cond)
            return ret

        return And(operation(a.raw, b.raw), paddded_cond)
    if (
        not isinstance(b, BitVecFunc)
        or not a.func_name
        or not a.input_
        or not a.func_name == b.func_name
        or str(operation) not in ("", "")
    ):
        return Bool(z3.BoolVal(default_value), annotations=union)

    condition = True
    for a_nest, b_nest in product(a.nested_functions, b.nested_functions):
        if a_nest.func_name != b_nest.func_name:

padded_a = z3.Concat(
                    z3.BitVecVal(0, b.potential_input.size() - a.input_.size()),
                    a.input_.raw,
                )
            else:
                padded_a = a.input_.raw
            paddded_cond = And(operation(padded_a, b.potential_input.raw), b.potential_input_cond)
        if a.potential_values:
            condition = False
            for value, cond in a.potential_values:
                if value is not None:
                    condition = Or(condition, And(operation(b.raw, value.value), cond))
            ret = And(condition, operation(a.raw, b.raw), paddded_cond)
            return ret

        return And(operation(a.raw, b.raw), paddded_cond)
    if (
        not isinstance(b, BitVecFunc)
        or not a.func_name
        or not a.input_
        or not a.func_name == b.func_name
        or str(operation) not in ("", "")
    ):
        return Bool(z3.BoolVal(default_value), annotations=union)

    condition = True
    for a_nest, b_nest in product(a.nested_functions, b.nested_functions):
        if a_nest.func_name != b_nest.func_name:
            continue
        if a_nest.func_name == "Hybrid":
            continue
        # a.input (eq/neq) b.input ==> a == b

),
            )
        else:
            condition = z3.And(
                condition,
                z3.Or(
                    z3.Not((a_nest.input_ != b_nest.input_).raw),
                    (a_nest.raw == b_nest.raw),
                ),
                z3.Or(
                    z3.Not((a_nest.raw == b_nest.raw)),
                    (a_nest.input_ != b_nest.input_).raw,
                ),
            )

    comparision = And(
        Bool(cast(z3.BoolRef, operation(a.raw, b.raw)), annotations=union),
        Bool(condition) if b.nested_functions else Bool(True),
        a.input_ == b.input_ if inputs_equal else a.input_ != b.input_,
    )
    if a.potential_values:
        for i, val in enumerate(a.potential_values):
            comparision = Or(comparision, And(operation(val[0].raw, b.raw), val[1]))

    comparision.simplify()
    return comparision

):
        from mythril.laser.smt.bitvec_helper import Extract
        a = Extract(511, 256, a)
        b = Extract(511, 256, b)

    if not isinstance(b, BitVecFunc):
        paddded_cond = True
        if b.potential_input and b.potential_input.size() >= a.input_.size():
            if b.potential_input.size() > a.input_.size():
                padded_a = z3.Concat(
                    z3.BitVecVal(0, b.potential_input.size() - a.input_.size()),
                    a.input_.raw,
                )
            else:
                padded_a = a.input_.raw
            paddded_cond = And(operation(padded_a, b.potential_input.raw), b.potential_input_cond)
        if a.potential_values:
            condition = False
            for value, cond in a.potential_values:
                if value is not None:
                    condition = Or(condition, And(operation(b.raw, value.value), cond))
            ret = And(condition, operation(a.raw, b.raw), paddded_cond)
            return ret

        return And(operation(a.raw, b.raw), paddded_cond)
    if (
        not isinstance(b, BitVecFunc)
        or not a.func_name
        or not a.input_
        or not a.func_name == b.func_name
        or str(operation) not in ("", "")
    ):

paddded_cond = True
        if b.potential_input and b.potential_input.size() >= a.input_.size():
            if b.potential_input.size() > a.input_.size():
                padded_a = z3.Concat(
                    z3.BitVecVal(0, b.potential_input.size() - a.input_.size()),
                    a.input_.raw,
                )
            else:
                padded_a = a.input_.raw
            paddded_cond = And(operation(padded_a, b.potential_input.raw), b.potential_input_cond)
        if a.potential_values:
            condition = False
            for value, cond in a.potential_values:
                if value is not None:
                    condition = Or(condition, And(operation(b.raw, value.value), cond))
            ret = And(condition, operation(a.raw, b.raw), paddded_cond)
            return ret

        return And(operation(a.raw, b.raw), paddded_cond)
    if (
        not isinstance(b, BitVecFunc)
        or not a.func_name
        or not a.input_
        or not a.func_name == b.func_name
        or str(operation) not in ("", "")
    ):
        return Bool(z3.BoolVal(default_value), annotations=union)

    condition = True
    for a_nest, b_nest in product(a.nested_functions, b.nested_functions):
        if a_nest.func_name != b_nest.func_name:
            continue