Пожалуйста, объясните код по подробнее C++

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <unordered_map>
#include <map>
 
namespace tools {
    std::string right_trim(const std::string &str) noexcept {
        std::string::size_type last_space = str.find_last_not_of(" \t\r\n");
        return last_space == std::string::npos ? "" : (
                str.size() == (last_space + 1) ? str : str.substr(0, last_space + 1)
        );
    }
}
 
namespace turing {
    /**
     * direction constants
     */
    enum directions {
        RIGHT = 'R',
        LEFT  = 'L',
        SAME  = '*'
    };
    template<typename T1, typename T2>
    using map = std::map<T1, T2>;
    using state_type = std::string;
    using symbol_type = char;
 
    /**
     * next state for turing::machine
     */
    struct next_state {
        /**
         * move direction
         */
        symbol_type direction;
        /**
         * next state
         */
        state_type next_state;
        /**
         * replace symbol
         */
        symbol_type next_char;
    };
 
    using state_list = map<symbol_type, next_state>;
    using state_map = map<state_type, state_list>;
 
    /**
     * machine state
     */
    struct machine {
        /**
         * current head position
         */
        size_t head_position;
        /**
         * current state
         */
        state_type state;
        /**
         * machine "tape"
         */
        std::string tape;
        /**
         * state table
         */
        state_map state_table;
    };
 
    /**
     * load machine state from input stream
     * 
     * @param input stream 
     * @return loaded state
     * @throw std::runtime_error if cant parse state line
     */
    machine load(std::istream& input) throw(std::runtime_error) {
        machine m;
        std::string line;
 
        input >> m.head_position;
        input >> m.tape;
 
        while (std::getline(input, line)) {
            line = tools::right_trim(line);
            if (line.empty())
                continue;
            std::istringstream parser(line);
            state_type current_state, next_state;
            symbol_type current_char, next_char, direction;
 
            parser >> current_state >> current_char >> next_char >> direction >> next_state;
            if (parser.fail()) {
                throw std::runtime_error("parser.fail()");
            }
            // fill state for current state+char pair
            {
                auto& state = m.state_table[current_state][current_char];
                state.direction  = direction;
                state.next_char  = next_char;
                state.next_state = next_state;
            }
        }
        m.state = m.state_table.begin()->first;
        m.tape = tools::right_trim(m.tape);
        --m.head_position;
        return m;
    }
 
    /**
     * run machine
     * @param m machine state
     * @return 0
     * @throw std::runtime_error if cant find next state
     * @throw std::out_of_range if head outside tape
     */
    int run(machine& m) throw(std::runtime_error, std::out_of_range) {
        bool in_cycle = false;
        bool stop = false;
 
        while (!stop) {
            state_map::iterator state;
            state_list::iterator next;
 
            // find state table for current state
            state = m.state_table.find(m.state);
            if (state == m.state_table.end()) {
                // m.state missing in m.state_table
                throw std::runtime_error("state == m.state_table.end()");
            }
            // find next state for current symbol
            const auto current_symbol = m.tape.at(m.head_position);
            next = state->second.find(current_symbol);
            if (next == state->second.end()) {
                // no rule for current_symbol, try find rule for "any" symbol
                next = state->second.find('*');
            }
            if (next == state->second.end()) {
                // current_symbol missing in m.state_table[m.state]
                throw std::runtime_error("next == state->second.end()");
            }
            next_state new_state = next->second;
            // no change if next char == '*'
            if (new_state.next_char != '*') {
                m.tape[m.head_position] = new_state.next_char;
            }
            m.state = new_state.next_state;
 
            switch (new_state.direction) {
                case RIGHT:
                    in_cycle = false;
                    m.head_position++;
                    break;
                case LEFT:
                    in_cycle = false;
                    m.head_position--;
                    break;
                case SAME:
                    if (in_cycle) {
                        throw std::runtime_error("loop detected");
                    }
                    in_cycle = true;
                    break;
                default:
                    throw std::runtime_error("wrong direction");
            }
            std::cout << m.tape << std::endl;
            stop = m.state == "X";
        }
        return 0;
    }
}
 
int main(int argc, char** argv) {
    std::string file_name;
    std::ifstream input;
 
 
    if (argc == 1) {
        std::cout << "Enter file name > ";
        std::cin >> file_name;
    } else {
        file_name = argv[1];
    }
 
    input.open(file_name);
 
    if (!input.is_open()) {
        std::cerr << "ERROR" << std::endl;
        return 0;
    }
    try
    {
        using namespace turing;
        machine m = load(input);
        return run(m);
    }
    catch (std::runtime_error& e) {
        std::cerr << "HALT" << e.what() << std::endl;
    }
    return 0;
}