Rewrite of file i/o.

Do not read and write data blocks in whole chunks. Read and
write value by value and do the md5 summing in steps.
This hopefully avoids memory alignment problems reported
on ARM architectures.

Fixed a bug freeing trajectory mapping memory.

Change-Id: I3438b3d3faf5349dcd477a31cfb4bacf236ed582

7 files changed, 2707 insertions, 2707 deletions

diff --git a/src/lib/tng_io.c b/src/lib/tng_io.c
index d0028bd..6e0f915 100644
--- a/src/lib/tng_io.c
+++ b/src/lib/tng_io.c
@@ -9,6 +9,8 @@
  * modify it under the terms of the Revised BSD License.
  */
 
+#include "tng/tng_io.h"
+
 #ifdef USE_STD_INTTYPES_H
 #include <inttypes.h>
 #endif
@@ -22,11 +24,16 @@
 #include <zlib.h>
 #endif
 
-#include "tng/tng_io.h"
 #include "tng/md5.h"
 #include "compression/tng_compress.h"
 #include "tng/version.h"
 
+#ifdef _MSC_VER
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#endif
+
+
 
 struct tng_bond {
     /** One of the atoms of the bond */
@@ -260,7 +267,7 @@ struct tng_trajectory {
     /** A handle to the input file */
     FILE *input_file;
     /** The length of the input file */
-    long input_file_len;
+    int64_t input_file_len;
     /** The path of the output trajectory file */
     char *output_file_path;
     /** A handle to the output file */
@@ -345,9 +352,9 @@ struct tng_trajectory {
     /** The currently active frame set */
     struct tng_trajectory_frame_set current_trajectory_frame_set;
     /** The pos in the src file of the current frame set */
-    long current_trajectory_frame_set_input_file_pos;
+    int64_t current_trajectory_frame_set_input_file_pos;
     /** The pos in the dest file of the current frame set */
-    long current_trajectory_frame_set_output_file_pos;
+    int64_t current_trajectory_frame_set_output_file_pos;
     /** The number of frame sets in the trajectory N.B. Not saved in file and
      *  cannot be trusted to be up-to-date */
     int64_t n_trajectory_frame_sets;
@@ -613,54 +620,110 @@ static tng_function_status tng_swap_byte_order_little_endian_64
         return(TNG_FAILURE);
     }
 }
-/** Generate the md5 hash of a block.
- * The hash is created based on the actual block contents.
- * @param block is a general block container.
- * @return TNG_SUCCESS (0) if successful.
- */
-static tng_function_status tng_block_md5_hash_generate(tng_gen_block_t block)
+
+static TNG_INLINE void tng_var_32_bit_input_swap(tng_trajectory_t tng_data, int32_t *var)
 {
-    md5_state_t md5_state;
+    if(tng_data->input_endianness_swap_func_32)
+    {
+        if(tng_data->input_endianness_swap_func_32(tng_data, var)
+            != TNG_SUCCESS)
+        {
+            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                    __FILE__, __LINE__);
+        }
+    }
+}
 
-    md5_init(&md5_state);
-    md5_append(&md5_state, (md5_byte_t *)block->block_contents,
-               (int)block->block_contents_size);
-    md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+static TNG_INLINE void tng_var_64_bit_input_swap(tng_trajectory_t tng_data, int64_t *var)
+{
+    if(tng_data->input_endianness_swap_func_64)
+    {
+        if(tng_data->input_endianness_swap_func_64(tng_data, var)
+            != TNG_SUCCESS)
+        {
+            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                    __FILE__, __LINE__);
+        }
+    }
+}
 
-    return(TNG_SUCCESS);
+static TNG_INLINE void tng_var_32_bit_output_swap(tng_trajectory_t tng_data, int32_t *var)
+{
+    if(tng_data->output_endianness_swap_func_32)
+    {
+        if(tng_data->output_endianness_swap_func_32(tng_data, var)
+            != TNG_SUCCESS)
+        {
+            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                    __FILE__, __LINE__);
+        }
+    }
 }
 
-/** Compare the current block md5 hash (e.g. read from file) with the md5 hash
- * calculated from the current contents.
- * If the current md5 hash is not set skip the comparison.
- * @param block is a general block container.
- * @param results If the hashes match results is set to TNG_TRUE, otherwise it is
- * set to TNG_FALSE. If the hash was not set results is set to TNG_TRUE.
- * @return TNG_SUCCESS (0) if successful or TNG_FAILURE (1) if the hash was not
- * set.
- */
-static tng_function_status tng_md5_hash_match_verify(tng_gen_block_t block,
-                                                     tng_bool *results)
+static TNG_INLINE void tng_var_64_bit_output_swap(tng_trajectory_t tng_data, int64_t *var)
 {
-    md5_state_t md5_state;
-    char hash[TNG_MD5_HASH_LEN];
+    if(tng_data->output_endianness_swap_func_64)
+    {
+        if(tng_data->output_endianness_swap_func_64(tng_data, var)
+            != TNG_SUCCESS)
+        {
+            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                    __FILE__, __LINE__);
+        }
+    }
+}
 
-    TNG_ASSERT(block->block_contents_size > 0, "The block contents size must be > 0");
+static int tng_freadstr(FILE* f, char** str)
+{
+    char temp[TNG_MAX_STR_LEN], *temp_alloc;
+    int c, count = 0;
 
-    *results = TNG_TRUE;
-    if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16) == 0)
+    do
     {
-        return(TNG_FAILURE);
+        c = fgetc(f);
+
+        if (c == EOF)
+        {
+            /* Clear file error flag and return -1 if EOF is read.*/
+            clearerr(f);
+            return -1;
+        }
+        else
+        {
+            /* Cast c to char */
+            temp[count++] = (char) c;
+        }
+    } while ((temp[count-1] != '\0') && (count < TNG_MAX_STR_LEN));
+
+    temp_alloc = realloc(*str, count);
+    if(!temp_alloc)
+    {
+        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", count,
+               __FILE__, __LINE__);
+        free(*str);
+        *str = 0;
+        return -1;
     }
+    *str = temp_alloc;
+
+    strncpy(*str, temp, count);
+
+    return count;
+}
+
+/** Generate the md5 hash of a block.
+ * The hash is created based on the actual block contents.
+ * @param block is a general block container.
+ * @return TNG_SUCCESS (0) if successful.
+ */
+static tng_function_status tng_block_md5_hash_generate(tng_gen_block_t block)
+{
+    md5_state_t md5_state;
+
     md5_init(&md5_state);
     md5_append(&md5_state, (md5_byte_t *)block->block_contents,
                (int)block->block_contents_size);
-    md5_finish(&md5_state, (md5_byte_t *)hash);
-
-    if(strncmp(block->md5_hash, hash, 16) != 0)
-    {
-        *results = TNG_FALSE;
-    }
+    md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
 
     return(TNG_SUCCESS);
 }
@@ -741,7 +804,7 @@ static tng_function_status tng_block_init(struct tng_gen_block **block_p)
 
     block->id = -1;
     /* Reset the md5_hash */
-    memcpy(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN);
+    memset(block->md5_hash, '\0', TNG_MD5_HASH_LEN);
     block->name = 0;
     block->block_version = TNG_API_VERSION;
     block->header_contents = 0;
@@ -801,7 +864,7 @@ static tng_function_status tng_block_destroy(struct tng_gen_block **block_p)
 static tng_function_status tng_block_header_read
                 (tng_trajectory_t tng_data, tng_gen_block_t block)
 {
-    int len, offset = 0;
+    int64_t start_pos;
 
     TNG_ASSERT(block != 0, "TNG library: Trying to read to uninitialized block (NULL pointer).");
 
@@ -810,6 +873,8 @@ static tng_function_status tng_block_header_read
         return(TNG_CRITICAL);
     }
 
+    start_pos = ftello(tng_data->input_file);
+
     /* First read the header size to be able to read the whole header. */
     if(fread(&block->header_contents_size, sizeof(block->header_contents_size),
         1, tng_data->input_file) == 0)
@@ -826,7 +891,7 @@ static tng_function_status tng_block_header_read
     }
 
     /* If this was the size of the general info block check the endianness */
-    if(ftell(tng_data->input_file) < 9)
+    if(ftello(tng_data->input_file) < 9)
     {
         /* File is little endian */
         if ( *((const char*)&block->header_contents_size) != 0x00 &&
@@ -881,114 +946,41 @@ static tng_function_status tng_block_header_read
         }
     }
 
-    if(tng_data->input_endianness_swap_func_64)
-    {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &block->header_contents_size)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
-    }
-
-    /* Move the reading position to the beginning of the header. */
-    fseek(tng_data->input_file, -(long)sizeof(block->header_contents_size),
-          SEEK_CUR);
-
-    /* If there is already memory allocated for the contents free it (we do not
-     * know if the size is correct). */
-    if(block->header_contents)
-    {
-        free(block->header_contents);
-    }
+    tng_var_64_bit_input_swap(tng_data, &block->header_contents_size);
 
-    block->header_contents = malloc(block->header_contents_size);
-    if(!block->header_contents)
+    if(fread(&block->block_contents_size, sizeof(block->block_contents_size),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->header_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    tng_var_64_bit_input_swap(tng_data, &block->block_contents_size);
 
-    /* Read the whole header into header_contents. This way it can be saved
-     * even if it cannot be interpreted
-     * for one reason or another. */
-    if(fread(block->header_contents, block->header_contents_size, 1,
-        tng_data->input_file) == 0)
+    if(fread(&block->id, sizeof(block->id),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot read header. %s: %d\n", __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    tng_var_64_bit_input_swap(tng_data, &block->id);
 
-    /* The header contents size has already been read. Skip ahead. */
-    offset = sizeof(block->header_contents_size);
-
-
-    /* Copy the respective parameters from the header contents block */
-    memcpy(&block->block_contents_size, block->header_contents+offset,
-           sizeof(block->block_contents_size));
-    if(tng_data->input_endianness_swap_func_64)
-    {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &block->block_contents_size)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
-    }
-
-    offset += sizeof(block->block_contents_size);
-
-    memcpy(&block->id, block->header_contents+offset, sizeof(block->id));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &block->id)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
 
-    offset += sizeof(block->id);
+    tng_freadstr(tng_data->input_file, &block->name);
 
-    memcpy(block->md5_hash, block->header_contents+offset, TNG_MD5_HASH_LEN);
-    offset += TNG_MD5_HASH_LEN;
-
-    if(block->name && strcmp(block->name, block->header_contents+offset) != 0)
-    {
-        free(block->name);
-        block->name = 0;
-    }
-    len = tng_min_i((int)strlen(block->header_contents+offset) + 1, TNG_MAX_STR_LEN);
-    if(!block->name)
+    if(fread(&block->block_version, sizeof(block->block_version),
+             1, tng_data->input_file) == 0)
     {
-        block->name = malloc(len);
-        if(!block->name)
-        {
-            fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-                    __FILE__, __LINE__);
-            return(TNG_CRITICAL);
-        }
-        strncpy(block->name, block->header_contents+offset, len);
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += len;
+    tng_var_64_bit_input_swap(tng_data, &block->block_version);
 
-    memcpy(&block->block_version, block->header_contents+offset,
-           sizeof(block->block_version));
-    if(tng_data->input_endianness_swap_func_64)
-    {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &block->block_version)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
-    }
+    fseeko(tng_data->input_file, start_pos + block->header_contents_size, SEEK_SET);
 
     return(TNG_SUCCESS);
 }
@@ -1061,7 +1053,7 @@ static tng_function_status tng_md5_hash_update(tng_trajectory_t tng_data,
         return(TNG_CRITICAL);
     }
 
-    fseek(tng_data->output_file, (long)contents_start_pos, SEEK_SET);
+    fseeko(tng_data->output_file, contents_start_pos, SEEK_SET);
     if(fread(block->block_contents, block->block_contents_size, 1,
             tng_data->output_file) == 0)
     {
@@ -1071,7 +1063,7 @@ static tng_function_status tng_md5_hash_update(tng_trajectory_t tng_data,
 
     tng_block_md5_hash_generate(block);
 
-    fseek(tng_data->output_file, (long)header_start_pos + 3 * sizeof(int64_t),
+    fseeko(tng_data->output_file, header_start_pos + 3 * sizeof(int64_t),
           SEEK_SET);
     fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file);
 
@@ -1104,8 +1096,8 @@ static tng_function_status tng_header_pointers_update
 
     tng_block_init(&block);
 
-    output_file_pos = ftell(tng_data->output_file);
-    fseek(tng_data->output_file, 0, SEEK_SET);
+    output_file_pos = ftello(tng_data->output_file);
+    fseeko(tng_data->output_file, 0, SEEK_SET);
 
     if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
     {
@@ -1116,10 +1108,10 @@ static tng_function_status tng_header_pointers_update
         return(TNG_CRITICAL);
     }
 
-    contents_start_pos = ftell(tng_data->output_file);
+    contents_start_pos = ftello(tng_data->output_file);
 
-    fseek(tng_data->output_file, (long)block->block_contents_size - 5 *
-          sizeof(int64_t), SEEK_CUR);
+    fseeko(tng_data->output_file, block->block_contents_size - 5 *
+           sizeof(int64_t), SEEK_CUR);
 
     tng_data->input_file = temp;
 
@@ -1169,7 +1161,7 @@ static tng_function_status tng_header_pointers_update
 
     tng_block_destroy(&block);
 
-    fseek(tng_data->output_file, (long)output_file_pos, SEEK_SET);
+    fseeko(tng_data->output_file, output_file_pos, SEEK_SET);
 
     return(TNG_SUCCESS);
 }
@@ -1199,7 +1191,7 @@ static tng_function_status tng_frame_set_pointers_update
     }
 
     tng_block_init(&block);
-    output_file_pos = ftell(tng_data->output_file);
+    output_file_pos = ftello(tng_data->output_file);
 
     tng_data->input_file = tng_data->output_file;
 
