Как нарисовать блок-схему для большой функции?

#include <windows.h>
#include <tlhelp32.h>
#include <cstring>
#include <iostream>
#include <iomanip>
 
using namespace std;
 
const ULONG MinUserAddress = 0x00000000;    // минимальный адрес виртуальной памяти процесса
const ULONG MaxUserAddress = 0x7FFF0000;    // максимальный адрес виртуальной памяти процесса (дальше идут системные адреса)
 
enum MemType        // тип участка памяти
{
  MemUnknown,       // неизвестный тип
  MemFree,          // область свободна
  MemReserve,       // область зарезервирована
  MemPrivate,       // область используется только одним процессом
  MemMapped,        // область отображена на файл данных
  MemImage,         // область отображена на файл образа задачи
};
 
void ShowMemoryStatus();                // выводит состояние памяти на консоль
void ShowMemType(MemType type);         // выводит название указанного типа памяти
void ShowMemoryMap(HANDLE hProcess, ULONG StartAddress, ULONG EndAddress);
     // выводит карту процесса hProcess, начиная от адреса StartAddress до адреса EndAddress
void ShowMemoryMap(HANDLE hProcess);    // выводит полную карту процесса hProcess
void ShowProcessList();                 // выводит список всех процессов и их идентификаторов
 
 
int main()
{
    setlocale(LC_ALL,"Russian");
    cout << "Лабораторная работа №4 Архитектура памяти Windows" << endl
         << endl
         << "Введите \'HELP\' для справки" << endl << endl;
    bool quitProgram = false;
    do
    {
         const char *spaceSymbols = " \t";      // символы, которые считаются пробельными
         const int commandLength = 255;         // максимальная длина введенной строки
         char command[commandLength];     // буфер, в который считывается введенная строка         
         cout << flush << "> ";
         cin.getline(command, commandLength);   // читаем строку
         char *cmd = command;
         while (*cmd == ' ' || *cmd == '\t')
            cmd++;
         if (*cmd == '\0')
            continue;
         char *arg1 = strupr(strtok(cmd, spaceSymbols));  // первый аргумент (сама команда)
         char *arg2 = strtok(NULL, spaceSymbols);   // второй аргумент (идентификатор процесса)
         if (!strcmp(arg1, "MEM"))              // выводит состояние памяти
            ShowMemoryStatus();
         else if (!strcmp(arg1, "MAP"))         // выводит карту процесса
         {
            if (arg2 == NULL)           // без аргумента - выводит карту текущего процесса
               ShowMemoryMap(GetCurrentProcess());
            else
            {
               char *endptr;
               ULONG id = strtoul(arg2, &endptr, 0);   // получаем число из строки
               if (*endptr == '\0')                    // если преобразование удалось
               {   // получаем дескриптор процесса по его идентификатору:
                   HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, true, id);
                   if (hProcess == NULL)
                   {
                       cout << "WinAPI Error #" << GetLastError();
                   }
                   else
                   {   // и вызываем функцию вывода карты памяти:
                       ShowMemoryMap(hProcess);
                       CloseHandle(hProcess);
                   }
               }
               else
               {
                   cout << "Error in argument \'" << arg2 << "\'!";
               }
            }
         }
         else if (!strcmp(arg1, "LIST"))          // вывести процессы и их идентификаторы
            ShowProcessList();
         else if (!strcmp(arg1, "HELP"))          // вывести список команд
            cout << "MEM    - показать состояние памяти" << endl
                 << "MAP    - показать карту памяти текущего процесса" << endl
                 << "MAP id - показать карту памяти процесса по его идентификатору \'id\'" << endl
                 << "LIST   - показать список всех процессов" << endl
                 << "EXIT   - выход из программы" << endl
                 << "HELP   - окно справки";
         else if (!strcmp(arg1, "EXIT"))          // выйти из цикла (и из программы)
            quitProgram = true;
         else                                     // неизвестная команда
            cout << "Unknown command \'" << arg1 << "\'. Type \'HELP\' for a command list.";
         cout << endl << endl;
    } while (quitProgram == false);
    return 0;
}
 
void ShowMemoryStatus()  // вывести состояние памяти
{
    MEMORYSTATUS memoryStatus;
    memoryStatus.dwLength = sizeof(memoryStatus);
    GlobalMemoryStatus(&memoryStatus);
    double memPhysFree = (double)memoryStatus.dwAvailPhys / memoryStatus.dwTotalPhys * 100; // процент свободной физической памяти
    double memPageFree = (double)memoryStatus.dwAvailPageFile / memoryStatus.dwTotalPageFile * 100; // процент свободного файла подкачки
    double memVirtFree = (double)memoryStatus.dwAvailVirtual / memoryStatus.dwTotalVirtual * 100; // процент свободной виртуальной памяти   
    double memTotalPageFile = (double)memoryStatus.dwTotalPageFile; // Размер в байтах файла подкачки
    cout << setiosflags(ios::uppercase | ios::fixed)   // теперь выводим все данные на консоль
         << "Total Memory Occupied: " << memoryStatus.dwMemoryLoad << '%' << endl
         << "Physical Memory: Free=" << setprecision(1) << memPhysFree << '%'
         << " (0x" << hex << memoryStatus.dwAvailPhys
         << " bytes), Total 0x" << hex << memoryStatus.dwTotalPhys << " bytes" << endl
         << "PageFile Memory: Free=" << setprecision(1) << memPageFree << '%'
         << " (0x" << hex << memoryStatus.dwAvailPageFile
         << " bytes), Total 0x" << hex << memoryStatus.dwTotalPageFile << " bytes" << endl
         << "Virtual  Memory: Free= " << setprecision(1) << memVirtFree << '%'
         << " (0x" << hex << memoryStatus.dwAvailVirtual
         << " bytes), Total 0x" << hex << memoryStatus.dwTotalVirtual << " bytes" << endl
         << "Total PageFile = " << setprecision(1) << memTotalPageFile /1024 /1024 << " Megabytes" << endl;
}
 
