Поставьте пожалуйста комментарии к каждой части кода, чтобы можно было понять, что происходит в коде

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <iostream>
#include <stdbool.h>
 
using namespace std;
 
typedef enum { VISITED, NOT_VISITED } vertex_proc_t;
 
typedef struct ADJ_LIST_NODE
{
    struct ADJ_LIST_NODE* next;
    int id;
    int cost;
    int parent;
} adj_list_node_t;
 
typedef struct LIST_NODE
{
    adj_list_node_t* adj_list;
    struct LIST_NODE* next;
    struct LIST_NODE* pred;
    vertex_proc_t visited;
} list_node_t;
 
adj_list_node_t* create_adj_list_node(int id, int cost, adj_list_node_t* next, int src)
{
    adj_list_node_t* n = (adj_list_node_t*)malloc(sizeof(adj_list_node_t));
    n->id = id;
    n->cost = cost;
    n->next = next;
    n->parent = src;
    return n;
}
 
list_node_t* create_list_node(adj_list_node_t* adj_list)
{
    list_node_t* n = (list_node_t*)malloc(sizeof(list_node_t));
    n->adj_list = adj_list;
    n->next = NULL;
    n->pred = NULL;
    n->visited = NOT_VISITED;
    return n;
}
 
void free_adj_list(adj_list_node_t* adj_list)
{
    while (adj_list != NULL) {
        adj_list_node_t* tmp = adj_list->next;
        free(adj_list);
        adj_list = tmp;
    }
}
 
adj_list_node_t* find_node(adj_list_node_t* v, int id)
{
    while (v != NULL) {
        if (v->id == id) {
            return v;
        }
        v = v->next;
    }
    return NULL;
}
 
void add_edge(list_node_t* v[], int src, int dst, int cost)
{
    v[src]->adj_list =
        create_adj_list_node(dst, cost, v[src]->adj_list, src);
}
 
list_node_t* QUEUE_FRONT;
list_node_t* QUEUE_BACK;
list_node_t* STACK_TOP;
 
void push(list_node_t* node)
{
    node->next = STACK_TOP;
    STACK_TOP = node;
}
 
void pop()
{
    if (STACK_TOP == NULL) {
        return;
    }
    STACK_TOP = STACK_TOP->next;
}
 
void enqueue(list_node_t* node)
{
    if (QUEUE_FRONT == NULL) {
        QUEUE_FRONT = node;
    }
    else {
        QUEUE_BACK->next = node;
    }
    QUEUE_BACK = node;
}
 
void dequeue(int c = 0)
{
    if (QUEUE_FRONT == NULL) {
        return;
    }
    if (c) {
        list_node_t* tmp = QUEUE_FRONT;
        QUEUE_FRONT = QUEUE_FRONT->next;
        free(tmp);
    }
    else {
        QUEUE_FRONT = QUEUE_FRONT->next;
    }
}
 
int list_node_lsearch_by_cost(adj_list_node_t* bheap[], int N, int cost)
{
    int i = 0;
    for (; i < N; ++i) {
        if (bheap[i] != NULL
            && bheap[i]->cost == cost) {
            return i;
        }
    }
    return -1;
}
 
int NODE_NE_ID_COND(list_node_t* node, void* id)
{
    return node != (list_node_t*)id;
}
int STUB_COND1(adj_list_node_t*, void*)
{
    return 1;
}
 
int VERTEX_NE_ID_COND(list_node_t* vertex, void* id)
{
    return vertex != (list_node_t*)id;
}
 
int VERTEX_COST_GT_COND(adj_list_node_t* vertex, void* cost)
{
    return vertex->cost > *((int*)cost);
}
 
int VERTEX_COST_GTZ_COND(adj_list_node_t* vertex, void*)
{
    return vertex->cost > 0;
}
 
int depth_first(list_node_t* v[], int root, int(*cond0)(list_node_t*, void*), int(*cond1)(adj_list_node_t*, void*), void* pcond0, void* pcond1)
{
    if (v[root]->visited == VISITED) {
        return 0;
    }
    v[root]->visited = VISITED;
    push(v[root]);
    int ret = 1;
    //printf("dfs: %d ", root + 1);
    while (STACK_TOP != NULL && cond0(STACK_TOP, pcond0)) {
        adj_list_node_t* tmp = STACK_TOP->adj_list;
        int vf = 0;
        while (tmp != NULL) {
            if (v[tmp->id]->visited == NOT_VISITED && cond1(tmp, pcond1)) { 
                v[tmp->id]->visited = VISITED;
                enqueue(create_list_node(tmp)); 
                push(v[tmp->id]);
                ++ret;
                vf = 1;
                //printf("%d [%d] ", tmp->id + 1, tmp->cost);
                break;
            }
            else {
                tmp = tmp->next;
            }
        }
        if (vf == 0) {
            pop();
            dequeue(1);
        }
    }
    //printf("\n");
    return ret;
}
 
