#include <stdio.h>
#include <stdlib.h>

// Dynamic Storage Allocation: First Fit & Best Fit
// Optimized for minimal code size (e.g., for writing on paper)

// Block structure: s=start, z=size, p=process_id (0 if free)
struct B {int s, z, p;} *b;
int nb = 0, cap = 4, mem_sz; // num_blocks, capacity, total_memory_size

// insb: insert block at index idx, maintain order by start address 's'
void insb(int idx, int s, int z, int p) {
    if (nb >= cap) {
        cap *= 2;
        b = realloc(b, cap * sizeof(struct B));
        // Note: Real-world code checks realloc failure. Skipped for brevity.
    }
    for (int k = nb; k > idx; k--) b[k] = b[k-1]; // Shift right
    b[idx] = (struct B){s, z, p};
    nb++;
}

// rmb: remove block at index idx
void rmb(int idx) {
    for (int k = idx; k < nb - 1; k++) b[k] = b[k+1]; // Shift left
    nb--;
}

// pb: print current blocks state
void pb() {
    printf("Mem:[");
    // Print each block: start:size! (allocated) or start:size (free)
    for(int i=0; i<nb; i++) printf(" %d:%d%s", b[i].s, b[i].z, b[i].p ? "!" : "");
    printf(" ]\n");
}

// ff: First Fit allocation
void ff(int pid, int sz) {
    int f = -1; // found index
    for (int i = 0; i < nb; i++) { // Find first free block large enough
        if (!b[i].p && b[i].z >= sz) { f = i; break; }
    }
    if (f != -1) { // Block found
        if (b[f].z > sz) { // Need to split block
            // Insert new free block for the remainder after the allocated part
            insb(f + 1, b[f].s + sz, b[f].z - sz, 0);
            b[f].z = sz; // Adjust size of the now-allocated block
        }
        b[f].p = pid; // Mark block as allocated to pid
        printf("FF OK P%d->%d@%d\n", pid, sz, b[f].s);
    } else printf("FF Fail P%d(%d)\n", pid, sz); // Allocation failed
    pb(); // Show memory state
}

// bf: Best Fit allocation
void bf(int pid, int sz) {
    int bi = -1, min_z = mem_sz + 1; // best_index, min_suitable_size
    for (int i = 0; i < nb; i++) { // Find smallest free block large enough
        if (!b[i].p && b[i].z >= sz && b[i].z < min_z) {
            min_z = b[i].z; // Update best size found
            bi = i;         // Update best index found
        }
    }
    if (bi != -1) { // Best fit block found
        if (b[bi].z > sz) { // Need to split block
             // Insert new free block for the remainder
            insb(bi + 1, b[bi].s + sz, b[bi].z - sz, 0);
            b[bi].z = sz; // Adjust size of the allocated block
        }
        b[bi].p = pid; // Mark block allocated
        printf("BF OK P%d->%d@%d\n", pid, sz, b[bi].s);
    } else printf("BF Fail P%d(%d)\n", pid, sz); // Allocation failed
    pb(); // Show memory state
}

// de: Deallocate block associated with pid
void de(int pid) {
    int f = -1; // found index
    for (int i = 0; i < nb; i++) if (b[i].p == pid) { f = i; break; } // Find block by pid

    if (f != -1) { // Block found
        printf("De OK P%d@%d(%d)\n", pid, b[f].s, b[f].z);
        b[f].p = 0; // Mark block as free

        // Try merging with the *next* block if it exists and is free
        if (f + 1 < nb && !b[f+1].p) {
            b[f].z += b[f+1].z; // Absorb next block's size
            rmb(f + 1);         // Remove the next block entry
        }
        // Try merging with the *previous* block if it exists and is free
        if (f > 0 && !b[f-1].p) {
            b[f-1].z += b[f].z; // Add current block's size to previous
            rmb(f);             // Remove the current block entry (now merged)
            // f = f-1; // If index 'f' were needed after merge, adjust it
        }
         pb(); // Show memory state
    } else printf("De Fail P%d\n", pid); // Deallocation failed (pid not found)
}

// Main driver loop
int main() {
    printf("MemSz:"); scanf("%d", &mem_sz); // Get total memory size
    b = malloc(cap * sizeof(struct B));     // Allocate initial block array
    if (!b) return 1; // Handle malloc failure
    b[0] = (struct B){0, mem_sz, 0};        // Create the first block (all memory, free)
    nb = 1;
    pb(); // Show initial state

    int choice, pid, sz;
    printf("1:FF 2:BF 3:Dealloc 0:Exit\n");
    // Loop until user enters 0
    while(scanf("%d", &choice) == 1 && choice) {
        if (choice == 1 || choice == 2) { // Allocate request
            printf("PID Sz:"); scanf("%d%d", &pid, &sz);
            if (choice == 1) ff(pid, sz); else bf(pid, sz);
        } else if (choice == 3) { // Deallocate request
            printf("PID:"); scanf("%d", &pid);
            de(pid);
        } else printf("?\n"); // Invalid choice
        printf("1:FF 2:BF 3:Dealloc 0:Exit\n"); // Prompt again
    }

    free(b); // Free the block array memory
    return 0;
}