diff --git a/encode.c b/encode.c
index aa5f7f2..08d50f8 100644
--- a/encode.c
+++ b/encode.c
@@ -33,76 +33,75 @@ unsigned char asciitob64[] = {
 
 
 int
-encode(unsigned char *octbuf, int octbufsize, unsigned char *sxtbuf, int urlencoded)
+encode(unsigned char *op, int olen, unsigned char *sp, int url)
 {
+    int tmp;
     unsigned char *table;
-    unsigned char *sxtbegin;
-    unsigned char *octleft;
-    int highorderbits;
+    unsigned char *sbeg;
+    unsigned char *tend;
 
-    table = (!urlencoded) ? b64toascii : b64urltoascii;
+    table = (!url) ? b64toascii : b64urltoascii;
 
-    sxtbegin = sxtbuf;
-    octleft = octbuf + octbufsize - (octbufsize % 3);
-    while (octbuf < octleft) {
-        *sxtbuf++ = table[(*octbuf & ~3) >> 2];
-        highorderbits = (*octbuf++ & 3) << 4;
-        *sxtbuf++ = table[highorderbits + ((*octbuf & ~15) >> 4)];
-        highorderbits = (*octbuf++ & 15) << 2;
-        *sxtbuf++ = table[highorderbits + ((*octbuf & 192) >> 6)];
-        *sxtbuf++ = table[*octbuf++ & ~192];
+    sbeg = sp;
+    tend = op + olen - (olen % 3);
+    while (op < tend) {
+        *sp++ = table[(*op & ~3) >> 2];
+        tmp = (*op++ & 3) << 4;
+        *sp++ = table[tmp + ((*op & ~15) >> 4)];
+        tmp = (*op++ & 15) << 2;
+        *sp++ = table[tmp + ((*op & 192) >> 6)];
+        *sp++ = table[*op++ & ~192];
     }
-    switch (octbufsize % 3) {
+    switch (olen % 3) {
         case 2:
-            *sxtbuf++ = table[(*octbuf & ~3) >> 2];
-            highorderbits = (*octbuf++ & 3) << 4;
-            *sxtbuf++ = table[highorderbits + ((*octbuf & ~15) >> 4)];
-            *sxtbuf++ = table[(*octbuf & 15) << 2];
-            *sxtbuf++ = PADDING;
+            *sp++ = table[(*op & ~3) >> 2];
+            tmp = (*op++ & 3) << 4;
+            *sp++ = table[tmp + ((*op & ~15) >> 4)];
+            *sp++ = table[(*op & 15) << 2];
+            *sp++ = PADDING;
             break;
         case 1:
-            *sxtbuf++ = table[(*octbuf & ~3) >> 2];
-            *sxtbuf++ = table[(*octbuf & 3) << 4];
-            *sxtbuf++ = PADDING;
-            *sxtbuf++ = PADDING;
+            *sp++ = table[(*op & ~3) >> 2];
+            *sp++ = table[(*op & 3) << 4];
+            *sp++ = PADDING;
+            *sp++ = PADDING;
             break;
     }
 
-    return sxtbuf-sxtbegin;
+    return sp-sbeg;
 }
 
 int
-decode(unsigned char *sxtbuf, int sxtbufsize, unsigned char *octbuf)
+decode(unsigned char *sp, int slen, unsigned char *op)
 {
-    unsigned char *octbegin;
-    unsigned char *sxtleft;
-    int highorderbits;
-    int loworderbits;
+    int tmp, b;
+    unsigned char *obeg;
+    unsigned char *qend;
 
-    octbegin = octbuf;
-    sxtleft = sxtbuf + sxtbufsize - (sxtbufsize % 4);
-    while (sxtbuf < sxtleft) {
-        highorderbits = asciitob64[*sxtbuf++] << 2;
-        loworderbits = asciitob64[*sxtbuf++];
-        *octbuf++ = highorderbits + ((loworderbits & ~15) >> 4);
-        highorderbits = (loworderbits & 15) << 4;
-        loworderbits = asciitob64[*sxtbuf++];
-        *octbuf++ = highorderbits + ((loworderbits & ~3) >> 2);
-        *octbuf++ = ((loworderbits & 3) << 6) + asciitob64[*sxtbuf++];
+    obeg = op;
+    qend = sp + slen - (slen % 4);
+    while (sp < qend) {
+        tmp = asciitob64[*sp++] << 2;
+        b = asciitob64[*sp++];
+        *op++ = tmp + ((b & ~15) >> 4);
+        tmp = (b & 15) << 4;
+        b = asciitob64[*sp++];
+        *op++ = tmp + ((b & ~3) >> 2);
+        *op++ = ((b & 3) << 6) + asciitob64[*sp++];
     }
-    switch (sxtbufsize % 4) {
+    switch (slen % 4) {
         case 3:
-            highorderbits = asciitob64[*sxtbuf++] << 2;
-            loworderbits = asciitob64[*sxtbuf++];
-            *octbuf++ = highorderbits + ((loworderbits & ~15) >> 4);
-            highorderbits = (loworderbits & 15) << 4;
-            *octbuf++ = highorderbits + ((asciitob64[*sxtbuf++] & ~3) >> 2);
+            tmp = asciitob64[*sp++] << 2;
+            b = asciitob64[*sp++];
+            *op++ = tmp + ((b & ~15) >> 4);
+            tmp = (b & 15) << 4;
+            *op++ = tmp + ((asciitob64[*sp++] & ~3) >> 2);
             break;
         case 2:
-            highorderbits = asciitob64[*sxtbuf++] << 2;
-            *octbuf++ = highorderbits + ((asciitob64[*sxtbuf++] & ~15) >> 4);
+            tmp = asciitob64[*sp++] << 2;
+            *op++ = tmp + ((asciitob64[*sp++] & ~15) >> 4);
             break;
     }
 
-    return octbuf-octbegin;
+    return op-obeg;
 }
diff --git a/encode.h b/encode.h
index 5c48d1a..7e6f217 100644
--- a/encode.h
+++ b/encode.h
@@ -2,9 +2,9 @@
 #define ENCODE_H
 
 int
-encode(unsigned char *octbuf, int octbufsize, unsigned char *sxtbuf, int urlencoded);
+encode(unsigned char *op, int olen, unsigned char *sp, int url);
 
 int
-decode(unsigned char *sxtbuf, int sxtbufsize, unsigned char *octbuf);
+decode(unsigned char *sp, int slen, unsigned char *op);
 
 #endif
diff --git a/input.c b/input.c
index cb0a890..8e500b3 100644
--- a/input.c
+++ b/input.c
@@ -3,30 +3,27 @@
 #define PADDING  '='
 
 int
-readb(FILE *fptr, unsigned char *buf, int bufsize)
+readb(FILE *fp, unsigned char *s, int slen)
 {
-    int read;
-    int total;
-    unsigned char *begin;
-    unsigned char *end;
-    unsigned char *left;
-    unsigned char *right;
+    int read, tread;
+    unsigned char *send, *sbeg;
+    unsigned char *l, *r;
     
-    read = total = 0;
-    begin = left = buf;
-    while (total < bufsize && (read = fread(left, sizeof(*left), bufsize-total, fptr))) {
-        total += read;
-        end = buf + total;
-        for (right = left; right < end; ++right)
-            if (*right != '\n')
-                *left++ = *right;
-        total -= right - left;
-    }
-    if (left > begin) {
-        for (--left; *left == PADDING; --left)
-            ;
-        ++left;
+    read = tread = 0;
+    sbeg = l = r = s;
+    while (tread < slen && (read = fread(l, sizeof(*l), slen-tread, fp))) {
+        tread += read;
+        send = s + tread;
+        for (r = l; r < send; ++r)
+            if (*r != '\n')
+                *l++ = *r;
+        tread -= r - l;
+        if (l > sbeg) {
+            for (--l; *l == PADDING; --l)
+                ;
+            ++l;
+        }
     }
 
-    return left-begin;
+    return l-sbeg;
 }
diff --git a/input.h b/input.h
index 57bb5de..901b2c4 100644
--- a/input.h
+++ b/input.h
@@ -4,6 +4,6 @@
 #include <stdio.h>
 
 int
-readb(FILE *fptr, unsigned char *buf, int bufsize);
+readb(FILE *fp, unsigned char *s, int slen);
 
 #endif
diff --git a/output.c b/output.c
index f671883..171c083 100644
--- a/output.c
+++ b/output.c
@@ -3,35 +3,35 @@
 #define WRAPCOL 76
 
 char
-printw(FILE *fptr, unsigned char *buf, int bufsize)
+printw(FILE *fp, unsigned char *s, int slen)
 {
-    static int column;
+    static int col;
     int c;
 
     c = '\n';
-    if (column > 0) {
-        if (bufsize >= WRAPCOL-column) {
-            fwrite(buf, sizeof(*buf), WRAPCOL-column, fptr);
-            buf += WRAPCOL-column;
-            bufsize -= WRAPCOL-column;
-            column = 0;
-            fputc('\n', fptr);
+    if (col) {
+        if (slen >= WRAPCOL-col) {
+            fwrite(s, sizeof(*s), WRAPCOL-col, fp);
+            s += WRAPCOL-col;
+            slen -= WRAPCOL-col;
+            col = 0;
+            fputc('\n', fp);
         } else {
-            fwrite(buf, sizeof(*buf), bufsize, fptr);
-            column += bufsize;
-            buf += bufsize;
-            bufsize -= bufsize;
-            c = *(buf+bufsize-1);
+            fwrite(s, sizeof(*s), slen, fp);
+            s += slen;
+            col += slen;
+            slen -= slen;
+            c = *(s+slen-1);
         }
     }
-    for (; bufsize >= WRAPCOL; bufsize -= WRAPCOL, buf += WRAPCOL) {
-        fwrite(buf, sizeof(*buf), WRAPCOL, fptr);
-        fputc('\n', fptr);
+    for (; slen >= WRAPCOL; slen -= WRAPCOL, s += WRAPCOL) {
+        fwrite(s, sizeof(*s), WRAPCOL, fp);
+        fputc('\n', fp);
     }
-    if (bufsize > 0) {
-        fwrite(buf, sizeof(*buf), bufsize, fptr);
-        column += bufsize;
-        c = *(buf+bufsize-1);
+    if (slen > 0) {
+        fwrite(s, sizeof(*s), slen, fp);
+        col += slen;
+        c = *(s+slen-1);
     }
 
     return c;
diff --git a/output.h b/output.h
index 48feaa8..85736f2 100644
--- a/output.h
+++ b/output.h
@@ -4,6 +4,6 @@
 #include <stdio.h>
 
 char
-printw(FILE *fptr, unsigned char *buf, int bufsize);
+printw(FILE *fp, unsigned char *s, int slen);
 
 #endif