def METHOD_NAME(self, expr: BinaryOp):
    if expr.op == "Sar":
        if isinstance(expr.operands[1], Const):
            op0, const = expr.operands
            const_value = const.value
            conv = None
            if isinstance(op0, Convert):
                # unpack it
                conv = op0
                op0 = op0.operand
            if isinstance(op0, ITE):
                r = self._check_signedness(op0.cond)
                if r is not None:
                    is_signed, inner_bits, inner_expr = r
                    if is_signed:
                        signed_result, unsigned_result = op0.iftrue, op0.iffalse
                    else:
                        signed_result, unsigned_result = op0.iffalse, op0.iftrue
                    if inner_bits != inner_expr.bits:
                        # unpack if necessary
                        if isinstance(signed_result, Convert) and signed_result.to_bits == inner_bits:
                            signed_result = signed_result.operand
                        if isinstance(unsigned_result, Convert) and unsigned_result.to_bits == inner_bits:
                            unsigned_result = unsigned_result.operand
                    if (
                        isinstance(signed_result, BinaryOp)
                        and signed_result.op == "Add"
                        and isinstance(signed_result.operands[1], Const)
                        and signed_result.operands[1].value == 2**const_value - 1
                    ):
                        if unsigned_result.likes(signed_result.operands[0]) and unsigned_result.likes(inner_expr):
                            # fully matched!
                            if inner_bits != inner_expr.bits:
                                converted_innerexpr = Convert(None, inner_expr.bits, inner_bits, False, inner_expr)
                            else:
                                converted_innerexpr = inner_expr
                            r = BinaryOp(
                                op0.idx,
                                "Div",
                                [
                                    converted_innerexpr,
                                    Const(None, None, 2**const_value, converted_innerexpr.bits),
                                ],
                                True,
                                **inner_expr.tags,
                            )
                            if conv is not None:
                                # wrap it up with a Convert again
                                r = Convert(conv.idx, conv.from_bits, conv.to_bits, conv.is_signed, r, **conv.tags)
                            return r
    return None