public void reorganization() throws ExitException, IOException {

        RandomAccessFile new_file = new RandomAccessFile("tmp.txt", "rw");
        new_file.setLength(0);
        int main_page_counter = 0;
        byte[] overflow_page = new byte[PAGE_SIZE];
        int overflow_off = 0;
        byte[] new_page = new byte[PAGE_SIZE];
        int new_off = 0;
        int tmp;
        ByteBuffer new_wrapper = ByteBuffer.wrap(new_page);
        ByteBuffer wrapper = ByteBuffer.wrap(this.databaseFile.getBuffer());
        ByteBuffer overflow_wrapper = ByteBuffer.wrap(overflow_page);
        this.databaseFile.setBufferOffset(0);
        this.databaseFile.seek(MAX_MAIN);

        try{
            this.databaseFile.read(overflow_page);
            this.read_counter++;
            this.databaseFile.seek(0);
            while(main_page_counter < pageAmount && this.databaseFile.read(this.databaseFile.getBuffer()) != -1) {
                main_page_counter++;
                this.read_counter++;
                while(this.databaseFile.getBuffer().length - this.databaseFile.getBufferOffset() >= RECORD_SIZE) {
                    if(new_off == PAGE_SIZE - ALFA * RECORD_SIZE) {
                        new_off = 0;
                        new_file.write(new_page);
                        write_counter++;
                        new_page = new byte[PAGE_SIZE];
                        new_wrapper = ByteBuffer.wrap(new_page);
                    }
                    if(overflow_off / RECORD_SIZE == this.overflow_counter || wrapper.getInt(this.databaseFile.getBufferOffset()) < overflow_wrapper.getInt(overflow_off)) {
                        new_wrapper.putInt(new_off, wrapper.getInt(this.databaseFile.getBufferOffset()));
                        new_wrapper.putFloat(new_off + 12, wrapper.getFloat(this.databaseFile.getBufferOffset() + 12));
                        new_wrapper.putDouble(new_off + 4, wrapper.getDouble(this.databaseFile.getBufferOffset() + 4));
                        new_wrapper.putInt(new_off + 16, wrapper.getInt(this.databaseFile.getBufferOffset() + 16));
                        new_off += RECORD_SIZE;
                        this.databaseFile.setBufferOffset(this.databaseFile.getBufferOffset() + RECORD_SIZE);
                    } else {
                        new_wrapper.putInt(new_off, overflow_wrapper.getInt(overflow_off));
                        new_wrapper.putFloat(new_off + 12, overflow_wrapper.getFloat(overflow_off + 12));
                        new_wrapper.putDouble(new_off + 4, overflow_wrapper.getDouble(overflow_off + 4));
                        new_wrapper.putInt(new_off + 16, overflow_wrapper.getInt(overflow_off + 16));
                        new_off += RECORD_SIZE;
                        overflow_off += RECORD_SIZE;
                    }
                    tmp = new_wrapper.getInt(new_off - 4);      //latest pointer
                        //if there's a list of elements
                    while(tmp != 0 && overflow_off / RECORD_SIZE < this.overflow_counter) {
                        new_wrapper.putInt(new_off - 4, 0);
                        if(new_off == PAGE_SIZE - ALFA * RECORD_SIZE) {
                            new_file.write(new_page);
                            this.write_counter++;
                            new_off = 0;
                            new_page = new byte[PAGE_SIZE];
                            new_wrapper = ByteBuffer.wrap(new_page);
                        }
                        while(overflow_wrapper.getInt(overflow_off) != tmp) {
                            overflow_off += RECORD_SIZE;
                        }
                        new_wrapper.putInt(new_off, overflow_wrapper.getInt(overflow_off));
                        new_wrapper.putFloat(new_off + 12, overflow_wrapper.getFloat(overflow_off + 12));
                        new_wrapper.putDouble(new_off + 4, overflow_wrapper.getDouble(overflow_off + 4));
                        new_wrapper.putInt(new_off + 16, overflow_wrapper.getInt(overflow_off + 16));
                        new_off += RECORD_SIZE;
                        overflow_off += RECORD_SIZE;
                        tmp = new_wrapper.getInt(new_off - 4);
                    }
                }
                this.databaseFile.setBufferOffset(0);
            }
        }
        catch (Exception e) {
            //End of file
        }
        new_file.write(new_page);
        this.write_counter++;
        new_page = new byte[PAGE_SIZE];
        new_wrapper = ByteBuffer.wrap(new_page);

        //rewriting files and creating new index file
        this.indexFile.seek(0);
        new_file.seek(0);
        this.databaseFile.seek(0);
        int i = 1;
        int index_off = 0;
        this.indexFile.setBuffer(new byte[PAGE_SIZE]);
        ByteBuffer index_wrapper = ByteBuffer.wrap(this.indexFile.getBuffer());
        pageAmount = 0;
        this.databaseFile.setLength(0);
        while(new_file.read(new_page) != -1) {
            pageAmount++;
            this.read_counter++;
            index_wrapper.putInt(index_off, new_wrapper.getInt(0));
            index_wrapper.putInt(index_off + 4, i++);
            index_off += INDEX_RECORD_SIZE;
            this.databaseFile.write(new_page);
            this.write_counter++;
        }
        this.indexFile.write(this.indexFile.getBuffer());
        this.databaseFile.write(new byte[PAGE_SIZE]);
        //overflow area
        new_file.close();

        this.MAX_MAIN = PAGE_SIZE * pageAmount;
        this.overflow_counter = 0;
        this.OVERFLOW_SIZE = 2 * pageAmount * RECORD_SIZE;

    }