Refactor this method to reduce its Cognitive Complexity from 16 to the 15 allowed

To reduce the Cognitive Complexity of the method, we can try to simplify its logic and break it down into smaller, more manageable parts. Here are some suggestions:

1. Extract some of the code into separate methods with clear, descriptive names that explain what they do. This can help to make the overall logic of the method easier to understand.

2. Use early exits or guard clauses to reduce the number of nested blocks and simplify the overall flow of the method.

3. Consider using a switch statement or a lookup table to handle different cases or inputs, instead of using multiple if-else blocks.

4. Use meaningful variable names and comments to make the code more readable and understandable.

Here is an example of how we could refactor a method to reduce its Cognitive Complexity:

public void doSomething(int input) {
    if (input < 0) {
        throw new IllegalArgumentException("Input must be non-negative");
    }

    int result = 0;
    if (input == 0) {
        // Handle special case where input is zero
        result = 1;
    } else if (input == 1) {
        // Handle special case where input is one
        result = 1;
    } else {
        // Handle all other cases
        for (int i = 2; i <= input; i++) {
            result += i;
        }
    }

    System.out.println("Result: " + result);
}

In this example, we have extracted the special cases into separate if-else blocks, and used an early exit to handle the non-negative input requirement. We have also used a meaningful variable name (`result`) to make the code more readable, and added a comment to explain the purpose of the method.