diff --git a/dsk2img.c b/dsk2img.c
index cfdd0e1..e77c5ed 100644
--- a/dsk2img.c
+++ b/dsk2img.c
@@ -196,92 +196,92 @@ void dump_dsk_header(struct dskheader* h)
 }
 #endif
 
-void update_checksum(uint32_t* sum, uint8_t* buffer, size_t size)
+void update_checksum(uint32_t* checksum, uint8_t* buffer, size_t size)
 {
     uint16_t* p = (uint16_t*)buffer;
     size_t i;
 
     for (i = 0; i < size / 2; i++)
-        *sum += p[i];
+        *checksum += p[i];
 
     if (size & 1)
-        *sum += buffer[size - 1] << 8;
+        *checksum += buffer[size - 1] << 8;
 }
 
 int copy_image_data(FILE* fin, FILE* fout, size_t size, uint32_t* checksum)
 {
     unsigned long int copied_bytes;
-    size_t rres, wres;
-    uint8_t* buffer = NULL;
+    size_t read_count, write_count;
+    uint8_t* read_buffer = NULL;
 
-    buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
-    if (buffer == NULL) {
+    read_buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
+    if (read_buffer == NULL) {
         perror("malloc()");
         return -1;
     }
     for (copied_bytes = 0; copied_bytes < size;) {
-        rres = fread(buffer, 1, READ_BUFFER_SIZE, fin);
-        if (rres == 0) {
+        read_count = fread(read_buffer, 1, READ_BUFFER_SIZE, fin);
+        if (read_count == 0) {
             perror("fread()");
-            free(buffer);
+            free(read_buffer);
             return -2;
         }
-        update_checksum(checksum, buffer, rres);
-        wres = fwrite(buffer, 1, rres, fout);
-        if (rres != wres) {
+        update_checksum(checksum, read_buffer, read_count);
+        write_count = fwrite(read_buffer, 1, read_count, fout);
+        if (read_count != write_count) {
             perror("fwrite()");
-            free(buffer);
+            free(read_buffer);
             return -3;
         }
-        copied_bytes += rres;
+        copied_bytes += read_count;
     }
 
-    free(buffer);
+    free(read_buffer);
     return 0;
 }
 
 int copy_compressed_image_data(FILE* fin, FILE* fout)
 {
-    size_t rres, wres;
-    uint8_t* buffer = NULL;
+    size_t read_count, write_count;
+    uint8_t* read_buffer = NULL;
 
-    buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
-    if (buffer == NULL) {
+    read_buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
+    if (read_buffer == NULL) {
         perror("malloc()");
         return -1;
     }
 
     for (;;) {
-        rres = fread(buffer, 1, READ_BUFFER_SIZE, fin);
-        if (rres == 0) {
+        read_count = fread(read_buffer, 1, READ_BUFFER_SIZE, fin);
+        if (read_count == 0) {
             perror("fread()");
-            free(buffer);
+            free(read_buffer);
             return -2;
         }
-        wres = fwrite(buffer, 1, rres, fout);
-        if (rres != wres) {
+        write_count = fwrite(read_buffer, 1, read_count, fout);
+        if (read_count != write_count) {
             perror("fwrite()");
-            free(buffer);
+            free(read_buffer);
             return -3;
         }
-        if (rres < READ_BUFFER_SIZE)
+        if (read_count < READ_BUFFER_SIZE)
             break;
     }
 
-    free(buffer);
+    free(read_buffer);
     return 0;
 }
 
 int decompress_image_data(FILE* fin, FILE* fout, size_t size, uint32_t* checksum)
 {
     unsigned long int copied_bytes = 0;
-    size_t to_decompress, space;
-    uint8_t *buffer, *decompress_buffer;
-    uint8_t *pin, *pout;
-    struct lzw_ctx* ctx = NULL;
+    size_t read_count, decompress_count;
+    uint8_t *read_buffer, *decompress_buffer;
+    uint8_t *read_ptr, *decompress_ptr;
+    struct lzw_ctx* lzw = NULL;
 
-    buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
-    if (buffer == NULL) {
+    read_buffer = (uint8_t*)malloc(READ_BUFFER_SIZE);
+    if (read_buffer == NULL) {
         perror("malloc()");
         return -1;
     }
@@ -289,52 +289,52 @@ int decompress_image_data(FILE* fin, FILE* fout, size_t size, uint32_t* checksum
     decompress_buffer = (uint8_t*)malloc(DECOMPRESS_BUFFER_SIZE);
     if (decompress_buffer == NULL) {
         perror("malloc()");
-        free(buffer);
+        free(read_buffer);
         return -2;
     }
 
-    ctx = (struct lzw_ctx*)malloc(sizeof(struct lzw_ctx));
-    if (ctx == NULL) {
+    lzw = (struct lzw_ctx*)malloc(sizeof(struct lzw_ctx));
+    if (lzw == NULL) {
         perror("malloc()");
-        free(buffer);
+        free(read_buffer);
         free(decompress_buffer);
         return -3;
     }
 
-    lzw_init(ctx);
+    lzw_init(lzw);
 
-    to_decompress = 0;
-    space = DECOMPRESS_BUFFER_SIZE;
-    pin = buffer;
-    pout = decompress_buffer;
-    while ((ctx->eos == 0) && (copied_bytes < size)) {
-        if (to_decompress == 0) {
-            to_decompress = fread(buffer, 1, READ_BUFFER_SIZE, fin);
-            pin = buffer;
+    read_count = 0;
+    decompress_count = DECOMPRESS_BUFFER_SIZE;
+    read_ptr = read_buffer;
+    decompress_ptr = decompress_buffer;
+    while ((lzw->eos == 0) && (copied_bytes < size)) {
+        if (read_count == 0) {
+            read_count = fread(read_buffer, 1, READ_BUFFER_SIZE, fin);
+            read_ptr = read_buffer;
         }
-        if (space == 0) {
+        if (decompress_count == 0) {
             update_checksum(checksum, decompress_buffer, DECOMPRESS_BUFFER_SIZE);
             fwrite(decompress_buffer, 1, DECOMPRESS_BUFFER_SIZE, fout);
             copied_bytes += DECOMPRESS_BUFFER_SIZE;
-            space = DECOMPRESS_BUFFER_SIZE;
-            pout = decompress_buffer;
+            decompress_count = DECOMPRESS_BUFFER_SIZE;
+            decompress_ptr = decompress_buffer;
         }
-        lzw_decompress(ctx, pin, &to_decompress, pout, &space);
-        pin = buffer + READ_BUFFER_SIZE - to_decompress;
-        pout = decompress_buffer + DECOMPRESS_BUFFER_SIZE - space;
+        lzw_decompress(lzw, read_ptr, &read_count, decompress_ptr, &decompress_count);
+        read_ptr = read_buffer + READ_BUFFER_SIZE - read_count;
+        decompress_ptr = decompress_buffer + DECOMPRESS_BUFFER_SIZE - decompress_count;
     }
-    if (space < DECOMPRESS_BUFFER_SIZE) {
-        update_checksum(checksum, decompress_buffer, DECOMPRESS_BUFFER_SIZE - space);
-        fwrite(decompress_buffer, 1, DECOMPRESS_BUFFER_SIZE - space, fout);
-        copied_bytes += DECOMPRESS_BUFFER_SIZE - space;
+    if (decompress_count < DECOMPRESS_BUFFER_SIZE) {
+        update_checksum(checksum, decompress_buffer, DECOMPRESS_BUFFER_SIZE - decompress_count);
+        fwrite(decompress_buffer, 1, DECOMPRESS_BUFFER_SIZE - decompress_count, fout);
+        copied_bytes += DECOMPRESS_BUFFER_SIZE - decompress_count;
     }
 
     if (copied_bytes != size)
         printf("WARNING: Decompressed image size (%lu) does not match expected (%lu)", copied_bytes, size);
 
-    free(buffer);
+    free(read_buffer);
     free(decompress_buffer);
-    free(ctx);
+    free(lzw);
 
     return 0;
 }