Даниил Дагаев · @DaniilDagaev · aff85f7e · Andrey Zhdanov
--- a/src/mem.c
+++ b/src/mem.c

 /*  аллоцировать регион памяти и инициализировать его блоком */
 static struct region alloc_region  ( void const * addr, size_t query ) {
-  /*  ??? */
+  size_t size = region_actual_size(size_from_capacity((block_capacity){query}).bytes);
+  void* region_addr = map_pages(addr, region_actual_size(size),MAP_FIXED_NOREPLACE);
+  region_addr = region_addr == MAP_FAILED ? map_pages(addr, region_actual_size(size), 0) : region_addr;
+  if(region_addr == MAP_FAILED){
+      return REGION_INVALID;
+  }
+  bool extend = region_addr ==addr;
+  struct region reg ={.addr = region_addr, .extends = extend, .size= region_actual_size(size)};
+  block_init(reg.addr, (block_size){.bytes = reg.size}, NULL);
+  return reg;
 }
--- a/src/mem.c
+++ b/src/mem.c
 }

 static bool split_if_too_big( struct block_header* block, size_t query ) {
-  /*  ??? */
+  if(!block_splittable(block,query)){
+      return false;
+  }
+  block_capacity capacity_b = ( block_capacity){ query };
+  void* new_block = block->contents + query;
+  block_init(new_block, (block_size) {block->capacity.bytes - capacity_b.bytes}, block-> next);
+  block->capacity = capacity_b;
+  block->next = new_block;
+  return true;
 }
--- a/src/mem.c
+++ b/src/mem.c
 }

 static bool try_merge_with_next( struct block_header* block ) {
-  /*  ??? */
+    struct block_header* second_block = block->next;
+    if(second_block == NULL || !mergeable(block, block->next)) {
+        return false;
+    }
+    block->capacity.bytes += size_from_capacity(second_block->capacity).bytes;
+    block->next = second_block->next;
+    return true;
 }
--- a/src/mem.c
+++ b/src/mem.c


 static struct block_search_result find_good_or_last  ( struct block_header* restrict block, size_t sz )    {
-  /*??? */
+  struct block_search_result find_block = {.block = block, .type = BSR_CORRUPTED};
+    if(!block) return find_block;
+    else{
--- a/src/mem.c
+++ b/src/mem.c
+    }
+
+    return res;
 }



 static struct block_header* grow_heap( struct block_header* restrict last, size_t query ) {
-  /*  ??? */
+    if(last ==NULL){
+        return NULL;
+    }
+    struct region reg = alloc_region(block_after(last), query);
+    if(region_is_invalid(&reg)){
+        return NULL;
+    } else{