@@ -1210,8 +1202,7 @@ static tng_function_status tng_frame_set_pointers_update
     /* Update next frame set */
     if(frame_set->next_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file, (long)frame_set->next_frame_set_file_pos,
-              SEEK_SET);
+        fseeko(tng_data->output_file, frame_set->next_frame_set_file_pos, SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
         {
@@ -1222,9 +1213,9 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (5 *
+        fseeko(tng_data->output_file, block->block_contents_size - (5 *
             sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
@@ -1250,12 +1241,12 @@ static tng_function_status tng_frame_set_pointers_update
             tng_md5_hash_update(tng_data, block, frame_set->next_frame_set_file_pos,
                                 contents_start_pos);
         }
-        fseek(tng_data->output_file, (long)output_file_pos, SEEK_SET);
+        fseeko(tng_data->output_file, output_file_pos, SEEK_SET);
     }
     /* Update previous frame set */
     if(frame_set->prev_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file, (long)frame_set->prev_frame_set_file_pos,
+        fseeko(tng_data->output_file, frame_set->prev_frame_set_file_pos,
               SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
@@ -1267,9 +1258,9 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (6 *
+        fseeko(tng_data->output_file, block->block_contents_size - (6 *
             sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
@@ -1295,14 +1286,14 @@ static tng_function_status tng_frame_set_pointers_update
             tng_md5_hash_update(tng_data, block, frame_set->prev_frame_set_file_pos,
                                 contents_start_pos);
         }
-        fseek(tng_data->output_file, (long)output_file_pos, SEEK_SET);
+        fseeko(tng_data->output_file, output_file_pos, SEEK_SET);
     }
 
     /* Update the frame set one medium stride step after */
     if(frame_set->medium_stride_next_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file,
-              (long)frame_set->medium_stride_next_frame_set_file_pos,
+        fseeko(tng_data->output_file,
+              frame_set->medium_stride_next_frame_set_file_pos,
               SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
@@ -1314,9 +1305,9 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (3 *
+        fseeko(tng_data->output_file, block->block_contents_size - (3 *
             sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
@@ -1347,9 +1338,9 @@ static tng_function_status tng_frame_set_pointers_update
     /* Update the frame set one medium stride step before */
     if(frame_set->medium_stride_prev_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file,
-              (long)frame_set->medium_stride_prev_frame_set_file_pos,
-              SEEK_SET);
+        fseeko(tng_data->output_file,
+               frame_set->medium_stride_prev_frame_set_file_pos,
+               SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
         {
@@ -1360,10 +1351,10 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (4 *
-            sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
+        fseeko(tng_data->output_file, block->block_contents_size - (4 *
+               sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
         {
@@ -1394,9 +1385,9 @@ static tng_function_status tng_frame_set_pointers_update
     /* Update the frame set one long stride step after */
     if(frame_set->long_stride_next_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file,
-              (long)frame_set->long_stride_next_frame_set_file_pos,
-              SEEK_SET);
+        fseeko(tng_data->output_file,
+               frame_set->long_stride_next_frame_set_file_pos,
+               SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
         {
@@ -1407,10 +1398,10 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (1 *
-            sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
+        fseeko(tng_data->output_file, block->block_contents_size - (1 *
+               sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
         {
@@ -1440,9 +1431,9 @@ static tng_function_status tng_frame_set_pointers_update
     /* Update the frame set one long stride step before */
     if(frame_set->long_stride_prev_frame_set_file_pos > 0)
     {
-        fseek(tng_data->output_file,
-              (long)frame_set->long_stride_prev_frame_set_file_pos,
-              SEEK_SET);
+        fseeko(tng_data->output_file,
+               frame_set->long_stride_prev_frame_set_file_pos,
+               SEEK_SET);
 
         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
         {
@@ -1453,10 +1444,10 @@ static tng_function_status tng_frame_set_pointers_update
             return(TNG_CRITICAL);
         }
 
-        contents_start_pos = ftell(tng_data->output_file);
+        contents_start_pos = ftello(tng_data->output_file);
 
-        fseek(tng_data->output_file, (long)block->block_contents_size - (2 *
-            sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
+        fseeko(tng_data->output_file, block->block_contents_size - (2 *
+               sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
         if(tng_data->input_endianness_swap_func_64)
         {
@@ -1484,7 +1475,7 @@ static tng_function_status tng_frame_set_pointers_update
         }
     }
 
-    fseek(tng_data->output_file, (long)output_file_pos, SEEK_SET);
+    fseeko(tng_data->output_file, output_file_pos, SEEK_SET);
 
     tng_data->input_file = temp;
 
@@ -1502,7 +1493,7 @@ static tng_function_status tng_reread_frame_set_at_file_pos
 
     tng_block_init(&block);
 
-    fseek(tng_data->input_file, pos, SEEK_SET);
+    fseeko(tng_data->input_file, pos, SEEK_SET);
     if(pos > 0)
     {
         stat = tng_block_header_read(tng_data, block);
@@ -1537,7 +1528,7 @@ static tng_function_status tng_file_pos_of_subsequent_trajectory_block_get
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
 
-    orig_pos = ftell(tng_data->input_file);
+    orig_pos = ftello(tng_data->input_file);
     curr_frame_set_pos = tng_data->current_trajectory_frame_set_input_file_pos;
 
     *pos = tng_data->first_trajectory_frame_set_input_file_pos;
@@ -1547,7 +1538,7 @@ static tng_function_status tng_file_pos_of_subsequent_trajectory_block_get
         return(TNG_SUCCESS);
     }
 
-    fseek(tng_data->input_file, *pos, SEEK_SET);
+    fseeko(tng_data->input_file, *pos, SEEK_SET);
 
     tng_block_init(&block);
     /* Read block headers first to see that a frame set block is found. */
@@ -1570,7 +1561,7 @@ static tng_function_status tng_file_pos_of_subsequent_trajectory_block_get
     /* Read all frame set blocks (not the blocks between them) */
     while(frame_set->next_frame_set_file_pos > 0)
     {
-        fseek(tng_data->input_file, frame_set->next_frame_set_file_pos, SEEK_SET);
+        fseeko(tng_data->input_file, frame_set->next_frame_set_file_pos, SEEK_SET);
         stat = tng_block_header_read(tng_data, block);
         if(stat == TNG_CRITICAL)
         {
@@ -1601,7 +1592,7 @@ static tng_function_status tng_file_pos_of_subsequent_trajectory_block_get
     /* Re-read the frame set that used to be the current one */
     tng_reread_frame_set_at_file_pos(tng_data, curr_frame_set_pos);
 
-    fseek(tng_data->input_file, orig_pos, SEEK_SET);
+    fseeko(tng_data->input_file, orig_pos, SEEK_SET);
 
     tng_block_destroy(&block);
 
@@ -1612,9 +1603,9 @@ static tng_function_status tng_frame_set_complete_migrate
                 (tng_trajectory_t tng_data,
                  int64_t block_start_pos,
                  int64_t block_len,
-                 int64_t new_pos)
+                 int64_t new_pos,
+                 const char hash_mode)
 {
-    int64_t i;
     tng_bool updated = TNG_FALSE;
 
     char *contents;
@@ -1624,7 +1615,7 @@ static tng_function_status tng_frame_set_complete_migrate
         return(TNG_CRITICAL);
     }
 
-    fseek(tng_data->input_file, block_start_pos, SEEK_SET);
+    fseeko(tng_data->input_file, block_start_pos, SEEK_SET);
 
     contents = malloc(block_len);
     if(!contents)
@@ -1641,7 +1632,7 @@ static tng_function_status tng_frame_set_complete_migrate
         free(contents);
         return(TNG_CRITICAL);
     }
-    fseek(tng_data->output_file, new_pos, SEEK_SET);
+    fseeko(tng_data->output_file, new_pos, SEEK_SET);
 
     if(fwrite(contents, block_len, 1, tng_data->output_file) != 1)
     {
@@ -1653,7 +1644,7 @@ static tng_function_status tng_frame_set_complete_migrate
 
     tng_data->current_trajectory_frame_set_output_file_pos = new_pos;
 
-    tng_frame_set_pointers_update(tng_data, TNG_USE_HASH);
+    tng_frame_set_pointers_update(tng_data, hash_mode);
 
     /* Update the general info block if needed */
     if(block_start_pos == tng_data->first_trajectory_frame_set_output_file_pos)
@@ -1668,15 +1659,12 @@ static tng_function_status tng_frame_set_complete_migrate
     }
     if(updated)
     {
-        tng_header_pointers_update(tng_data, TNG_USE_HASH);
+        tng_header_pointers_update(tng_data, hash_mode);
     }
 
     /* Fill the block with NULL to avoid confusion. */
-    for(i = 0; i < block_len; i++)
-    {
-        contents[i] = '\0';
-    }
-    fseek(tng_data->output_file, block_start_pos, SEEK_SET);
+    memset(contents, '\0', block_len);
+    fseeko(tng_data->output_file, block_start_pos, SEEK_SET);
 
     /* FIXME: casting block_len to size_t is dangerous */
     fwrite(contents, 1, block_len, tng_data->output_file);
@@ -1694,12 +1682,12 @@ static tng_function_status tng_length_of_current_frame_set_contents_get
     tng_gen_block_t block;
     tng_function_status stat;
 
-    orig_pos = ftell(tng_data->input_file);
+    orig_pos = ftello(tng_data->input_file);
     curr_frame_set_pos = pos = tng_data->current_trajectory_frame_set_input_file_pos;
 
     *len = 0;
 
-    fseek(tng_data->input_file, curr_frame_set_pos, SEEK_SET);
+    fseeko(tng_data->input_file, curr_frame_set_pos, SEEK_SET);
 
     tng_block_init(&block);
     /* Read block headers first to see that a frame set block is found. */
@@ -1715,7 +1703,7 @@ static tng_function_status tng_length_of_current_frame_set_contents_get
     /* Read the headers of all blocks in the frame set (not the actual contents of them) */
     while(stat == TNG_SUCCESS)
     {
-        fseek(tng_data->input_file, block->block_contents_size, SEEK_CUR);
+        fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
         *len += block->header_contents_size + block->block_contents_size;
         pos += block->header_contents_size + block->block_contents_size;
         if(pos >= tng_data->input_file_len)
@@ -1732,7 +1720,7 @@ static tng_function_status tng_length_of_current_frame_set_contents_get
     /* Re-read the frame set that used to be the current one */
     tng_reread_frame_set_at_file_pos(tng_data, curr_frame_set_pos);
 
-    fseek(tng_data->input_file, orig_pos, SEEK_SET);
+    fseeko(tng_data->input_file, orig_pos, SEEK_SET);
 
     tng_block_destroy(&block);
 
@@ -1753,7 +1741,8 @@ static tng_function_status tng_length_of_current_frame_set_contents_get
 static tng_function_status tng_migrate_data_in_file
                 (tng_trajectory_t tng_data,
                  int64_t start_pos,
-                 int64_t offset)
+                 int64_t offset,
+                 const char hash_mode)
 {
     int64_t traj_start_pos, empty_space, orig_file_pos, frame_set_length;
     tng_gen_block_t block;
@@ -1783,12 +1772,12 @@ static tng_function_status tng_migrate_data_in_file
         return(TNG_SUCCESS);
     }
 
-    orig_file_pos = ftell(tng_data->input_file);
+    orig_file_pos = ftello(tng_data->input_file);
     tng_block_init(&block);
 
     while(empty_space < offset)
     {
-        fseek(tng_data->input_file, traj_start_pos, SEEK_SET);
+        fseeko(tng_data->input_file, traj_start_pos, SEEK_SET);
         stat = tng_block_header_read(tng_data, block);
         if(stat == TNG_CRITICAL)
         {
@@ -1812,7 +1801,8 @@ static tng_function_status tng_migrate_data_in_file
             return(stat);
         }
         stat = tng_frame_set_complete_migrate(tng_data, traj_start_pos,
-                                              frame_set_length, tng_data->input_file_len);
+                                              frame_set_length, tng_data->input_file_len,
+                                              hash_mode);
         if(stat != TNG_SUCCESS)
         {
             tng_data->input_file = temp;
@@ -1822,7 +1812,7 @@ static tng_function_status tng_migrate_data_in_file
 
         empty_space += frame_set_length;
     }
-    fseek(tng_data->input_file, orig_file_pos, SEEK_SET);
+    fseeko(tng_data->input_file, orig_file_pos, SEEK_SET);
     tng_block_destroy(&block);
 
     return(TNG_SUCCESS);
@@ -1850,7 +1840,7 @@ static tng_function_status tng_block_header_len_calculate
         block->name[0] = 0;
     }
 
-    name_len = tng_min_i((int)strlen(block->name) + 1, TNG_MAX_STR_LEN);
+    name_len = tng_min_i((unsigned int)strlen(block->name) + 1, TNG_MAX_STR_LEN);
 
     /* Calculate the size of the header to write */
     *len = sizeof(block->header_contents_size) +
@@ -1873,10 +1863,10 @@ static tng_function_status tng_block_header_len_calculate
  */
 static tng_function_status tng_block_header_write
                 (tng_trajectory_t tng_data,
-                 tng_gen_block_t block,
-                 const char hash_mode)
+                 tng_gen_block_t block)
 {
-    int name_len, offset = 0;
+    int name_len;
+    int64_t temp_i64;
 
     TNG_ASSERT(block != 0, "TNG library: Trying to write uninitialized block (NULL pointer).");
 
@@ -1895,94 +1885,52 @@ static tng_function_status tng_block_header_write
         return(TNG_CRITICAL);
     }
 
-    if(hash_mode == TNG_USE_HASH)
-    {
-        tng_block_md5_hash_generate(block);
-    }
-
-    if(block->header_contents)
-    {
-        free(block->header_contents);
-    }
+    name_len = tng_min_i((unsigned int)strlen(block->name) + 1, TNG_MAX_STR_LEN);
 
-    block->header_contents = malloc(block->header_contents_size);
-    if(!block->header_contents)
+    temp_i64 = block->header_contents_size;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->header_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
 
-    name_len = tng_min_i((int)strlen(block->name) + 1, TNG_MAX_STR_LEN);
-
-    /* First copy all data into the header_contents block and finally write
-     * the whole block at once. */
-    memcpy(block->header_contents, &block->header_contents_size,
-           sizeof(block->header_contents_size));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = block->block_contents_size;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(block->header_contents_size);
 
-    memcpy(block->header_contents+offset, &block->block_contents_size,
-           sizeof(block->block_contents_size));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = block->id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(block->block_contents_size);
 
-    memcpy(block->header_contents+offset, &block->id, sizeof(block->id));
-    if(tng_data->output_endianness_swap_func_64)
+    if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(block->id);
 
-    memcpy(block->header_contents+offset, block->md5_hash, TNG_MD5_HASH_LEN);
-    offset += TNG_MD5_HASH_LEN;
-
-    strncpy(block->header_contents+offset, block->name, name_len);
-    offset += name_len;
-
-    memcpy(block->header_contents+offset, &block->block_version,
-           sizeof(block->block_version));
-    if(tng_data->output_endianness_swap_func_64)
+    if(fwrite(block->name, name_len, 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
 
-    if(fwrite(block->header_contents, block->header_contents_size,
-       1, tng_data->output_file) != 1)
+    temp_i64 = block->block_version;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Could not write all header data. %s: %d\n", __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write header data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+
     return(TNG_SUCCESS);
 }
 
@@ -2098,23 +2046,23 @@ static tng_function_status tng_general_info_block_len_calculate
         tng_data->forcefield_name[0] = 0;
     }
 
-    first_program_name_len = tng_min_i((int)strlen(tng_data->first_program_name) + 1,
+    first_program_name_len = tng_min_i((unsigned int)strlen(tng_data->first_program_name) + 1,
                            TNG_MAX_STR_LEN);
-    last_program_name_len = tng_min_i((int)strlen(tng_data->last_program_name) + 1,
+    last_program_name_len = tng_min_i((unsigned int)strlen(tng_data->last_program_name) + 1,
                            TNG_MAX_STR_LEN);
-    first_user_name_len = tng_min_i((int)strlen(tng_data->first_user_name) + 1,
+    first_user_name_len = tng_min_i((unsigned int)strlen(tng_data->first_user_name) + 1,
                         TNG_MAX_STR_LEN);
-    last_user_name_len = tng_min_i((int)strlen(tng_data->last_user_name) + 1,
+    last_user_name_len = tng_min_i((unsigned int)strlen(tng_data->last_user_name) + 1,
                         TNG_MAX_STR_LEN);
-    first_computer_name_len = tng_min_i((int)strlen(tng_data->first_computer_name) + 1,
+    first_computer_name_len = tng_min_i((unsigned int)strlen(tng_data->first_computer_name) + 1,
                             TNG_MAX_STR_LEN);
-    last_computer_name_len = tng_min_i((int)strlen(tng_data->last_computer_name) + 1,
+    last_computer_name_len = tng_min_i((unsigned int)strlen(tng_data->last_computer_name) + 1,
                             TNG_MAX_STR_LEN);
-    first_pgp_signature_len = tng_min_i((int)strlen(tng_data->first_pgp_signature) + 1,
+    first_pgp_signature_len = tng_min_i((unsigned int)strlen(tng_data->first_pgp_signature) + 1,
                             TNG_MAX_STR_LEN);
-    last_pgp_signature_len = tng_min_i((int)strlen(tng_data->last_pgp_signature) + 1,
+    last_pgp_signature_len = tng_min_i((unsigned int)strlen(tng_data->last_pgp_signature) + 1,
                             TNG_MAX_STR_LEN);
-    forcefield_name_len = tng_min_i((int)strlen(tng_data->forcefield_name) + 1,
+    forcefield_name_len = tng_min_i((unsigned int)strlen(tng_data->forcefield_name) + 1,
                               TNG_MAX_STR_LEN);
 
     *len = sizeof(tng_data->time) +
@@ -2152,10 +2100,9 @@ static tng_function_status tng_general_info_block_read
                 (tng_trajectory_t tng_data, tng_gen_block_t block,
                  const char hash_mode)
 {
-    int len, offset = 0;
-    tng_bool same_hash;
-
-    void *temp;
+    int64_t start_pos, curr_file_pos;
+    char hash[TNG_MD5_HASH_LEN], *temp_data;
+    md5_state_t md5_state;
 
     TNG_ASSERT(block != 0, "TNG library: Trying to read data to an uninitialized block (NULL pointer)");
 
@@ -2164,277 +2111,191 @@ static tng_function_status tng_general_info_block_read
         return(TNG_CRITICAL);
     }
 
-    temp = realloc(block->block_contents, block->block_contents_size);
-    if(!temp)
+    start_pos = ftello(tng_data->input_file);
+
+    tng_freadstr(tng_data->input_file, &tng_data->first_program_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->last_program_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->first_user_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->last_user_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->first_computer_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->last_computer_name);
+
+    tng_freadstr(tng_data->input_file, &tng_data->first_pgp_signature);
+
+    tng_freadstr(tng_data->input_file, &tng_data->last_pgp_signature);
+
+    tng_freadstr(tng_data->input_file, &tng_data->forcefield_name);
+
+    /* Add all the above strings to the MD5 hash at the same time. */
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        free(block->block_contents);
-        block->block_contents = 0;
-        return(TNG_CRITICAL);
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_program_name, strlen(tng_data->first_program_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_program_name, strlen(tng_data->last_program_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_user_name, strlen(tng_data->first_user_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_user_name, strlen(tng_data->last_user_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_computer_name, strlen(tng_data->first_computer_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_computer_name, strlen(tng_data->last_computer_name) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_pgp_signature, strlen(tng_data->first_pgp_signature) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_pgp_signature, strlen(tng_data->last_pgp_signature) + 1);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->forcefield_name, strlen(tng_data->forcefield_name) + 1);
     }
-    block->block_contents = temp;
 
-    /* Read the whole block into block_contents to be able to write it to disk
-     * even if it cannot be interpreted. */
-    if(fread(block->block_contents, block->block_contents_size, 1,
-             tng_data->input_file) == 0)
+    if(fread(&tng_data->time, sizeof(tng_data->time),
+             1, tng_data->input_file) == 0)
     {
         fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-
-    /* FIXME: Does not check if the size of the contents matches the expected
-     * size or if the contents can be read. */
-
     if(hash_mode == TNG_USE_HASH)
     {
-        tng_md5_hash_match_verify(block, &same_hash);
-        if(same_hash != TNG_TRUE)
-        {
-            fprintf(stderr, "TNG library: General info block contents corrupt. Hashes do not match. "
-                "%s: %d\n",
-                __FILE__, __LINE__);
-    /*         return(TNG_FAILURE); */
-        }
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->time, sizeof(tng_data->time));
     }
+    tng_var_64_bit_input_swap(tng_data, &tng_data->time);
 
-    len = tng_min_i((int)strlen(block->block_contents) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->first_program_name, len);
-    if(!temp)
+    if(fread(&tng_data->var_num_atoms_flag, sizeof(tng_data->var_num_atoms_flag),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->first_program_name);
-        tng_data->first_program_name = 0;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    tng_data->first_program_name = temp;
-    strncpy(tng_data->first_program_name, block->block_contents, len);
-    offset += len;
-
-    len = tng_min_i((int)strlen(block->block_contents + offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->last_program_name, len);
-    if(!temp)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->last_program_name);
-        tng_data->last_program_name = 0;
-        return(TNG_CRITICAL);
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->var_num_atoms_flag,
+                   sizeof(tng_data->var_num_atoms_flag));
     }
-    tng_data->last_program_name = temp;
-    strncpy(tng_data->last_program_name, block->block_contents + offset, len);
-    offset += len;
 
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->first_user_name, len);
-    if(!temp)
+    if(fread(&tng_data->frame_set_n_frames, sizeof(tng_data->frame_set_n_frames),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->first_user_name);
-        tng_data->first_user_name = 0;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    tng_data->first_user_name = temp;
-    strncpy(tng_data->first_user_name, block->block_contents+offset, len);
-    offset += len;
-
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->last_user_name, len);
-    if(!temp)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->last_user_name);
-        tng_data->last_user_name = 0;
-        return(TNG_CRITICAL);
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->frame_set_n_frames, sizeof(tng_data->frame_set_n_frames));
     }
-    tng_data->last_user_name = temp;
-    strncpy(tng_data->last_user_name, block->block_contents+offset, len);
-    offset += len;
+    tng_var_64_bit_input_swap(tng_data, &tng_data->frame_set_n_frames);
 
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->first_computer_name, len);
-    if(!temp)
+    if(fread(&tng_data->first_trajectory_frame_set_input_file_pos,
+             sizeof(tng_data->first_trajectory_frame_set_input_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->first_computer_name);
-        tng_data->first_computer_name = 0;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    tng_data->first_computer_name = temp;
-    strncpy(tng_data->first_computer_name, block->block_contents+offset, len);
-    offset += len;
-
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->last_computer_name, len);
-    if(!temp)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->last_computer_name);
-        tng_data->last_computer_name = 0;
-        return(TNG_CRITICAL);
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->first_trajectory_frame_set_input_file_pos,
+                   sizeof(tng_data->first_trajectory_frame_set_input_file_pos));
     }
-    tng_data->last_computer_name = temp;
-    strncpy(tng_data->last_computer_name, block->block_contents+offset, len);
-    offset += len;
+    tng_var_64_bit_input_swap(tng_data, &tng_data->first_trajectory_frame_set_input_file_pos);
 
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->first_pgp_signature, len);
-    if(!temp)
+    tng_data->current_trajectory_frame_set.next_frame_set_file_pos =
+    tng_data->first_trajectory_frame_set_input_file_pos;
+
+    if(fread(&tng_data->last_trajectory_frame_set_input_file_pos,
+             sizeof(tng_data->last_trajectory_frame_set_input_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->first_pgp_signature);
-        tng_data->first_pgp_signature = 0;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    tng_data->first_pgp_signature = temp;
-    strncpy(tng_data->first_pgp_signature, block->block_contents+offset, len);
-    offset += len;
-
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->last_pgp_signature, len);
-    if(!temp)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->last_pgp_signature);
-        tng_data->last_pgp_signature = 0;
-        return(TNG_CRITICAL);
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->last_trajectory_frame_set_input_file_pos,
+                   sizeof(tng_data->last_trajectory_frame_set_input_file_pos));
     }
-    tng_data->last_pgp_signature = temp;
-    strncpy(tng_data->last_pgp_signature, block->block_contents+offset, len);
-    offset += len;
+    tng_var_64_bit_input_swap(tng_data, &tng_data->last_trajectory_frame_set_input_file_pos);
 
-    len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-    temp = realloc(tng_data->forcefield_name, len);
-    if(!temp)
+    if(fread(&tng_data->medium_stride_length,
+             sizeof(tng_data->medium_stride_length),
+             1, tng_data->input_file) == 0)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n", len,
-               __FILE__, __LINE__);
-        free(tng_data->forcefield_name);
-        tng_data->forcefield_name = 0;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    tng_data->forcefield_name = temp;
-    strncpy(tng_data->forcefield_name, block->block_contents+offset, len);
-    offset += len;
-
-    memcpy(&tng_data->time, block->block_contents+offset,
-           sizeof(tng_data->time));
-    if(tng_data->input_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &tng_data->time)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->medium_stride_length,
+                   sizeof(tng_data->medium_stride_length));
     }
-    offset += sizeof(tng_data->time);
-
-    memcpy(&tng_data->var_num_atoms_flag, block->block_contents+offset,
-           sizeof(tng_data->var_num_atoms_flag));
-    offset += sizeof(tng_data->var_num_atoms_flag);
+    tng_var_64_bit_input_swap(tng_data, &tng_data->medium_stride_length);
 
-    memcpy(&tng_data->frame_set_n_frames, block->block_contents+offset,
-           sizeof(tng_data->frame_set_n_frames));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&tng_data->long_stride_length,
+             sizeof(tng_data->long_stride_length),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                 &tng_data->frame_set_n_frames)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(tng_data->frame_set_n_frames);
-
-    memcpy(&tng_data->first_trajectory_frame_set_input_file_pos,
-           block->block_contents+offset,
-           sizeof(tng_data->first_trajectory_frame_set_input_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                          &tng_data->first_trajectory_frame_set_input_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->long_stride_length,
+                   sizeof(tng_data->long_stride_length));
     }
-    offset += sizeof(tng_data->first_trajectory_frame_set_input_file_pos);
+    tng_var_64_bit_input_swap(tng_data, &tng_data->long_stride_length);
 
-    tng_data->current_trajectory_frame_set.next_frame_set_file_pos =
-    tng_data->first_trajectory_frame_set_input_file_pos;
-
-
-    memcpy(&tng_data->last_trajectory_frame_set_input_file_pos,
-           block->block_contents+offset,
-           sizeof(tng_data->last_trajectory_frame_set_input_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(block->block_version >= 3)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                          &tng_data->last_trajectory_frame_set_input_file_pos)
-            != TNG_SUCCESS)
+        if(fread(&tng_data->distance_unit_exponential,
+                 sizeof(tng_data->distance_unit_exponential),
+                 1, tng_data->input_file) == 0)
         {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-    }
-    offset += sizeof(tng_data->last_trajectory_frame_set_input_file_pos);
-
-    memcpy(&tng_data->medium_stride_length, block->block_contents+offset,
-           sizeof(tng_data->medium_stride_length));
-    if(tng_data->input_endianness_swap_func_64)
-    {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                               &tng_data->medium_stride_length)
-            != TNG_SUCCESS)
+        if(hash_mode == TNG_USE_HASH)
         {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
+            md5_append(&md5_state, (md5_byte_t *)&tng_data->distance_unit_exponential,
+                       sizeof(tng_data->distance_unit_exponential));
         }
+        tng_var_64_bit_input_swap(tng_data, &tng_data->distance_unit_exponential);
     }
-    offset += sizeof(tng_data->medium_stride_length);
 
-    memcpy(&tng_data->long_stride_length, block->block_contents+offset,
-           sizeof(tng_data->long_stride_length));
-    if(tng_data->input_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                 &tng_data->long_stride_length)
-            != TNG_SUCCESS)
+        /* If there is data left in the block that the current version of the library
+         * cannot interpret still read that to generate the MD5 hash. */
+        curr_file_pos = ftello(tng_data->input_file);
+        if(curr_file_pos < start_pos + block->block_contents_size)
         {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
+            temp_data = malloc(start_pos + block->block_contents_size - curr_file_pos);
+            if(!temp_data)
+            {
+                fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                        start_pos + block->block_contents_size - curr_file_pos, __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(fread(temp_data, start_pos + block->block_contents_size - curr_file_pos,
+                     1, tng_data->input_file) == 0)
+            {
+                fprintf(stderr, "TNG library: Cannot read remaining part of block to generate MD5 sum. %s: %d\n", __FILE__, __LINE__);
+                free(temp_data);
+                return(TNG_CRITICAL);
+            }
+            md5_append(&md5_state, (md5_byte_t *)temp_data,
+                       start_pos + block->block_contents_size - curr_file_pos);
+            free(temp_data);
         }
-    }
-    offset += sizeof(tng_data->long_stride_length);
-
-    if(block->block_version >= 3)
-    {
-        memcpy(&tng_data->distance_unit_exponential, block->block_contents+offset,
-            sizeof(tng_data->distance_unit_exponential));
-        if(tng_data->input_endianness_swap_func_64)
+        md5_finish(&md5_state, (md5_byte_t *)hash);
+        if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN) != 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                          &tng_data->distance_unit_exponential)
-                != TNG_SUCCESS)
+            if(strncmp(block->md5_hash, hash, TNG_MD5_HASH_LEN) != 0)
             {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
+                fprintf(stderr, "TNG library: General info block contents corrupt. Hashes do not match. "
+                        "%s: %d\n", __FILE__, __LINE__);
             }
         }
     }
 
+    fseeko(tng_data->input_file, start_pos + block->block_contents_size, SEEK_SET);
+
     return(TNG_SUCCESS);
 }
 
@@ -2449,24 +2310,25 @@ static tng_function_status tng_general_info_block_write
                 (tng_trajectory_t tng_data,
                  const char hash_mode)
 {
+    int64_t temp_i64, header_file_pos, curr_file_pos;
     int first_program_name_len, first_user_name_len;
     int first_computer_name_len, first_pgp_signature_len;
     int last_program_name_len, last_user_name_len;
     int last_computer_name_len, last_pgp_signature_len;
     int forcefield_name_len, name_len;
-    int offset = 0;
     tng_gen_block_t block;
+    md5_state_t md5_state;
 
     if(tng_output_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    fseek(tng_data->output_file, 0, SEEK_SET);
+    fseeko(tng_data->output_file, 0, SEEK_SET);
 
     tng_block_init(&block);
 
-    name_len = (int)strlen("GENERAL INFO");
+    name_len = (unsigned int)strlen("GENERAL INFO");
 
     block->name = malloc(name_len + 1);
     if(!block->name)
@@ -2489,188 +2351,210 @@ static tng_function_status tng_general_info_block_write
         return(TNG_CRITICAL);
     }
 
-    first_program_name_len = tng_min_i((int)strlen(tng_data->first_program_name) + 1,
+    header_file_pos = 0;
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
+    {
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
+        tng_block_destroy(&block);
+        return(TNG_CRITICAL);
+    }
+
+    first_program_name_len = tng_min_i((unsigned int)strlen(tng_data->first_program_name) + 1,
                            TNG_MAX_STR_LEN);
-    last_program_name_len = tng_min_i((int)strlen(tng_data->last_program_name) + 1,
+    last_program_name_len = tng_min_i((unsigned int)strlen(tng_data->last_program_name) + 1,
                            TNG_MAX_STR_LEN);
-    first_user_name_len = tng_min_i((int)strlen(tng_data->first_user_name) + 1,
+    first_user_name_len = tng_min_i((unsigned int)strlen(tng_data->first_user_name) + 1,
                         TNG_MAX_STR_LEN);
-    last_user_name_len = tng_min_i((int)strlen(tng_data->last_user_name) + 1,
+    last_user_name_len = tng_min_i((unsigned int)strlen(tng_data->last_user_name) + 1,
                         TNG_MAX_STR_LEN);
-    first_computer_name_len = tng_min_i((int)strlen(tng_data->first_computer_name) + 1,
+    first_computer_name_len = tng_min_i((unsigned int)strlen(tng_data->first_computer_name) + 1,
                             TNG_MAX_STR_LEN);
-    last_computer_name_len = tng_min_i((int)strlen(tng_data->last_computer_name) + 1,
+    last_computer_name_len = tng_min_i((unsigned int)strlen(tng_data->last_computer_name) + 1,
                             TNG_MAX_STR_LEN);
-    first_pgp_signature_len = tng_min_i((int)strlen(tng_data->first_pgp_signature) + 1,
+    first_pgp_signature_len = tng_min_i((unsigned int)strlen(tng_data->first_pgp_signature) + 1,
                             TNG_MAX_STR_LEN);
-    last_pgp_signature_len = tng_min_i((int)strlen(tng_data->last_pgp_signature) + 1,
+    last_pgp_signature_len = tng_min_i((unsigned int)strlen(tng_data->last_pgp_signature) + 1,
                             TNG_MAX_STR_LEN);
-    forcefield_name_len = tng_min_i((int)strlen(tng_data->forcefield_name) + 1,
+    forcefield_name_len = tng_min_i((unsigned int)strlen(tng_data->forcefield_name) + 1,
                               TNG_MAX_STR_LEN);
 
-    if(block->block_contents)
+    if(fwrite(tng_data->first_program_name, first_program_name_len, 1, tng_data->output_file) != 1)
     {
-        free(block->block_contents);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+
+    if(fwrite(tng_data->last_program_name, last_program_name_len, 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        tng_block_destroy(&block);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
 
-    strncpy(block->block_contents, tng_data->first_program_name, first_program_name_len);
-    offset += first_program_name_len;
-
-    strncpy(block->block_contents+offset, tng_data->last_program_name, last_program_name_len);
-    offset += last_program_name_len;
-
-    strncpy(block->block_contents+offset, tng_data->first_user_name, first_user_name_len);
-    offset += first_user_name_len;
-
-    strncpy(block->block_contents+offset, tng_data->last_user_name, last_user_name_len);
-    offset += last_user_name_len;
+    if(fwrite(tng_data->first_user_name, first_user_name_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    strncpy(block->block_contents+offset, tng_data->first_computer_name,
-            first_computer_name_len);
-    offset += first_computer_name_len;
+    if(fwrite(tng_data->last_user_name, last_user_name_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    strncpy(block->block_contents+offset, tng_data->last_computer_name,
-            last_computer_name_len);
-    offset += last_computer_name_len;
+    if(fwrite(tng_data->first_computer_name, first_computer_name_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    strncpy(block->block_contents+offset, tng_data->first_pgp_signature,
-            first_pgp_signature_len);
-    offset += first_pgp_signature_len;
+    if(fwrite(tng_data->last_computer_name, last_computer_name_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    strncpy(block->block_contents+offset, tng_data->last_pgp_signature,
-            last_pgp_signature_len);
-    offset += last_pgp_signature_len;
+    if(fwrite(tng_data->first_pgp_signature, first_pgp_signature_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    strncpy(block->block_contents+offset, tng_data->forcefield_name,
-            forcefield_name_len);
-    offset += forcefield_name_len;
+    if(fwrite(tng_data->last_pgp_signature, last_pgp_signature_len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
 
-    memcpy(block->block_contents+offset, &tng_data->time,
-           sizeof(tng_data->time));
-    if(tng_data->output_endianness_swap_func_64)
+    if(fwrite(tng_data->forcefield_name, forcefield_name_len, 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(tng_data->time);
 
-    memcpy(block->block_contents+offset, &tng_data->var_num_atoms_flag,
-           sizeof(tng_data->var_num_atoms_flag));
-    offset += sizeof(tng_data->var_num_atoms_flag);
+    /* Add all the above strings to the MD5 hash at the same time. */
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_program_name, first_program_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_program_name, last_program_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_user_name, first_user_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_user_name, last_user_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_computer_name, first_computer_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_computer_name, last_computer_name_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->first_pgp_signature, first_pgp_signature_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->last_pgp_signature, last_pgp_signature_len);
+        md5_append(&md5_state, (md5_byte_t *)tng_data->forcefield_name, forcefield_name_len);
+    }
 
-    memcpy(block->block_contents+offset, &tng_data->frame_set_n_frames,
-           sizeof(tng_data->frame_set_n_frames));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->time;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(tng_data->frame_set_n_frames);
 
-    memcpy(block->block_contents+offset,
-           &tng_data->first_trajectory_frame_set_output_file_pos,
-           sizeof(tng_data->first_trajectory_frame_set_output_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    if(fwrite(&tng_data->var_num_atoms_flag, sizeof(tng_data->var_num_atoms_flag),
+              1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->var_num_atoms_flag,
+                   sizeof(tng_data->var_num_atoms_flag));
     }
-    offset += sizeof(tng_data->first_trajectory_frame_set_output_file_pos);
 
-    memcpy(block->block_contents+offset,
-           &tng_data->last_trajectory_frame_set_output_file_pos,
-           sizeof(tng_data->last_trajectory_frame_set_output_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->frame_set_n_frames;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(tng_data->last_trajectory_frame_set_output_file_pos);
 
-    memcpy(block->block_contents+offset, &tng_data->medium_stride_length,
-           sizeof(tng_data->medium_stride_length));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->first_trajectory_frame_set_output_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(tng_data->medium_stride_length);
 
-    memcpy(block->block_contents+offset, &tng_data->long_stride_length,
-           sizeof(tng_data->long_stride_length));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->last_trajectory_frame_set_output_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(tng_data->long_stride_length);
 
-    memcpy(block->block_contents+offset, &tng_data->distance_unit_exponential,
-           sizeof(tng_data->distance_unit_exponential));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->medium_stride_length;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
 
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
+    temp_i64 = tng_data->long_stride_length;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
-        tng_block_destroy(&block);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
+    }
 
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-        tng_data->output_file) != 1)
+    temp_i64 = tng_data->distance_unit_exponential;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__, __LINE__);
-        tng_block_destroy(&block);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+               3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
+    }
 
     tng_block_destroy(&block);
 
@@ -2681,52 +2565,42 @@ static tng_function_status tng_general_info_block_write
  * @param tng_data is a trajectory data container.
  * @param block is a general block container.
  * @param chain is the chain data container.
- * @param offset is the offset of the block input and is updated when reading.
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_chain_data_read(tng_trajectory_t tng_data,
-                                               tng_gen_block_t block,
                                                tng_chain_t chain,
-                                               int *offset)
+                                               const char hash_mode,
+                                               md5_state_t *md5_state)
 {
-    int len;
-
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(&chain->id, block->block_contents+*offset,
-            sizeof(chain->id));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&chain->id, sizeof(chain->id),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &chain->id)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&chain->id, sizeof(chain->id));
     }
-    *offset += sizeof(chain->id);
+    tng_var_64_bit_input_swap(tng_data, &chain->id);
 
-    len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
-            TNG_MAX_STR_LEN);
-    chain->name = malloc(len);
-    strncpy(chain->name,
-            block->block_contents+*offset, len);
-    *offset += len;
+    tng_freadstr(tng_data->input_file, &chain->name);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)chain->name, strlen(chain->name) + 1);
+    }
 
-    memcpy(&chain->n_residues, block->block_contents+*offset,
-        sizeof(chain->n_residues));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&chain->n_residues, sizeof(chain->n_residues),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &chain->n_residues)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&chain->n_residues, sizeof(chain->n_residues));
     }
-    *offset += sizeof(chain->n_residues);
+    tng_var_64_bit_input_swap(tng_data, &chain->n_residues);
 
     return(TNG_SUCCESS);
 }
@@ -2739,44 +2613,47 @@ static tng_function_status tng_chain_data_read(tng_trajectory_t tng_data,
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_chain_data_write(tng_trajectory_t tng_data,
-                                                tng_gen_block_t block,
                                                 tng_chain_t chain,
-                                                int *offset)
+                                                const char hash_mode,
+                                                md5_state_t *md5_state)
 {
+    int64_t temp_i64;
     int len;
 
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(block->block_contents+*offset, &chain->id, sizeof(chain->id));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = chain->id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                    (int64_t *)block->header_contents+*offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    *offset += sizeof(chain->id);
 
-    len = tng_min_i((int)strlen(chain->name) + 1, TNG_MAX_STR_LEN);
-    strncpy(block->block_contents + *offset, chain->name, len);
-    *offset += len;
+    len = tng_min_i((unsigned int)strlen(chain->name) + 1, TNG_MAX_STR_LEN);
+    if(fwrite(chain->name, len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)chain->name, len);
+    }
 
-    memcpy(block->block_contents+*offset, &chain->n_residues,
-        sizeof(chain->n_residues));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = chain->n_residues;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                    (int64_t *)block->header_contents+*offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    *offset += sizeof(chain->n_residues);
 
     return(TNG_SUCCESS);
 }
@@ -2789,48 +2666,39 @@ static tng_function_status tng_chain_data_write(tng_trajectory_t tng_data,
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_residue_data_read(tng_trajectory_t tng_data,
-                                                 tng_gen_block_t block,
                                                  tng_residue_t residue,
-                                                 int *offset)
+                                                 const char hash_mode,
+                                                 md5_state_t *md5_state)
 {
-    int len;
-
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(&residue->id, block->block_contents+*offset,
-        sizeof(residue->id));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&residue->id, sizeof(residue->id),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &residue->id)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    *offset += sizeof(residue->id);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&residue->id, sizeof(residue->id));
+    }
+    tng_var_64_bit_input_swap(tng_data, &residue->id);
 
-    len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
-            TNG_MAX_STR_LEN);
-    residue->name = malloc(len);
-    strncpy(residue->name,
-            block->block_contents+*offset, len);
-    *offset += len;
+    tng_freadstr(tng_data->input_file, &residue->name);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)residue->name, strlen(residue->name) + 1);
+    }
 
-    memcpy(&residue->n_atoms, block->block_contents+*offset,
-            sizeof(residue->n_atoms));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&residue->n_atoms, sizeof(residue->n_atoms),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &residue->n_atoms)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block header. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    *offset += sizeof(residue->n_atoms);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&residue->n_atoms, sizeof(residue->n_atoms));
+    }
+    tng_var_64_bit_input_swap(tng_data, &residue->n_atoms);
 
     return(TNG_SUCCESS);
 }
@@ -2843,44 +2711,47 @@ static tng_function_status tng_residue_data_read(tng_trajectory_t tng_data,
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_residue_data_write(tng_trajectory_t tng_data,
-                                                  tng_gen_block_t block,
                                                   tng_residue_t residue,
-                                                  int *offset)
+                                                  const char hash_mode,
+                                                  md5_state_t *md5_state)
 {
+    int64_t temp_i64;
     int len;
 
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(block->block_contents+*offset, &residue->id, sizeof(residue->id));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = residue->id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                    (int64_t *)block->header_contents+*offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    *offset += sizeof(residue->id);
 
-    len = tng_min_i((int)strlen(residue->name) + 1, TNG_MAX_STR_LEN);
-    strncpy(block->block_contents + *offset, residue->name, len);
-    *offset += len;
+    len = tng_min_i((unsigned int)strlen(residue->name) + 1, TNG_MAX_STR_LEN);
+    if(fwrite(residue->name, len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)residue->name, len);
+    }
 
-    memcpy(block->block_contents+*offset, &residue->n_atoms,
-        sizeof(residue->n_atoms));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = residue->n_atoms;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                    (int64_t *)block->header_contents+*offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    *offset += sizeof(residue->n_atoms);
 
     return(TNG_SUCCESS);
 }
@@ -2893,41 +2764,33 @@ static tng_function_status tng_residue_data_write(tng_trajectory_t tng_data,
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_atom_data_read(tng_trajectory_t tng_data,
-                                              tng_gen_block_t block,
                                               tng_atom_t atom,
-                                              int *offset)
+                                              const char hash_mode,
+                                              md5_state_t *md5_state)
 {
-    int len;
-
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(&atom->id, block->block_contents+*offset,
-        sizeof(atom->id));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&atom->id, sizeof(atom->id),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                    &atom->id)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    *offset += sizeof(atom->id);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&atom->id, sizeof(atom->id));
+    }
+    tng_var_64_bit_input_swap(tng_data, &atom->id);
 
-    len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
-            TNG_MAX_STR_LEN);
-    atom->name = malloc(len);
-    strncpy(atom->name,
-            block->block_contents+*offset, len);
-    *offset += len;
+    tng_freadstr(tng_data->input_file, &atom->name);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)atom->name, strlen(atom->name) + 1);
+    }
 
-    len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
-            TNG_MAX_STR_LEN);
-    atom->atom_type = malloc(len);
-    strncpy(atom->atom_type,
-            block->block_contents+*offset, len);
-    *offset += len;
+    tng_freadstr(tng_data->input_file, &atom->atom_type);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)atom->atom_type, strlen(atom->atom_type) + 1);
+    }
 
     return(TNG_SUCCESS);
 }
@@ -2940,35 +2803,46 @@ static tng_function_status tng_atom_data_read(tng_trajectory_t tng_data,
  * @return TNG_SUCCESS(0) is successful.
  */
 static tng_function_status tng_atom_data_write(tng_trajectory_t tng_data,
-                                               tng_gen_block_t block,
                                                tng_atom_t atom,
-                                               int *offset)
+                                               const char hash_mode,
+                                               md5_state_t *md5_state)
 {
+    int64_t temp_i64;
     int len;
 
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
-
-    memcpy(block->block_contents+*offset, &atom->id,
-            sizeof(atom->id));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = atom->id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                    (int64_t *)block->header_contents+*offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    *offset += sizeof(atom->id);
 
-    len = tng_min_i((int)strlen(atom->name) + 1, TNG_MAX_STR_LEN);
-    strncpy(block->block_contents + *offset, atom->name, len);
-    *offset += len;
+    len = tng_min_i((unsigned int)strlen(atom->name) + 1, TNG_MAX_STR_LEN);
+    if(fwrite(atom->name, len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)atom->name, len);
+    }
 
-    len = tng_min_i((int)strlen(atom->atom_type) + 1, TNG_MAX_STR_LEN);
-    strncpy(block->block_contents + *offset, atom->atom_type, len);
-    *offset += len;
+    len = tng_min_i((unsigned int)strlen(atom->atom_type) + 1, TNG_MAX_STR_LEN);
+    if(fwrite(atom->atom_type, len, 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)atom->atom_type, len);
+    }
 
     return(TNG_SUCCESS);
 }
@@ -3000,7 +2874,7 @@ static tng_function_status tng_molecules_block_len_calculate
             }
             molecule->name[0] = 0;
         }
-        *len += tng_min_i((int)strlen(molecule->name) + 1, TNG_MAX_STR_LEN);
+        *len += tng_min_i((unsigned int)strlen(molecule->name) + 1, TNG_MAX_STR_LEN);
 
         chain = molecule->chains;
         for(j = 0; j < molecule->n_chains; j++)
@@ -3018,7 +2892,7 @@ static tng_function_status tng_molecules_block_len_calculate
                 }
                 chain->name[0] = 0;
             }
-            *len += tng_min_i((int)strlen(chain->name) + 1, TNG_MAX_STR_LEN);
+            *len += tng_min_i((unsigned int)strlen(chain->name) + 1, TNG_MAX_STR_LEN);
 
             *len += sizeof(chain->n_residues);
 
@@ -3041,7 +2915,7 @@ static tng_function_status tng_molecules_block_len_calculate
                 }
                 residue->name[0] = 0;
             }
-            *len += tng_min_i((int)strlen(residue->name) + 1, TNG_MAX_STR_LEN);
+            *len += tng_min_i((unsigned int)strlen(residue->name) + 1, TNG_MAX_STR_LEN);
 
             *len += sizeof(residue->n_atoms);
 
@@ -3063,7 +2937,7 @@ static tng_function_status tng_molecules_block_len_calculate
                 }
                 atom->name[0] = 0;
             }
-            *len += tng_min_i((int)strlen(atom->name) + 1, TNG_MAX_STR_LEN);
+            *len += tng_min_i((unsigned int)strlen(atom->name) + 1, TNG_MAX_STR_LEN);
 
             if(!atom->atom_type)
             {
@@ -3076,7 +2950,7 @@ static tng_function_status tng_molecules_block_len_calculate
                 }
                 atom->atom_type[0] = 0;
             }
-            *len += tng_min_i((int)strlen(atom->atom_type) + 1, TNG_MAX_STR_LEN);
+            *len += tng_min_i((unsigned int)strlen(atom->atom_type) + 1, TNG_MAX_STR_LEN);
 
             atom++;
         }
