def METHOD_NAME(self) -> List[Output]:  # pylint: disable=too-many-branches
    """"""
    super().METHOD_NAME()
    reentrancies = self.find_reentrancies()
    results = []
    result_sorted = sorted(list(reentrancies.items()), key=lambda x: x[0].function.name)
    varsWritten: List[FindingValue]
    varsWrittenSet: Set[FindingValue]
    for (func, calls), varsWrittenSet in result_sorted:
        calls = sorted(list(set(calls)), key=lambda x: x[0].node_id)
        varsWritten = sorted(varsWrittenSet, key=lambda x: (x.variable.name, x.node.node_id))
        info = ["Reentrancy in ", func, ":\n"]
        info += ["\tExternal calls:\n"]
        for (call_info, calls_list) in calls:
            info += ["\t- ", call_info, "\n"]
            for call_list_info in calls_list:
                if call_list_info != call_info:
                    info += ["\t\t- ", call_list_info, "\n"]
        info += "\tState variables written after the call(s):\n"
        for finding_value in varsWritten:
            info += ["\t- ", finding_value.node, "\n"]
            for other_node in finding_value.nodes:
                if other_node != finding_value.node:
                    info += ["\t\t- ", other_node, "\n"]
            if finding_value.cross_functions:
                info += [
                    "\t",
                    finding_value.variable,
                    " can be used in cross function reentrancies:\n",
                ]
                for cross in finding_value.cross_functions:
                    info += ["\t- ", cross, "\n"]
        # Create our JSON result
        res = self.generate_result(info)
        # Add the function with the re-entrancy first
        res.add(func)
        # Add all underlying calls in the function which are potentially problematic.
        for (call_info, calls_list) in calls:
            res.add(call_info, {"underlying_type": "external_calls"})
            for call_list_info in calls_list:
                if call_list_info != call_info:
                    res.add(
                        call_list_info,
                        {"underlying_type": "external_calls_sending_eth"},
                    )
        # Add all variables written via nodes which write them.
        for finding_value in varsWritten:
            res.add(
                finding_value.node,
                {
                    "underlying_type": "variables_written",
                    "variable_name": finding_value.variable.name,
                },
            )
            for other_node in finding_value.nodes:
                if other_node != finding_value.node:
                    res.add(
                        other_node,
                        {
                            "underlying_type": "variables_written",
                            "variable_name": finding_value.variable.name,
                        },
                    )
        # Append our result
        results.append(res)
    return results