diff --git a/include/fs.h b/include/fs.h
index e91df8c..52e2eb6 100644
--- a/include/fs.h
+++ b/include/fs.h
@@ -7,6 +7,8 @@
 one inode equipped with one 512 bytes block
 
 *****************************************************/
+#define SECTOR_SIZE 512
+#define IO_BLOCK_SIZE 4096
 #define MAX_INODE 524288
 #define MAX_BLOCKNUM 62914560
 
@@ -20,7 +22,7 @@ public:
 
     }
     static off_t getFreeListHead(RawDisk &disk){
-        char buffer[512] = {0};
+        char buffer[SECTOR_SIZE] = {0};
         disk.rawdisk_read(0, buffer, sizeof(buffer));
         off_t t = 0;
         for (int j = 0; j < 8; j++)
@@ -29,7 +31,7 @@ public:
     }
 
     static void writeFreeListHead(RawDisk &disk, off_t t){
-        char buffer[512] = {0};
+        char buffer[SECTOR_SIZE] = {0};
         for (int j = 0; j < 8; j++){
             buffer[j] = (t >> (8 * j)) & 0xFF;
         }
@@ -58,9 +60,16 @@ public:
         current_pos += 8;
     }
 
+    off_t read_byte_at(int current_pos, char *buffer){
+        off_t t = 0;
+        for (int j = 0; j < 8; j++)
+            t = t | (((off_t)buffer[j+current_pos])<<(8*j));
+        return t;
+    }
+
     void inode_construct(off_t blockNumber, RawDisk &disk){
-        char buffer[512] = {0};
-        disk.rawdisk_read(blockNumber*512, buffer, sizeof(buffer));
+        char buffer[SECTOR_SIZE] = {0};
+        disk.rawdisk_read(blockNumber*SECTOR_SIZE, buffer, sizeof(buffer));
         block_number = blockNumber;
         int current_pos = 0;
         // initialize blocks
@@ -78,14 +87,21 @@ public:
 
     void write_get_byte(off_t t, int &current_pos, char *buffer){
         for (int j = 0; j < 8; j++){
-            buffer[j+current_pos] = t & (((off_t)1<<(8*j))-1);
+            buffer[j+current_pos] = t & (((off_t)1<<(8))-1);
             t >>= 8;
         }
         current_pos += 8;
     }
 
+    void write_byte_at(off_t t, int current_pos, char *buffer){
+        for (int j = 0; j < 8; j++){
+            buffer[j+current_pos] = t & (((off_t)1<<(8))-1);
+            t >>= 8;
+        }
+    }
+
     void inode_save(RawDisk &disk){
-        char buffer[512] = {0};
+        char buffer[SECTOR_SIZE] = {0};
         int current_pos = 0;
         for (int i = 0; i < 48; i++){
             write_get_byte(blocks[i], current_pos, buffer);
@@ -97,7 +113,7 @@ public:
         write_get_byte(gid, current_pos, buffer);
         write_get_byte(permissions, current_pos, buffer);
         write_get_byte(size, current_pos, buffer);
-        disk.rawdisk_write(block_number*512, buffer, sizeof(buffer));
+        disk.rawdisk_write(block_number*SECTOR_SIZE, buffer, sizeof(buffer));
     }
 
     off_t datablock_allocate_in_list(RawDisk &disk){
@@ -108,9 +124,9 @@ public:
         2. data block starting position
         3. r/w between storage and rawdisk to maintain 
         */
-        char buffer[512] = {0};
+        char buffer[IO_BLOCK_SIZE] = {0};
         off_t freeBlockNum = 0;
-        disk.rawdisk_read(freeListHead*512, buffer, sizeof(buffer));
+        disk.rawdisk_read(freeListHead, buffer, sizeof(buffer));
         for (int i = 8; i < 264; i++){
             if(buffer[i] != 255){
                 int j = 0;
@@ -120,9 +136,10 @@ public:
                         break;
                     }
                 }
-                freeBlockNum = freeListHead + (i-8)*8 + j + 1;
+                freeBlockNum = freeListHead + ((i-8)*8 + j + 1)*IO_BLOCK_SIZE;
             }
         }
+        disk.rawdisk_write(freeListHead, buffer, sizeof(buffer));
         bool notFull = false;
         for (int i = 8; i < 264; i++){
             if((i < 263 && buffer[i] != 255) || (i == 263 && buffer[i] != 127)){
@@ -144,14 +161,17 @@ public:
             single_i = datablock_allocate_in_list(disk);
         }
         bool inSingle = false;
-        char buffer[512] = {0};
-        disk.rawdisk_read(single_i*512, buffer, sizeof(buffer));
-        for (int i = 0; i < 512; i++){
-            if(buffer[i] == 0){
+        char buffer[IO_BLOCK_SIZE] = {0};
+        disk.rawdisk_read(single_i, buffer, sizeof(buffer));
+        for (int i = 0; i < IO_BLOCK_SIZE; i+=8){
+            off_t addr = read_byte_at(i, buffer);
+            if(addr == 0){
                 inSingle = true;
-                buffer[i] = freeBlockNum;
+                write_byte_at(freeBlockNum, i, buffer);
+                disk.rawdisk_write(single_i, buffer, sizeof(buffer));
                 break;
             }
+        }
         return inSingle;
     }
 
@@ -160,11 +180,14 @@ public:
             double_i = datablock_allocate_in_list(disk);
         }
         bool inDouble = false;
-        char buffer[512] = {0};
-        disk.rawdisk_read(double_i*512, buffer, sizeof(buffer));
-        for (int i = 0; i < 512; i++){
-            bool flag = allo_single_indirect(disk, buffer[i], freeBlockNum);
+        char buffer[IO_BLOCK_SIZE] = {0};
+        disk.rawdisk_read(double_i, buffer, sizeof(buffer));
+        for (int i = 0; i < IO_BLOCK_SIZE; i+=8){
+            off_t addr = read_byte_at(i, buffer);
+            bool flag = allo_single_indirect(disk, addr, freeBlockNum);
             if (flag){
+                write_byte_at(addr, i, buffer);
+                disk.rawdisk_write(double_i, buffer, sizeof(buffer));
                 inDouble = true;
                 break;
             }
@@ -177,11 +200,14 @@ public:
             triple_i = datablock_allocate_in_list(disk);
         }
         bool inTriple = false;
-        char buffer[512] = {0};
-        disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer));
-        for (int i = 0; i < 512, i++){
-            bool flag = allo_double_indirect(disk, buffer[i], freeBlockNum);
+        char buffer[IO_BLOCK_SIZE] = {0};
+        disk.rawdisk_read(triple_i, buffer, sizeof(buffer));
+        for (int i = 0; i < IO_BLOCK_SIZE, i+=8){
+            off_t addr = read_byte_at(i, buffer);
+            bool flag = allo_double_indirect(disk, addr, freeBlockNum);
             if (flag){
+                write_byte_at(addr, i, buffer);
+                disk.rawdisk_write(triple_i, buffer, sizeof(buffer));
                 inTriple = true;
                 break;
             }
@@ -220,77 +246,118 @@ public:
     }
 
     void datablock_deallocate_in_list(off_t freeBlockNum) {
+        // find the related 2048block head
 
+        // mark it alive in its bitmap
+
+        // if its bitmap was 0, add it back to the list head
     }
 
-    bool deallow_single_indirect(RawDisk &disk, off_t &single_i){
+    off_t deallo_single_indirect(RawDisk &disk, off_t &single_i){
         if (single_i == 0){
-            return false;
+            return 0;
         }
-        char buffer[512] = {0};
+        off_t freeBlockNum = 0;
+        char buffer[IO_BLOCK_SIZE] = {0};
         int delpoint = -1;
-        disk.rawdisk_read(single_i*512, buffer, sizeof(buffer));
-        for (int i=255; i >= 0; i--)
-            if(buffer[i] != 0){
-                buffer[i] = 0;
+        disk.rawdisk_read(single_i, buffer, sizeof(buffer));
+        for (int i=4088; i >= 0; i--){
+            off_t addr = read_byte_at(i, buffer);
+            if(addr != 0){
+                freeBlockNum = addr;
+                addr = 0;
+                write_byte_at(addr, i, buffer);
                 delpoint = i;
                 break;
             }
-        if (delpoint == 0 && buffer[0] == 0){
+        }
+        disk.rawdisk_read(triple_i, buffer, sizeof(buffer));
+        off_t addr = read_byte_at(0, buffer);
+        if (delpoint == 0 && addr == 0){
             datablock_deallocate_in_list(single_i);
             single_i = 0;
         }
-        return true;
+        return freeBlockNum;
     }
 
-    bool deallow_double_indirect(RawDisk &disk, off_t &double_i){
+    bool deallo_double_indirect(RawDisk &disk, off_t &double_i){
         if (double_i == 0){
             return false;
         }
-        char buffer[512] = {0};
+        off_t freeBlockNum = 0;
+        char buffer[IO_BLOCK_SIZE] = {0};
         int delpoint = -1;
-        disk.rawdisk_read(double_i*512, buffer, sizeof(buffer));
-        for (int i=255; i >= 0; i--){
-            bool inSingle = deallo_single_indirect(disk, buffer[i]);
+        disk.rawdisk_read(double_i, buffer, sizeof(buffer));
+        for (int i=4088; i >= 0; i-=8){
+            off_t addr = read_byte_at(i, buffer);
+            off_t inSingle = deallo_single_indirect(disk, addr);
             if (inSingle){
+                freeBlockNum = inSingle;
+                write_byte_at(addr, i, buffer);
                 delpoint = i;
                 break;
             }
         }
-        if (delpoint == 0 && buffer[0] == 0){
+        disk.rawdisk_read(triple_i, buffer, sizeof(buffer));
+        off_t addr = read_byte_at(0, buffer);
+        if (delpoint == 0 && addr == 0){
             datablock_deallocate_in_list(double_i);
             double_i = 0;
         }
-        return true;
+        return freeBlockNum;
     }
 
     bool deallo_triple_indirect(RawDisk &disk, off_t &triple_i){
         if (triple_i == 0){
             return false;
         }
-        char buffer[512] = {0};
+        off_t freeBlockNum = 0;
+        char buffer[IO_BLOCK_SIZE] = {0};
         int delpoint = -1;
-        disk.rawdisk_read(triple_i*512, buffer, sizeof(buffer));
-        for (int i=255; i >= 0; i--){
-            bool inDouble = deallo_double_indirect(disk, buffer[i]);
+        disk.rawdisk_read(triple_i, buffer, sizeof(buffer));
+        for (int i=4088; i >= 0; i-=8){
+            off_t addr = read_byte_at(i, buffer);
+            off_t inDouble = deallo_double_indirect(disk, addr);
             if (inDouble){
+                freeBlockNum = inDouble;
+                write_byte_at(addr, i, buffer);
                 delpoint = i;
                 break;
             }
         }
-        if (delpoint == 0 && buffer[0] == 0){
+        disk.rawdisk_read(triple_i, buffer, sizeof(buffer));
+        off_t addr = read_byte_at(0, buffer);
+        if (delpoint == 0 && addr == 0){
             datablock_deallocate_in_list(triple_i);
             triple_i = 0;
         }
-        return true;
+        return freeBlockNum;
     }
 
     // deallocate 1 datablock from the end of the file
     void datablock_deallocate(RawDisk &disk){
         // find the last datablock and remove it from inode (triple->direct)
-        
+        off_t freeBlockNum = 0;
+        freeBlockNum = deallo_triple_indirect(disk, triple_indirect);
+        if(!freeBlockNum){
+            freeBlockNum = deallo_double_indirect(disk, double_indirect);
+            if(!freeBlockNum){
+                freeBlockNum = deallo_single_indirect(disk, single_indirect);
+                if(!freeBlockNum){
+                    for(int i = 47; i>=0; i--)
+                        if(blocks[i] != 0){
+                            freeBlockNum = block[i];
+                            blocks[i] = 0;
+                            break;
+                        }
+                    // deal with empty
+                }
+            }
+        }
 
         // add it back to freeBlocklist
+        datablock_deallocate_in_list(freeBlockNum);
+        inode_save(disk);
     }
 };
 
@@ -300,17 +367,17 @@ class INodeOperation{
 public:
     //initialization of the rawdisk
     void initialize(RawDisk &disk){
-        SuperBlock::writeFreeListHead(disk, MAX_INODE); // maximum inode number 2^19 0x80000
+        SuperBlock::writeFreeListHead(disk, MAX_INODE*SECTOR_SIZE); // maximum inode number 2^19 0x80000
         //Have tested this initialize function but MAX_BLOCK too much, MAX_INODE*2 works
-        for (off_t i = MAX_INODE; i < MAX_BLOCKNUM; i += 2048){
-            char buffer[512] = {0};
-            off_t t = i + 2048;
+        for (off_t i = MAX_INODE; i < MAX_BLOCKNUM-4096; i += 2048*8){
+            char buffer[IO_BLOCK_SIZE] = {0};
+            off_t t = (i + 2048*8)*SECTOR_SIZE;
             if (t < MAX_BLOCKNUM){
                 for (int j = 0; j < 8; j++){
                     buffer[j] = (t >> (8 * j)) & 0xFF;
                 }
             }
-            disk.rawdisk_write(i*512, buffer, sizeof(buffer));
+            disk.rawdisk_write(i*SECTOR_SIZE, buffer, sizeof(buffer));
         }
     }