sheet_name = "Fund Report"

            headers += [["Additions"], ["Releases from", "Restrictions"]]

        headers.append(["Balance as of", self.stop_date.isoformat()])

        if expanded:

            headers += [

                ["Of which", "Receivable"],

                ["Of which", "Prepaid Expenses"],

                ["Of which", "Payable"],

                ["Of which", "Unearned Income"],

            ]

        self.use_sheet(sheet_name)

        for header in headers:

            first_line = header[0]

            if first_line == 'Fund':

                width = 2.0

            elif first_line == 'Balance as of':

                width = 1.5

            elif first_line == 'Of which':

                width = 1.3

            else:

                width = 1.2

            col_style = self.column_style(width)

            self.sheet.addElement(odf.table.TableColumn(stylename=col_style))

        center_bold = self.merge_styles(self.style_centertext, self.style_bold)

        row = self.add_row(*(

            self.multiline_cell(header, stylename=center_bold)

            for header in headers

        ))

        row.firstChild.setAttribute(

            'stylename', self.merge_styles(self.style_endtext, self.style_bold),

        )

        self.lock_first_row()

        self.lock_first_column()

        self.add_row()

        self.add_row(self.string_cell(

            f"Fund Report From {self.start_date.isoformat()} To {self.stop_date.isoformat()}",

            stylename=center_bold,

            numbercolumnsspanned=6,

        ))

        self.add_row()

    def end_spreadsheet(self) -> None:

        start_sheet = self.sheet

        self.set_open_sheet(self.sheet)

        self.start_spreadsheet(expanded=False)

        bal_indexes = [0, 1, 2, 4]

        totals = [core.MutableBalance() for _ in bal_indexes]

        threshold = Decimal('.5')

        for fund, balances in self.balances.items():

            balances = [balances[index] for index in bal_indexes]

            if (not all(bal.clean_copy(threshold).le_zero() for bal in balances)

                and fund != UNRESTRICTED_FUND):

                self.write_balances(fund, balances)

                for total, bal in zip(totals, balances):

                    total += bal

        self.write_balances('', totals, self.merge_styles(

            self.border_style(core.Border.TOP, '.75pt'),

            self.border_style(core.Border.BOTTOM, '1.5pt', 'double'),

        ))

        self.document.spreadsheet.childNodes.reverse()

        self.sheet = start_sheet

        acct_order = ['Income', 'Expenses', 'Equity']

        key_order = [core.OPENING_BALANCE_NAME, *acct_order, core.ENDING_BALANCE_NAME]

        balances: Dict[str, core.Balance] = {key: core.MutableBalance() for key in key_order}

        for acct_s, balance in core.account_balances(accounts_map, acct_order):

            if acct_s in balances:

                balances[acct_s] = balance

            else:

                acct_root, _, _ = acct_s.partition(':')

                balances[acct_root] += balance

        for key in key_order:

            if key == 'Expenses':

                yield balances[key]

            else:

                yield -balances[key]

        for info_key in INFO_ACCOUNTS:

            for _, balance in core.account_balances(accounts_map, [info_key]):

                pass

            yield core.normalize_amount_func(info_key)(balance)

    def write_balances(self,

                       fund: str,

                       balances: Iterable[core.Balance],

                       style: Union[None, str, odf.style.Style]=None,

    ) -> odf.table.TableRow:

        return self.add_row(

            self.string_cell(fund, stylename=self.style_endtext),

            *(self.balance_cell(bal, stylename=style) for bal in balances),

        )

    def write_row(self, row: FundPosts) -> None:

        fund, accounts_map = row

        self.balances[fund] = list(self._row_balances(accounts_map))

        if fund != UNRESTRICTED_FUND:

            self.write_balances(fund, self.balances[fund])

    def write(self, rows: Iterable[FundPosts]) -> None:

        self.balances: Dict[str, Sequence[core.Balance]] = collections.OrderedDict()

        super().write(rows)

        try:

            unrestricted = self.balances[UNRESTRICTED_FUND]

        except KeyError:

            pass

        else:

            self.add_row()

            self.write_balances("Unrestricted", unrestricted)

class TextReport:

    def __init__(self,

                 start_date: datetime.date,

                 stop_date: datetime.date,

                 out_file: TextIO) -> None:

        self.start_date = start_date

        self.stop_date = stop_date

        self.out_file = out_file

    def _account_balances(self,

                          fund: str,

                          account_map: AccountsMap,

    ) -> Iterator[Tuple[str, Sequence[str]]]:

        total_fmt = f'{fund} balance as of {{}}'

        for acct_s, balance in core.account_balances(account_map, EQUITY_ACCOUNTS):

            if acct_s is core.OPENING_BALANCE_NAME:

                acct_s = total_fmt.format(self.start_date.isoformat())