MapRemoveFirst

        size padded         = live_rec->padded_size;
        self->bytes_in_use -= (u64)requested;
        MapRemoveFirst(&self->live, ptr);
    
        if (self->config.force_page_backing) {

        MapInsertR(&first, 1, 11);
        MapInsertR(&first, 2, 20);
        MapRemoveFirst(&first, 1);
    
        MapInsertR(&second, 9, 90);

    
        // Removing one of two pairs must keep it non-empty.
        MapRemoveFirst(&map, 1);
        result = result && !MapEmpty(&map);

    
        // Removing the last pair must make it empty again.
        MapRemoveFirst(&map, 2);
        result = result && MapEmpty(&map);
        result = result && (MapPairCount(&map) == 0);

        MapInsertR(&map, 2, 20);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 2);
    
        bool result = (MapTombstones(&map) == 1);

        MapInsertR(&map, 2, 21);
        MapInsertR(&map, 3, 30);
        MapRemoveFirst(&map, 1);
    
        bool result = (MapTombstones(&map) == 1);

        MapInsertR(&map, 1, 11);
        MapInsertR(&map, 2, 20);
        MapRemoveFirst(&map, 1);
        MapClear(&map);

    
        MapInsertR(&map, 7, 70);
        MapRemoveFirst(&map, 7);
        bool result = (MapTombstones(&map) == 1);

        g_value_copy_should_fail = false;
        bool result              = MapInsertR(&map, 5, 50);
        MapRemoveFirst(&map, 5);
        result = result && (MapTombstones(&map) == 1);

        u64 length_before = MapPairCount(&map);
    
        bool result = MapRemoveFirst(&map, 1);
        result      = result && MapContainsKey(&map, 1);
        result      = result && (MapValueCountForKey(&map, 1) == 1);

        u64 tombstones_before = MapTombstones(&map);
    
        bool result = !MapRemoveFirst(&map, 99);
        result      = result && (MapPairCount(&map) == length_before);
        result      = result && (MapTombstones(&map) == tombstones_before);

        bool result = (MapTombstones(&map) == 0);
    
        MapRemoveFirst(&map, 5);
        result = result && (MapTombstones(&map) == 1);
        result = result && !MapContainsKey(&map, 5);

        u64 length_before = MapPairCount(&map);
    
        MapRemoveFirst(&map, 5);
        bool result = !MapContainsKey(&map, 5);
        result      = result && (MapPairCount(&map) == length_before - 1);

    
        // Exercise every removal path against the deep-copy map.
        result = result && MapRemoveFirst(&map, "alpha");       // one clone pair freed
        result = result && MapRemovePair(&map, "alpha", "two"); // remaining alpha freed
        result = result && (MapRemoveAll(&map, "beta") == 1);   // beta freed

    
        // Remove two interior keys; the ones before and after must stay reachable.
        bool result = MapRemoveFirst(&map, 1) && MapRemoveFirst(&map, 2);
        result      = result && (MapPairCount(&map) == 2);
        result      = result && !MapContainsKey(&map, 1) && !MapContainsKey(&map, 2);

        bool           ok     = MapValueCursorIsValid(cursor);
    
        MapRemoveFirst(&map, 10);
        MapRehashWithPolicy(&map, 5, policy);

        }
    
        MapRemoveFirst(&map, 5);
    
        bool result = (MapValuePtrFromCursor(&map, cursor) == NULL);

        // Remove an INTERIOR key from the collision chain.
        const int removed = KEY_COUNT / 2;
        MapRemoveFirst(&map, removed);
    
        // Count dropped by exactly one; the removed key is gone.