@@ -3117,55 +2991,25 @@ static tng_function_status tng_molecules_block_read
                  tng_gen_block_t block,
                  const char hash_mode)
 {
-    int64_t i, j, k, l;
-    int len, offset = 0;
+    int64_t start_pos, curr_file_pos, i, j, k, l;
     tng_molecule_t molecule;
     tng_chain_t chain;
     tng_residue_t residue;
     tng_atom_t atom;
     tng_bond_t bond;
-    tng_bool same_hash;
+    char hash[TNG_MD5_HASH_LEN], *temp_data;
+    md5_state_t md5_state;
 
     if(tng_input_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
-    {
-        free(block->block_contents);
-    }
-
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
-    {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    /* Read the whole block into block_contents to be able to write it to disk
-     * even if it cannot be interpreted. */
-    if(fread(block->block_contents, block->block_contents_size, 1,
-             tng_data->input_file) == 0)
-    {
-        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
-    }
+    start_pos = ftello(tng_data->input_file);
 
     /* FIXME: Does not check if the size of the contents matches the expected
      * size or if the contents can be read. */
 
-    if(hash_mode == TNG_USE_HASH)
-    {
-        tng_md5_hash_match_verify(block, &same_hash);
-        if(same_hash != TNG_TRUE)
-        {
-            fprintf(stderr, "TNG library: Molecules block contents corrupt. Hashes do not match. "
-                "%s: %d\n",
-                __FILE__, __LINE__);
-        }
-    }
-
     if(tng_data->molecules)
     {
         for(i=0; i<tng_data->n_molecules; i++)
@@ -3177,19 +3021,18 @@ static tng_function_status tng_molecules_block_read
         tng_data->n_molecules = 0;
     }
 
-    memcpy(&tng_data->n_molecules, block->block_contents,
-           sizeof(tng_data->n_molecules));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&tng_data->n_molecules, sizeof(tng_data->n_molecules),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &tng_data->n_molecules)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&tng_data->n_molecules, sizeof(tng_data->n_molecules));
     }
-    offset += sizeof(tng_data->n_molecules);
+    tng_var_64_bit_input_swap(tng_data, &tng_data->n_molecules);
 
     if(tng_data->molecules)
     {
@@ -3230,100 +3073,89 @@ static tng_function_status tng_molecules_block_read
     {
         molecule = &tng_data->molecules[i];
 
-        memcpy(&molecule->id, block->block_contents+offset,
-               sizeof(molecule->id));
-        if(tng_data->input_endianness_swap_func_64)
+        molecule->name = 0;
+
+        if(fread(&molecule->id, sizeof(molecule->id),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       &molecule->id)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(molecule->id);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->id, sizeof(molecule->id));
+        }
+        tng_var_64_bit_input_swap(tng_data, &molecule->id);
 
 /*         fprintf(stderr, "TNG library: Read id: %"PRId64" offset: %d\n", molecule->id, offset);*/
-        len = tng_min_i((int)strlen(block->block_contents+offset) + 1, TNG_MAX_STR_LEN);
-        molecule->name = malloc(len);
-        strncpy(molecule->name, block->block_contents+offset, len);
-        offset += len;
+        tng_freadstr(tng_data->input_file, &molecule->name);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)molecule->name, strlen(molecule->name) + 1);
+        }
 
-        memcpy(&molecule->quaternary_str, block->block_contents+offset,
-               sizeof(molecule->quaternary_str));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&molecule->quaternary_str, sizeof(molecule->quaternary_str),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                     &molecule->quaternary_str)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(molecule->quaternary_str);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->quaternary_str, sizeof(molecule->quaternary_str));
+        }
+        tng_var_64_bit_input_swap(tng_data, &molecule->quaternary_str);
 
         if(!tng_data->var_num_atoms_flag)
         {
-            memcpy(&tng_data->molecule_cnt_list[i],
-                   block->block_contents+offset,
-                   sizeof(int64_t));
-            if(tng_data->input_endianness_swap_func_64)
+            if(fread(&tng_data->molecule_cnt_list[i], sizeof(int64_t),
+                    1, tng_data->input_file) == 0)
             {
-                if(tng_data->input_endianness_swap_func_64(tng_data,
-                                               &tng_data->molecule_cnt_list[i])
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&tng_data->molecule_cnt_list[i], sizeof(int64_t));
             }
-            offset += sizeof(int64_t);
+            tng_var_64_bit_input_swap(tng_data, &tng_data->molecule_cnt_list[i]);
         }
 
-
-        memcpy(&molecule->n_chains, block->block_contents+offset,
-               sizeof(molecule->n_chains));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&molecule->n_chains, sizeof(molecule->n_chains),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       &molecule->n_chains)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(molecule->n_chains);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->n_chains, sizeof(molecule->n_chains));
+        }
+        tng_var_64_bit_input_swap(tng_data, &molecule->n_chains);
 
-        memcpy(&molecule->n_residues, block->block_contents+offset,
-               sizeof(molecule->n_residues));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&molecule->n_residues, sizeof(molecule->n_residues),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       &molecule->n_residues)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->n_residues, sizeof(molecule->n_residues));
         }
-        offset += sizeof(molecule->n_residues);
+        tng_var_64_bit_input_swap(tng_data, &molecule->n_residues);
 
-        memcpy(&molecule->n_atoms, block->block_contents+offset,
-               sizeof(molecule->n_atoms));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&molecule->n_atoms, sizeof(molecule->n_atoms),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       &molecule->n_atoms)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(molecule->n_atoms);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->n_atoms, sizeof(molecule->n_atoms));
+        }
+        tng_var_64_bit_input_swap(tng_data, &molecule->n_atoms);
 
         tng_data->n_particles += molecule->n_atoms *
                                  tng_data->molecule_cnt_list[i];
@@ -3400,17 +3232,28 @@ static tng_function_status tng_molecules_block_read
             {
                 chain->molecule = molecule;
 
-                tng_chain_data_read(tng_data, block, chain, &offset);
+                chain->name = 0;
 
-                chain->residues = molecule->residues;
-                residue = chain->residues;
+                tng_chain_data_read(tng_data, chain, hash_mode, &md5_state);
+
+                if(j==0)
+                {
+                    chain->residues = molecule->residues;
+                    residue = chain->residues;
+                }
+                else
+                {
+                    chain->residues = residue;
+                }
 
                 /* Read the residues of the chain */
                 for(k=0; k<chain->n_residues; k++)
                 {
                     residue->chain = chain;
 
-                    tng_residue_data_read(tng_data, block, residue, &offset);
+                    residue->name = 0;
+
+                    tng_residue_data_read(tng_data, residue, hash_mode, &md5_state);
 
                     residue->atoms_offset = atom - molecule->atoms;
                     /* Read the atoms of the residue */
@@ -3418,7 +3261,10 @@ static tng_function_status tng_molecules_block_read
                     {
                         atom->residue = residue;
 
-                        tng_atom_data_read(tng_data, block, atom, &offset);
+                        atom->name = 0;
+                        atom->atom_type = 0;
+
+                        tng_atom_data_read(tng_data,atom, hash_mode, &md5_state);
 
                         atom++;
                     }
@@ -3435,7 +3281,9 @@ static tng_function_status tng_molecules_block_read
                 {
                     residue->chain = 0;
 
-                    tng_residue_data_read(tng_data, block, residue, &offset);
+                    residue->name = 0;
+
+                    tng_residue_data_read(tng_data, residue, hash_mode, &md5_state);
 
                     residue->atoms_offset = atom - molecule->atoms;
                     /* Read the atoms of the residue */
@@ -3443,7 +3291,7 @@ static tng_function_status tng_molecules_block_read
                     {
                         atom->residue = residue;
 
-                        tng_atom_data_read(tng_data, block, atom, &offset);
+                        tng_atom_data_read(tng_data, atom, hash_mode, &md5_state);
 
                         atom++;
                     }
@@ -3456,26 +3304,27 @@ static tng_function_status tng_molecules_block_read
                 {
                     atom->residue = 0;
 
-                    tng_atom_data_read(tng_data, block, atom, &offset);
+                    atom->name = 0;
+                    atom->atom_type = 0;
+
+                    tng_atom_data_read(tng_data, atom, hash_mode, &md5_state);
 
                     atom++;
                 }
             }
         }
 
-        memcpy(&molecule->n_bonds, block->block_contents+offset,
-               sizeof(molecule->n_bonds));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&molecule->n_bonds, sizeof(molecule->n_bonds),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       &molecule->n_bonds)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(molecule->n_bonds);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&molecule->n_bonds, sizeof(molecule->n_bonds));
+        }
+        tng_var_64_bit_input_swap(tng_data, &molecule->n_bonds);
 
         if(molecule->n_bonds > 0)
         {
@@ -3508,33 +3357,29 @@ static tng_function_status tng_molecules_block_read
 
             for(j=0; j<molecule->n_bonds; j++)
             {
-                memcpy(&bond->from_atom_id, block->block_contents+offset,
-                    sizeof(bond->from_atom_id));
-                if(tng_data->input_endianness_swap_func_64)
+                if(fread(&bond->from_atom_id, sizeof(bond->from_atom_id),
+                        1, tng_data->input_file) == 0)
                 {
-                    if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                               &bond->from_atom_id)
-                        != TNG_SUCCESS)
-                    {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
-                    }
+                    fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                    return(TNG_CRITICAL);
                 }
-                offset += sizeof(bond->from_atom_id);
+                if(hash_mode == TNG_USE_HASH)
+                {
+                    md5_append(&md5_state, (md5_byte_t *)&bond->from_atom_id, sizeof(bond->from_atom_id));
+                }
+                tng_var_64_bit_input_swap(tng_data, &bond->from_atom_id);
 
-                memcpy(&bond->to_atom_id, block->block_contents+offset,
-                    sizeof(bond->to_atom_id));
-                if(tng_data->input_endianness_swap_func_64)
+                if(fread(&bond->to_atom_id, sizeof(bond->to_atom_id),
+                        1, tng_data->input_file) == 0)
                 {
-                    if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                               &bond->to_atom_id)
-                        != TNG_SUCCESS)
-                    {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
-                    }
+                    fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                    return(TNG_CRITICAL);
                 }
-                offset += sizeof(bond->to_atom_id);
+                if(hash_mode == TNG_USE_HASH)
+                {
+                    md5_append(&md5_state, (md5_byte_t *)&bond->to_atom_id, sizeof(bond->to_atom_id));
+                }
+                tng_var_64_bit_input_swap(tng_data, &bond->to_atom_id);
 
                 bond++;
             }
@@ -3545,6 +3390,44 @@ static tng_function_status tng_molecules_block_read
         }
     }
 
+    if(hash_mode == TNG_USE_HASH)
+    {
+        /* If there is data left in the block that the current version of the library
+         * cannot interpret still read that to generate the MD5 hash. */
+        curr_file_pos = ftello(tng_data->input_file);
+        if(curr_file_pos < start_pos + block->block_contents_size)
+        {
+            temp_data = malloc(start_pos + block->block_contents_size - curr_file_pos);
+            if(!temp_data)
+            {
+                fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                        start_pos + block->block_contents_size - curr_file_pos, __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(fread(temp_data, start_pos + block->block_contents_size - curr_file_pos,
+                     1, tng_data->input_file) == 0)
+            {
+                fprintf(stderr, "TNG library: Cannot read remaining part of block to generate MD5 sum. %s: %d\n", __FILE__, __LINE__);
+                free(temp_data);
+                return(TNG_CRITICAL);
+            }
+            md5_append(&md5_state, (md5_byte_t *)temp_data,
+                       start_pos + block->block_contents_size - curr_file_pos);
+            free(temp_data);
+        }
+        md5_finish(&md5_state, (md5_byte_t *)hash);
+        if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN) != 0)
+        {
+            if(strncmp(block->md5_hash, hash, TNG_MD5_HASH_LEN) != 0)
+            {
+                fprintf(stderr, "TNG library: Molecules block contents corrupt. Hashes do not match. "
+                        "%s: %d\n", __FILE__, __LINE__);
+            }
+        }
+    }
+
+    fseeko(tng_data->input_file, start_pos + block->block_contents_size, SEEK_SET);
+
     return(TNG_SUCCESS);
 }
 
@@ -3559,14 +3442,15 @@ static tng_function_status tng_molecules_block_write
                 (tng_trajectory_t tng_data,
                  const char hash_mode)
 {
-    int len = 0, name_len, offset = 0;
-    int64_t i, j, k, l;
+    int len = 0, name_len;
+    int64_t temp_i64, i, j, k, l, header_file_pos, curr_file_pos;
     tng_molecule_t molecule;
     tng_chain_t chain;
     tng_residue_t residue;
     tng_atom_t atom;
     tng_bond_t bond;
     tng_gen_block_t block;
+    md5_state_t md5_state;
 
     if(tng_output_file_init(tng_data) != TNG_SUCCESS)
     {
@@ -3575,7 +3459,7 @@ static tng_function_status tng_molecules_block_write
 
     tng_block_init(&block);
 
-    name_len = (int)strlen("MOLECULES");
+    name_len = (unsigned int)strlen("MOLECULES");
 
     block->name = malloc(name_len + 1);
     if(!block->name)
@@ -3598,140 +3482,136 @@ static tng_function_status tng_molecules_block_write
         return(TNG_CRITICAL);
     }
 
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+    header_file_pos = ftello(tng_data->output_file);
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(TNG_CRITICAL);
     }
 
-    memcpy(block->block_contents+offset, &tng_data->n_molecules,
-           sizeof(tng_data->n_molecules));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = tng_data->n_molecules;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(tng_data->n_molecules);
 
     for(i = 0; i < tng_data->n_molecules; i++)
     {
         molecule = &tng_data->molecules[i];
-        memcpy(block->block_contents+offset, &molecule->id,
-               sizeof(molecule->id));
-        if(tng_data->output_endianness_swap_func_64)
+
+        temp_i64 = molecule->id;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->id);
 
 /*         fprintf(stderr, "TNG library: Wrote id: %"PRId64" offset: %d\n", molecule->id, offset); */
-        len = tng_min_i((int)strlen(molecule->name) + 1, TNG_MAX_STR_LEN);
-        strncpy(block->block_contents + offset, molecule->name, len);
-        offset += len;
+        len = tng_min_i((unsigned int)strlen(molecule->name) + 1, TNG_MAX_STR_LEN);
+        if(fwrite(molecule->name, len, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)molecule->name, len);
+        }
 
-        memcpy(block->block_contents+offset, &molecule->quaternary_str,
-               sizeof(molecule->quaternary_str));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = molecule->quaternary_str;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->quaternary_str);
 
         if(!tng_data->var_num_atoms_flag)
         {
-            memcpy(block->block_contents+offset,
-                   &tng_data->molecule_cnt_list[i], sizeof(int64_t));
-            if(tng_data->output_endianness_swap_func_64)
+            temp_i64 = tng_data->molecule_cnt_list[i];
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
             {
-                if(tng_data->output_endianness_swap_func_64(tng_data,
-                                            (int64_t *)block->header_contents+offset)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
             }
-            offset += sizeof(int64_t);
         }
 
-        memcpy(block->block_contents+offset, &molecule->n_chains,
-               sizeof(molecule->n_chains));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = molecule->n_chains;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->n_chains);
 
-        memcpy(block->block_contents+offset, &molecule->n_residues,
-               sizeof(molecule->n_residues));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = molecule->n_residues;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->n_residues);
 
-        memcpy(block->block_contents+offset, &molecule->n_atoms,
-               sizeof(molecule->n_atoms));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = molecule->n_atoms;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->n_atoms);
 
         if(molecule->n_chains > 0)
         {
             chain = molecule->chains;
             for(j = 0; j < molecule->n_chains; j++)
             {
-                tng_chain_data_write(tng_data, block, chain, &offset);
+                tng_chain_data_write(tng_data, chain, hash_mode, &md5_state);
 
                 residue = chain->residues;
                 for(k = 0; k < chain->n_residues; k++)
                 {
-                    tng_residue_data_write(tng_data, block, residue, &offset);
+                    tng_residue_data_write(tng_data, residue, hash_mode, &md5_state);
 
                     atom = molecule->atoms + residue->atoms_offset;
                     for(l = 0; l < residue->n_atoms; l++)
                     {
-                        tng_atom_data_write(tng_data, block, atom, &offset);
+                        tng_atom_data_write(tng_data, atom, hash_mode, &md5_state);
 
                         atom++;
                     }
@@ -3747,12 +3627,12 @@ static tng_function_status tng_molecules_block_write
                 residue = molecule->residues;
                 for(k = 0; k < molecule->n_residues; k++)
                 {
-                    tng_residue_data_write(tng_data, block, residue, &offset);
+                    tng_residue_data_write(tng_data, residue, hash_mode, &md5_state);
 
                     atom = molecule->atoms + residue->atoms_offset;
                     for(l = 0; l < residue->n_atoms; l++)
                     {
-                        tng_atom_data_write(tng_data, block, atom, &offset);
+                        tng_atom_data_write(tng_data, atom, hash_mode, &md5_state);
 
                         atom++;
                     }
@@ -3764,77 +3644,68 @@ static tng_function_status tng_molecules_block_write
                 atom = molecule->atoms;
                 for(l = 0; l < molecule->n_atoms; l++)
                 {
-                    tng_atom_data_write(tng_data, block, atom, &offset);
+                    tng_atom_data_write(tng_data, atom, hash_mode, &md5_state);
 
                     atom++;
                 }
             }
         }
 
-        memcpy(block->block_contents+offset, &molecule->n_bonds,
-               sizeof(molecule->n_bonds));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = molecule->n_bonds;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(molecule->n_bonds);
 
         bond = molecule->bonds;
         for(j = 0; j < molecule->n_bonds; j++)
         {
-            memcpy(block->block_contents+offset, &bond->from_atom_id,
-                   sizeof(bond->from_atom_id));
-            if(tng_data->output_endianness_swap_func_64)
+            temp_i64 = bond->from_atom_id;
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
             {
-                if(tng_data->output_endianness_swap_func_64(tng_data,
-                                            (int64_t *)block->header_contents+offset)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
             }
-            offset += sizeof(bond->from_atom_id);
 
-            memcpy(block->block_contents+offset, &bond->to_atom_id,
-                   sizeof(bond->to_atom_id));
-            if(tng_data->output_endianness_swap_func_64)
+            temp_i64 = bond->to_atom_id;
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
             {
-                if(tng_data->output_endianness_swap_func_64(tng_data,
-                                            (int64_t *)block->header_contents+offset)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
             }
-            offset += sizeof(bond->to_atom_id);
 
             bond++;
         }
     }
-
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
-    {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
-        tng_block_destroy(&block);
-        return(TNG_CRITICAL);
-    }
-
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-              tng_data->output_file) != 1)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n",
-               __FILE__, __LINE__);
-        tng_block_destroy(&block);
-        return(TNG_CRITICAL);
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+               3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
     }
 
     tng_block_destroy(&block);
@@ -3870,100 +3741,52 @@ static tng_function_status tng_frame_set_block_read
                  tng_gen_block_t block,
                  const char hash_mode)
 {
-    long file_pos;
-    int offset = 0;
-    int64_t i, prev_n_particles;
-    tng_bool same_hash;
+    int64_t file_pos, start_pos, i, prev_n_particles;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
+    char hash[TNG_MD5_HASH_LEN], *temp_data;
+    md5_state_t md5_state;
 
     if(tng_input_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
-    {
-        free(block->block_contents);
-    }
-
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
-    {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    /* Read the whole block into block_contents to be able to write it to
-     * disk even if it cannot be interpreted. */
-    if(fread(block->block_contents, block->block_contents_size, 1,
-             tng_data->input_file) == 0)
-    {
-        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
+    start_pos = ftello(tng_data->input_file);
 
     /* FIXME: Does not check if the size of the contents matches the expected
      * size or if the contents can be read. */
 
-    file_pos = (int64_t)ftell(tng_data->input_file) -
-               (long)(block->block_contents_size + block->header_contents_size);
-
-    if(hash_mode == TNG_USE_HASH)
-    {
-        tng_md5_hash_match_verify(block, &same_hash);
-        if(same_hash != TNG_TRUE)
-        {
-            fprintf(stderr, "TNG library: Frame set block contents corrupt. File pos %ld Hashes do not match. "
-                "%s: %d\n",
-                file_pos, __FILE__, __LINE__);
-    /*         return(TNG_FAILURE); */
-        }
-    }
+    file_pos = start_pos - block->header_contents_size;
 
     tng_data->current_trajectory_frame_set_input_file_pos = file_pos;
 
     tng_frame_set_particle_mapping_free(tng_data);
 
-    if(tng_data->first_trajectory_frame_set_input_file_pos <= 0)
+    if(fread(&frame_set->first_frame, sizeof(frame_set->first_frame),
+             1, tng_data->input_file) == 0)
     {
-        tng_data->first_trajectory_frame_set_input_file_pos = file_pos;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    /* FIXME: Should check the frame number instead of the file_pos, in case
-     * frame sets are not in order */
-    if(tng_data->last_trajectory_frame_set_input_file_pos < file_pos)
+    if(hash_mode == TNG_USE_HASH)
     {
-        tng_data->last_trajectory_frame_set_input_file_pos = file_pos;
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->first_frame, sizeof(frame_set->first_frame));
     }
+    tng_var_64_bit_input_swap(tng_data, &frame_set->first_frame);
 
-    memcpy(&frame_set->first_frame, block->block_contents,
-           sizeof(frame_set->first_frame));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->n_frames, sizeof(frame_set->n_frames),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &frame_set->first_frame)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->first_frame);
-
-    memcpy(&frame_set->n_frames, block->block_contents + offset,
-           sizeof(frame_set->n_frames));
-    if(tng_data->input_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &frame_set->n_frames)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->n_frames, sizeof(frame_set->n_frames));
     }
-    offset += sizeof(frame_set->n_frames);
+    tng_var_64_bit_input_swap(tng_data, &frame_set->n_frames);
 
     if(tng_data->var_num_atoms_flag)
     {
@@ -3986,20 +3809,18 @@ static tng_function_status tng_frame_set_block_read
         }
         for(i = 0; i < tng_data->n_molecules; i++)
         {
-            memcpy(&frame_set->molecule_cnt_list[i],
-                   block->block_contents + offset,
-                   sizeof(int64_t));
-            if(tng_data->input_endianness_swap_func_64)
+            if(fread(&frame_set->molecule_cnt_list[i], sizeof(int64_t),
+                    1, tng_data->input_file) == 0)
             {
-                if(tng_data->input_endianness_swap_func_64(tng_data,
-                                              &frame_set->molecule_cnt_list[i])
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
             }
-            offset += sizeof(int64_t);
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&frame_set->molecule_cnt_list[i], sizeof(int64_t));
+            }
+            tng_var_64_bit_input_swap(tng_data, &frame_set->molecule_cnt_list[i]);
+
             frame_set->n_particles += tng_data->molecules[i].n_atoms *
                                       frame_set->molecule_cnt_list[i];
         }
@@ -4009,126 +3830,117 @@ static tng_function_status tng_frame_set_block_read
         }
     }
 
-    memcpy(&frame_set->next_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->next_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->next_frame_set_file_pos, sizeof(frame_set->next_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                           &frame_set->next_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->next_frame_set_file_pos);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->next_frame_set_file_pos, sizeof(frame_set->next_frame_set_file_pos));
+    }
+    tng_var_64_bit_input_swap(tng_data, &frame_set->next_frame_set_file_pos);
 
-    memcpy(&frame_set->prev_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->prev_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->prev_frame_set_file_pos, sizeof(frame_set->prev_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                           &frame_set->prev_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->prev_frame_set_file_pos,
+                   sizeof(frame_set->prev_frame_set_file_pos));
     }
-    offset += sizeof(frame_set->prev_frame_set_file_pos);
+    tng_var_64_bit_input_swap(tng_data, &frame_set->prev_frame_set_file_pos);
 
-    memcpy(&frame_set->medium_stride_next_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->medium_stride_next_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->medium_stride_next_frame_set_file_pos,
+             sizeof(frame_set->medium_stride_next_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                             &frame_set->medium_stride_next_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->medium_stride_next_frame_set_file_pos);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->medium_stride_next_frame_set_file_pos,
+                   sizeof(frame_set->medium_stride_next_frame_set_file_pos));
+    }
+    tng_var_64_bit_input_swap(tng_data, &frame_set->medium_stride_next_frame_set_file_pos);
 
-    memcpy(&frame_set->medium_stride_prev_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->medium_stride_prev_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->medium_stride_prev_frame_set_file_pos,
+             sizeof(frame_set->medium_stride_prev_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                             &frame_set->medium_stride_prev_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->medium_stride_prev_frame_set_file_pos);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->medium_stride_prev_frame_set_file_pos,
+                   sizeof(frame_set->medium_stride_prev_frame_set_file_pos));
+    }
+    tng_var_64_bit_input_swap(tng_data, &frame_set->medium_stride_prev_frame_set_file_pos);
 
-    memcpy(&frame_set->long_stride_next_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->long_stride_next_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->long_stride_next_frame_set_file_pos,
+             sizeof(frame_set->long_stride_next_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                               &frame_set->long_stride_next_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->long_stride_next_frame_set_file_pos,
+                   sizeof(frame_set->long_stride_next_frame_set_file_pos));
     }
-    offset += sizeof(frame_set->long_stride_next_frame_set_file_pos);
+    tng_var_64_bit_input_swap(tng_data, &frame_set->long_stride_next_frame_set_file_pos);
 
-    memcpy(&frame_set->long_stride_prev_frame_set_file_pos,
-           block->block_contents + offset,
-           sizeof(frame_set->long_stride_prev_frame_set_file_pos));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&frame_set->long_stride_prev_frame_set_file_pos,
+             sizeof(frame_set->long_stride_prev_frame_set_file_pos),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                               &frame_set->long_stride_prev_frame_set_file_pos)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->long_stride_prev_frame_set_file_pos);
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&frame_set->long_stride_prev_frame_set_file_pos,
+                   sizeof(frame_set->long_stride_prev_frame_set_file_pos));
+    }
+    tng_var_64_bit_input_swap(tng_data, &frame_set->long_stride_prev_frame_set_file_pos);
+
 
     if(block->block_version >= 3)
     {
-        memcpy(&frame_set->first_frame_time,
-            block->block_contents + offset,
-            sizeof(frame_set->first_frame_time));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&frame_set->first_frame_time,
+                 sizeof(frame_set->first_frame_time),
+                 1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                (int64_t *)&frame_set->first_frame_time)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        offset += sizeof(frame_set->first_frame_time);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&frame_set->first_frame_time,
+                       sizeof(frame_set->first_frame_time));
+        }
+        tng_var_64_bit_input_swap(tng_data, (int64_t *)&frame_set->first_frame_time);
 
-        memcpy(&tng_data->time_per_frame,
-            block->block_contents + offset,
-            sizeof(tng_data->time_per_frame));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(&tng_data->time_per_frame,
+                 sizeof(tng_data->time_per_frame),
+                 1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                (int64_t *)&tng_data->time_per_frame)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&tng_data->time_per_frame,
+                       sizeof(tng_data->time_per_frame));
         }
+        tng_var_64_bit_input_swap(tng_data, (int64_t *)&tng_data->time_per_frame);
     }
     else
     {
@@ -4136,6 +3948,42 @@ static tng_function_status tng_frame_set_block_read
         tng_data->time_per_frame = -1;
     }
 
+    if(hash_mode == TNG_USE_HASH)
+    {
+        /* If there is data left in the block that the current version of the library
+         * cannot interpret still read that to generate the MD5 hash. */
+        file_pos = ftello(tng_data->input_file);
+        if(file_pos < start_pos + block->block_contents_size)
+        {
+            temp_data = malloc(start_pos + block->block_contents_size - file_pos);
+            if(!temp_data)
+            {
+                fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                        start_pos + block->block_contents_size - file_pos, __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(fread(temp_data, start_pos + block->block_contents_size - file_pos,
+                     1, tng_data->input_file) == 0)
+            {
+                fprintf(stderr, "TNG library: Cannot read remaining part of block to generate MD5 sum. %s: %d\n", __FILE__, __LINE__);
+                free(temp_data);
+                return(TNG_CRITICAL);
+            }
+            md5_append(&md5_state, (md5_byte_t *)temp_data,
+                       start_pos + block->block_contents_size - file_pos);
+            free(temp_data);
+        }
+        md5_finish(&md5_state, (md5_byte_t *)hash);
+        if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN) != 0)
+        {
+            if(strncmp(block->md5_hash, hash, TNG_MD5_HASH_LEN) != 0)
+            {
+                fprintf(stderr, "TNG library: Frame set block contents corrupt (first frame %"PRId64"). Hashes do not match. "
+                        "%s: %d\n", frame_set->first_frame, __FILE__, __LINE__);
+            }
+        }
+    }
+
     /* If the output file and the input files are the same the number of
      * frames in the file are the same number as has just been read.
      * This is updated here to later on see if there have been new frames
@@ -4162,18 +4010,19 @@ static tng_function_status tng_frame_set_block_write
                  const char hash_mode)
 {
     char *temp_name;
-    int64_t i;
-    int offset = 0;
+    int64_t temp_i64, i, header_file_pos, curr_file_pos;
+    double temp_d;
     unsigned int name_len;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
+    md5_state_t md5_state;
 
     if(tng_output_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    name_len = (int)strlen("TRAJECTORY FRAME SET");
+    name_len = (unsigned int)strlen("TRAJECTORY FRAME SET");
 
     if(!block->name || strlen(block->name) < name_len)
     {
@@ -4199,198 +4048,164 @@ static tng_function_status tng_frame_set_block_write
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
+    header_file_pos = ftello(tng_data->output_file);
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
     {
-        free(block->block_contents);
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+
+    temp_i64 = frame_set->first_frame;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-
-    memcpy(block->block_contents, &frame_set->first_frame,
-           sizeof(frame_set->first_frame));
-    if(tng_data->output_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->first_frame);
 
-    memcpy(block->block_contents+offset, &frame_set->n_frames,
-           sizeof(frame_set->n_frames));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->n_frames;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->n_frames);
 
     if(tng_data->var_num_atoms_flag)
     {
         for(i = 0; i < tng_data->n_molecules; i++)
         {
-            memcpy(block->block_contents+offset,
-                   &frame_set->molecule_cnt_list[i],
-                   sizeof(int64_t));
-            if(tng_data->output_endianness_swap_func_64)
+            temp_i64 = frame_set->molecule_cnt_list[i];
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
             {
-                if(tng_data->output_endianness_swap_func_64(tng_data,
-                                            (int64_t *)block->header_contents+offset)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
             }
-            offset += sizeof(int64_t);
         }
     }
 
-
-    memcpy(block->block_contents+offset, &frame_set->next_frame_set_file_pos,
-           sizeof(frame_set->next_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->next_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->next_frame_set_file_pos);
-
-    memcpy(block->block_contents+offset, &frame_set->prev_frame_set_file_pos,
-           sizeof(frame_set->prev_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->prev_frame_set_file_pos);
 
-    memcpy(block->block_contents+offset,
-           &frame_set->medium_stride_next_frame_set_file_pos,
-           sizeof(frame_set->medium_stride_next_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->prev_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    offset += sizeof(frame_set->medium_stride_next_frame_set_file_pos);
-
-    memcpy(block->block_contents+offset,
-           &frame_set->medium_stride_prev_frame_set_file_pos,
-           sizeof(frame_set->medium_stride_prev_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->medium_stride_prev_frame_set_file_pos);
 
-    memcpy(block->block_contents+offset,
-           &frame_set->long_stride_next_frame_set_file_pos,
-           sizeof(frame_set->long_stride_next_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->medium_stride_next_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->long_stride_next_frame_set_file_pos);
 
-    memcpy(block->block_contents+offset,
-           &frame_set->long_stride_prev_frame_set_file_pos,
-           sizeof(frame_set->long_stride_prev_frame_set_file_pos));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->medium_stride_prev_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->long_stride_prev_frame_set_file_pos);
 
-    memcpy(block->block_contents+offset,
-           &frame_set->first_frame_time,
-           sizeof(frame_set->first_frame_time));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->long_stride_next_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(frame_set->first_frame_time);
 
-    memcpy(block->block_contents+offset,
-           &tng_data->time_per_frame,
-           sizeof(tng_data->time_per_frame));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = frame_set->long_stride_prev_frame_set_file_pos;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
 
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
+    temp_d = frame_set->first_frame_time;
+    tng_var_64_bit_output_swap(tng_data, (int64_t *)&temp_d);
+    if(fwrite(&temp_d, sizeof(temp_d), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_d, sizeof(temp_d));
+    }
 
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-              tng_data->output_file) != 1)
+    temp_d = tng_data->time_per_frame;
+    tng_var_64_bit_output_swap(tng_data, (int64_t *)&temp_d);
+    if(fwrite(&temp_d, sizeof(temp_d), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_d, sizeof(temp_d));
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+               3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
+    }
 
     return(TNG_SUCCESS);
 }
@@ -4421,56 +4236,23 @@ static tng_function_status tng_trajectory_mapping_block_read
                  tng_gen_block_t block,
                  const char hash_mode)
 {
-    int64_t i;
-    int offset = 0;
-    tng_bool same_hash;
+    int64_t start_pos, curr_file_pos, i;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
-
     tng_particle_mapping_t mapping, mappings;
+    char hash[TNG_MD5_HASH_LEN], *temp_data;
+    md5_state_t md5_state;
 
     if(tng_input_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
-    {
-        free(block->block_contents);
-    }
-
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
-    {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    /* Read the whole block into block_contents to be able to write it to disk
-     *  even if it cannot be interpreted. */
-    if(fread(block->block_contents, block->block_contents_size, 1,
-        tng_data->input_file) == 0)
-    {
-        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
+    start_pos = ftello(tng_data->input_file);
 
     /* FIXME: Does not check if the size of the contents matches the expected
      * size or if the contents can be read. */
 
-    if(hash_mode == TNG_USE_HASH)
-    {
-        tng_md5_hash_match_verify(block, &same_hash);
-        if(same_hash != TNG_TRUE)
-        {
-            fprintf(stderr, "TNG library: Particle mapping block contents corrupt. Hashes do not match. "
-                "%s: %d\n",
-                __FILE__, __LINE__);
-    /*         return(TNG_FAILURE); */
-        }
-    }
-
     frame_set->n_mapping_blocks++;
     mappings = realloc(frame_set->mappings,
                        sizeof(struct tng_particle_mapping) *
@@ -4487,33 +4269,30 @@ static tng_function_status tng_trajectory_mapping_block_read
     mapping = &mappings[frame_set->n_mapping_blocks - 1];
 
 
-    memcpy(&mapping->num_first_particle, block->block_contents+offset,
-           sizeof(mapping->num_first_particle));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&mapping->num_first_particle, sizeof(mapping->num_first_particle),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &mapping->num_first_particle)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&mapping->num_first_particle, sizeof(mapping->num_first_particle));
     }