void breadth_first(list_node_t* v[], int root) {
    if (v[root]->visited == VISITED) {
        return;
    }
    v[root]->visited = VISITED;
    enqueue(v[root]);
    //printf("bfs: %d ", root + 1);
    while (QUEUE_FRONT != NULL) {
        adj_list_node_t* tmp = QUEUE_FRONT->adj_list;
        while (tmp != NULL) {
            if (v[tmp->id]->visited == NOT_VISITED) {
                v[tmp->id]->visited = VISITED;
                enqueue(v[tmp->id]);
                //printf("%d ", tmp->id + 1);
            }
            tmp = tmp->next;
        }
        dequeue();
    }
    //printf("\n");
}
 
void clean_graph(list_node_t* v[], int n)
{
    int i;
    for (i = 0; i < n; ++i) {
        free_adj_list(v[i]->adj_list);
        free(v[i]);
    }
}
 
void print_queue()
{
    list_node_t* curr_node = QUEUE_FRONT;
    while (curr_node != NULL) {
        printf("%d %d ", curr_node->adj_list->cost, curr_node->adj_list->id + 1);
        curr_node = curr_node->next;
    }
    printf("\n");
}
 
void clear_queue(int c = 0)
{
    while (QUEUE_FRONT != NULL) {
        dequeue(c);
    }
}
 
int min_cost() {
    list_node_t* p_tmp = QUEUE_FRONT;
    int ret = INT_MAX;
    while (p_tmp != NULL) {
        if (p_tmp->adj_list->cost < ret)
            ret = p_tmp->adj_list->cost;
        p_tmp = p_tmp->next;
    }
    return ret;
}
 
void cut_flow(list_node_t* v[], int cost) {
    list_node_t* p_tmp = QUEUE_FRONT;
    while (p_tmp != NULL) {
        p_tmp->adj_list->cost -= cost;
        adj_list_node_t* rev = find_node(v[p_tmp->adj_list->id]->adj_list, p_tmp->adj_list->parent);
        //printf("%d %d %d ", p_tmp->adj_list->id + 1, p_tmp->adj_list->parent + 1, rev->cost);
        rev->cost += cost;
        p_tmp = p_tmp->next;
    }
}
 
void print_stack()
{
    list_node_t* curr_node = STACK_TOP;
    while (curr_node != NULL) {
        printf("%p ", curr_node);
        curr_node = curr_node->next;
    }
    printf("\n");
}
 
void clear_stack()
{
    while (STACK_TOP != NULL) {
        STACK_TOP->visited = NOT_VISITED;
        pop();
    }
}
 
void print_graph(list_node_t* v[], int n)
{
    int i;
    for (i = 0; i < n; ++i) {
        if (v[i] == NULL)
            continue;
        adj_list_node_t* tmp = v[i]->adj_list;
        if (tmp == NULL) {
            printf("nil");
        }
        while (tmp != NULL) {
            printf("%d -[%d]-> %d ", i + 1, tmp->cost, tmp->id + 1);
            tmp = tmp->next;
            if (tmp == NULL) {
                printf("-> nil");
            }
        }
        printf("\n");
    }
    printf("\n");
}
 
int main() {
    int N, M, S, T;
    std::cin >> N >> M;
    const static size_t MAX_VERTICES = 1000;
    list_node_t* v[MAX_VERTICES];
    for (int a1 = 0; a1 < N; ++a1) {
        v[a1] = create_list_node(NULL);
    }
    for (int a0 = 0; a0 < M; a0++) {
        int x, y, f;
        std::cin >> x >> y >> f;
        --x; --y;
        add_edge(v, x, y, f);
        add_edge(v, y, x, 0);
 
    }
    std::cin >> S >> T;
    --S, --T;
 
    int ANS = 0;
    for (;;) {
        //print_graph(v, N);
        depth_first(v, S, NODE_NE_ID_COND, VERTEX_COST_GTZ_COND, v[T], NULL);
        if (QUEUE_FRONT == NULL)
            break;
        //print_queue();
 
        int min_flow = min_cost();
        ANS += min_flow;
        cut_flow(v, min_flow);
 
        //printf("\n");
        clear_stack();
        clear_queue(1);
    }
 
    clean_graph(v, N);
    //printf("%d\n", ANS);
    std::cout << ANS << "\n";
    system("pause");
}