@NotNull
  private Triple<PyExpression, List<Pair<PsiElement, Instruction>>, Boolean> visitPyConditionalPart(@NotNull PyConditionalStatementPart part,
                                                                                                    @NotNull PyStatement node) {
    final PyExpression condition = part.getCondition();
    final PyTypeAssertionEvaluator assertionEvaluator = new PyTypeAssertionEvaluator();
    final Boolean conditionResult = PyEvaluator.evaluateAsBooleanNoResolve(condition);

    if (condition != null) {
      condition.accept(this);
      condition.accept(assertionEvaluator);
    }

    final List<Pair<PsiElement, Instruction>> branchingPoints = getBranchingPoints(condition);
    if (conditionResult == Boolean.FALSE) {
      myBuilder.flowAbrupted();
    }
    else if (isConjunctionOrDisjunction(condition)) {
      // to make edges between positive sub-conditions inside and the statement below
      final var shortCircuitPositivePoints = selectShortCircuitPositivePoints(branchingPoints);

      branchingPoints.removeAll(shortCircuitPositivePoints);
      shortCircuitPositivePoints.forEach(pair -> myBuilder.addPendingEdge(pair.getFirst(), pair.getSecond()));
    }

    visitPyConditionalPartStatements(part, assertionEvaluator, node);

    return new Triple<>(condition, branchingPoints, conditionResult);
  }
@NotNull
  private Triple<PyExpression, List<Pair<PsiElement, Instruction>>, Boolean> visitPyConditionalPart(@NotNull PyConditionalStatementPart part,
                                                                                                    @NotNull PyStatement node)