-    offset += sizeof(mapping->num_first_particle);
+    tng_var_64_bit_input_swap(tng_data, &mapping->num_first_particle);
 
-    memcpy(&mapping->n_particles, block->block_contents+offset,
-           sizeof(mapping->n_particles));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(&mapping->n_particles, sizeof(mapping->n_particles),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   &mapping->n_particles)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&mapping->n_particles, sizeof(mapping->n_particles));
     }
-    offset += sizeof(mapping->n_particles);
+    tng_var_64_bit_input_swap(tng_data, &mapping->n_particles);
 
     mapping->real_particle_numbers = malloc(mapping->n_particles *
                                             sizeof(int64_t));
@@ -4530,26 +4309,72 @@ static tng_function_status tng_trajectory_mapping_block_read
     {
         for(i = 0; i < mapping->n_particles; i++)
         {
-            memcpy(&mapping->real_particle_numbers[i],
-                    block->block_contents + offset,
-                    sizeof(int64_t));
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                            &mapping->real_particle_numbers[i])
-                != TNG_SUCCESS)
+            if(fread(&mapping->real_particle_numbers[i], sizeof(int64_t),
+                    1, tng_data->input_file) == 0)
             {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
+                fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
             }
-            offset += sizeof(int64_t);
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&mapping->real_particle_numbers[i],
+                           sizeof(mapping->real_particle_numbers[i]));
+            }
+            tng_var_64_bit_input_swap(tng_data, &mapping->real_particle_numbers[i]);
         }
     }
     /* Otherwise the data can be read all at once */
     else
     {
-        memcpy(mapping->real_particle_numbers, block->block_contents + offset,
-               mapping->n_particles * sizeof(int64_t));
+        if(fread(mapping->real_particle_numbers, mapping->n_particles * sizeof(int64_t),
+                1, tng_data->input_file) == 0)
+        {
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)mapping->real_particle_numbers, mapping->n_particles * sizeof(int64_t));
+        }
+    }
+
+    if(hash_mode == TNG_USE_HASH)
+    {
+        /* If there is data left in the block that the current version of the library
+         * cannot interpret still read that to generate the MD5 hash. */
+        curr_file_pos = ftello(tng_data->input_file);
+        if(curr_file_pos < start_pos + block->block_contents_size)
+        {
+            temp_data = malloc(start_pos + block->block_contents_size - curr_file_pos);
+            if(!temp_data)
+            {
+                fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                        start_pos + block->block_contents_size - curr_file_pos, __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(fread(temp_data, start_pos + block->block_contents_size - curr_file_pos,
+                     1, tng_data->input_file) == 0)
+            {
+                fprintf(stderr, "TNG library: Cannot read remaining part of block to generate MD5 sum. %s: %d\n", __FILE__, __LINE__);
+                free(temp_data);
+                return(TNG_CRITICAL);
+            }
+            md5_append(&md5_state, (md5_byte_t *)temp_data,
+                       start_pos + block->block_contents_size - curr_file_pos);
+            free(temp_data);
+        }
+        md5_finish(&md5_state, (md5_byte_t *)hash);
+        if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN) != 0)
+        {
+            if(strncmp(block->md5_hash, hash, TNG_MD5_HASH_LEN) != 0)
+            {
+                fprintf(stderr, "TNG library: Particle mapping block contents corrupt. Hashes do not match. "
+                        "%s: %d\n", __FILE__, __LINE__);
+            }
+        }
     }
 
+    fseeko(tng_data->input_file, start_pos + block->block_contents_size, SEEK_SET);
 
     return(TNG_SUCCESS);
 }
@@ -4569,9 +4394,11 @@ static tng_function_status tng_trajectory_mapping_block_write
                  int mapping_block_nr,
                  const char hash_mode)
 {
+    int64_t temp_i64, header_file_pos, curr_file_pos;
     char *temp_name;
-    int i, offset = 0;
+    int i;
     unsigned int name_len;
+    md5_state_t md5_state;
     tng_particle_mapping_t mapping =
     &tng_data->current_trajectory_frame_set.mappings[mapping_block_nr];
 
@@ -4588,7 +4415,7 @@ static tng_function_status tng_trajectory_mapping_block_write
         return(TNG_CRITICAL);
     }
 
-    name_len = (int)strlen("PARTICLE MAPPING");
+    name_len = (unsigned int)strlen("PARTICLE MAPPING");
 
     if(!block->name || strlen(block->name) < name_len)
     {
@@ -4616,81 +4443,86 @@ static tng_function_status tng_trajectory_mapping_block_write
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
+    header_file_pos = ftello(tng_data->output_file);
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
     {
-        free(block->block_contents);
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+
+    temp_i64 = mapping->num_first_particle;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-
-    memcpy(block->block_contents, &mapping->num_first_particle,
-           sizeof(mapping->num_first_particle));
-    if(tng_data->output_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(mapping->num_first_particle);
 
-    memcpy(block->block_contents+offset, &mapping->n_particles,
-           sizeof(mapping->n_particles));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = mapping->n_particles;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-                                      (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(mapping->n_particles);
 
     if(tng_data->output_endianness_swap_func_64)
     {
         for(i = 0; i < mapping->n_particles; i++)
         {
-            memcpy(block->block_contents+offset, &mapping->real_particle_numbers[i],
-                sizeof(int64_t));
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-                                        (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
+            temp_i64 = mapping->real_particle_numbers[i];
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
             {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
             }
-            offset += sizeof(int64_t);
         }
     }
     else
     {
-        memcpy(block->block_contents+offset, mapping->real_particle_numbers,
-               mapping->n_particles * sizeof(int64_t));
-    }
-
-
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
-    {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+        if(fwrite(mapping->real_particle_numbers,
+                  mapping->n_particles * sizeof(int64_t),
+                  1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)mapping->real_particle_numbers,
+                       mapping->n_particles * sizeof(int64_t));
+        }
     }
 
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-              tng_data->output_file) != 1)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+               3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
     }
 
     return(TNG_SUCCESS);
@@ -4757,14 +4589,14 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
                                         const int64_t n_frames,
                                         const int64_t n_particles,
                                         const char type,
-                                        void *start_pos)
+                                        char **data,
+                                        int64_t *new_len)
 {
     int nalgo;
-    int new_len;
+    int compressed_len;
     int *alt_algo = 0;
-    char *dest, *temp;
-    int64_t algo_find_n_frames;
-    unsigned long offset;
+    char *dest;
+    int64_t algo_find_n_frames = -1;
     float f_precision;
     double d_precision;
 
@@ -4799,28 +4631,57 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
         if(n_frames == 1 && tng_data->frame_set_n_frames > 1)
         {
             nalgo = tng_compress_nalgo();
-            alt_algo=malloc(nalgo * sizeof *tng_data->compress_algo_pos);
+            alt_algo = malloc(nalgo * sizeof *tng_data->compress_algo_pos);
+
+            /* If we have already determined the initial coding and
+             * initial coding parameter do not determine them again. */
+            if(tng_data->compress_algo_pos)
+            {
+                alt_algo[0] = tng_data->compress_algo_pos[0];
+                alt_algo[1] = tng_data->compress_algo_pos[1];
+            }
+            else
+            {
+                alt_algo[0] = -1;
+                alt_algo[1] = -1;
+            }
+
+            /* If the initial coding and initial coding parameter are -1
+             * they will be determined in tng_compress_pos/_float/. */
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_pos_float_find_algo(start_pos, (int)n_particles,
-                                                        (int)n_frames,
-                                                        f_precision,
-                                                        0, alt_algo,
-                                                        &new_len);
+                dest = tng_compress_pos_float((float *)*data, (int)n_particles,
+                                              (int)n_frames,
+                                              f_precision,
+                                              0, alt_algo,
+                                              &compressed_len);
 
             }
             else
             {
-                dest = tng_compress_pos_find_algo(start_pos, (int)n_particles,
-                                           (int)n_frames,
-                                           d_precision,
-                                           0, alt_algo,
-                                           &new_len);
+                dest = tng_compress_pos((double *)*data, (int)n_particles,
+                                        (int)n_frames,
+                                        d_precision,
+                                        0, alt_algo,
+                                        &compressed_len);
+            }
+            /* If there had been no algorithm determined before keep the initial coding
+             * and initial coding parameter so that they won't have to be determined again. */
+            if(!tng_data->compress_algo_pos)
+            {
+                nalgo = tng_compress_nalgo();
+                tng_data->compress_algo_pos=malloc(nalgo *
+                                                   sizeof *tng_data->compress_algo_pos);
+                tng_data->compress_algo_pos[0] = alt_algo[0];
+                tng_data->compress_algo_pos[1] = alt_algo[1];
+                tng_data->compress_algo_pos[2] = -1;
+                tng_data->compress_algo_pos[3] = -1;
             }
         }
-        else if(!tng_data->compress_algo_pos)
+        else if(!tng_data->compress_algo_pos || tng_data->compress_algo_pos[2] == -1 ||
+                tng_data->compress_algo_pos[2] == -1)
         {
-            if(n_frames > 10)
+            if(n_frames > 6)
             {
                 algo_find_n_frames = 5;
             }
@@ -4829,43 +4690,54 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
                 algo_find_n_frames = n_frames;
             }
 
-            nalgo = tng_compress_nalgo();
-            tng_data->compress_algo_pos=malloc(nalgo *
-                                           sizeof *tng_data->compress_algo_pos);
+            /* If the algorithm parameters are -1 they will be determined during the
+             * compression. */
+            if(!tng_data->compress_algo_pos)
+            {
+                nalgo = tng_compress_nalgo();
+                tng_data->compress_algo_pos=malloc(nalgo *
+                                                   sizeof *tng_data->compress_algo_pos);
+                tng_data->compress_algo_pos[0] = -1;
+                tng_data->compress_algo_pos[1] = -1;
+                tng_data->compress_algo_pos[2] = -1;
+                tng_data->compress_algo_pos[3] = -1;
+            }
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_pos_float_find_algo(start_pos, (int)n_particles,
-                                                        (int)algo_find_n_frames,
-                                                        f_precision,
-                                                        0, tng_data->
-                                                        compress_algo_pos,
-                                                        &new_len);
+                dest = tng_compress_pos_float((float *)*data, (int)n_particles,
+                                              (int)algo_find_n_frames,
+                                              f_precision,
+                                              0, tng_data->
+                                              compress_algo_pos,
+                                              &compressed_len);
 
                 if(algo_find_n_frames < n_frames)
                 {
-                    dest = tng_compress_pos_float(start_pos, (int)n_particles,
+                    free(dest);
+                    dest = tng_compress_pos_float((float *)*data, (int)n_particles,
                                                   (int)n_frames,
                                                   f_precision,
                                                   0, tng_data->compress_algo_pos,
-                                                  &new_len);
+                                                  &compressed_len);
                 }
             }
             else
             {
-                dest = tng_compress_pos_find_algo(start_pos, (int)n_particles,
-                                           (int)algo_find_n_frames,
-                                           d_precision,
-                                           0, tng_data->
-                                           compress_algo_pos,
-                                           &new_len);
+                dest = tng_compress_pos((double *)*data, (int)n_particles,
+                                        (int)algo_find_n_frames,
+                                        d_precision,
+                                        0, tng_data->
+                                        compress_algo_pos,
+                                        &compressed_len);
 
                 if(algo_find_n_frames < n_frames)
                 {
-                    dest = tng_compress_pos(start_pos, (int)n_particles,
+                    free(dest);
+                    dest = tng_compress_pos((double *)*data, (int)n_particles,
                                             (int)n_frames,
                                             d_precision, 0,
                                             tng_data->compress_algo_pos,
-                                            &new_len);
+                                            &compressed_len);
                 }
             }
         }
@@ -4873,18 +4745,18 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
         {
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_pos_float(start_pos, (int)n_particles,
+                dest = tng_compress_pos_float((float *)*data, (int)n_particles,
                                               (int)n_frames,
                                               f_precision, 0,
-                                              tng_data->compress_algo_pos, &new_len);
+                                              tng_data->compress_algo_pos, &compressed_len);
             }
             else
             {
-                dest = tng_compress_pos(start_pos, (int)n_particles,
+                dest = tng_compress_pos((double *)*data, (int)n_particles,
                                         (int)n_frames,
                                         d_precision, 0,
                                         tng_data->compress_algo_pos,
-                                        &new_len);
+                                        &compressed_len);
             }
         }
     }
@@ -4896,28 +4768,57 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
         if(n_frames == 1 && tng_data->frame_set_n_frames > 1)
         {
             nalgo = tng_compress_nalgo();
-            alt_algo=malloc(nalgo * sizeof *tng_data->compress_algo_pos);
+            alt_algo=malloc(nalgo * sizeof *tng_data->compress_algo_vel);
+
+            /* If we have already determined the initial coding and
+             * initial coding parameter do not determine them again. */
+            if(tng_data->compress_algo_pos)
+            {
+                alt_algo[0] = tng_data->compress_algo_vel[0];
+                alt_algo[1] = tng_data->compress_algo_vel[1];
+            }
+            else
+            {
+                alt_algo[0] = -1;
+                alt_algo[1] = -1;
+            }
+
+            /* If the initial coding and initial coding parameter are -1
+             * they will be determined in tng_compress_pos/_float/. */
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_vel_float_find_algo(start_pos, (int)n_particles,
-                                                        (int)n_frames,
-                                                        f_precision,
-                                                        0, alt_algo,
-                                                        &new_len);
+                dest = tng_compress_vel_float((float *)*data, (int)n_particles,
+                                              (int)n_frames,
+                                              f_precision,
+                                              0, alt_algo,
+                                              &compressed_len);
 
             }
             else
             {
-                dest = tng_compress_vel_find_algo(start_pos, (int)n_particles,
-                                                  (int)n_frames,
-                                                  d_precision,
-                                                  0, alt_algo,
-                                                  &new_len);
+                dest = tng_compress_vel((double *)*data, (int)n_particles,
+                                        (int)n_frames,
+                                        d_precision,
+                                        0, alt_algo,
+                                        &compressed_len);
+            }
+            /* If there had been no algorithm determined before keep the initial coding
+             * and initial coding parameter so that they won't have to be determined again. */
+            if(!tng_data->compress_algo_vel)
+            {
+                nalgo = tng_compress_nalgo();
+                tng_data->compress_algo_vel=malloc(nalgo *
+                                                   sizeof *tng_data->compress_algo_vel);
+                tng_data->compress_algo_vel[0] = alt_algo[0];
+                tng_data->compress_algo_vel[1] = alt_algo[1];
+                tng_data->compress_algo_vel[2] = -1;
+                tng_data->compress_algo_vel[3] = -1;
             }
         }
-        else if(!tng_data->compress_algo_vel)
+        else if(!tng_data->compress_algo_vel || tng_data->compress_algo_vel[2] == -1 ||
+                tng_data->compress_algo_vel[2] == -1)
         {
-            if(n_frames > 10)
+            if(n_frames > 6)
             {
                 algo_find_n_frames = 5;
             }
@@ -4926,42 +4827,52 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
                 algo_find_n_frames = n_frames;
             }
 
-            nalgo = tng_compress_nalgo();
-            tng_data->compress_algo_vel=malloc(nalgo *
-                                           sizeof *tng_data->compress_algo_vel);
-
+            /* If the algorithm parameters are -1 they will be determined during the
+             * compression. */
+            if(!tng_data->compress_algo_vel)
+            {
+                nalgo = tng_compress_nalgo();
+                tng_data->compress_algo_vel=malloc(nalgo *
+                                                   sizeof *tng_data->compress_algo_vel);
+                tng_data->compress_algo_vel[0] = -1;
+                tng_data->compress_algo_vel[1] = -1;
+                tng_data->compress_algo_vel[2] = -1;
+                tng_data->compress_algo_vel[3] = -1;
+            }
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_vel_float_find_algo(start_pos, (int)n_particles,
-                                                        (int)algo_find_n_frames,
-                                                        f_precision,
-                                                        0, tng_data->
-                                                        compress_algo_vel,
-                                                        &new_len);
+                dest = tng_compress_vel_float((float *)*data, (int)n_particles,
+                                              (int)algo_find_n_frames,
+                                              f_precision,
+                                              0, tng_data->
+                                              compress_algo_vel,
+                                              &compressed_len);
                 if(algo_find_n_frames < n_frames)
                 {
-                    dest = tng_compress_vel_float(start_pos, (int)n_particles,
+                    free(dest);
+                    dest = tng_compress_vel_float((float *)*data, (int)n_particles,
                                                   (int)n_frames,
                                                   f_precision,
                                                   0, tng_data->compress_algo_vel,
-                                                  &new_len);
+                                                  &compressed_len);
                 }
             }
             else
             {
-                dest = tng_compress_vel_find_algo(start_pos, (int)n_particles,
-                                                  (int)algo_find_n_frames,
-                                                  d_precision,
-                                                  0, tng_data->
-                                                  compress_algo_vel,
-                                                  &new_len);
+                dest = tng_compress_vel((double *)*data, (int)n_particles,
+                                        (int)algo_find_n_frames,
+                                        d_precision,
+                                        0, tng_data->
+                                        compress_algo_vel,
+                                        &compressed_len);
                 if(algo_find_n_frames < n_frames)
                 {
-                    dest = tng_compress_vel(start_pos, (int)n_particles,
+                    free(dest);
+                    dest = tng_compress_vel((double *)*data, (int)n_particles,
                                             (int)n_frames,
                                             d_precision,
                                             0, tng_data->compress_algo_vel,
-                                            &new_len);
+                                            &compressed_len);
                 }
             }
         }
@@ -4969,21 +4880,21 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
         {
             if(type == TNG_FLOAT_DATA)
             {
-                dest = tng_compress_vel_float(start_pos, (int)n_particles,
+                dest = tng_compress_vel_float((float *)*data, (int)n_particles,
                                               (int)n_frames,
                                               f_precision,
                                               0, tng_data->
                                               compress_algo_vel,
-                                              &new_len);
+                                              &compressed_len);
             }
             else
             {
-                dest = tng_compress_vel(start_pos, (int)n_particles,
+                dest = tng_compress_vel((double *)*data, (int)n_particles,
                                         (int)n_frames,
                                         d_precision,
                                         0, tng_data->
                                         compress_algo_vel,
-                                        &new_len);
+                                        &compressed_len);
             }
         }
     }
@@ -4993,35 +4904,16 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
         return(TNG_FAILURE);
     }
 
-    offset = (unsigned long)((char *)start_pos - block->block_contents);
-
     if(alt_algo)
     {
         free(alt_algo);
     }
 
-    block->block_contents_size = new_len + offset;
+    free(*data);
 
-    temp = realloc(block->block_contents, block->block_contents_size);
-    if(!temp)
-    {
-        free(block->block_contents);
-        block->block_contents = 0;
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-    block->block_contents = temp;
-    if(dest)
-    {
-        memcpy(temp + offset, dest, new_len);
-        free(dest);
-    }
-    else
-    {
-        fprintf(stderr, "TNG library: Error during TNG compression. %s: %d\n", __FILE__, __LINE__);
-        return(TNG_FAILURE);
-    }
+    *data = (char *)dest;
+
+    *new_len = compressed_len;
 
     return(TNG_SUCCESS);
 }
