Flatten deeply nested conditionals into readable logic

You are a senior software engineer doing a focused refactor. I have a block of code with deeply nested conditionals that I want to simplify.

Here is the code:

```
{{NESTED_CODE_BLOCK}}
```

Language: {{LANGUAGE}}

Follow these steps:

1. Read the code and describe in plain English what each branch is doing. Do not skip any branch.
2. Identify which conditions can be inverted into guard clauses (early returns or throws) to reduce nesting depth.
3. Identify any conditions that are logically equivalent and can be merged.
4. Rewrite the code using guard clauses, early returns, or a lookup structure where appropriate. Preserve the exact same observable behavior — do not change logic.
5. Annotate each significant change with a one-line comment explaining the transformation.
6. Flag any branch where the original intent is ambiguous and you had to make an assumption. List these at the end under 'Assumptions made'.

Do not introduce new dependencies or change the function signature unless I ask.

Edge cases to flag: if the nesting is caused by missing abstraction (a whole branch should be its own function), say so but do not refactor it automatically — just note it.