void ShowMemType(MemType type)  // вывести тип памяти на консоль
{
    switch (type)
    {
       case MemFree:           cout << "Free";    break;
       case MemReserve:        cout << "Reserve"; break;
       case MemPrivate:        cout << "Private"; break;
       case MemMapped:         cout << "Mapped";  break;
       case MemImage:          cout << "Image";   break;
       default:                cout << "Unknown"; break;
    }
}
 
void ShowMemoryMap(HANDLE hProcess, ULONG StartAddress, ULONG EndAddress)  // вывести карту памяти процесса
{
    DWORD exCurrentId = GetCurrentProcessId();
    printf("\nCurrent ID = %d", exCurrentId);
    MEMORY_BASIC_INFORMATION MBI; // структура, используемая при вызове функции WinAPI
    for (ULONG Address = StartAddress;    // текущий адрес
         Address < EndAddress && Address < MaxUserAddress;
         Address = DWORD(MBI.BaseAddress) + MBI.RegionSize)
    {
        int retSize = VirtualQueryEx(hProcess, (LPCVOID)Address, &MBI, sizeof(MBI));  // вызов функции WinAPI
        if (retSize != sizeof(MBI))    // если ошибка
        {
            cout << endl << "WinAPI Error #" << GetLastError();
            return;
        }
        MemType mtMemType;  // определяем тип области памяти, исходя из структуры MBI
        switch (MBI.State)
        {
          case MEM_FREE:    mtMemType = MemFree;
                            break;
          case MEM_RESERVE: mtMemType = MemReserve;
                            break;
          case MEM_COMMIT:  switch (MBI.Type)
                            {      
                              case MEM_IMAGE:   mtMemType = MemImage; break;
                              case MEM_MAPPED:  mtMemType = MemMapped; break;
                              case MEM_PRIVATE: mtMemType = MemPrivate; break;
                              default:          mtMemType = MemUnknown;
                            }
                            break;
          default:          mtMemType = MemUnknown;
        }
        DWORD MapAddress = DWORD(MBI.BaseAddress); // адрес начала блока памяти
        DWORD MapSize = MBI.RegionSize;            // размер блока памяти
        if (MapAddress < Address)                  // поправка для адреса и размера
        {
            MapSize -= Address - MapAddress;
            MapAddress = Address;
        }
        if (MapAddress + MapSize > EndAddress)     // еще одна поправка для размера
            MapSize = EndAddress - MapAddress + 1;
        if (MBI.RegionSize == 0)      // устанавливаем минимальный размер для увеличения адреса Address в цикле for
            MBI.RegionSize = 4096;
        cout << endl
             << setiosflags(ios::uppercase)
             << "Address=0x" << setw(8) << setfill('0') << hex << MapAddress
             << ", Size=0x"  << setw(8) << setfill('0') << hex << MapSize << " bytes"
             << ", Type="    << hex;
        ShowMemType(mtMemType);       // выводим на консоль тип области памяти в виде строки
    }
}
 
void ShowMemoryMap(HANDLE hProcess)   // выводим карту всего процесса
{
    ShowMemoryMap(hProcess, MinUserAddress, MaxUserAddress);
}
 
void ShowProcessList()                // выводим список процессов и их идентификаторов
{
    // делаем вызов функции ToolHelp32 - снимок всех процессов:
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 entry;             // структура, в которую будет помещаться информация об очередном процессе
    entry.dwSize = sizeof(PROCESSENTRY32);
    const int idFieldLength = 6;      // длина поля вывода идентификатора процесса
    // выводим шапку таблицы:
    cout << setiosflags(ios::right)
         << setw(idFieldLength) << setfill(' ') << "ID"
         << setw(0) << " | Process Name";
    for (bool fRepeat = Process32First(hSnapshot, &entry); // цикл по всем процессам из снимка hSnapshot
         fRepeat == true;
         fRepeat = Process32Next(hSnapshot, &entry))
    {    // выводим информацию об очередном процессе
         cout << endl
              << setiosflags(ios::right | ios::dec)
              << setw(idFieldLength) << setfill(' ') << entry.th32ProcessID
              << " | " << setw(0) << entry.szExeFile;
    }
    CloseHandle(hSnapshot);       // закрываем дескриптор снимка}