@@ -5029,13 +4921,11 @@ static tng_function_status tng_compress(tng_trajectory_t tng_data,
 static tng_function_status tng_uncompress(tng_trajectory_t tng_data,
                                           tng_gen_block_t block,
                                           const char type,
-                                          void *start_pos,
-                                          const unsigned long uncompressed_len)
+                                          char **data,
+                                          const int64_t uncompressed_len)
 {
-    char *temp;
     double *d_dest = 0;
     float *f_dest = 0;
-    unsigned long offset;
     int result;
     (void)tng_data;
 
@@ -5059,22 +4949,30 @@ static tng_function_status tng_uncompress(tng_trajectory_t tng_data,
         f_dest = malloc(uncompressed_len);
         if(!f_dest)
         {
-            fprintf(stderr, "TNG library: Cannot allocate memory (%lu bytes). %s: %d\n",
+            fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
                 uncompressed_len, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
-        result = tng_compress_uncompress_float(start_pos, f_dest);
+        result = tng_compress_uncompress_float(*data, f_dest);
+
+        free(*data);
+
+        *data = (char *)f_dest;
     }
     else
     {
         d_dest = malloc(uncompressed_len);
         if(!d_dest)
         {
-            fprintf(stderr, "TNG library: Cannot allocate memory (%lu bytes). %s: %d\n",
+            fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
                 uncompressed_len, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
-        result = tng_compress_uncompress(start_pos, d_dest);
+        result = tng_compress_uncompress(*data, d_dest);
+
+        free(*data);
+
+        *data = (char *)d_dest;
     }
 
     if(result == 1)
@@ -5083,58 +4981,16 @@ static tng_function_status tng_uncompress(tng_trajectory_t tng_data,
         return(TNG_FAILURE);
     }
 
-    offset = (unsigned long)((char *)start_pos - (char *)block->block_contents);
-
-    block->block_contents_size = (int64_t)(uncompressed_len + offset);
-
-    temp = realloc(block->block_contents, uncompressed_len + offset);
-    if(!temp)
-    {
-        free(block->block_contents);
-        block->block_contents = 0;
-        if(d_dest)
-        {
-            free(d_dest);
-        }
-        if(f_dest)
-        {
-            free(f_dest);
-        }
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    if(type == TNG_FLOAT_DATA)
-    {
-        memcpy(temp + offset, f_dest, uncompressed_len);
-    }
-    else
-    {
-        memcpy(temp + offset, d_dest, uncompressed_len);
-    }
-
-    block->block_contents = temp;
-
-    if(d_dest)
-    {
-        free(d_dest);
-    }
-    if(f_dest)
-    {
-        free(f_dest);
-    }
     return(TNG_SUCCESS);
 }
 
 #ifdef USE_ZLIB
 static tng_function_status tng_gzip_compress(tng_trajectory_t tng_data,
-                                             tng_gen_block_t block,
-                                             void *start_pos, const int len)
+                                             char **data, const int64_t len,
+                                             int64_t *new_len)
 {
     Bytef *dest;
-    char *temp;
-    unsigned long max_len, stat, offset;
+    uLongf stat, max_len;
     (void)tng_data;
 
     max_len = compressBound(len);
@@ -5146,7 +5002,7 @@ static tng_function_status tng_gzip_compress(tng_trajectory_t tng_data,
         return(TNG_CRITICAL);
     }
 
-    stat = compress(dest, &max_len, start_pos, len);
+    stat = compress(dest, &max_len, (Bytef *)*data, len);
     if(stat != (unsigned long)Z_OK)
     {
         free(dest);
@@ -5162,53 +5018,35 @@ static tng_function_status tng_gzip_compress(tng_trajectory_t tng_data,
         return(TNG_FAILURE);
     }
 
-    offset = (char *)start_pos - block->block_contents;
-
-    block->block_contents_size = max_len + offset;
-
-    temp = realloc(block->block_contents, block->block_contents_size);
-    if(!temp)
-    {
-        free(block->block_contents);
-        free(dest);
-        block->block_contents = 0;
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    block->block_contents = temp;
+    *new_len = max_len;
 
-    memcpy(temp + offset, dest, max_len);
+    free(*data);
 
-    free(dest);
+    *data = (char *)dest;
 
     return(TNG_SUCCESS);
 }
 
 static tng_function_status tng_gzip_uncompress(tng_trajectory_t tng_data,
-                                               tng_gen_block_t block,
-                                               void *start_pos,
-                                               unsigned long uncompressed_len)
+                                               char **data,
+                                               const int64_t compressed_len,
+                                               const int64_t uncompressed_len)
 {
     Bytef *dest;
-    char *temp;
     unsigned long stat;
-    int offset;
     (void)tng_data;
-
-    offset = (char *)start_pos - (char *)block->block_contents;
+    uLongf new_len = uncompressed_len;
 
     dest = malloc(uncompressed_len);
     if(!dest)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%lud bytes). %s: %d\n",
+        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
                uncompressed_len, __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
 
-    stat = uncompress(dest, &uncompressed_len, (Bytef *) start_pos,
-                      block->block_contents_size - offset);
+    stat = uncompress(dest, &new_len, (Bytef *) *data,
+                      compressed_len);
 
     if(stat != Z_OK)
     {
@@ -5230,25 +5068,10 @@ static tng_function_status tng_gzip_uncompress(tng_trajectory_t tng_data,
         return(TNG_FAILURE);
     }
 
+    free(*data);
 
-    block->block_contents_size = uncompressed_len + offset;
-
-    temp = realloc(block->block_contents, uncompressed_len + offset);
-    if(!temp)
-    {
-        free(block->block_contents);
-        block->block_contents = 0;
-        free(dest);
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
-
-    memcpy(temp + offset, dest, uncompressed_len);
-
-    block->block_contents = temp;
+    *data = (char *)dest;
 
-    free(dest);
     return(TNG_SUCCESS);
 }
 #endif
@@ -5620,7 +5443,7 @@ static tng_function_status tng_data_block_len_calculate
 static tng_function_status tng_particle_data_read
                 (tng_trajectory_t tng_data,
                  tng_gen_block_t block,
-                 int *offset,
+                 int64_t block_data_len,
                  const char datatype,
                  const int64_t num_first_particle,
                  const int64_t n_particles,
@@ -5629,18 +5452,18 @@ static tng_function_status tng_particle_data_read
                  int64_t n_frames,
                  const int64_t n_values,
                  const int64_t codec_id,
-                 const double multiplier)
+                 const double multiplier,
+                 const char hash_mode,
+                 md5_state_t *md5_state)
 {
     int64_t i, j, k, tot_n_particles, n_frames_div;
+    int64_t offset, full_data_len;
     int size, len;
-    unsigned long data_size;
     char ***first_dim_values, **second_dim_values;
     tng_particle_data_t data;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
-    char block_type_flag;
-
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
+    char block_type_flag, *contents;
 
     switch(datatype)
     {
@@ -5693,7 +5516,7 @@ static tng_function_status tng_particle_data_read
         if(!data->block_name)
         {
             fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-                   (int)strlen(block->name)+1, __FILE__, __LINE__);
+                   (unsigned int)strlen(block->name)+1, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
         strcpy(data->block_name, block->name);
@@ -5722,9 +5545,28 @@ static tng_function_status tng_particle_data_read
 
     n_frames_div = (n_frames % stride_length) ? n_frames / stride_length + 1 : n_frames / stride_length;
 
+    contents = malloc(block_data_len);
+    if(!contents)
+    {
+        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                block_data_len, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+
+    if(fread(contents, block_data_len, 1, tng_data->input_file) == 0)
+    {
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)contents, block_data_len);
+    }
+
     if(codec_id != TNG_UNCOMPRESSED)
     {
-        data_size = (unsigned long)(n_frames_div * size * n_particles * n_values);
+        full_data_len = n_frames_div * size * n_particles * n_values;
         switch(codec_id)
         {
         case TNG_XTC_COMPRESSION:
@@ -5733,11 +5575,11 @@ static tng_function_status tng_particle_data_read
         case TNG_TNG_COMPRESSION:
 /*            fprintf(stderr, "TNG library: Before TNG uncompression: %"PRId64"\n", block->block_contents_size);*/
             if(tng_uncompress(tng_data, block, datatype,
-                              block->block_contents + *offset,
-                              data_size) != TNG_SUCCESS)
+                              &contents, full_data_len) != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not read tng compressed block data. %s: %d\n",
                        __FILE__, __LINE__);
+                free(contents);
                 return(TNG_CRITICAL);
             }
 /*            fprintf(stderr, "TNG library: After TNG uncompression: %"PRId64"\n", block->block_contents_size);*/
@@ -5745,12 +5587,12 @@ static tng_function_status tng_particle_data_read
 #ifdef USE_ZLIB
         case TNG_GZIP_COMPRESSION:
 /*            fprintf(stderr, "TNG library: Before GZIP uncompression: %"PRId64"\n", block->block_contents_size);*/
-            if(tng_gzip_uncompress(tng_data, block,
-                                   block->block_contents + *offset,
-                                   data_size) != TNG_SUCCESS)
+            if(tng_gzip_uncompress(tng_data, &contents, block_data_len,
+                                   full_data_len) != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not read gzipped block data. %s: %d\n", __FILE__,
                     __LINE__);
+                free(contents);
                 return(TNG_CRITICAL);
             }
 /*            fprintf(stderr, "TNG library: After GZIP uncompression: %"PRId64"\n", block->block_contents_size);*/
@@ -5758,6 +5600,11 @@ static tng_function_status tng_particle_data_read
 #endif
         }
     }
+    else
+    {
+        full_data_len = block_data_len;
+    }
+
     /* Allocate memory */
     if(!data->values || data->n_frames != n_frames ||
        data->n_values_per_frame != n_values)
@@ -5769,6 +5616,7 @@ static tng_function_status tng_particle_data_read
         {
             fprintf(stderr, "TNG library: Cannot allocate memory for particle data. %s: %d\n",
                    __FILE__, __LINE__);
+            free(contents);
             return(TNG_CRITICAL);
         }
     }
@@ -5777,6 +5625,7 @@ static tng_function_status tng_particle_data_read
 
     if(datatype == TNG_CHAR_DATA)
     {
+        offset = 0;
         for(i = 0; i < n_frames_div; i++)
         {
             first_dim_values = data->strings[i];
@@ -5786,7 +5635,7 @@ static tng_function_status tng_particle_data_read
                 second_dim_values = first_dim_values[j];
                 for(k = 0; k < n_values; k++)
                 {
-                    len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
+                    len = tng_min_i((unsigned int)strlen(contents+offset) + 1,
                               TNG_MAX_STR_LEN);
                     if(second_dim_values[k])
                     {
@@ -5797,11 +5646,11 @@ static tng_function_status tng_particle_data_read
                     {
                         fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
                             len, __FILE__, __LINE__);
+                        free(contents);
                         return(TNG_CRITICAL);
                     }
-                    strncpy(second_dim_values[k],
-                            block->block_contents+*offset, len);
-                    *offset += len;
+                    strncpy(second_dim_values[k], contents+offset, len);
+                    offset += len;
                 }
             }
         }
@@ -5810,14 +5659,13 @@ static tng_function_status tng_particle_data_read
     {
         memcpy((char *)data->values + n_frames_div * size * n_values *
                num_first_particle,
-               block->block_contents + *offset,
-               block->block_contents_size - *offset);
+               contents, full_data_len);
         switch(datatype)
         {
         case TNG_FLOAT_DATA:
             if(tng_data->input_endianness_swap_func_32)
             {
-                for(i = 0; i < (block->block_contents_size - *offset); i+=size)
+                for(i = 0; i < full_data_len; i+=size)
                 {
                     if(tng_data->input_endianness_swap_func_32(tng_data,
                         (int32_t *)((char *)data->values + i))
@@ -5833,7 +5681,7 @@ static tng_function_status tng_particle_data_read
         case TNG_DOUBLE_DATA:
             if(tng_data->input_endianness_swap_func_64)
             {
-                for(i = 0; i < (block->block_contents_size - *offset); i+=size)
+                for(i = 0; i < full_data_len; i+=size)
                 {
                     if(tng_data->input_endianness_swap_func_64(tng_data,
                         (int64_t *)((char *)data->values + i))
@@ -5849,6 +5697,9 @@ static tng_function_status tng_particle_data_read
             break;
         }
     }
+
+    free(contents);
+
     return(TNG_SUCCESS);
 }
 
@@ -5871,18 +5722,18 @@ static tng_function_status tng_particle_data_block_write
                  const char hash_mode)
 {
     int64_t n_particles, num_first_particle, n_frames, stride_length;
-    int64_t frame_step, data_start_pos;
-    int64_t i, j, k;
+    int64_t full_data_len, block_data_len, frame_step, data_start_pos;
+    int64_t temp_i64, i, j, k, curr_file_pos, header_file_pos;
     int size;
-    size_t len, offset = 0;
+    size_t len;
     char dependency, temp, *temp_name;
-    double multiplier;
-    char ***first_dim_values, **second_dim_values;
+    double multiplier, temp_d;
+    char ***first_dim_values, **second_dim_values, *contents;
     tng_trajectory_frame_set_t frame_set;
     tng_function_status stat;
-
     tng_particle_data_t data;
     char block_type_flag;
+    md5_state_t md5_state;
 
     frame_set = &tng_data->current_trajectory_frame_set;
 
@@ -6023,24 +5874,35 @@ static tng_function_status tng_particle_data_block_write
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
+    header_file_pos = ftello(tng_data->output_file);
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
     {
-        free(block->block_contents);
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+
+    if(fwrite(&data->datatype, sizeof(data->datatype), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&data->datatype, sizeof(data->datatype));
+    }
 
-
-    memcpy(block->block_contents, &data->datatype, sizeof(char));
-    offset += sizeof(char);
-
-    memcpy(block->block_contents+offset, &dependency, sizeof(char));
-    offset += sizeof(char);
+    if(fwrite(&dependency, sizeof(dependency), 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&dependency, sizeof(dependency));
+    }
 
     if(dependency & TNG_FRAME_DEPENDENT)
     {
@@ -6052,53 +5914,54 @@ static tng_function_status tng_particle_data_block_write
         {
             temp = 0;
         }
-        memcpy(block->block_contents+offset, &temp, sizeof(char));
-        offset += sizeof(char);
+        if(fwrite(&temp, sizeof(temp), 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp, sizeof(temp));
+        }
     }
 
-    memcpy(block->block_contents+offset, &data->n_values_per_frame,
-           sizeof(data->n_values_per_frame));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = data->n_values_per_frame;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(data->n_values_per_frame);
 
-    memcpy(block->block_contents+offset, &data->codec_id,
-           sizeof(data->codec_id));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = data->codec_id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(data->codec_id);
 
     if(data->codec_id != TNG_UNCOMPRESSED)
     {
-        memcpy(block->block_contents+offset, &data->compression_multiplier,
-               sizeof(data->compression_multiplier));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_d = data->compression_multiplier;
+        tng_var_64_bit_output_swap(tng_data, (int64_t *)&temp_d);
+        if(fwrite(&temp_d, sizeof(temp_d), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-               (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_d, sizeof(temp_d));
         }
-        offset += sizeof(data->compression_multiplier);
     }
 
     if(data->n_frames > 0 && stride_length > 1)
@@ -6108,62 +5971,54 @@ static tng_function_status tng_particle_data_block_write
         {
             data->first_frame_with_data = frame_set->first_frame;
         }
-        memcpy(block->block_contents+offset, &data->first_frame_with_data,
-               sizeof(data->first_frame_with_data));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = data->first_frame_with_data;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-               (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(data->first_frame_with_data);
 
-        memcpy(block->block_contents+offset, &stride_length,
-               sizeof(stride_length));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = stride_length;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-               (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(stride_length);
     }
 
-
-    memcpy(block->block_contents+offset, &num_first_particle,
-           sizeof(num_first_particle));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = num_first_particle;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(num_first_particle);
 
-    memcpy(block->block_contents+offset, &n_particles, sizeof(n_particles));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = n_particles;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(n_particles);
 
     if(data->datatype == TNG_CHAR_DATA)
     {
@@ -6178,129 +6033,143 @@ static tng_function_status tng_particle_data_block_write
                     second_dim_values = first_dim_values[j];
                     for(k = 0; k < data->n_values_per_frame; k++)
                     {
-                        len = (unsigned int)strlen(second_dim_values[k]) + 1;
-                        strncpy(block->block_contents+offset,
-                                second_dim_values[k], len);
-                        offset += len;
+                        len = tng_min_i((unsigned int)strlen(second_dim_values[k]) + 1,
+                                        TNG_MAX_STR_LEN);
+                        if(fwrite(second_dim_values[k], len, 1, tng_data->output_file) != 1)
+                        {
+                            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                            return(TNG_CRITICAL);
+                        }
+                        if(hash_mode == TNG_USE_HASH)
+                        {
+                            md5_append(&md5_state, (md5_byte_t *)second_dim_values[k], len);
+                        }
                     }
                 }
             }
         }
     }
-    else if(data->values)
+    else
     {
-        memcpy(block->block_contents + offset, data->values,
-               block->block_contents_size - offset);
+        full_data_len = size * frame_step * n_particles * data->n_values_per_frame;
+        contents = malloc(full_data_len);
+        if(!contents)
+        {
+            fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                    full_data_len, __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
 
-        switch(data->datatype)
+        if(data->values)
         {
-        case TNG_FLOAT_DATA:
-            if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-               data->codec_id == TNG_TNG_COMPRESSION)
+            memcpy(contents, data->values, full_data_len);
+
+            switch(data->datatype)
             {
-                if(tng_data->input_endianness_swap_func_32)
+            case TNG_FLOAT_DATA:
+                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
+                   data->codec_id == TNG_TNG_COMPRESSION)
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    if(tng_data->output_endianness_swap_func_32)
                     {
-                        if(tng_data->input_endianness_swap_func_32(tng_data,
-                           (int32_t *)(block->block_contents + i))
-                           != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            if(tng_data->output_endianness_swap_func_32(tng_data,
+                               (int32_t *)(contents + i))
+                               != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            else
-            {
-                multiplier = data->compression_multiplier;
-                if(fabs(multiplier - 1.0) > 0.00001 ||
-                   tng_data->input_endianness_swap_func_32)
+                else
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    multiplier = data->compression_multiplier;
+                    if(fabs(multiplier - 1.0) > 0.00001 ||
+                       tng_data->output_endianness_swap_func_32)
                     {
-                        *(float *)(block->block_contents + i) *= (float)multiplier;
-                        if(tng_data->input_endianness_swap_func_32 &&
-                        tng_data->input_endianness_swap_func_32(tng_data,
-                        (int32_t *)(block->block_contents + i))
-                        != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            *(float *)(contents + i) *= (float)multiplier;
+                            if(tng_data->output_endianness_swap_func_32 &&
+                            tng_data->output_endianness_swap_func_32(tng_data,
+                            (int32_t *)(contents + i))
+                            != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            break;
-        case TNG_INT_DATA:
-            if(tng_data->input_endianness_swap_func_64)
-            {
-                for(i = offset; i < block->block_contents_size; i+=size)
+                break;
+            case TNG_INT_DATA:
+                if(tng_data->output_endianness_swap_func_64)
                 {
-                    if(tng_data->input_endianness_swap_func_64(tng_data,
-                       (int64_t *)(block->block_contents + i))
-                       != TNG_SUCCESS)
+                    for(i = 0; i < full_data_len; i+=size)
                     {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
+                        if(tng_data->output_endianness_swap_func_64(tng_data,
+                           (int64_t *)(contents + i))
+                           != TNG_SUCCESS)
+                        {
+                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                    __FILE__, __LINE__);
+                        }
                     }
                 }
-            }
-            break;
-        case TNG_DOUBLE_DATA:
-            if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-               data->codec_id == TNG_TNG_COMPRESSION)
-            {
-                if(tng_data->input_endianness_swap_func_64)
+                break;
+            case TNG_DOUBLE_DATA:
+                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
+                   data->codec_id == TNG_TNG_COMPRESSION)
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    if(tng_data->output_endianness_swap_func_64)
                     {
-                        if(tng_data->input_endianness_swap_func_64(tng_data,
-                           (int64_t *)(block->block_contents + i))
-                           != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            if(tng_data->output_endianness_swap_func_64(tng_data,
+                               (int64_t *)(contents + i))
+                               != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            else
-            {
-                multiplier = data->compression_multiplier;
-                if(fabs(multiplier - 1.0) > 0.00001 ||
-                   tng_data->input_endianness_swap_func_64)
+                else
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    multiplier = data->compression_multiplier;
+                    if(fabs(multiplier - 1.0) > 0.00001 ||
+                       tng_data->output_endianness_swap_func_64)
                     {
-                        *(double *)(block->block_contents + i) *= multiplier;
-                        if(tng_data->input_endianness_swap_func_64 &&
-                        tng_data->input_endianness_swap_func_64(tng_data,
-                        (int64_t *)(block->block_contents + i))
-                        != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            *(double *)(contents + i) *= multiplier;
+                            if(tng_data->output_endianness_swap_func_64 &&
+                            tng_data->output_endianness_swap_func_64(tng_data,
+                            (int64_t *)(contents + i))
+                            != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
+                break;
+            case TNG_CHAR_DATA:
+                break;
             }
-            break;
-        case TNG_CHAR_DATA:
-            break;
         }
-    }
-    else
-    {
-        memset(block->block_contents+offset, 0, block->block_contents_size - offset);
-    }
+        else
+        {
+            memset(contents, 0, full_data_len);
+        }
 
-    frame_set->n_written_frames += frame_set->n_unwritten_frames;
-    frame_set->n_unwritten_frames = 0;
+        block_data_len = full_data_len;
 
-    if(block_type_flag == TNG_NON_TRAJECTORY_BLOCK || frame_set->n_written_frames > 0)
-    {
         switch(data->codec_id)
         {
         case TNG_XTC_COMPRESSION:
@@ -6310,7 +6179,7 @@ static tng_function_status tng_particle_data_block_write
         case TNG_TNG_COMPRESSION:
             stat = tng_compress(tng_data, block, frame_step,
                                 n_particles, data->datatype,
-                                block->block_contents + data_start_pos);
+                                &contents, &block_data_len);
             if(stat != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not write tng compressed block data. %s: %d\n",
@@ -6325,15 +6194,17 @@ static tng_function_status tng_particle_data_block_write
                 stat = tng_particle_data_block_write(tng_data, block,
                                                      block_index, mapping,
                                                      hash_mode);
+                free(contents);
                 return(stat);
             }
             break;
 #ifdef USE_ZLIB
         case TNG_GZIP_COMPRESSION:
     /*         fprintf(stderr, "TNG library: Before compression: %"PRId64"\n", block->block_contents_size);*/
-            stat = tng_gzip_compress(tng_data, block,
-                                     block->block_contents + data_start_pos,
-                                     block->block_contents_size - data_start_pos);
+            stat = tng_gzip_compress(tng_data,
+                                     &contents,
+                                     full_data_len,
+                                     &block_data_len);
             if(stat != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not write gzipped block data. %s: %d\n", __FILE__,
@@ -6348,29 +6219,61 @@ static tng_function_status tng_particle_data_block_write
                 stat = tng_particle_data_block_write(tng_data, block,
                                                      block_index, mapping,
                                                      hash_mode);
+                free(contents);
                 return(stat);
             }
     /*         fprintf(stderr, "TNG library: After compression: %"PRId64"\n", block->block_contents_size);*/
             break;
 #endif
         }
-    }
+        if(block_data_len != full_data_len)
+        {
+            block->block_contents_size -= full_data_len - block_data_len;
 
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
-    {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+            curr_file_pos = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, header_file_pos + sizeof(block->header_contents_size), SEEK_SET);
+
+            temp_i64 = block->block_contents_size;
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
+            {
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
+        }
+        if(fwrite(contents, block_data_len, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)contents, block_data_len);
+        }
+
+        free(contents);
     }
 
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-        tng_data->output_file) != 1)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__,
-                __LINE__);
-        return(TNG_CRITICAL);
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+                3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
     }
 
+    frame_set->n_written_frames += frame_set->n_unwritten_frames;
+    frame_set->n_unwritten_frames = 0;
+
     return(TNG_SUCCESS);
 }
 
@@ -6534,9 +6437,6 @@ static tng_function_status tng_allocate_data_mem
  * @param tng_data is a trajectory data container.
  * @param block is the block to store the data (should already contain
  * the block headers and the block contents).
- * @param offset is the reading offset to point at the place where the actual
- * values are stored, starting from the beginning of the block_contents. The
- * offset is changed during the reading.
  * @param datatype is the type of data of the data block (char, int, float or
  * double).
  * @param first_frame_with_data is the frame number of the first frame with data
@@ -6553,26 +6453,24 @@ static tng_function_status tng_allocate_data_mem
  */
 static tng_function_status tng_data_read(tng_trajectory_t tng_data,
                                          tng_gen_block_t block,
-                                         int *offset,
+                                         int64_t block_data_len,
                                          const char datatype,
                                          const int64_t first_frame_with_data,
                                          const int64_t stride_length,
                                          int64_t n_frames,
                                          const int64_t n_values,
                                          const int64_t codec_id,
-                                         const double multiplier)
+                                         const double multiplier,
+                                         const char hash_mode,
+                                         md5_state_t *md5_state)
 {
-    int64_t i, j, n_frames_div;
+    int64_t i, j, n_frames_div, offset;
     int size, len;
-#ifdef USE_ZLIB
-    unsigned long data_size;
-#endif
+    int64_t full_data_len;
     tng_non_particle_data_t data;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
-    char block_type_flag;
-
-    TNG_ASSERT(offset != 0, "TNG library: offset must not be a NULL pointer.");
+    char block_type_flag, *contents;
 
 /*     fprintf(stderr, "TNG library: %s\n", block->name);*/
 
@@ -6625,7 +6523,7 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
         if(!data->block_name)
         {
             fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-                   (int)strlen(block->name)+1, __FILE__, __LINE__);
+                   (unsigned int)strlen(block->name)+1, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
         strcpy(data->block_name, block->name);
@@ -6643,20 +6541,39 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
 
     n_frames_div = (n_frames % stride_length) ? n_frames / stride_length + 1 : n_frames / stride_length;
 
+    contents = malloc(block_data_len);
+    if(!contents)
+    {
+        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                block_data_len, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+
+    if(fread(contents, block_data_len, 1, tng_data->input_file) == 0)
+    {
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)contents, block_data_len);
+    }
+
     if(codec_id != TNG_UNCOMPRESSED)
     {
+        full_data_len = n_frames_div * size * n_values;
         switch(codec_id)
         {
 #ifdef USE_ZLIB
         case TNG_GZIP_COMPRESSION:
-            data_size = n_frames_div * size * n_values;
     /*         fprintf(stderr, "TNG library: Before compression: %"PRId64"\n", block->block_contents_size); */
-            if(tng_gzip_uncompress(tng_data, block,
-                                   block->block_contents + *offset,
-                                   data_size) != TNG_SUCCESS)
+            if(tng_gzip_uncompress(tng_data, &contents,
+                                   block_data_len, full_data_len) != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not read gzipped block data. %s: %d\n", __FILE__,
                     __LINE__);
+                free(contents);
                 return(TNG_CRITICAL);
             }
     /*         fprintf(stderr, "TNG library: After compression: %"PRId64"\n", block->block_contents_size); */
@@ -6664,6 +6581,10 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
 #endif
         }
     }
+    else
+    {
+        full_data_len = block_data_len;
+    }
 
     /* Allocate memory */
     if(!data->values || data->n_frames != n_frames ||
@@ -6675,6 +6596,7 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
         {
             fprintf(stderr, "TNG library: Cannot allocate memory for data. %s: %d\n",
                    __FILE__, __LINE__);
+            free(contents);
             return(TNG_CRITICAL);
         }
     }
@@ -6683,12 +6605,13 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
 
     if(datatype == TNG_CHAR_DATA)
     {
+        offset = 0;
         for(i = 0; i < n_frames_div; i++)
         {
             for(j = 0; j < n_values; j++)
             {
-                len = tng_min_i((int)strlen(block->block_contents+*offset) + 1,
-                              TNG_MAX_STR_LEN);
+                len = tng_min_i((unsigned int)strlen(contents+offset) + 1,
+                                 TNG_MAX_STR_LEN);
                 if(data->strings[i][j])
                 {
                     free(data->strings[i][j]);
@@ -6698,24 +6621,23 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
                 {
                     fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
                            len, __FILE__, __LINE__);
+                    free(contents);
                     return(TNG_CRITICAL);
                 }
-                strncpy(data->strings[i][j], block->block_contents+*offset,
-                        len);
-                *offset += len;
+                strncpy(data->strings[i][j], contents+offset, len);
+                offset += len;
             }
         }
     }
     else
     {
-        memcpy(data->values, block->block_contents + *offset,
-               block->block_contents_size - *offset);
+        memcpy(data->values, contents, full_data_len);
         switch(datatype)
         {
         case TNG_FLOAT_DATA:
             if(tng_data->input_endianness_swap_func_32)
             {
-                for(i = 0; i < (block->block_contents_size - *offset); i+=size)
+                for(i = 0; i < full_data_len; i+=size)
                 {
                     if(tng_data->input_endianness_swap_func_32(tng_data,
                         (int32_t *)((char *)data->values + i))
@@ -6731,7 +6653,7 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
         case TNG_DOUBLE_DATA:
             if(tng_data->input_endianness_swap_func_64)
             {
-                for(i = 0; i < (block->block_contents_size - *offset); i+=size)
+                for(i = 0; i < full_data_len; i+=size)
                 {
                     if(tng_data->input_endianness_swap_func_64(tng_data,
                         (int64_t *)((char *)data->values + i))
@@ -6747,6 +6669,9 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data,
             break;
         }
     }
+
+    free(contents);
+
     return(TNG_SUCCESS);
 }
 
@@ -6766,19 +6691,20 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
                                                 const char hash_mode)
 {
     int64_t n_frames, stride_length, frame_step, data_start_pos;
-    int64_t i, j;
-    int offset = 0, size;
+    int64_t temp_i64, full_data_len, block_data_len, i, j;
+    int64_t curr_file_pos, header_file_pos;
+    int size;
     unsigned int len;
 #ifdef USE_ZLIB
     tng_function_status stat;
 #endif
-    char temp, dependency, *temp_name;
-    double multiplier;
+    char temp, dependency, *temp_name, *contents;
+    double multiplier, temp_d;
     tng_trajectory_frame_set_t frame_set =
     &tng_data->current_trajectory_frame_set;
-
     tng_non_particle_data_t data;
     char block_type_flag;
+    md5_state_t md5_state;
 
     /* If we have already started writing frame sets it is too late to write
      * non-trajectory data blocks */
@@ -6899,24 +6825,35 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
+    header_file_pos = ftello(tng_data->output_file);
+
+    if(tng_block_header_write(tng_data, block) != TNG_SUCCESS)
     {
-        free(block->block_contents);
+        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
+               tng_data->output_file_path, __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
+
+    if(fwrite(&data->datatype, sizeof(data->datatype), 1, tng_data->output_file) != 1)
     {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_init(&md5_state);
+        md5_append(&md5_state, (md5_byte_t *)&data->datatype, sizeof(data->datatype));
+    }
 
-
-    memcpy(block->block_contents, &data->datatype, sizeof(char));
-    offset += sizeof(char);
-
-    memcpy(block->block_contents+offset, &dependency, sizeof(char));
-    offset += sizeof(char);
+    if(fwrite(&dependency, sizeof(dependency), 1, tng_data->output_file) != 1)
+    {
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&dependency, sizeof(dependency));
+    }
 
     if(dependency & TNG_FRAME_DEPENDENT)
     {
@@ -6928,53 +6865,54 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
         {
             temp = 0;
         }
-        memcpy(block->block_contents+offset, &temp, sizeof(char));
-        offset += sizeof(char);
+        if(fwrite(&temp, sizeof(temp), 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp, sizeof(temp));
+        }
     }
 
-    memcpy(block->block_contents+offset, &data->n_values_per_frame,
-           sizeof(data->n_values_per_frame));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = data->n_values_per_frame;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(data->n_values_per_frame);
 
-    memcpy(block->block_contents+offset, &data->codec_id,
-           sizeof(data->codec_id));
-    if(tng_data->output_endianness_swap_func_64)
+    temp_i64 = data->codec_id;
+    tng_var_64_bit_output_swap(tng_data, &temp_i64);
+    if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
     {
-        if(tng_data->output_endianness_swap_func_64(tng_data,
-           (int64_t *)block->header_contents+offset)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
     }
-    offset += sizeof(data->codec_id);
 
     if(data->codec_id != TNG_UNCOMPRESSED)
     {
-        memcpy(block->block_contents+offset, &data->compression_multiplier,
-               sizeof(data->compression_multiplier));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_d = data->compression_multiplier;
+        tng_var_64_bit_output_swap(tng_data, (int64_t *)&temp_d);
+        if(fwrite(&temp_d, sizeof(temp_d), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-            (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_d, sizeof(temp_d));
         }
-        offset += sizeof(data->compression_multiplier);
     }
 
     if(data->n_frames > 0 && stride_length > 1)
@@ -6984,33 +6922,29 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
         {
             data->first_frame_with_data = frame_set->first_frame;
         }
-        memcpy(block->block_contents+offset, &data->first_frame_with_data,
-               sizeof(data->first_frame_with_data));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = data->first_frame_with_data;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-            (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(data->first_frame_with_data);
 
-        memcpy(block->block_contents+offset, &stride_length,
-               sizeof(data->stride_length));
-        if(tng_data->output_endianness_swap_func_64)
+        temp_i64 = stride_length;
+        tng_var_64_bit_output_swap(tng_data, &temp_i64);
+        if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
         {
-            if(tng_data->output_endianness_swap_func_64(tng_data,
-            (int64_t *)block->header_contents+offset)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)&temp_i64, sizeof(temp_i64));
         }
-        offset += sizeof(data->stride_length);
     }
 
     if(data->datatype == TNG_CHAR_DATA)
@@ -7022,134 +6956,148 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
                 for(j = 0; j < data->n_values_per_frame; j++)
                 {
                     len = (unsigned int)strlen(data->strings[i][j]) + 1;
-                    strncpy(block->block_contents+offset, data->strings[i][j],
-                            len);
-                    offset += len;
+                    if(fwrite(data->strings[i][j], len, 1, tng_data->output_file) != 1)
+                    {
+                        fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                        return(TNG_CRITICAL);
+                    }
+                    if(hash_mode == TNG_USE_HASH)
+                    {
+                        md5_append(&md5_state, (md5_byte_t *)data->strings[i][j], len);
+                    }
                 }
             }
         }
     }
-    else if(data->values)
+    else
     {
-        memcpy(block->block_contents + offset, data->values,
-               block->block_contents_size - offset);
-        switch(data->datatype)
+        full_data_len = size * frame_step * data->n_values_per_frame;
+        contents = malloc(full_data_len);
+        if(!contents)
         {
-        case TNG_FLOAT_DATA:
-            if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-               data->codec_id == TNG_TNG_COMPRESSION)
+            fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                    full_data_len, __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+
+        if(data->values)
+        {
+            memcpy(contents, data->values, full_data_len);
+            switch(data->datatype)
             {
-                if(tng_data->input_endianness_swap_func_32)
+            case TNG_FLOAT_DATA:
+                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
+                   data->codec_id == TNG_TNG_COMPRESSION)
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    if(tng_data->output_endianness_swap_func_32)
                     {
-                        if(tng_data->input_endianness_swap_func_32(tng_data,
-                           (int32_t *)(block->block_contents + i))
-                           != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            if(tng_data->output_endianness_swap_func_32(tng_data,
+                               (int32_t *)(contents + i))
+                               != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            else
-            {
-                multiplier = data->compression_multiplier;
-                if(fabs(multiplier - 1.0) > 0.00001 ||
-                   tng_data->input_endianness_swap_func_32)
+                else
                 {
-                    for(i = offset; block->block_contents_size; i+=size)
+                    multiplier = data->compression_multiplier;
+                    if(fabs(multiplier - 1.0) > 0.00001 ||
+                       tng_data->output_endianness_swap_func_32)
                     {
-                        *(float *)(block->block_contents + i) *= (float)multiplier;
-                        if(tng_data->input_endianness_swap_func_32 &&
-                        tng_data->input_endianness_swap_func_32(tng_data,
-                        (int32_t *)(block->block_contents + i))
-                        != TNG_SUCCESS)
+                        for(i = 0; full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            *(float *)(contents + i) *= (float)multiplier;
+                            if(tng_data->output_endianness_swap_func_32 &&
+                            tng_data->output_endianness_swap_func_32(tng_data,
+                            (int32_t *)(contents + i))
+                            != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            break;
-        case TNG_INT_DATA:
-            if(tng_data->input_endianness_swap_func_64)
-            {
-                for(i = offset; i < block->block_contents_size; i+=size)
+                break;
+            case TNG_INT_DATA:
+                if(tng_data->output_endianness_swap_func_64)
                 {
-                    if(tng_data->input_endianness_swap_func_64(tng_data,
-                       (int64_t *)(block->block_contents + i))
-                       != TNG_SUCCESS)
+                    for(i = 0; i < full_data_len; i+=size)
                     {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
+                        if(tng_data->output_endianness_swap_func_64(tng_data,
+                           (int64_t *)(contents + i))
+                           != TNG_SUCCESS)
+                        {
+                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                    __FILE__, __LINE__);
+                        }
                     }
                 }
-            }
-            break;
-        case TNG_DOUBLE_DATA:
-            if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-               data->codec_id == TNG_TNG_COMPRESSION)
-            {
-                if(tng_data->input_endianness_swap_func_64)
+                break;
+            case TNG_DOUBLE_DATA:
+                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
+                   data->codec_id == TNG_TNG_COMPRESSION)
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    if(tng_data->output_endianness_swap_func_64)
                     {
-                        if(tng_data->input_endianness_swap_func_64(tng_data,
-                           (int64_t *)(block->block_contents + i))
-                           != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            if(tng_data->output_endianness_swap_func_64(tng_data,
+                               (int64_t *)(contents + i))
+                               != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
-            }
-            else
-            {
-                multiplier = data->compression_multiplier;
-                if(fabs(multiplier - 1.0) > 0.00001 ||
-                   tng_data->input_endianness_swap_func_64)
+                else
                 {
-                    for(i = offset; i < block->block_contents_size; i+=size)
+                    multiplier = data->compression_multiplier;
+                    if(fabs(multiplier - 1.0) > 0.00001 ||
+                       tng_data->output_endianness_swap_func_64)
                     {
-                        *(double *)(block->block_contents + i) *= multiplier;
-                        if(tng_data->input_endianness_swap_func_64 &&
-                        tng_data->input_endianness_swap_func_64(tng_data,
-                        (int64_t *)(block->block_contents + i))
-                        != TNG_SUCCESS)
+                        for(i = 0; i < full_data_len; i+=size)
                         {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
+                            *(double *)(contents + i) *= multiplier;
+                            if(tng_data->output_endianness_swap_func_64 &&
+                            tng_data->output_endianness_swap_func_64(tng_data,
+                            (int64_t *)(contents + i))
+                            != TNG_SUCCESS)
+                            {
+                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                        __FILE__, __LINE__);
+                            }
                         }
                     }
                 }
+                break;
+            case TNG_CHAR_DATA:
+                break;
             }
-            break;
-        case TNG_CHAR_DATA:
-            break;
         }
-    }
-    else
-    {
-        memset(block->block_contents+offset, 0, block->block_contents_size - offset);
-    }
+        else
+        {
+            memset(contents, 0, full_data_len);
+        }
 
-    frame_set->n_written_frames += frame_set->n_unwritten_frames;
-    frame_set->n_unwritten_frames = 0;
+        block_data_len = full_data_len;
 
-    if(block_type_flag == TNG_NON_TRAJECTORY_BLOCK || frame_set->n_written_frames > 0)
-    {
         switch(data->codec_id)
         {
 #ifdef USE_ZLIB
         case TNG_GZIP_COMPRESSION:
     /*         fprintf(stderr, "TNG library: Before compression: %"PRId64"\n", block->block_contents_size); */
-            stat = tng_gzip_compress(tng_data, block,
-                                     block->block_contents + data_start_pos,
-                                     block->block_contents_size - data_start_pos);
+            stat = tng_gzip_compress(tng_data,
+                                     &contents,
+                                     full_data_len,
+                                     &block_data_len);
             if(stat != TNG_SUCCESS)
             {
                 fprintf(stderr, "TNG library: Could not write gzipped block data. %s: %d\n", __FILE__,
@@ -7164,23 +7112,54 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
             break;
 #endif
         }
-    }
+        if(block_data_len != full_data_len)
+        {
+            block->block_contents_size -= full_data_len - block_data_len;
 
-    if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS)
-    {
-        fprintf(stderr, "TNG library: Cannot write header of file %s. %s: %d\n",
-               tng_data->output_file_path, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+            curr_file_pos = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, header_file_pos + sizeof(block->header_contents_size), SEEK_SET);
+
+            temp_i64 = block->block_contents_size;
+            tng_var_64_bit_output_swap(tng_data, &temp_i64);
+            if(fwrite(&temp_i64, sizeof(temp_i64), 1, tng_data->output_file) != 1)
+            {
+                fprintf(stderr, "TNG library: Could not write block data. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
+        }
+        if(fwrite(contents, block_data_len, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(&md5_state, (md5_byte_t *)contents, block_data_len);
+        }
+
+        free(contents);
     }
 
-    if(fwrite(block->block_contents, block->block_contents_size, 1,
-              tng_data->output_file) != 1)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Could not write all block data. %s: %d\n",
-               __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+        md5_finish(&md5_state, (md5_byte_t *)block->md5_hash);
+        curr_file_pos = ftello(tng_data->output_file);
+        fseeko(tng_data->output_file, header_file_pos +
+                3 * sizeof(int64_t), SEEK_SET);
+        if(fwrite(block->md5_hash, TNG_MD5_HASH_LEN, 1, tng_data->output_file) != 1)
+        {
+            fprintf(stderr, "TNG library: Could not write MD5 hash. %s: %d\n", __FILE__,
+                    __LINE__);
+            return(TNG_CRITICAL);
+        }
+        fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
     }
 
+    frame_set->n_written_frames += frame_set->n_unwritten_frames;
+    frame_set->n_unwritten_frames = 0;
+
     return(TNG_SUCCESS);
 }
 
@@ -7193,8 +7172,6 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data,
  */
 static tng_function_status tng_data_block_meta_information_read
                 (tng_trajectory_t tng_data,
-                 tng_gen_block_t block,
-                 int *offset,
                  char *datatype,
                  char *dependency,
                  char *sparse_data,
@@ -7205,91 +7182,83 @@ static tng_function_status tng_data_block_meta_information_read
                  int64_t *n_frames,
                  int64_t *num_first_particle,
                  int64_t *block_n_particles,
-                 double *multiplier)
+                 double *multiplier,
+                 const char hash_mode,
+                 md5_state_t *md5_state)
 {
-    int meta_size;
-    char *contents;
+    if(fread(datatype, sizeof(char),
+             1, tng_data->input_file) == 0)
+    {
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)datatype, sizeof(char));
+    }
 
-    if(block->block_contents)
+    if(fread(dependency, sizeof(char),
+             1, tng_data->input_file) == 0)
     {
-        contents = block->block_contents;
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-    else
+    if(hash_mode == TNG_USE_HASH)
     {
-        meta_size = 3 * sizeof(char) + sizeof(double) + 6 * sizeof(int64_t);
-        contents = malloc(meta_size);
-        if(!contents)
-        {
-            fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-               meta_size, __FILE__, __LINE__);
-        }
+        md5_append(md5_state, (md5_byte_t *)dependency, sizeof(char));
+    }
 
-        if(fread(contents, meta_size, 1, tng_data->input_file) == 0)
+    if(*dependency & TNG_FRAME_DEPENDENT)
+    {
+        if(fread(sparse_data, sizeof(char),
+                1, tng_data->input_file) == 0)
         {
-            fprintf(stderr, "TNG library: Cannot read data block meta information. %s: %d\n", __FILE__, __LINE__);
-            free(contents);
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(md5_state, (md5_byte_t *)sparse_data, sizeof(char));
+        }
     }
 
-    memcpy(datatype, contents+*offset,
-           sizeof(*datatype));
-    *offset += sizeof(*datatype);
-
-    memcpy(dependency, contents+*offset,
-           sizeof(*dependency));
-    *offset += sizeof(*dependency);
-
-    if(*dependency & TNG_FRAME_DEPENDENT)
+    if(fread(n_values, sizeof(int64_t),
+             1, tng_data->input_file) == 0)
     {
-        memcpy(sparse_data, contents+*offset,
-               sizeof(*sparse_data));
-        *offset += sizeof(*sparse_data);
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
     }
-
-    memcpy(n_values, contents+*offset,
-        sizeof(*n_values));
-    if(tng_data->input_endianness_swap_func_64)
+    if(hash_mode == TNG_USE_HASH)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   n_values)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        md5_append(md5_state, (md5_byte_t *)n_values, sizeof(*n_values));
     }
-    *offset += sizeof(*n_values);
+    tng_var_64_bit_input_swap(tng_data, n_values);
 
-    memcpy(codec_id, contents+*offset,
-        sizeof(*codec_id));
-    if(tng_data->input_endianness_swap_func_64)
+    if(fread(codec_id, sizeof(int64_t),
+             1, tng_data->input_file) == 0)
     {
-        if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                   codec_id)
-            != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                    __FILE__, __LINE__);
-        }
+        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+        return(TNG_CRITICAL);
+    }
+    if(hash_mode == TNG_USE_HASH)
+    {
+        md5_append(md5_state, (md5_byte_t *)codec_id, sizeof(*codec_id));
     }
-    *offset += sizeof(*codec_id);
+    tng_var_64_bit_input_swap(tng_data, codec_id);
 
     if(*codec_id != TNG_UNCOMPRESSED)
     {
-        memcpy(multiplier, contents+*offset,
-            sizeof(*multiplier));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(multiplier, sizeof(double),
+                 1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       (int64_t *) multiplier)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        *offset += sizeof(*multiplier);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(md5_state, (md5_byte_t *)multiplier, sizeof(*multiplier));
+        }
+        tng_var_64_bit_input_swap(tng_data, (int64_t *)multiplier);
     }
     else
     {
@@ -7300,33 +7269,30 @@ static tng_function_status tng_data_block_meta_information_read
     {
         if(*sparse_data)
         {
-            memcpy(first_frame_with_data, contents+*offset,
-                sizeof(*first_frame_with_data));
-            if(tng_data->input_endianness_swap_func_64)
+            if(fread(first_frame_with_data, sizeof(int64_t),
+                    1, tng_data->input_file) == 0)
             {
-                if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                           first_frame_with_data)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
             }
-            *offset += sizeof(*first_frame_with_data);
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(md5_state, (md5_byte_t *)first_frame_with_data, sizeof(*first_frame_with_data));
+            }
+            tng_var_64_bit_input_swap(tng_data, first_frame_with_data);
 
-            memcpy(stride_length, contents+*offset,
-                sizeof(*stride_length));
-            if(tng_data->input_endianness_swap_func_64)
+            if(fread(stride_length, sizeof(int64_t),
+                    1, tng_data->input_file) == 0)
             {
-                if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                           stride_length)
-                    != TNG_SUCCESS)
-                {
-                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                            __FILE__, __LINE__);
-                }
+                fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(hash_mode == TNG_USE_HASH)
+            {
+                md5_append(md5_state, (md5_byte_t *)stride_length, sizeof(*stride_length));
             }
-            *offset += sizeof(*stride_length);
+            tng_var_64_bit_input_swap(tng_data, stride_length);
+
             *n_frames = tng_data->current_trajectory_frame_set.n_frames -
                         (*first_frame_with_data -
                         tng_data->current_trajectory_frame_set.first_frame);
@@ -7347,39 +7313,31 @@ static tng_function_status tng_data_block_meta_information_read
 
     if (*dependency & TNG_PARTICLE_DEPENDENT)
     {
-        memcpy(num_first_particle, contents+*offset,
-               sizeof(*num_first_particle));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(num_first_particle, sizeof(int64_t),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       num_first_particle)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
+        }
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(md5_state, (md5_byte_t *)num_first_particle, sizeof(*num_first_particle));
         }
-        *offset += sizeof(*num_first_particle);
+        tng_var_64_bit_input_swap(tng_data, num_first_particle);
 
-        memcpy(block_n_particles, contents+*offset,
-            sizeof(*block_n_particles));
-        if(tng_data->input_endianness_swap_func_64)
+        if(fread(block_n_particles, sizeof(int64_t),
+                1, tng_data->input_file) == 0)
         {
-            if(tng_data->input_endianness_swap_func_64(tng_data,
-                                                       block_n_particles)
-                != TNG_SUCCESS)
-            {
-                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                        __FILE__, __LINE__);
-            }
+            fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
+            return(TNG_CRITICAL);
         }
-        *offset += sizeof(*block_n_particles);
+        if(hash_mode == TNG_USE_HASH)
+        {
+            md5_append(md5_state, (md5_byte_t *)block_n_particles, sizeof(*block_n_particles));
+        }
+        tng_var_64_bit_input_swap(tng_data, block_n_particles);
     }
 
-    if(!block->block_contents)
-    {
-        free(contents);
-    }
     return(TNG_SUCCESS);
 }
 
@@ -7398,89 +7356,114 @@ static tng_function_status tng_data_block_contents_read
                  tng_gen_block_t block,
                  const char hash_mode)
 {
-    int64_t n_values, codec_id, n_frames, first_frame_with_data;
-    int64_t stride_length, block_n_particles, num_first_particle;
+    int64_t start_pos, curr_file_pos, n_values, codec_id, n_frames, first_frame_with_data;
+    int64_t remaining_len, stride_length, block_n_particles, num_first_particle;
     double multiplier;
     char datatype, dependency, sparse_data;
-    int offset = 0;
-    tng_bool same_hash;
+    tng_function_status stat = TNG_SUCCESS;
+    char hash[TNG_MD5_HASH_LEN], *temp_data;
+    md5_state_t md5_state;
 
     if(tng_input_file_init(tng_data) != TNG_SUCCESS)
     {
         return(TNG_CRITICAL);
     }
 
-    if(block->block_contents)
-    {
-        free(block->block_contents);
-    }
-
-    block->block_contents = malloc(block->block_contents_size);
-    if(!block->block_contents)
-    {
-        fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               block->block_contents_size, __FILE__, __LINE__);
-        return(TNG_CRITICAL);
-    }
+    start_pos = ftello(tng_data->input_file);
 
-    /* Read the whole block into block_contents to be able to write it to
-     * disk even if it cannot be interpreted. */
-    if(fread(block->block_contents, block->block_contents_size, 1,
-             tng_data->input_file) == 0)
+    if(hash_mode == TNG_USE_HASH)
     {
-        fprintf(stderr, "TNG library: Cannot read block. %s: %d\n", __FILE__, __LINE__);
-        return(TNG_CRITICAL);
+        md5_init(&md5_state);
     }
 
     /* FIXME: Does not check if the size of the contents matches the expected
      * size or if the contents can be read. */
 
-    if(hash_mode == TNG_USE_HASH)
-    {
-        tng_md5_hash_match_verify(block, &same_hash);
-        if(same_hash != TNG_TRUE)
-        {
-            fprintf(stderr, "TNG library: '%s' data block contents corrupt. Hashes do not match. %s: %d\n",
-                block->name, __FILE__, __LINE__);
-    /*         return(TNG_FAILURE); */
-        }
-    }
-
-    if(tng_data_block_meta_information_read(tng_data, block,
-                                            &offset, &datatype,
+    if(tng_data_block_meta_information_read(tng_data,
+                                            &datatype,
                                             &dependency, &sparse_data,
                                             &n_values, &codec_id,
                                             &first_frame_with_data,
                                             &stride_length, &n_frames,
                                             &num_first_particle,
                                             &block_n_particles,
-                                            &multiplier) == TNG_CRITICAL)
+                                            &multiplier,
+                                            hash_mode,
+                                            &md5_state) == TNG_CRITICAL)
     {
         fprintf(stderr, "TNG library: Cannot read data block (%s) meta information. %s: %d\n",
             block->name, __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
 
+    remaining_len = block->block_contents_size - (ftello(tng_data->input_file) - start_pos);
+
     if (dependency & TNG_PARTICLE_DEPENDENT)
     {
-        return(tng_particle_data_read(tng_data, block,
-                                      &offset, datatype,
+        stat = tng_particle_data_read(tng_data, block,
+                                      remaining_len,
+                                      datatype,
                                       num_first_particle,
                                       block_n_particles,
                                       first_frame_with_data,
                                       stride_length,
                                       n_frames, n_values,
-                                      codec_id, multiplier));
+                                      codec_id, multiplier,
+                                      hash_mode,
+                                      &md5_state);
     }
     else
     {
-        return(tng_data_read(tng_data, block,
-                             &offset, datatype,
+        stat = tng_data_read(tng_data, block,
+                             remaining_len,
+                             datatype,
                              first_frame_with_data,
                              stride_length,
                              n_frames, n_values,
-                             codec_id, multiplier));
+                             codec_id, multiplier,
+                             hash_mode,
+                             &md5_state);
+    }
+
+    if(hash_mode == TNG_USE_HASH)
+    {
+        /* If there is data left in the block that the current version of the library
+         * cannot interpret still read that to generate the MD5 hash. */
+        curr_file_pos = ftello(tng_data->input_file);
+        if(curr_file_pos < start_pos + block->block_contents_size)
+        {
+            temp_data = malloc(start_pos + block->block_contents_size - curr_file_pos);
+            if(!temp_data)
+            {
+                fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
+                        start_pos + block->block_contents_size - curr_file_pos, __FILE__, __LINE__);
+                return(TNG_CRITICAL);
+            }
+            if(fread(temp_data, start_pos + block->block_contents_size - curr_file_pos,
+                     1, tng_data->input_file) == 0)
+            {
+                fprintf(stderr, "TNG library: Cannot read remaining part of block to generate MD5 sum. %s: %d\n", __FILE__, __LINE__);
+                free(temp_data);
+                return(TNG_CRITICAL);
+            }
+            md5_append(&md5_state, (md5_byte_t *)temp_data,
+                       start_pos + block->block_contents_size - curr_file_pos);
+            free(temp_data);
+        }
+        md5_finish(&md5_state, (md5_byte_t *)hash);
+        if(strncmp(block->md5_hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", TNG_MD5_HASH_LEN) != 0)
+        {
+            if(strncmp(block->md5_hash, hash, TNG_MD5_HASH_LEN) != 0)
+            {
+                fprintf(stderr, "TNG library: Data block contents corrupt (%s). Hashes do not match. "
+                        "%s: %d\n", block->name, __FILE__, __LINE__);
+            }
+        }
     }
+
+    fseeko(tng_data->input_file, start_pos + block->block_contents_size, SEEK_SET);
+
+    return(stat);
 }
 
 /*
@@ -7521,13 +7504,13 @@ static tng_function_status tng_data_block_contents_read
 //     }
 //
 //     tng_block_init(&block);
-// //     output_file_pos = ftell(tng_data->output_file);
+// //     output_file_pos = ftello(tng_data->output_file);
 //
 //     tng_data->input_file = tng_data->output_file;
 //
 //     pos = tng_data->current_trajectory_frame_set_output_file_pos;
 //
-//     fseek(tng_data->output_file, pos, SEEK_SET);
+//     fseeko(tng_data->output_file, pos, SEEK_SET);
 //     if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
 //     {
 //         fprintf(stderr, "TNG library: Cannot read frame set header. %s: %d\n",
@@ -7537,12 +7520,12 @@ static tng_function_status tng_data_block_contents_read
 //         return(TNG_CRITICAL);
 //     }
 //
-//     contents_start_pos = ftell(tng_data->output_file);
+//     contents_start_pos = ftello(tng_data->output_file);
 //
-//     fseek(tng_data->output_file, 0, SEEK_END);
-//     output_file_len = ftell(tng_data->output_file);
+//     fseeko(tng_data->output_file, 0, SEEK_END);
+//     output_file_len = ftello(tng_data->output_file);
 //     pos = contents_start_pos + block->block_contents_size;
-//     fseek(tng_data->output_file, pos,
+//     fseeko(tng_data->output_file, pos,
 //           SEEK_SET);
 //
 //     while(pos < output_file_len)
@@ -7556,7 +7539,7 @@ static tng_function_status tng_data_block_contents_read
 //             return(TNG_CRITICAL);
 //         }
 //         pos += block->header_contents_size + block->block_contents_size;
-//         fseek(tng_data->output_file, pos, SEEK_SET);
+//         fseeko(tng_data->output_file, pos, SEEK_SET);
 //     }
 //
 //     return(TNG_SUCCESS);
@@ -7577,7 +7560,7 @@ static tng_function_status tng_frame_set_finalize
     tng_gen_block_t block;
     tng_trajectory_frame_set_t frame_set;
     FILE *temp = tng_data->input_file;
-    int64_t pos, contents_start_pos, output_file_len;
+    int64_t pos, curr_file_pos;
 
     frame_set = &tng_data->current_trajectory_frame_set;
 
@@ -7586,6 +7569,8 @@ static tng_function_status tng_frame_set_finalize
         return(TNG_SUCCESS);
     }
 
+    frame_set->n_written_frames = frame_set->n_frames;
+
     if(tng_output_file_init(tng_data) != TNG_SUCCESS)
     {
         fprintf(stderr, "TNG library: Cannot initialise destination file. %s: %d\n",
@@ -7594,13 +7579,15 @@ static tng_function_status tng_frame_set_finalize
     }
 
     tng_block_init(&block);
-/*     output_file_pos = ftell(tng_data->output_file); */
+/*     output_file_pos = ftello(tng_data->output_file); */
 
     tng_data->input_file = tng_data->output_file;
 
+    curr_file_pos = ftello(tng_data->output_file);
+
     pos = tng_data->current_trajectory_frame_set_output_file_pos;
 
-    fseek(tng_data->output_file, (long)pos, SEEK_SET);
+    fseeko(tng_data->output_file, pos, SEEK_SET);
 
     if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
     {
@@ -7611,10 +7598,10 @@ static tng_function_status tng_frame_set_finalize
         return(TNG_CRITICAL);
     }
 
-    contents_start_pos = ftell(tng_data->output_file);
+//     contents_start_pos = ftello(tng_data->output_file);
 
-    fseek(tng_data->output_file, sizeof(frame_set->first_frame), SEEK_CUR);
-    if(fwrite(&frame_set->n_written_frames, sizeof(frame_set->n_frames),
+    fseeko(tng_data->output_file, sizeof(frame_set->first_frame), SEEK_CUR);
+    if(fwrite(&frame_set->n_frames, sizeof(frame_set->n_frames),
               1, tng_data->output_file) != 1)
     {
         tng_data->input_file = temp;
@@ -7629,30 +7616,32 @@ static tng_function_status tng_frame_set_finalize
                             pos + block->header_contents_size);
     }
 
-    fseek(tng_data->output_file, 0, SEEK_END);
-    output_file_len = ftell(tng_data->output_file);
-    pos = contents_start_pos + block->block_contents_size;
-    fseek(tng_data->output_file, (long)pos, SEEK_SET);
+//     fseeko(tng_data->output_file, 0, SEEK_END);
+//     output_file_len = ftello(tng_data->output_file);
+//     pos = contents_start_pos + block->block_contents_size;
+//     fseeko(tng_data->output_file, pos, SEEK_SET);
 
-    while(pos < output_file_len)
-    {
-        if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
-        {
-            fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n", pos,
-                   __FILE__, __LINE__);
-            tng_data->input_file = temp;
-            tng_block_destroy(&block);
-            return(TNG_CRITICAL);
-        }
+//     while(pos < output_file_len)
+//     {
+//         if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
+//         {
+//             fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n", pos,
+//                    __FILE__, __LINE__);
+//             tng_data->input_file = temp;
+//             tng_block_destroy(&block);
+//             return(TNG_CRITICAL);
+//         }
+//
+//         if(hash_mode == TNG_USE_HASH)
+//         {
+//             tng_md5_hash_update(tng_data, block, pos,
+//                                 pos + block->header_contents_size);
+//         }
+//         pos += block->header_contents_size + block->block_contents_size;
+//         fseeko(tng_data->output_file, pos, SEEK_SET);
+//     }
 
-        if(hash_mode == TNG_USE_HASH)
-        {
-            tng_md5_hash_update(tng_data, block, pos,
-                                pos + block->header_contents_size);
-        }
-        pos += block->header_contents_size + block->block_contents_size;
-        fseek(tng_data->output_file, (long)pos, SEEK_SET);
-    }
+    fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
 
     tng_data->input_file = temp;
     tng_block_destroy(&block);
@@ -7673,7 +7662,7 @@ static tng_function_status tng_frame_set_finalize
 // {
 //     int len;
 //
-//     len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+//     len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 //
 //      * If the currently stored string length is not enough to store the new
 //      * string it is freed and reallocated. *
@@ -7741,7 +7730,7 @@ tng_function_status tng_atom_name_set(tng_trajectory_t tng_data,
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer.");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -7795,7 +7784,7 @@ tng_function_status tng_atom_type_set(tng_trajectory_t tng_data,
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_type, "TNG library: new_type must not be a NULL pointer.");
 
-    len = tng_min_i((int)strlen(new_type) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_type) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -8081,7 +8070,7 @@ tng_function_status DECLSPECDLLEXPORT tng_molecule_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer.");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -8651,7 +8640,7 @@ tng_function_status DECLSPECDLLEXPORT tng_chain_name_set
 
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer.");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -8883,7 +8872,7 @@ tng_function_status DECLSPECDLLEXPORT tng_residue_name_set(tng_trajectory_t tng_
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -9899,12 +9888,6 @@ tng_function_status DECLSPECDLLEXPORT tng_trajectory_destroy(tng_trajectory_t *t
 
     frame_set = &tng_data->current_trajectory_frame_set;
 
-    if(tng_data->input_file_path)
-    {
-        free(tng_data->input_file_path);
-        tng_data->input_file_path = 0;
-    }
-
     if(tng_data->input_file)
     {
         if(tng_data->output_file == tng_data->input_file)
@@ -9916,10 +9899,10 @@ tng_function_status DECLSPECDLLEXPORT tng_trajectory_destroy(tng_trajectory_t *t
         tng_data->input_file = 0;
     }
 
-    if(tng_data->output_file_path)
+    if(tng_data->input_file_path)
     {
-        free(tng_data->output_file_path);
-        tng_data->output_file_path = 0;
+        free(tng_data->input_file_path);
+        tng_data->input_file_path = 0;
     }
 
     if(tng_data->output_file)
@@ -9930,6 +9913,12 @@ tng_function_status DECLSPECDLLEXPORT tng_trajectory_destroy(tng_trajectory_t *t
         tng_data->output_file = 0;
     }
 
+    if(tng_data->output_file_path)
+    {
+        free(tng_data->output_file_path);
+        tng_data->output_file_path = 0;
+    }
+
     if(tng_data->first_program_name)
     {
         free(tng_data->first_program_name);
@@ -10260,7 +10249,7 @@ tng_function_status DECLSPECDLLEXPORT tng_trajectory_init_from_src(tng_trajector
     if(!dest->input_file_path)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-               (int)strlen(src->input_file_path) + 1, __FILE__, __LINE__);
+               (unsigned int)strlen(src->input_file_path) + 1, __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
     strcpy(dest->input_file_path, src->input_file_path);
@@ -10270,7 +10259,7 @@ tng_function_status DECLSPECDLLEXPORT tng_trajectory_init_from_src(tng_trajector
     if(!dest->output_file_path)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-               (int)strlen(src->output_file_path) + 1, __FILE__, __LINE__);
+               (unsigned int)strlen(src->output_file_path) + 1, __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
     strcpy(dest->output_file_path, src->output_file_path);
@@ -10392,7 +10381,7 @@ tng_function_status DECLSPECDLLEXPORT tng_input_file_set(tng_trajectory_t tng_da
         fclose(tng_data->input_file);
     }
 
-    len = tng_min_i((int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
     temp = realloc(tng_data->input_file_path, len);
     if(!temp)
     {
@@ -10445,7 +10434,7 @@ tng_function_status DECLSPECDLLEXPORT tng_output_file_set(tng_trajectory_t tng_d
         fclose(tng_data->output_file);
     }
 
-    len = tng_min_i((int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
     temp = realloc(tng_data->output_file_path, len);
     if(!temp)
     {
@@ -10483,7 +10472,7 @@ tng_function_status DECLSPECDLLEXPORT tng_output_append_file_set
         fclose(tng_data->output_file);
     }
 
-    len = tng_min_i((int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(file_name) + 1, TNG_MAX_STR_LEN);
     temp = realloc(tng_data->output_file_path, len);
     if(!temp)
     {
@@ -10594,7 +10583,7 @@ tng_function_status DECLSPECDLLEXPORT tng_output_file_endianness_set
 
     /* Tne endianness cannot be changed if the data has already been written
      * to the output file. */
-    if(ftell(tng_data->output_file) > 0)
+    if(ftello(tng_data->output_file) > 0)
     {
         return(TNG_FAILURE);
     }
@@ -10674,7 +10663,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_program_name_set(tng_trajectory_
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     if(tng_data->first_program_name && strlen(tng_data->first_program_name) < len)
     {
@@ -10723,7 +10712,7 @@ tng_function_status DECLSPECDLLEXPORT tng_last_program_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     if(tng_data->last_program_name && strlen(tng_data->last_program_name) < len)
     {
@@ -10772,7 +10761,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_user_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -10823,7 +10812,7 @@ tng_function_status DECLSPECDLLEXPORT tng_last_user_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -10874,7 +10863,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_computer_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -10925,7 +10914,7 @@ tng_function_status DECLSPECDLLEXPORT tng_last_computer_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -10977,7 +10966,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_signature_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(signature, "TNG library: signature must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(signature) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(signature) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -11029,7 +11018,7 @@ tng_function_status DECLSPECDLLEXPORT tng_last_signature_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(signature, "TNG library: signature must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(signature) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(signature) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -11081,7 +11070,7 @@ tng_function_status DECLSPECDLLEXPORT tng_forcefield_name_set
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(new_name, "TNG library: new_name must not be a NULL pointer");
 
-    len = tng_min_i((int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
+    len = tng_min_i((unsigned int)strlen(new_name) + 1, TNG_MAX_STR_LEN);
 
     /* If the currently stored string length is not enough to store the new
      * string it is freed and reallocated. */
@@ -11218,14 +11207,13 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frames_get
 {
     tng_gen_block_t block;
     tng_function_status stat;
-    long file_pos;
-    int64_t last_file_pos, first_frame, n_frames;
+    int64_t file_pos, last_file_pos, first_frame, n_frames;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(tng_data->input_file, "TNG library: An input file must be open to find the next frame set");
     TNG_ASSERT(n, "TNG library: n must not be a NULL pointer");
 
-    file_pos = ftell(tng_data->input_file);
+    file_pos = ftello(tng_data->input_file);
     last_file_pos = tng_data->last_trajectory_frame_set_input_file_pos;
 
     if(last_file_pos <= 0)
@@ -11234,9 +11222,9 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frames_get
     }
 
     tng_block_init(&block);
-    fseek(tng_data->input_file,
-          (long)last_file_pos,
-          SEEK_SET);
+    fseeko(tng_data->input_file,
+           last_file_pos,
+           SEEK_SET);
     /* Read block headers first to see that a frame set block is found. */
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11254,13 +11242,17 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frames_get
                __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
+    tng_var_64_bit_input_swap(tng_data, &first_frame);
+
     if(fread(&n_frames, sizeof(int64_t), 1, tng_data->input_file) == 0)
     {
         fprintf(stderr, "TNG library: Cannot read n frames of frame set. %s: %d\n",
                __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    fseek(tng_data->input_file, file_pos, SEEK_SET);
+    tng_var_64_bit_input_swap(tng_data, &n_frames);
+
+    fseeko(tng_data->input_file, file_pos, SEEK_SET);
 
     *n = first_frame + n_frames;
 
@@ -11523,7 +11515,7 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
                  int64_t *n)
 {
     int64_t long_stride_length, medium_stride_length;
-    long file_pos, orig_frame_set_file_pos;
+    int64_t file_pos, orig_frame_set_file_pos;
     tng_trajectory_frame_set_t frame_set;
     struct tng_trajectory_frame_set orig_frame_set;
     tng_gen_block_t block;
@@ -11538,7 +11530,7 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
     frame_set = &tng_data->current_trajectory_frame_set;
 
     orig_frame_set_file_pos = tng_data->current_trajectory_frame_set_input_file_pos;
-    file_pos = (long)tng_data->first_trajectory_frame_set_input_file_pos;
+    file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
 
     if(file_pos < 0)
     {
@@ -11547,15 +11539,15 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
     }
 
     tng_block_init(&block);
-    fseek(tng_data->input_file,
-          file_pos,
-          SEEK_SET);
+    fseeko(tng_data->input_file,
+           file_pos,
+           SEEK_SET);
     tng_data->current_trajectory_frame_set_input_file_pos = file_pos;
     /* Read block headers first to see what block is found. */
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n", file_pos,
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n", file_pos,
                 __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(TNG_CRITICAL);
@@ -11575,18 +11567,18 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
 
     /* Take long steps forward until a long step forward would be too long or
      * the last frame set is found */
-    file_pos = (long)frame_set->long_stride_next_frame_set_file_pos;
+    file_pos = frame_set->long_stride_next_frame_set_file_pos;
     while(file_pos > 0)
     {
         if(file_pos > 0)
         {
             cnt += long_stride_length;
-            fseek(tng_data->input_file, file_pos, SEEK_SET);
+            fseeko(tng_data->input_file, file_pos, SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
             {
-                fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+                fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                        file_pos, __FILE__, __LINE__);
                 tng_block_destroy(&block);
                 return(TNG_CRITICAL);
@@ -11599,25 +11591,25 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
                 return(TNG_CRITICAL);
             }
         }
-        file_pos = (long)frame_set->long_stride_next_frame_set_file_pos;
+        file_pos = frame_set->long_stride_next_frame_set_file_pos;
     }
 
     /* Take medium steps forward until a medium step forward would be too long
      * or the last frame set is found */
-    file_pos = (long)frame_set->medium_stride_next_frame_set_file_pos;
+    file_pos = frame_set->medium_stride_next_frame_set_file_pos;
     while(file_pos > 0)
     {
         if(file_pos > 0)
         {
             cnt += medium_stride_length;
-            fseek(tng_data->input_file,
-                  file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
             {
-                fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+                fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                        file_pos, __FILE__, __LINE__);
                 tng_block_destroy(&block);
                 return(TNG_CRITICAL);
@@ -11630,24 +11622,24 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
                 return(TNG_CRITICAL);
             }
         }
-        file_pos = (long)frame_set->medium_stride_next_frame_set_file_pos;
+        file_pos = frame_set->medium_stride_next_frame_set_file_pos;
     }
 
     /* Take one step forward until the last frame set is found */
-    file_pos = (long)frame_set->next_frame_set_file_pos;
+    file_pos = frame_set->next_frame_set_file_pos;
     while(file_pos > 0)
     {
         if(file_pos > 0)
         {
             ++cnt;
-            fseek(tng_data->input_file,
-                  file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
             {
-                fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+                fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                        file_pos, __FILE__, __LINE__);
                 tng_block_destroy(&block);
                 return(TNG_CRITICAL);
@@ -11660,7 +11652,7 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
                 return(TNG_CRITICAL);
             }
         }
-        file_pos = (long)frame_set->next_frame_set_file_pos;
+        file_pos = frame_set->next_frame_set_file_pos;
     }
 
     tng_block_destroy(&block);
@@ -11668,10 +11660,14 @@ tng_function_status DECLSPECDLLEXPORT tng_num_frame_sets_get
     *n = tng_data->n_trajectory_frame_sets = cnt;
 
     *frame_set = orig_frame_set;
+    /* The mapping block in the original frame set has been freed when reading
+     * other frame sets. */
+    frame_set->mappings = 0;
+    frame_set->n_mapping_blocks = 0;
 
-    fseek(tng_data->input_file,
-          (long)tng_data->first_trajectory_frame_set_input_file_pos,
-          SEEK_SET);
+    fseeko(tng_data->input_file,
+           tng_data->first_trajectory_frame_set_input_file_pos,
+           SEEK_SET);
 
     tng_data->current_trajectory_frame_set_input_file_pos = orig_frame_set_file_pos;
 
@@ -11738,10 +11734,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
     }
 
     tng_block_init(&block);
-    fseek(tng_data->input_file,
-          (long)file_pos,
-          SEEK_SET);
-    tng_data->current_trajectory_frame_set_input_file_pos = (long)file_pos;
+    fseeko(tng_data->input_file,
+           file_pos,
+           SEEK_SET);
+    tng_data->current_trajectory_frame_set_input_file_pos = file_pos;
     /* Read block headers first to see what block is found. */
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11775,7 +11771,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             curr_nr += long_stride_length;
-            fseek(tng_data->input_file, (long)file_pos, SEEK_SET);
+            fseeko(tng_data->input_file, file_pos, SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11808,9 +11804,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             curr_nr += medium_stride_length;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11843,9 +11839,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             ++curr_nr;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11878,9 +11874,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             curr_nr -= long_stride_length;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11913,9 +11909,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             curr_nr -= medium_stride_length;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11947,9 +11943,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             --curr_nr;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -11982,9 +11978,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_nr_find
         if(file_pos > 0)
         {
             ++curr_nr;
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12034,10 +12030,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
     if(tng_data->current_trajectory_frame_set_input_file_pos < 0)
     {
         file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
-        fseek(tng_data->input_file,
-                (long)file_pos,
-                SEEK_SET);
-        tng_data->current_trajectory_frame_set_input_file_pos = (long)file_pos;
+        fseeko(tng_data->input_file,
+               file_pos,
+               SEEK_SET);
+        tng_data->current_trajectory_frame_set_input_file_pos = file_pos;
         /* Read block headers first to see what block is found. */
         stat = tng_block_header_read(tng_data, block);
         if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12117,10 +12113,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
 
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
-            tng_data->current_trajectory_frame_set_input_file_pos = (long)file_pos;
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
+            tng_data->current_trajectory_frame_set_input_file_pos = file_pos;
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12159,7 +12155,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->long_stride_next_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file, (long)file_pos, SEEK_SET);
+            fseeko(tng_data->input_file, file_pos, SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12194,9 +12190,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->medium_stride_next_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12229,9 +12225,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->next_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12266,9 +12262,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->long_stride_prev_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12303,9 +12299,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->medium_stride_prev_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12338,9 +12334,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->prev_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12374,9 +12370,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_of_frame_find
         file_pos = frame_set->next_frame_set_file_pos;
         if(file_pos > 0)
         {
-            fseek(tng_data->input_file,
-                  (long)file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   file_pos,
+                   SEEK_SET);
             /* Read block headers first to see what block is found. */
             stat = tng_block_header_read(tng_data, block);
             if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
@@ -12543,14 +12539,14 @@ static tng_function_status tng_file_headers_len_get
 
     *len = 0;
 
-    orig_pos = ftell(tng_data->input_file);
+    orig_pos = ftello(tng_data->input_file);
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
     }
-    fseek(tng_data->input_file, 0, SEEK_SET);
+    fseeko(tng_data->input_file, 0, SEEK_SET);
 
     tng_block_init(&block);
     /* Read through the headers of non-trajectory blocks (they come before the
@@ -12561,10 +12557,10 @@ static tng_function_status tng_file_headers_len_get
            block->id != TNG_TRAJECTORY_FRAME_SET)
     {
         *len += block->header_contents_size + block->block_contents_size;
-        fseek(tng_data->input_file, block->block_contents_size, SEEK_CUR);
+        fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
     }
 
-    fseek(tng_data->input_file, orig_pos, SEEK_SET);
+    fseeko(tng_data->input_file, orig_pos, SEEK_SET);
 
     tng_block_destroy(&block);
 
@@ -12589,10 +12585,10 @@ tng_function_status DECLSPECDLLEXPORT tng_file_headers_read
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
     }
-    fseek(tng_data->input_file, 0, SEEK_SET);
+    fseeko(tng_data->input_file, 0, SEEK_SET);
 
     tng_block_init(&block);
     /* Non trajectory blocks (they come before the trajectory
@@ -12603,13 +12599,13 @@ tng_function_status DECLSPECDLLEXPORT tng_file_headers_read
            block->id != TNG_TRAJECTORY_FRAME_SET)
     {
         tng_block_read_next(tng_data, block, hash_mode);
-        prev_pos = ftell(tng_data->input_file);
+        prev_pos = ftello(tng_data->input_file);
     }
 
     /* Go back if a trajectory block was encountered */
     if(block->id == TNG_TRAJECTORY_FRAME_SET)
     {
-        fseek(tng_data->input_file, prev_pos, SEEK_SET);
+        fseeko(tng_data->input_file, prev_pos, SEEK_SET);
     }
 
     tng_block_destroy(&block);
@@ -12690,7 +12686,7 @@ tng_function_status DECLSPECDLLEXPORT tng_file_headers_write
 
         if(tot_len > orig_len)
         {
-            tng_migrate_data_in_file(tng_data, orig_len+1, tot_len - orig_len);
+            tng_migrate_data_in_file(tng_data, orig_len+1, tot_len - orig_len, hash_mode);
         }
 
         tng_data->current_trajectory_frame_set_output_file_pos = -1;
@@ -12763,7 +12759,7 @@ tng_function_status DECLSPECDLLEXPORT tng_block_read_next(tng_trajectory_t tng_d
         else
         {
             /* Skip to the next block */
-            fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+            fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
             return(TNG_FAILURE);
         }
     }
@@ -12773,7 +12769,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
                 (tng_trajectory_t tng_data,
                  const char hash_mode)
 {
-    long file_pos;
+    int64_t file_pos;
     tng_gen_block_t block;
     tng_function_status stat;
 
@@ -12784,15 +12780,15 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
         return(TNG_CRITICAL);
     }
 
-    file_pos = ftell(tng_data->input_file);
+    file_pos = ftello(tng_data->input_file);
 
     tng_block_init(&block);
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
-        fseek(tng_data->input_file, file_pos, SEEK_SET);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
+        fseeko(tng_data->input_file, file_pos, SEEK_SET);
     }
 
     /* Read block headers first to see what block is found. */
@@ -12800,7 +12796,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET ||
        block->id == -1)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                file_pos, __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(TNG_CRITICAL);
@@ -12812,7 +12808,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
                            hash_mode) == TNG_SUCCESS)
     {
         tng_data->n_trajectory_frame_sets++;
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -12824,7 +12820,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
                                        hash_mode);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -12833,7 +12829,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
         }
         if(stat == TNG_CRITICAL)
         {
-            fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+            fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                    file_pos, __FILE__, __LINE__);
             tng_block_destroy(&block);
             return(stat);
@@ -12841,7 +12837,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read
 
         if(block->id == TNG_TRAJECTORY_FRAME_SET)
         {
-            fseek(tng_data->input_file, file_pos, SEEK_SET);
+            fseeko(tng_data->input_file, file_pos, SEEK_SET);
         }
     }
 
@@ -12856,7 +12852,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
                  const char hash_mode,
                  const int64_t block_id)
 {
-    long file_pos;
+    int64_t file_pos;
     tng_gen_block_t block;
     tng_function_status stat;
     int found_flag = 1;
@@ -12868,19 +12864,19 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
         return(TNG_CRITICAL);
     }
 
-    file_pos = (long)tng_data->current_trajectory_frame_set_input_file_pos;
+    file_pos = tng_data->current_trajectory_frame_set_input_file_pos;
 
     if(file_pos < 0)
     {
         /* No current frame set. This means that the first frame set must be
          * read */
         found_flag = 0;
-        file_pos = (long)tng_data->first_trajectory_frame_set_input_file_pos;
+        file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
     }
 
     if(file_pos > 0)
     {
-        fseek(tng_data->input_file,
+        fseeko(tng_data->input_file,
               file_pos,
               SEEK_SET);
     }
@@ -12893,16 +12889,16 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
-        fseek(tng_data->input_file, file_pos, SEEK_SET);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
+        fseeko(tng_data->input_file, file_pos, SEEK_SET);
     }
 
     /* Read block headers first to see what block is found. */
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                file_pos, __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(TNG_CRITICAL);
@@ -12910,9 +12906,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
     /* If the current frame set had already been read skip its block contents */
     if(found_flag)
     {
-        fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+        fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
     }
-    /* Otherwiese read the frame set block */
+    /* Otherwise read the frame set block */
     else
     {
         stat = tng_block_read_next(tng_data, block,
@@ -12924,7 +12920,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
             return(stat);
         }
     }
-    file_pos = ftell(tng_data->input_file);
+    file_pos = ftello(tng_data->input_file);
 
     found_flag = 0;
 
@@ -12932,9 +12928,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
         * until next frame set block */
     stat = tng_block_header_read(tng_data, block);
     while(file_pos < tng_data->input_file_len &&
-            stat != TNG_CRITICAL &&
-            block->id != TNG_TRAJECTORY_FRAME_SET &&
-            block->id != -1)
+          stat != TNG_CRITICAL &&
+          block->id != TNG_TRAJECTORY_FRAME_SET &&
+          block->id != -1)
     {
         if(block->id == block_id)
         {
@@ -12942,7 +12938,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
                                        hash_mode);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 found_flag = 1;
                 if(file_pos < tng_data->input_file_len)
                 {
@@ -12952,8 +12948,8 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
         }
         else
         {
-            file_pos += (long)(block->block_contents_size + block->header_contents_size);
-            fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+            file_pos += block->block_contents_size + block->header_contents_size;
+            fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
             if(file_pos < tng_data->input_file_len)
             {
                 stat = tng_block_header_read(tng_data, block);
@@ -12962,7 +12958,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
     }
     if(stat == TNG_CRITICAL)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                 file_pos, __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(stat);
@@ -12970,7 +12966,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_current_only_data_from_
 
     if(block->id == TNG_TRAJECTORY_FRAME_SET)
     {
-        fseek(tng_data->input_file, file_pos, SEEK_SET);
+        fseeko(tng_data->input_file, file_pos, SEEK_SET);
     }
 
     tng_block_destroy(&block);
@@ -12989,7 +12985,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_next
                 (tng_trajectory_t tng_data,
                  const char hash_mode)
 {
-    long file_pos;
+    int64_t file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
 
@@ -12998,18 +12994,18 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_next
         return(TNG_CRITICAL);
     }
 
-    file_pos = (long)tng_data->current_trajectory_frame_set.next_frame_set_file_pos;
+    file_pos = tng_data->current_trajectory_frame_set.next_frame_set_file_pos;
 
     if(file_pos < 0 && tng_data->current_trajectory_frame_set_input_file_pos <= 0)
     {
-        file_pos = (long)tng_data->first_trajectory_frame_set_input_file_pos;
+        file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
     }
 
     if(file_pos > 0)
     {
-        fseek(tng_data->input_file,
-              file_pos,
-              SEEK_SET);
+        fseeko(tng_data->input_file,
+               file_pos,
+               SEEK_SET);
     }
     else
     {
@@ -13024,7 +13020,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_next_only_data_from_blo
                  const char hash_mode,
                  const int64_t block_id)
 {
-    long file_pos;
+    int64_t file_pos;
     tng_gen_block_t block;
     tng_function_status stat;
 
@@ -13035,18 +13031,18 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_next_only_data_from_blo
         return(TNG_CRITICAL);
     }
 
-    file_pos = (long)tng_data->current_trajectory_frame_set.next_frame_set_file_pos;
+    file_pos = tng_data->current_trajectory_frame_set.next_frame_set_file_pos;
 
     if(file_pos < 0 && tng_data->current_trajectory_frame_set_input_file_pos <= 0)
     {
-        file_pos = (long)tng_data->first_trajectory_frame_set_input_file_pos;
+        file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
     }
 
     if(file_pos > 0)
     {
-        fseek(tng_data->input_file,
-              file_pos,
-              SEEK_SET);
+        fseeko(tng_data->input_file,
+               file_pos,
+               SEEK_SET);
     }
     else
     {
@@ -13057,17 +13053,17 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_read_next_only_data_from_blo
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
-        fseek(tng_data->input_file, file_pos, SEEK_SET);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
+        fseeko(tng_data->input_file, file_pos, SEEK_SET);
     }
 
     /* Read block headers first to see what block is found. */
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
-               file_pos, __FILE__, __LINE__);
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
+                file_pos, __FILE__, __LINE__);
         tng_block_destroy(&block);
         return(TNG_CRITICAL);
     }
@@ -13103,7 +13099,7 @@ tng_function_status tng_frame_set_write(tng_trajectory_t tng_data,
     }
 
     tng_data->current_trajectory_frame_set_output_file_pos =
-    ftell(tng_data->output_file);
+    ftello(tng_data->output_file);
     tng_data->last_trajectory_frame_set_output_file_pos =
     tng_data->current_trajectory_frame_set_output_file_pos;
 
@@ -13206,7 +13202,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
     tng_gen_block_t block;
     tng_trajectory_frame_set_t frame_set;
     FILE *temp = tng_data->input_file;
-    int64_t curr_pos;
+    int64_t curr_file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(first_frame >= 0, "TNG library: first_frame must be >= 0.");
@@ -13214,9 +13210,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
 
     frame_set = &tng_data->current_trajectory_frame_set;
 
-    curr_pos = ftell(tng_data->output_file);
+    curr_file_pos = ftello(tng_data->output_file);
 
-    if(curr_pos <= 10)
+    if(curr_file_pos <= 10)
     {
         tng_file_headers_write(tng_data, TNG_USE_HASH);
     }
@@ -13232,7 +13228,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
     }
 
     tng_data->current_trajectory_frame_set_output_file_pos =
-    ftell(tng_data->output_file);
+    ftello(tng_data->output_file);
 
     tng_data->n_trajectory_frame_sets++;
 
@@ -13252,10 +13248,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
             tng_block_init(&block);
             tng_data->input_file = tng_data->output_file;
 
-            curr_pos = ftell(tng_data->output_file);
-            fseek(tng_data->output_file,
-                  (long)frame_set->medium_stride_prev_frame_set_file_pos,
-                  SEEK_SET);
+            curr_file_pos = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file,
+                   frame_set->medium_stride_prev_frame_set_file_pos,
+                   SEEK_SET);
 
             if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
             {
@@ -13268,7 +13264,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
 
             /* Read the next frame set from the previous frame set and one
              * medium stride step back */
-            fseek(tng_data->output_file, (long)block->block_contents_size - (6 *
+            fseeko(tng_data->output_file, block->block_contents_size - (6 *
             sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
             if(fread(&frame_set->medium_stride_prev_frame_set_file_pos,
                sizeof(frame_set->medium_stride_prev_frame_set_file_pos),
@@ -13309,9 +13305,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
                     tng_block_init(&block);
                     tng_data->input_file = tng_data->output_file;
 
-                    fseek(tng_data->output_file,
-                          (long)frame_set->long_stride_prev_frame_set_file_pos,
-                          SEEK_SET);
+                    fseeko(tng_data->output_file,
+                           frame_set->long_stride_prev_frame_set_file_pos,
+                           SEEK_SET);
 
                     if(tng_block_header_read(tng_data, block) != TNG_SUCCESS)
                     {
@@ -13324,7 +13320,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
 
                     /* Read the next frame set from the previous frame set and one
                     * long stride step back */
-                    fseek(tng_data->output_file, (long)block->block_contents_size - (6 *
+                    fseeko(tng_data->output_file, block->block_contents_size - (6 *
                           sizeof(int64_t) + 2 * sizeof(double)), SEEK_CUR);
 
                     tng_block_destroy(&block);
@@ -13353,7 +13349,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_set_new
             }
 
             tng_data->input_file = temp;
-            fseek(tng_data->output_file, (long)curr_pos, SEEK_SET);
+            fseeko(tng_data->output_file, curr_file_pos, SEEK_SET);
         }
     }
 
@@ -13423,7 +13419,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_frame_nr_of_next_frame_set_get
                 (const tng_trajectory_t tng_data,
                  int64_t *frame)
 {
-    long file_pos, next_frame_set_file_pos;
+    int64_t file_pos, next_frame_set_file_pos;
     tng_gen_block_t block;
     tng_function_status stat;
 
@@ -13433,16 +13429,16 @@ tng_function_status DECLSPECDLLEXPORT tng_first_frame_nr_of_next_frame_set_get
     TNG_ASSERT(tng_data->input_file, "TNG library: An input file must be open to find the next frame set");
     TNG_ASSERT(frame, "TNG library: frame must not be a NULL pointer");
 
-    file_pos = ftell(tng_data->input_file);
+    file_pos = ftello(tng_data->input_file);
 
     if(tng_data->current_trajectory_frame_set_input_file_pos <= 0)
     {
-        next_frame_set_file_pos = (long)tng_data->first_trajectory_frame_set_input_file_pos;
+        next_frame_set_file_pos = tng_data->first_trajectory_frame_set_input_file_pos;
     }
     else
     {
         frame_set = &tng_data->current_trajectory_frame_set;
-        next_frame_set_file_pos = (long)frame_set->next_frame_set_file_pos;
+        next_frame_set_file_pos = frame_set->next_frame_set_file_pos;
     }
 
     if(next_frame_set_file_pos <= 0)
@@ -13450,13 +13446,13 @@ tng_function_status DECLSPECDLLEXPORT tng_first_frame_nr_of_next_frame_set_get
         return(TNG_FAILURE);
     }
 
-    fseek(tng_data->input_file, (long)next_frame_set_file_pos, SEEK_SET);
+    fseeko(tng_data->input_file, next_frame_set_file_pos, SEEK_SET);
     /* Read block headers first to see that a frame set block is found. */
     tng_block_init(&block);
     stat = tng_block_header_read(tng_data, block);
     if(stat == TNG_CRITICAL || block->id != TNG_TRAJECTORY_FRAME_SET)
     {
-        fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+        fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                file_pos, __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
@@ -13472,7 +13468,7 @@ tng_function_status DECLSPECDLLEXPORT tng_first_frame_nr_of_next_frame_set_get
                __FILE__, __LINE__);
         return(TNG_CRITICAL);
     }
-    fseek(tng_data->input_file, file_pos, SEEK_SET);
+    fseeko(tng_data->input_file, file_pos, SEEK_SET);
 
     return(TNG_SUCCESS);
 }
@@ -13531,7 +13527,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_block_add
         if(!data->block_name)
         {
             fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-                   (int)strlen(block_name)+1, __FILE__, __LINE__);
+                   (unsigned int)strlen(block_name)+1, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
         strncpy(data->block_name, block_name, strlen(block_name) + 1);
@@ -13593,7 +13589,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_block_add
                 first_dim_values = data->strings[i];
                 for(j = 0; j < n_values_per_frame; j++)
                 {
-                    len = tng_min_i((int)strlen(new_data_c) + 1,
+                    len = tng_min_i((unsigned int)strlen(new_data_c) + 1,
                                 TNG_MAX_STR_LEN);
                     if(first_dim_values[j])
                     {
@@ -13684,7 +13680,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_block_add
         if(!data->block_name)
         {
             fprintf(stderr, "TNG library: Cannot allocate memory (%d bytes). %s: %d\n",
-                   (int)strlen(block_name)+1, __FILE__, __LINE__);
+                   (unsigned int)strlen(block_name)+1, __FILE__, __LINE__);
             return(TNG_CRITICAL);
         }
         strncpy(data->block_name, block_name, strlen(block_name) + 1);
@@ -13748,7 +13744,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_block_add
                     second_dim_values = first_dim_values[j];
                     for(k = 0; k < n_values_per_frame; k++)
                     {
-                        len = tng_min_i((int)strlen(new_data_c) + 1,
+                        len = tng_min_i((unsigned int)strlen(new_data_c) + 1,
                                 TNG_MAX_STR_LEN);
                         if(second_dim_values[k])
                         {
@@ -14052,8 +14048,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
     int64_t header_pos, file_pos;
     int64_t output_file_len, n_values_per_frame, size, contents_size;
     int64_t header_size, temp_first, temp_last;
-    int64_t i, last_frame;
-    long temp_current;
+    int64_t i, last_frame, temp_current;
     tng_gen_block_t block;
     tng_trajectory_frame_set_t frame_set;
     FILE *temp = tng_data->input_file;
@@ -14108,10 +14103,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
             tng_frame_set_new(tng_data,
                               last_frame+1,
                               tng_data->frame_set_n_frames);
-            file_pos = ftell(tng_data->output_file);
-            fseek(tng_data->output_file, 0, SEEK_END);
-            output_file_len = ftell(tng_data->output_file);
-            fseek(tng_data->output_file, (long)file_pos, SEEK_SET);
+            file_pos = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, 0, SEEK_END);
+            output_file_len = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, file_pos, SEEK_SET);
 
             /* Read mapping blocks from the last frame set */
             tng_block_init(&block);
@@ -14129,10 +14124,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
                 }
                 else
                 {
-                    fseek(tng_data->output_file, (long)block->block_contents_size,
+                    fseeko(tng_data->output_file, block->block_contents_size,
                         SEEK_CUR);
                 }
-                file_pos = ftell(tng_data->output_file);
+                file_pos = ftello(tng_data->output_file);
                 if(file_pos < output_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -14161,9 +14156,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
 
     file_pos = tng_data->current_trajectory_frame_set_output_file_pos;
 
-    fseek(tng_data->output_file, 0, SEEK_END);
-    output_file_len = ftell(tng_data->output_file);
-    fseek(tng_data->output_file, (long)file_pos, SEEK_SET);
+    fseeko(tng_data->output_file, 0, SEEK_END);
+    output_file_len = ftello(tng_data->output_file);
+    fseeko(tng_data->output_file, file_pos, SEEK_SET);
 
     /* Read past the frame set block first */
     stat = tng_block_header_read(tng_data, block);
@@ -14179,7 +14174,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
         tng_data->current_trajectory_frame_set_input_file_pos = temp_current;
         return(stat);
     }
-    fseek(tng_data->output_file, (long)block->block_contents_size,
+    fseeko(tng_data->output_file, block->block_contents_size,
             SEEK_CUR);
 
     /* Read all block headers until next frame set block or
@@ -14191,8 +14186,8 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
             block->id != TNG_TRAJECTORY_FRAME_SET &&
             block->id != -1)
     {
-        fseek(tng_data->output_file, (long)block->block_contents_size, SEEK_CUR);
-        file_pos = ftell(tng_data->output_file);
+        fseeko(tng_data->output_file, block->block_contents_size, SEEK_CUR);
+        file_pos = ftello(tng_data->output_file);
         if(file_pos < output_file_len)
         {
             stat = tng_block_header_read(tng_data, block);
@@ -14213,7 +14208,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
     contents_size = block->block_contents_size;
     header_size = block->header_contents_size;
 
-    header_pos = ftell(tng_data->output_file) - header_size;
+    header_pos = ftello(tng_data->output_file) - header_size;
     frame_set = &tng_data->current_trajectory_frame_set;
 
     if(fread(&datatype, sizeof(datatype), 1, tng_data->input_file) == 0)
@@ -14395,7 +14390,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_data_write
         return(TNG_FAILURE);
     }
 
-    fseek(tng_data->output_file, (long)file_pos, SEEK_CUR);
+    fseeko(tng_data->output_file, file_pos, SEEK_CUR);
 
     /* If the endianness is not big endian the data needs to be swapped */
     if((data.datatype == TNG_INT_DATA ||
@@ -14478,8 +14473,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
     int64_t output_file_len, n_values_per_frame, size, contents_size;
     int64_t header_size, temp_first, temp_last;
     int64_t mapping_block_end_pos, num_first_particle, block_n_particles;
-    int64_t i, last_frame;
-    long temp_current;
+    int64_t i, last_frame, temp_current;
     tng_gen_block_t block;
     tng_trajectory_frame_set_t frame_set;
     FILE *temp = tng_data->input_file;
@@ -14538,10 +14532,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
                               last_frame+1,
                               tng_data->frame_set_n_frames);
 
-            file_pos = ftell(tng_data->output_file);
-            fseek(tng_data->output_file, 0, SEEK_END);
-            output_file_len = ftell(tng_data->output_file);
-            fseek(tng_data->output_file, (long)file_pos, SEEK_SET);
+            file_pos = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, 0, SEEK_END);
+            output_file_len = ftello(tng_data->output_file);
+            fseeko(tng_data->output_file, file_pos, SEEK_SET);
 
             /* Read mapping blocks from the last frame set */
             tng_block_init(&block);
@@ -14559,10 +14553,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
                 }
                 else
                 {
-                    fseek(tng_data->output_file, (long)block->block_contents_size,
+                    fseeko(tng_data->output_file, block->block_contents_size,
                         SEEK_CUR);
                 }
-                file_pos = ftell(tng_data->output_file);
+                file_pos = ftello(tng_data->output_file);
                 if(file_pos < output_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -14592,9 +14586,9 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
 
     file_pos = tng_data->current_trajectory_frame_set_output_file_pos;
 
-    fseek(tng_data->output_file, 0, SEEK_END);
-    output_file_len = ftell(tng_data->output_file);
-    fseek(tng_data->output_file, (long)file_pos, SEEK_SET);
+    fseeko(tng_data->output_file, 0, SEEK_END);
+    output_file_len = ftello(tng_data->output_file);
+    fseeko(tng_data->output_file, file_pos, SEEK_SET);
 
     /* Read past the frame set block first */
     stat = tng_block_header_read(tng_data, block);
@@ -14610,7 +14604,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
         tng_data->current_trajectory_frame_set_input_file_pos = temp_current;
         return(stat);
     }
-    fseek(tng_data->output_file, (long)block->block_contents_size,
+    fseeko(tng_data->output_file, block->block_contents_size,
             SEEK_CUR);
 
     if(tng_data->var_num_atoms_flag)
@@ -14638,10 +14632,10 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
             }
             else
             {
-                fseek(tng_data->output_file, (long)block->block_contents_size,
-                      SEEK_CUR);
+                fseeko(tng_data->output_file, block->block_contents_size,
+                       SEEK_CUR);
             }
-            file_pos = ftell(tng_data->output_file);
+            file_pos = ftello(tng_data->output_file);
             if(block->id == TNG_PARTICLE_MAPPING)
             {
                 mapping = &frame_set->mappings[frame_set->n_mapping_blocks - 1];
@@ -14681,7 +14675,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
             tng_data->current_trajectory_frame_set_input_file_pos = temp_current;
             return(TNG_FAILURE);
         }
-        fseek(tng_data->output_file, (long)mapping_block_end_pos, SEEK_SET);
+        fseeko(tng_data->output_file, mapping_block_end_pos, SEEK_SET);
     }
 
     /* Read all block headers until next frame set block or
@@ -14694,8 +14688,8 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
             block->id != TNG_TRAJECTORY_FRAME_SET &&
             block->id != -1)
     {
-        fseek(tng_data->output_file, (long)block->block_contents_size, SEEK_CUR);
-        file_pos = ftell(tng_data->output_file);
+        fseeko(tng_data->output_file, block->block_contents_size, SEEK_CUR);
+        file_pos = ftello(tng_data->output_file);
         if(file_pos < output_file_len)
         {
             stat = tng_block_header_read(tng_data, block);
@@ -14717,7 +14711,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
     contents_size = block->block_contents_size;
     header_size = block->header_contents_size;
 
-    header_pos = ftell(tng_data->output_file) - header_size;
+    header_pos = ftello(tng_data->output_file) - header_size;
     frame_set = &tng_data->current_trajectory_frame_set;
 
     if(fread(&datatype, sizeof(datatype), 1, tng_data->input_file) == 0)
@@ -14941,7 +14935,7 @@ tng_function_status DECLSPECDLLEXPORT tng_frame_particle_data_write
         return(TNG_FAILURE);
     }
 
-    fseek(tng_data->output_file, (long)file_pos, SEEK_CUR);
+    fseeko(tng_data->output_file, file_pos, SEEK_CUR);
 
     /* If the endianness is not big endian the data needs to be swapped */
     if((data.datatype == TNG_INT_DATA ||
@@ -15249,7 +15243,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_get
     if(tng_data_find(tng_data, block_id, &data) != TNG_SUCCESS)
     {
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -15262,7 +15256,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_get
                                     TNG_USE_HASH);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -15368,7 +15362,7 @@ tng_function_status tng_data_vector_get(tng_trajectory_t tng_data,
                                         int64_t *n_values_per_frame,
                                         char *type)
 {
-    int64_t file_pos, data_size, n_frames_div, block_index;
+    int64_t file_pos, full_data_len, n_frames_div, block_index;
     int i, size;
     tng_non_particle_data_t data;
     tng_trajectory_frame_set_t frame_set;
@@ -15390,7 +15384,7 @@ tng_function_status tng_data_vector_get(tng_trajectory_t tng_data,
     if(tng_data_find(tng_data, block_id, &data) != TNG_SUCCESS)
     {
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -15403,7 +15397,7 @@ tng_function_status tng_data_vector_get(tng_trajectory_t tng_data,
                                     TNG_USE_HASH);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -15456,14 +15450,14 @@ tng_function_status tng_data_vector_get(tng_trajectory_t tng_data,
     n_frames_div = (*n_frames % *stride_length) ? *n_frames / *stride_length + 1:
                    *n_frames / *stride_length;
 
-    data_size = n_frames_div * size *
+    full_data_len = n_frames_div * size *
                 *n_values_per_frame;
 
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -15471,7 +15465,7 @@ tng_function_status tng_data_vector_get(tng_trajectory_t tng_data,
 
     *values = temp;
 
-    memcpy(*values, data->values, data_size);
+    memcpy(*values, data->values, full_data_len);
 
     data->last_retrieved_frame = frame_set->first_frame + data->n_frames - 1;
 
@@ -15519,7 +15513,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_interval_get
        frame_set->n_data_blocks <= 0)
     {
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -15531,7 +15525,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_interval_get
                                     hash_mode);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -15693,7 +15687,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
                  char *type)
 {
     int64_t n_frames, tot_n_frames, n_frames_div, n_frames_div_2, first_frame;
-    int64_t file_pos, current_frame_pos, data_size, frame_size;
+    int64_t file_pos, current_frame_pos, full_data_len, frame_size;
     int64_t last_frame_pos;
     int size;
     tng_trajectory_frame_set_t frame_set;
@@ -15726,9 +15720,9 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
         tng_block_init(&block);
         if(stat != TNG_SUCCESS)
         {
-            fseek(tng_data->input_file,
-                  (long)tng_data->current_trajectory_frame_set_input_file_pos,
-                  SEEK_SET);
+            fseeko(tng_data->input_file,
+                   tng_data->current_trajectory_frame_set_input_file_pos,
+                   SEEK_SET);
             stat = tng_block_header_read(tng_data, block);
             if(stat != TNG_SUCCESS)
             {
@@ -15737,9 +15731,9 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
                 return(stat);
             }
 
-            fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+            fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
         }
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -15753,7 +15747,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
                                         hash_mode);
                 if(stat != TNG_CRITICAL)
                 {
-                    file_pos = ftell(tng_data->input_file);
+                    file_pos = ftello(tng_data->input_file);
                     if(file_pos < tng_data->input_file_len)
                     {
                         stat = tng_block_header_read(tng_data, block);
@@ -15763,7 +15757,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
             else
             {
                 file_pos += block->block_contents_size + block->header_contents_size;
-                fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+                fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -15825,16 +15819,16 @@ tng_function_status DECLSPECDLLEXPORT tng_data_vector_interval_get
     n_frames_div = (tot_n_frames % *stride_length) ?
                  tot_n_frames / *stride_length + 1:
                  tot_n_frames / *stride_length;
-    data_size = n_frames_div * size * (*n_values_per_frame);
+    full_data_len = n_frames_div * size * (*n_values_per_frame);
 
-/*     fprintf(stderr, "TNG library: size: %d, n_frames_div: %"PRId64", data_size: %"PRId64"\n",
-              size, n_frames_div, data_size);
+/*     fprintf(stderr, "TNG library: size: %d, n_frames_div: %"PRId64", full_data_len: %"PRId64"\n",
+              size, n_frames_div, full_data_len);
 */
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -15963,7 +15957,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_get
         }
 
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -15976,7 +15970,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_get
                                     TNG_USE_HASH);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -16135,7 +16129,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_get
                  int64_t *n_values_per_frame,
                  char *type)
 {
-    int64_t i, j, mapping, file_pos, i_step, data_size, n_frames_div;
+    int64_t i, j, mapping, file_pos, i_step, full_data_len, n_frames_div;
     int64_t block_index;
     int size;
     tng_particle_data_t data;
@@ -16159,7 +16153,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_get
     if(tng_particle_data_find(tng_data, block_id, &data) != TNG_SUCCESS)
     {
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -16172,7 +16166,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_get
                                     TNG_USE_HASH);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -16246,14 +16240,14 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_get
                    *n_frames / *stride_length + 1:
                    *n_frames / *stride_length;
 
-    data_size = n_frames_div * size * (*n_particles) *
+    full_data_len = n_frames_div * size * (*n_particles) *
                 (*n_values_per_frame);
 
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -16263,7 +16257,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_get
 
     if(frame_set->n_mapping_blocks <= 0)
     {
-        memcpy(*values, data->values, data_size);
+        memcpy(*values, data->values, full_data_len);
     }
     else
     {
@@ -16330,7 +16324,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_interval_get
        frame_set->n_particle_data_blocks <= 0)
     {
         tng_block_init(&block);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read all blocks until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -16342,7 +16336,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_interval_get
                                     hash_mode);
             if(stat != TNG_CRITICAL)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -16541,7 +16535,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
                  char *type)
 {
     int64_t n_frames, tot_n_frames, n_frames_div, n_frames_div_2, first_frame;
-    int64_t file_pos, current_frame_pos, last_frame_pos, data_size, frame_size;
+    int64_t file_pos, current_frame_pos, last_frame_pos, full_data_len, frame_size;
     int size;
     tng_trajectory_frame_set_t frame_set;
     tng_particle_data_t p_data;
@@ -16574,8 +16568,8 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
         tng_block_init(&block);
         if(stat != TNG_SUCCESS)
         {
-            fseek(tng_data->input_file,
-                  (long)tng_data->current_trajectory_frame_set_input_file_pos,
+            fseeko(tng_data->input_file,
+                  tng_data->current_trajectory_frame_set_input_file_pos,
                   SEEK_SET);
             stat = tng_block_header_read(tng_data, block);
             if(stat != TNG_SUCCESS)
@@ -16585,9 +16579,9 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
                 return(stat);
             }
 
-            fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+            fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
         }
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         /* Read until next frame set block */
         stat = tng_block_header_read(tng_data, block);
         while(file_pos < tng_data->input_file_len &&
@@ -16601,7 +16595,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
                                         hash_mode);
                 if(stat != TNG_CRITICAL)
                 {
-                    file_pos = ftell(tng_data->input_file);
+                    file_pos = ftello(tng_data->input_file);
                     if(file_pos < tng_data->input_file_len)
                     {
                         stat = tng_block_header_read(tng_data, block);
@@ -16611,7 +16605,7 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
             else
             {
                 file_pos += block->block_contents_size + block->header_contents_size;
-                fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+                fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
                 if(file_pos < tng_data->input_file_len)
                 {
                     stat = tng_block_header_read(tng_data, block);
@@ -16673,14 +16667,14 @@ tng_function_status DECLSPECDLLEXPORT tng_particle_data_vector_interval_get
                  tot_n_frames / *stride_length + 1:
                  tot_n_frames / *stride_length;
 
-    data_size = n_frames_div * size * (*n_particles) *
+    full_data_len = n_frames_div * size * (*n_particles) *
                 (*n_values_per_frame);
 
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -16778,7 +16772,7 @@ tng_function_status DECLSPECDLLEXPORT tng_data_get_stride_length
     tng_function_status stat;
     tng_non_particle_data_t np_data;
     tng_particle_data_t p_data;
-    long orig_file_pos, file_pos;
+    int64_t orig_file_pos, file_pos;
     int is_particle_data;
 
     if(tng_data->current_trajectory_frame_set_input_file_pos <= 0)
@@ -16805,11 +16799,11 @@ tng_function_status DECLSPECDLLEXPORT tng_data_get_stride_length
             /* If no specific frame was required read until this data block is found */
             if(frame < 0)
             {
-                file_pos = ftell(tng_data->input_file);
+                file_pos = ftello(tng_data->input_file);
                 while(stat != TNG_SUCCESS && file_pos < tng_data->input_file_len)
                 {
                     stat = tng_frame_set_read_next_only_data_from_block_id(tng_data, TNG_USE_HASH, block_id);
-                    file_pos = ftell(tng_data->input_file);
+                    file_pos = ftello(tng_data->input_file);
                 }
             }
             if(stat != TNG_SUCCESS)
@@ -16919,7 +16913,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_open
 
     if(mode == 'w')
     {
-        tng_output_file_set(*tng_data_p, filename);
+        stat = tng_output_file_set(*tng_data_p, filename);
     }
     else if(mode == 'a')
     {
@@ -16928,8 +16922,8 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_open
             fclose((*tng_data_p)->output_file);
         }
         (*tng_data_p)->output_file = (*tng_data_p)->input_file;
-        fseek((*tng_data_p)->input_file,
-                (long)(*tng_data_p)->last_trajectory_frame_set_input_file_pos,
+        fseeko((*tng_data_p)->input_file,
+                (*tng_data_p)->last_trajectory_frame_set_input_file_pos,
                 SEEK_SET);
 
         stat = tng_frame_set_read(*tng_data_p, TNG_USE_HASH);
@@ -16958,10 +16952,10 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_open
         }
         tng_output_append_file_set(*tng_data_p, filename);
 
-        fseek((*tng_data_p)->output_file, 0, SEEK_END);
+        fseeko((*tng_data_p)->output_file, 0, SEEK_END);
     }
 
-    return(TNG_SUCCESS);
+    return(stat);
 }
 
 tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_close
@@ -17306,9 +17300,9 @@ tng_function_status DECLSPECDLLEXPORT tng_util_particle_data_next_frame_read
     tng_particle_data_t data = 0;
     tng_function_status stat;
     int size;
-    int64_t i, data_size, n_particles;
+    int64_t i, full_data_len, n_particles;
     void *temp;
-    long file_pos;
+    int64_t file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(values, "TNG library: The pointer to the values array must not be a NULL pointer");
@@ -17322,11 +17316,11 @@ tng_function_status DECLSPECDLLEXPORT tng_util_particle_data_next_frame_read
     if(stat != TNG_SUCCESS)
     {
         stat = tng_frame_set_read_current_only_data_from_block_id(tng_data, TNG_USE_HASH, block_id);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         while(stat != TNG_SUCCESS && file_pos < tng_data->input_file_len)
         {
             stat = tng_frame_set_read_next_only_data_from_block_id(tng_data, TNG_USE_HASH, block_id);
-            file_pos = ftell(tng_data->input_file);
+            file_pos = ftello(tng_data->input_file);
         }
         if(stat != TNG_SUCCESS)
         {
@@ -17340,8 +17334,8 @@ tng_function_status DECLSPECDLLEXPORT tng_util_particle_data_next_frame_read
     }
     if(data->last_retrieved_frame < 0)
     {
-        fseek(tng_data->input_file,
-              (long)tng_data->first_trajectory_frame_set_input_file_pos,
+        fseeko(tng_data->input_file,
+              tng_data->first_trajectory_frame_set_input_file_pos,
               SEEK_SET);
         stat = tng_frame_set_read(tng_data, TNG_USE_HASH);
         if(stat != TNG_SUCCESS)
@@ -17436,16 +17430,16 @@ tng_function_status DECLSPECDLLEXPORT tng_util_particle_data_next_frame_read
         size = sizeof(double);
     }
 
-    data_size = size * n_particles * data->n_values_per_frame;
+    full_data_len = size * n_particles * data->n_values_per_frame;
 
-//     fprintf(stderr, "TNG library: TEMP: i = %"PRId64", data_size = %"PRId64", size = %d, n_particles = %"PRId64", n_values_per_frame = %"PRId64"\n",
-//            i, data_size, size, n_particles, data->n_values_per_frame);
+//     fprintf(stderr, "TNG library: TEMP: i = %"PRId64", full_data_len = %"PRId64", size = %d, n_particles = %"PRId64", n_values_per_frame = %"PRId64"\n",
+//            i, full_data_len, size, n_particles, data->n_values_per_frame);
 
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -17453,7 +17447,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_particle_data_next_frame_read
 
     *values = temp;
 
-    memcpy(*values, (char *)data->values + i * data_size, data_size);
+    memcpy(*values, (char *)data->values + i * full_data_len, full_data_len);
 
     return(TNG_SUCCESS);
 }
@@ -17470,9 +17464,9 @@ tng_function_status DECLSPECDLLEXPORT tng_util_non_particle_data_next_frame_read
     tng_non_particle_data_t data = 0;
     tng_function_status stat;
     int size;
-    int64_t i, data_size;
+    int64_t i, full_data_len;
     void *temp;
-    long file_pos;
+    int64_t file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(values, "TNG library: The pointer to the values array must not be a NULL pointer");
@@ -17486,11 +17480,11 @@ tng_function_status DECLSPECDLLEXPORT tng_util_non_particle_data_next_frame_read
     if(stat != TNG_SUCCESS)
     {
         stat = tng_frame_set_read_current_only_data_from_block_id(tng_data, TNG_USE_HASH, block_id);
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         while(stat != TNG_SUCCESS && file_pos < tng_data->input_file_len)
         {
             stat = tng_frame_set_read_next_only_data_from_block_id(tng_data, TNG_USE_HASH, block_id);
-            file_pos = ftell(tng_data->input_file);
+            file_pos = ftello(tng_data->input_file);
         }
         if(stat != TNG_SUCCESS)
         {
@@ -17504,8 +17498,8 @@ tng_function_status DECLSPECDLLEXPORT tng_util_non_particle_data_next_frame_read
     }
     if(data->last_retrieved_frame < 0)
     {
-        fseek(tng_data->input_file,
-                (long)tng_data->first_trajectory_frame_set_input_file_pos,
+        fseeko(tng_data->input_file,
+                tng_data->first_trajectory_frame_set_input_file_pos,
                 SEEK_SET);
         stat = tng_frame_set_read(tng_data, TNG_USE_HASH);
         if(stat != TNG_SUCCESS)
@@ -17598,13 +17592,13 @@ tng_function_status DECLSPECDLLEXPORT tng_util_non_particle_data_next_frame_read
         size = sizeof(double);
     }
 
-    data_size = size * data->n_values_per_frame;
+    full_data_len = size * data->n_values_per_frame;
 
-    temp = realloc(*values, data_size);
+    temp = realloc(*values, full_data_len);
     if(!temp)
     {
         fprintf(stderr, "TNG library: Cannot allocate memory (%"PRId64" bytes). %s: %d\n",
-               data_size, __FILE__, __LINE__);
+               full_data_len, __FILE__, __LINE__);
         free(*values);
         *values = 0;
         return(TNG_CRITICAL);
@@ -17612,7 +17606,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_non_particle_data_next_frame_read
 
     *values = temp;
 
-    memcpy(*values, (char *)data->values + i * data_size, data_size);
+    memcpy(*values, (char *)data->values + i * full_data_len, full_data_len);
 
     return(TNG_SUCCESS);
 }
@@ -18174,7 +18168,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_generic_write
     tng_function_status stat;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(values, "TNG library: values must not be a NULL pointer");
 
     if(particle_dependency == TNG_PARTICLE_BLOCK_DATA)
@@ -18388,7 +18381,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_generic_double_write
     tng_function_status stat;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(values, "TNG library: values must not be a NULL pointer");
 
     if(particle_dependency == TNG_PARTICLE_BLOCK_DATA)
@@ -18591,7 +18583,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_pos_write
                  const float *positions)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(positions, "TNG library: positions must not be a NULL pointer");
 
     return(tng_util_generic_write(tng_data, frame_nr, positions, 3,
@@ -18606,7 +18597,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_pos_double_write
                  const double *positions)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(positions, "TNG library: positions must not be a NULL pointer");
 
     return(tng_util_generic_double_write(tng_data, frame_nr, positions, 3,
@@ -18621,7 +18611,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_vel_write
                  const float *velocities)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(velocities, "TNG library: velocities must not be a NULL pointer");
 
     return(tng_util_generic_write(tng_data, frame_nr, velocities, 3,
@@ -18636,7 +18625,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_vel_double_write
                  const double *velocities)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(velocities, "TNG library: velocities must not be a NULL pointer");
 
     return(tng_util_generic_double_write(tng_data, frame_nr, velocities, 3,
@@ -18651,7 +18639,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_force_write
                  const float *forces)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(forces, "TNG library: forces must not be a NULL pointer");
 
     return(tng_util_generic_write(tng_data, frame_nr, forces, 3,
@@ -18666,7 +18653,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_force_double_write
                  const double *forces)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(forces, "TNG library: forces must not be a NULL pointer");
 
     return(tng_util_generic_double_write(tng_data, frame_nr, forces, 3,
@@ -18681,7 +18667,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_box_shape_write
                  const float *box_shape)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(box_shape, "TNG library: box_shape must not be a NULL pointer");
 
     return(tng_util_generic_write(tng_data, frame_nr, box_shape, 9,
@@ -18696,7 +18681,6 @@ tng_function_status DECLSPECDLLEXPORT tng_util_box_shape_double_write
                  const double *box_shape)
 {
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
-    TNG_ASSERT(frame_nr >= 0, "TNG library: frame_nr must be >= 0.");
     TNG_ASSERT(box_shape, "TNG library: box_shape must not be a NULL pointer");
 
     return(tng_util_generic_double_write(tng_data, frame_nr, box_shape, 9,
@@ -19079,7 +19063,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_next_frame_present_dat
     int64_t data_frame, frame_diff, min_diff;
     int64_t size, frame_set_file_pos;
     int found, read_all = 0;
-    long file_pos;
+    int64_t file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(next_frame, "TNG library: The pointer to the next frame must not be NULL.");
@@ -19130,7 +19114,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_next_frame_present_dat
     /* Check for data blocks only if they have not already been found. */
     if(frame_set->n_particle_data_blocks <= 0 && frame_set->n_data_blocks <= 0)
     {
-        file_pos = ftell(tng_data->input_file);
+        file_pos = ftello(tng_data->input_file);
         if(file_pos < tng_data->input_file_len)
         {
             tng_block_init(&block);
@@ -19144,7 +19128,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_next_frame_present_dat
                                         TNG_USE_HASH);
                 if(stat != TNG_CRITICAL)
                 {
-                    file_pos = ftell(tng_data->input_file);
+                    file_pos = ftello(tng_data->input_file);
                     if(file_pos < tng_data->input_file_len)
                     {
                         stat = tng_block_header_read(tng_data, block);
@@ -19154,7 +19138,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_next_frame_present_dat
             tng_block_destroy(&block);
             if(stat == TNG_CRITICAL)
             {
-                fprintf(stderr, "TNG library: Cannot read block header at pos %ld. %s: %d\n",
+                fprintf(stderr, "TNG library: Cannot read block header at pos %"PRId64". %s: %d\n",
                         file_pos, __FILE__, __LINE__);
                 return(stat);
             }
@@ -19362,7 +19346,7 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_all_data_block_types_g
                  char **compressions)
 {
     tng_gen_block_t block;
-    long orig_file_pos, file_pos;
+    int64_t orig_file_pos, file_pos;
 
     TNG_ASSERT(tng_data, "TNG library: Trajectory container not properly setup.");
     TNG_ASSERT(n_data_blocks, "TNG library: The pointer to n_data_blocks must not be NULL.");
@@ -19370,15 +19354,15 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_all_data_block_types_g
     TNG_ASSERT(data_block_names, "TNG library: The pointer to the list of data block names must not be NULL.");
     TNG_ASSERT(stride_lengths, "TNG library: The pointer to the list of stride lengths must not be NULL.");
 
-    orig_file_pos = ftell(tng_data->input_file);
+    orig_file_pos = ftello(tng_data->input_file);
 
     if(!tng_data->input_file_len)
     {
-        fseek(tng_data->input_file, 0, SEEK_END);
-        tng_data->input_file_len = ftell(tng_data->input_file);
+        fseeko(tng_data->input_file, 0, SEEK_END);
+        tng_data->input_file_len = ftello(tng_data->input_file);
     }
 
-    fseek(tng_data->input_file, 0, SEEK_SET);
+    fseeko(tng_data->input_file, 0, SEEK_SET);
     file_pos = 0;
 
     *n_data_blocks = 0;
@@ -19392,11 +19376,11 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_all_data_block_types_g
         {
 
         }
-        file_pos += (long)(block->block_contents_size + block->header_contents_size);
-        fseek(tng_data->input_file, (long)block->block_contents_size, SEEK_CUR);
+        file_pos += (block->block_contents_size + block->header_contents_size);
+        fseeko(tng_data->input_file, block->block_contents_size, SEEK_CUR);
     }
 
-    fseek(tng_data->input_file, orig_file_pos, SEEK_SET);
+    fseeko(tng_data->input_file, orig_file_pos, SEEK_SET);
 
     return(TNG_SUCCESS);
 }
diff --git a/src/tests/md_openmp.c b/src/tests/md_openmp.c
index aac8b3b..d500167 100644
--- a/src/tests/md_openmp.c
+++ b/src/tests/md_openmp.c
@@ -1,11 +1,11 @@
 #ifdef TNG_BUILD_OPENMP_EXAMPLES
 
+#include "tng/tng_io.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <math.h>
 #include <omp.h>
-#include "tng/tng_io.h"
 
 int main ();
 void compute ( int np, int nd, double pos[], double vel[],
diff --git a/src/tests/md_openmp_util.c b/src/tests/md_openmp_util.c
index 9fe6c91..11a7fa0 100644
--- a/src/tests/md_openmp_util.c
+++ b/src/tests/md_openmp_util.c
@@ -1,11 +1,11 @@
 #ifdef TNG_BUILD_OPENMP_EXAMPLES
 
+#include "tng/tng_io.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <math.h>
 #include <omp.h>
-#include "tng/tng_io.h"
 
 int main ();
 void compute ( int np, int nd, float pos[], float vel[],
diff --git a/src/tests/tng_io_read_pos.c b/src/tests/tng_io_read_pos.c
index b29cec7..8e3d266 100644
--- a/src/tests/tng_io_read_pos.c
+++ b/src/tests/tng_io_read_pos.c
@@ -9,13 +9,14 @@
  * modify it under the terms of the Revised BSD License.
  */
 
+#include "tng/tng_io.h"
+
 #ifdef USE_STD_INTTYPES_H
 #include <inttypes.h>
 #endif
 
 #include <stdlib.h>
 #include <stdio.h>
-#include "tng/tng_io.h"
 
 int main(int argc, char **argv)
 {
diff --git a/src/tests/tng_io_read_pos_util.c b/src/tests/tng_io_read_pos_util.c
index b237dad..699f52d 100644
--- a/src/tests/tng_io_read_pos_util.c
+++ b/src/tests/tng_io_read_pos_util.c
@@ -11,13 +11,14 @@
  * modify it under the terms of the Revised BSD License.
  */
 
+#include "tng/tng_io.h"
+
 #ifdef USE_STD_INTTYPES_H
 #include <inttypes.h>
 #endif
 
 #include <stdlib.h>
 #include <stdio.h>
-#include "tng/tng_io.h"
 
 int main(int argc, char **argv)
 {
diff --git a/src/tests/tng_io_testing.c b/src/tests/tng_io_testing.c
index e1e2726..9f51bb1 100644
--- a/src/tests/tng_io_testing.c
+++ b/src/tests/tng_io_testing.c
@@ -9,13 +9,14 @@
  * modify it under the terms of the Revised BSD License.
  */
 
+#include "tng/tng_io.h"
+
 #ifdef USE_STD_INTTYPES_H
 #include <inttypes.h>
 #endif
 
 #include <stdlib.h>
 #include <string.h>
-#include "tng/tng_io.h"
 #include "tng/version.h"
 
 static tng_function_status tng_test_setup_molecules(tng_trajectory_t traj)
@@ -107,16 +108,16 @@ static tng_function_status tng_test_setup_molecules(tng_trajectory_t traj)
 }
 
 static tng_function_status tng_test_read_and_write_file
-                (tng_trajectory_t traj)
+                (tng_trajectory_t traj, const char hash_mode)
 {
     tng_function_status stat;
 
-    stat = tng_file_headers_read(traj, TNG_USE_HASH);
+    stat = tng_file_headers_read(traj, hash_mode);
     if(stat == TNG_CRITICAL)
     {
         return(stat);
     }
-    stat = tng_file_headers_write(traj, TNG_USE_HASH);
+    stat = tng_file_headers_write(traj, hash_mode);
     if(stat == TNG_CRITICAL)
     {
         return(stat);
@@ -124,22 +125,24 @@ static tng_function_status tng_test_read_and_write_file
 
     while(stat == TNG_SUCCESS)
     {
-        stat = tng_frame_set_read_next(traj, TNG_USE_HASH);
+        stat = tng_frame_set_read_next(traj, hash_mode);
         if(stat != TNG_SUCCESS)
         {
             return(stat);
         }
-        stat = tng_frame_set_write(traj, TNG_USE_HASH);
+        stat = tng_frame_set_write(traj, hash_mode);
     }
 
     return(stat);
 }
 
-static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
+static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj,
+                                                        const char hash_mode)
 {
     int i, j, k, nr, cnt;
     float *data, *molpos, *charges;
     int64_t mapping[300], n_particles, n_frames_per_frame_set, tot_n_mols;
+    int64_t codec_id;
 //     int64_t frame_nr;
     double box_shape[9];
     char atom_type[16], annotation[128];
@@ -223,7 +226,7 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
     }
 
     /* Write file headers (includes non trajectory data blocks */
-    if(tng_file_headers_write(*traj, TNG_SKIP_HASH) == TNG_CRITICAL)
+    if(tng_file_headers_write(*traj, hash_mode) == TNG_CRITICAL)
     {
         printf("Cannot write file headers.\n");
     }
@@ -257,6 +260,14 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
     for(i = 0; i < 200; i++)
     {
         cnt = 0;
+        if(i < 100)
+        {
+            codec_id = TNG_GZIP_COMPRESSION;
+        }
+        else
+        {
+            codec_id = TNG_TNG_COMPRESSION;
+        }
         for(j = 0; j < n_frames_per_frame_set; j++)
         {
             for(k = 0; k < tot_n_mols; k++)
@@ -349,7 +360,7 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
                                        n_frames_per_frame_set, 3,
                                        1, 0, n_particles,
 /*                                        TNG_UNCOMPRESSED, */
-                                       TNG_GZIP_COMPRESSION,
+                                       codec_id,
                                        data) != TNG_SUCCESS)
         {
             printf("Error adding data. %s: %d\n", __FILE__, __LINE__);
@@ -358,7 +369,7 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
             return(TNG_CRITICAL);
         }
         /* Write the frame set */
-        if(tng_frame_set_write(*traj, TNG_SKIP_HASH) != TNG_SUCCESS)
+        if(tng_frame_set_write(*traj, hash_mode) != TNG_SUCCESS)
         {
             printf("Error writing frame set. %s: %d\n", __FILE__, __LINE__);
             free(molpos);
@@ -427,7 +438,7 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
     }
 
     *//* Write the frame set to disk *//*
-    if(tng_frame_set_write(*traj, TNG_SKIP_HASH) != TNG_SUCCESS)
+    if(tng_frame_set_write(*traj, hash_mode) != TNG_SUCCESS)
     {
         printf("Error writing frame set. %s: %d\n", __FILE__, __LINE__);
         free(molpos);
@@ -461,7 +472,7 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
             }
             if(tng_frame_particle_data_write(*traj, frame_nr + i,
                                           TNG_TRAJ_POSITIONS, j * 300, 300,
-                                          data, TNG_SKIP_HASH) != TNG_SUCCESS)
+                                          data, hash_mode) != TNG_SUCCESS)
             {
                 printf("Error adding data. %s: %d\n", __FILE__, __LINE__);
                 free(molpos);
@@ -478,11 +489,11 @@ static tng_function_status tng_test_write_and_read_traj(tng_trajectory_t *traj)
     tng_trajectory_init(traj);
     tng_input_file_set(*traj, TNG_EXAMPLE_FILES_DIR "tng_test.tng");
 
-    stat = tng_file_headers_read(*traj, TNG_SKIP_HASH);
+    stat = tng_file_headers_read(*traj, hash_mode);
 
     while(stat == TNG_SUCCESS)
     {
-        stat = tng_frame_set_read_next(*traj, TNG_SKIP_HASH);
+        stat = tng_frame_set_read_next(*traj, hash_mode);
     }
 
     return(stat);
@@ -522,7 +533,8 @@ tng_function_status tng_test_get_box_data(tng_trajectory_t traj)
 /* This test relies on knowing that the positions are stored as float
  * and that the data is not sparse (i.e. as many frames in the data
  * as in the frame set */
-tng_function_status tng_test_get_positions_data(tng_trajectory_t traj)
+tng_function_status tng_test_get_positions_data(tng_trajectory_t traj,
+                                                const char hash_mode)
 {
     int64_t n_frames, n_particles, n_values_per_frame;
     union data_values ***values = 0;
@@ -560,7 +572,7 @@ tng_function_status tng_test_get_positions_data(tng_trajectory_t traj)
     values = 0;
 
     tng_particle_data_interval_get(traj, TNG_TRAJ_POSITIONS, 11000, 11499,
-                                   TNG_SKIP_HASH, &values, &n_particles,
+                                   hash_mode, &values, &n_particles,
                                    &n_values_per_frame, &type);
 
     /* Here the particle positions can be printed */
@@ -572,7 +584,7 @@ tng_function_status tng_test_get_positions_data(tng_trajectory_t traj)
 }
 
 
-tng_function_status tng_test_append(tng_trajectory_t traj)
+tng_function_status tng_test_append(tng_trajectory_t traj, const char hash_mode)
 {
     tng_function_status stat;
 
@@ -584,7 +596,7 @@ tng_function_status tng_test_append(tng_trajectory_t traj)
 
     tng_last_user_name_set(traj, "User2");
     tng_last_program_name_set(traj, "tng_testing");
-    tng_file_headers_write(traj, TNG_USE_HASH);
+    tng_file_headers_write(traj, hash_mode);
 
     stat = tng_util_trajectory_close(&traj);
 
@@ -597,6 +609,7 @@ int main()
     tng_function_status stat;
     char time_str[TNG_MAX_DATE_STR_LEN];
     char version_str[TNG_MAX_STR_LEN];
+    char hash_mode = TNG_USE_HASH;
 
     tng_version(traj, version_str, TNG_MAX_STR_LEN);
     if(strncmp(TNG_VERSION, version_str, TNG_MAX_STR_LEN) == 0)
@@ -625,7 +638,7 @@ int main()
     tng_output_file_set(traj, TNG_EXAMPLE_FILES_DIR "tng_example_out.tng");
 
 
-    if(tng_test_read_and_write_file(traj) == TNG_CRITICAL)
+    if(tng_test_read_and_write_file(traj, hash_mode) == TNG_CRITICAL)
     {
         printf("Test Read and write file:\t\t\tFailed. %s: %d\n",
                __FILE__, __LINE__);
@@ -659,7 +672,7 @@ int main()
 
     tng_output_file_set(traj, TNG_EXAMPLE_FILES_DIR "tng_test.tng");
 
-    if(tng_test_write_and_read_traj(&traj) == TNG_CRITICAL)
+    if(tng_test_write_and_read_traj(&traj, hash_mode) == TNG_CRITICAL)
     {
         printf("Test Write and read file:\t\t\tFailed. %s: %d\n",
                __FILE__, __LINE__);
@@ -669,7 +682,7 @@ int main()
         printf("Test Write and read file:\t\t\tSucceeded.\n");
     }
 
-    if(tng_test_get_positions_data(traj) != TNG_SUCCESS)
+    if(tng_test_get_positions_data(traj, hash_mode) != TNG_SUCCESS)
     {
         printf("Test Get particle data:\t\t\t\tFailed. %s: %d\n",
                __FILE__, __LINE__);
@@ -716,7 +729,7 @@ int main()
         printf("Test Utility function close:\t\t\tSucceeded.\n");
     }
 
-    if(tng_test_append(traj) != TNG_SUCCESS)
+    if(tng_test_append(traj, hash_mode) != TNG_SUCCESS)
     {
         printf("Test Append:\t\t\t\t\tFailed. %s: %d.\n",
                __FILE__, __LINE__);
diff --git a/src/tests/tng_parallel_read.c b/src/tests/tng_parallel_read.c
index 44e8f79..c2ef2d6 100644
--- a/src/tests/tng_parallel_read.c
+++ b/src/tests/tng_parallel_read.c
@@ -11,9 +11,10 @@
  * modify it under the terms of the Revised BSD License.
  */
 
+#include "tng/tng_io.h"
+
 #include <stdlib.h>
 #include <stdio.h>
-#include "tng/tng_io.h"
 
 
 /* N.B. this code is for testing parallel reading of trajectory frame sets. The