diff --git a/ldump.c b/ldump.c
index 4d29b94..fbadbcc 100644
--- a/ldump.c
+++ b/ldump.c
@@ -29,15 +29,15 @@
 
 
 /*
-** All high-level dumps go through DumpVector; you can change it to
+** All high-level dumps go through dumpVector; you can change it to
 ** change the endianness of the result
 */
-#define DumpVector(v,n,D)	DumpBlock(v,(n)*sizeof((v)[0]),D)
+#define dumpVector(D,v,n)	dumpBlock(D,v,(n)*sizeof((v)[0]))
 
-#define DumpLiteral(s,D)	DumpBlock(s, sizeof(s) - sizeof(char), D)
+#define dumpLiteral(D, s)	dumpBlock(D,s,sizeof(s) - sizeof(char))
 
 
-static void DumpBlock (const void *b, size_t size, DumpState *D) {
+static void dumpBlock (DumpState *D, const void *b, size_t size) {
   if (D->status == 0 && size > 0) {
     lua_unlock(D->L);
     D->status = (*D->writer)(D->L, b, size, D->data);
@@ -46,19 +46,19 @@
 }
 
 
-#define DumpVar(x,D)		DumpVector(&x,1,D)
+#define dumpVar(D,x)		dumpVector(D,&x,1)
 
 
-static void DumpByte (int y, DumpState *D) {
+static void dumpByte (DumpState *D, int y) {
   lu_byte x = (lu_byte)y;
-  DumpVar(x, D);
+  dumpVar(D, x);
 }
 
 
-/* DumpInt Buff Size */
+/* dumpInt Buff Size */
 #define DIBS    ((sizeof(size_t) * 8 / 7) + 1)
 
-static void DumpSize (size_t x, DumpState *D) {
+static void dumpSize (DumpState *D, size_t x) {
   lu_byte buff[DIBS];
   int n = 0;
   do {
@@ -66,63 +66,63 @@
     x >>= 7;
   } while (x != 0);
   buff[DIBS - 1] |= 0x80;  /* mark last byte */
-  DumpVector(buff + DIBS - n, n, D);
+  dumpVector(D, buff + DIBS - n, n);
 }
 
 
-static void DumpInt (int x, DumpState *D) {
-  DumpSize(x, D);
+static void dumpInt (DumpState *D, int x) {
+  dumpSize(D, x);
 }
 
 
-static void DumpNumber (lua_Number x, DumpState *D) {
-  DumpVar(x, D);
+static void dumpNumber (DumpState *D, lua_Number x) {
+  dumpVar(D, x);
 }
 
 
-static void DumpInteger (lua_Integer x, DumpState *D) {
-  DumpVar(x, D);
+static void dumpInteger (DumpState *D, lua_Integer x) {
+  dumpVar(D, x);
 }
 
 
-static void DumpString (const TString *s, DumpState *D) {
+static void dumpString (DumpState *D, const TString *s) {
   if (s == NULL)
-    DumpSize(0, D);
+    dumpSize(D, 0);
   else {
     size_t size = tsslen(s);
     const char *str = getstr(s);
-    DumpSize(size + 1, D);
-    DumpVector(str, size, D);
+    dumpSize(D, size + 1);
+    dumpVector(D, str, size);
   }
 }
 
 
-static void DumpCode (const Proto *f, DumpState *D) {
-  DumpInt(f->sizecode, D);
-  DumpVector(f->code, f->sizecode, D);
+static void dumpCode (DumpState *D, const Proto *f) {
+  dumpInt(D, f->sizecode);
+  dumpVector(D, f->code, f->sizecode);
 }
 
 
-static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
+static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
 
-static void DumpConstants (const Proto *f, DumpState *D) {
+static void dumpConstants (DumpState *D, const Proto *f) {
   int i;
   int n = f->sizek;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++) {
     const TValue *o = &f->k[i];
     int tt = ttypetag(o);
-    DumpByte(tt, D);
+    dumpByte(D, tt);
     switch (tt) {
       case LUA_VNUMFLT:
-        DumpNumber(fltvalue(o), D);
+        dumpNumber(D, fltvalue(o));
         break;
       case LUA_VNUMINT:
-        DumpInteger(ivalue(o), D);
+        dumpInteger(D, ivalue(o));
         break;
       case LUA_VSHRSTR:
       case LUA_VLNGSTR:
-        DumpString(tsvalue(o), D);
+        dumpString(D, tsvalue(o));
         break;
       default:
         lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
@@ -131,79 +131,79 @@
 }
 
 
-static void DumpProtos (const Proto *f, DumpState *D) {
+static void dumpProtos (DumpState *D, const Proto *f) {
   int i;
   int n = f->sizep;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++)
-    DumpFunction(f->p[i], f->source, D);
+    dumpFunction(D, f->p[i], f->source);
 }
 
 
-static void DumpUpvalues (const Proto *f, DumpState *D) {
+static void dumpUpvalues (DumpState *D, const Proto *f) {
   int i, n = f->sizeupvalues;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++) {
-    DumpByte(f->upvalues[i].instack, D);
-    DumpByte(f->upvalues[i].idx, D);
-    DumpByte(f->upvalues[i].kind, D);
+    dumpByte(D, f->upvalues[i].instack);
+    dumpByte(D, f->upvalues[i].idx);
+    dumpByte(D, f->upvalues[i].kind);
   }
 }
 
 
-static void DumpDebug (const Proto *f, DumpState *D) {
+static void dumpDebug (DumpState *D, const Proto *f) {
   int i, n;
   n = (D->strip) ? 0 : f->sizelineinfo;
-  DumpInt(n, D);
-  DumpVector(f->lineinfo, n, D);
+  dumpInt(D, n);
+  dumpVector(D, f->lineinfo, n);
   n = (D->strip) ? 0 : f->sizeabslineinfo;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++) {
-    DumpInt(f->abslineinfo[i].pc, D);
-    DumpInt(f->abslineinfo[i].line, D);
+    dumpInt(D, f->abslineinfo[i].pc);
+    dumpInt(D, f->abslineinfo[i].line);
   }
   n = (D->strip) ? 0 : f->sizelocvars;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++) {
-    DumpString(f->locvars[i].varname, D);
-    DumpInt(f->locvars[i].startpc, D);
-    DumpInt(f->locvars[i].endpc, D);
+    dumpString(D, f->locvars[i].varname);
+    dumpInt(D, f->locvars[i].startpc);
+    dumpInt(D, f->locvars[i].endpc);
   }
   n = (D->strip) ? 0 : f->sizeupvalues;
-  DumpInt(n, D);
+  dumpInt(D, n);
   for (i = 0; i < n; i++)
-    DumpString(f->upvalues[i].name, D);
+    dumpString(D, f->upvalues[i].name);
 }
 
 
-static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
+static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
   if (D->strip || f->source == psource)
-    DumpString(NULL, D);  /* no debug info or same source as its parent */
+    dumpString(D, NULL);  /* no debug info or same source as its parent */
   else
-    DumpString(f->source, D);
-  DumpInt(f->linedefined, D);
-  DumpInt(f->lastlinedefined, D);
-  DumpByte(f->numparams, D);
-  DumpByte(f->is_vararg, D);
-  DumpByte(f->maxstacksize, D);
-  DumpCode(f, D);
-  DumpConstants(f, D);
-  DumpUpvalues(f, D);
-  DumpProtos(f, D);
-  DumpDebug(f, D);
+    dumpString(D, f->source);
+  dumpInt(D, f->linedefined);
+  dumpInt(D, f->lastlinedefined);
+  dumpByte(D, f->numparams);
+  dumpByte(D, f->is_vararg);
+  dumpByte(D, f->maxstacksize);
+  dumpCode(D, f);
+  dumpConstants(D, f);
+  dumpUpvalues(D, f);
+  dumpProtos(D, f);
+  dumpDebug(D, f);
 }
 
 
-static void DumpHeader (DumpState *D) {
-  DumpLiteral(LUA_SIGNATURE, D);
-  DumpInt(LUAC_VERSION, D);
-  DumpByte(LUAC_FORMAT, D);
-  DumpLiteral(LUAC_DATA, D);
-  DumpByte(sizeof(Instruction), D);
-  DumpByte(sizeof(lua_Integer), D);
-  DumpByte(sizeof(lua_Number), D);
-  DumpInteger(LUAC_INT, D);
-  DumpNumber(LUAC_NUM, D);
+static void dumpHeader (DumpState *D) {
+  dumpLiteral(D, LUA_SIGNATURE);
+  dumpInt(D, LUAC_VERSION);
+  dumpByte(D, LUAC_FORMAT);
+  dumpLiteral(D, LUAC_DATA);
+  dumpByte(D, sizeof(Instruction));
+  dumpByte(D, sizeof(lua_Integer));
+  dumpByte(D, sizeof(lua_Number));
+  dumpInteger(D, LUAC_INT);
+  dumpNumber(D, LUAC_NUM);
 }
 
 
@@ -218,9 +218,9 @@
   D.data = data;
   D.strip = strip;
   D.status = 0;
-  DumpHeader(&D);
-  DumpByte(f->sizeupvalues, &D);
-  DumpFunction(f, NULL, &D);
+  dumpHeader(&D);
+  dumpByte(&D, f->sizeupvalues);
+  dumpFunction(&D, f, NULL);
   return D.status;
 }
 
diff --git a/lundump.c b/lundump.c
index 1fa322f..1736499 100644
--- a/lundump.c
+++ b/lundump.c
@@ -44,21 +44,21 @@
 
 
 /*
-** All high-level loads go through LoadVector; you can change it to
+** All high-level loads go through loadVector; you can change it to
 ** adapt to the endianness of the input
 */
-#define LoadVector(S,b,n)	LoadBlock(S,b,(n)*sizeof((b)[0]))
+#define loadVector(S,b,n)	loadBlock(S,b,(n)*sizeof((b)[0]))
 
-static void LoadBlock (LoadState *S, void *b, size_t size) {
+static void loadBlock (LoadState *S, void *b, size_t size) {
   if (luaZ_read(S->Z, b, size) != 0)
     error(S, "truncated chunk");
 }
 
 
-#define LoadVar(S,x)		LoadVector(S,&x,1)
+#define loadVar(S,x)		loadVector(S,&x,1)
 
 
-static lu_byte LoadByte (LoadState *S) {
+static lu_byte loadByte (LoadState *S) {
   int b = zgetc(S->Z);
   if (b == EOZ)
     error(S, "truncated chunk");
@@ -66,12 +66,12 @@
 }
 
 
-static size_t LoadUnsigned (LoadState *S, size_t limit) {
+static size_t loadUnsigned (LoadState *S, size_t limit) {
   size_t x = 0;
   int b;
   limit >>= 7;
   do {
-    b = LoadByte(S);
+    b = loadByte(S);
     if (x >= limit)
       error(S, "integer overflow");
     x = (x << 7) | (b & 0x7f);
@@ -80,45 +80,45 @@
 }
 
 
-static size_t LoadSize (LoadState *S) {
-  return LoadUnsigned(S, ~(size_t)0);
+static size_t loadSize (LoadState *S) {
+  return loadUnsigned(S, ~(size_t)0);
 }
 
 
-static int LoadInt (LoadState *S) {
-  return cast_int(LoadUnsigned(S, INT_MAX));
+static int loadInt (LoadState *S) {
+  return cast_int(loadUnsigned(S, INT_MAX));
 }
 
 
-static lua_Number LoadNumber (LoadState *S) {
+static lua_Number loadNumber (LoadState *S) {
   lua_Number x;
-  LoadVar(S, x);
+  loadVar(S, x);
   return x;
 }
 
 
-static lua_Integer LoadInteger (LoadState *S) {
+static lua_Integer loadInteger (LoadState *S) {
   lua_Integer x;
-  LoadVar(S, x);
+  loadVar(S, x);
   return x;
 }
 
 
 /*
-** Load a nullable string
+** Load a nullable string.
 */
-static TString *LoadStringN (LoadState *S) {
-  size_t size = LoadSize(S);
+static TString *loadStringN (LoadState *S) {
+  size_t size = loadSize(S);
   if (size == 0)
     return NULL;
   else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
     char buff[LUAI_MAXSHORTLEN];
-    LoadVector(S, buff, size);
+    loadVector(S, buff, size);
     return luaS_newlstr(S->L, buff, size);
   }
   else {  /* long string */
     TString *ts = luaS_createlngstrobj(S->L, size);
-    LoadVector(S, getstr(ts), size);  /* load directly in final place */
+    loadVector(S, getstr(ts), size);  /* load directly in final place */
     return ts;
   }
 }
@@ -127,35 +127,35 @@
 /*
 ** Load a non-nullable string.
 */
-static TString *LoadString (LoadState *S) {
-  TString *st = LoadStringN(S);
+static TString *loadString (LoadState *S) {
+  TString *st = loadStringN(S);
   if (st == NULL)
     error(S, "bad format for constant string");
   return st;
 }
 
 
-static void LoadCode (LoadState *S, Proto *f) {
-  int n = LoadInt(S);
+static void loadCode (LoadState *S, Proto *f) {
+  int n = loadInt(S);
   f->code = luaM_newvectorchecked(S->L, n, Instruction);
   f->sizecode = n;
-  LoadVector(S, f->code, n);
+  loadVector(S, f->code, n);
 }
 
 
-static void LoadFunction(LoadState *S, Proto *f, TString *psource);
+static void loadFunction(LoadState *S, Proto *f, TString *psource);
 
 
-static void LoadConstants (LoadState *S, Proto *f) {
+static void loadConstants (LoadState *S, Proto *f) {
   int i;
-  int n = LoadInt(S);
+  int n = loadInt(S);
   f->k = luaM_newvectorchecked(S->L, n, TValue);
   f->sizek = n;
   for (i = 0; i < n; i++)
     setnilvalue(&f->k[i]);
   for (i = 0; i < n; i++) {
     TValue *o = &f->k[i];
-    int t = LoadByte(S);
+    int t = loadByte(S);
     switch (t) {
       case LUA_VNIL:
         setnilvalue(o);
@@ -167,14 +167,14 @@
         setbtvalue(o);
         break;
       case LUA_VNUMFLT:
-        setfltvalue(o, LoadNumber(S));
+        setfltvalue(o, loadNumber(S));
         break;
       case LUA_VNUMINT:
-        setivalue(o, LoadInteger(S));
+        setivalue(o, loadInteger(S));
         break;
       case LUA_VSHRSTR:
       case LUA_VLNGSTR:
-        setsvalue2n(S->L, o, LoadString(S));
+        setsvalue2n(S->L, o, loadString(S));
         break;
       default: lua_assert(0);
     }
@@ -182,91 +182,91 @@
 }
 
 
-static void LoadProtos (LoadState *S, Proto *f) {
+static void loadProtos (LoadState *S, Proto *f) {
   int i;
-  int n = LoadInt(S);
+  int n = loadInt(S);
   f->p = luaM_newvectorchecked(S->L, n, Proto *);
   f->sizep = n;
   for (i = 0; i < n; i++)
     f->p[i] = NULL;
   for (i = 0; i < n; i++) {
     f->p[i] = luaF_newproto(S->L);
-    LoadFunction(S, f->p[i], f->source);
+    loadFunction(S, f->p[i], f->source);
   }
 }
 
 
-static void LoadUpvalues (LoadState *S, Proto *f) {
+static void loadUpvalues (LoadState *S, Proto *f) {
   int i, n;
-  n = LoadInt(S);
+  n = loadInt(S);
   f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
   f->sizeupvalues = n;
   for (i = 0; i < n; i++) {
     f->upvalues[i].name = NULL;
-    f->upvalues[i].instack = LoadByte(S);
-    f->upvalues[i].idx = LoadByte(S);
-    f->upvalues[i].kind = LoadByte(S);
+    f->upvalues[i].instack = loadByte(S);
+    f->upvalues[i].idx = loadByte(S);
+    f->upvalues[i].kind = loadByte(S);
   }
 }
 
 
-static void LoadDebug (LoadState *S, Proto *f) {
+static void loadDebug (LoadState *S, Proto *f) {
   int i, n;
-  n = LoadInt(S);
+  n = loadInt(S);
   f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
   f->sizelineinfo = n;
-  LoadVector(S, f->lineinfo, n);
-  n = LoadInt(S);
+  loadVector(S, f->lineinfo, n);
+  n = loadInt(S);
   f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
   f->sizeabslineinfo = n;
   for (i = 0; i < n; i++) {
-    f->abslineinfo[i].pc = LoadInt(S);
-    f->abslineinfo[i].line = LoadInt(S);
+    f->abslineinfo[i].pc = loadInt(S);
+    f->abslineinfo[i].line = loadInt(S);
   }
-  n = LoadInt(S);
+  n = loadInt(S);
   f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
   f->sizelocvars = n;
   for (i = 0; i < n; i++)
     f->locvars[i].varname = NULL;
   for (i = 0; i < n; i++) {
-    f->locvars[i].varname = LoadStringN(S);
-    f->locvars[i].startpc = LoadInt(S);
-    f->locvars[i].endpc = LoadInt(S);
+    f->locvars[i].varname = loadStringN(S);
+    f->locvars[i].startpc = loadInt(S);
+    f->locvars[i].endpc = loadInt(S);
   }
-  n = LoadInt(S);
+  n = loadInt(S);
   for (i = 0; i < n; i++)
-    f->upvalues[i].name = LoadStringN(S);
+    f->upvalues[i].name = loadStringN(S);
 }
 
 
-static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
-  f->source = LoadStringN(S);
+static void loadFunction (LoadState *S, Proto *f, TString *psource) {
+  f->source = loadStringN(S);
   if (f->source == NULL)  /* no source in dump? */
     f->source = psource;  /* reuse parent's source */
-  f->linedefined = LoadInt(S);
-  f->lastlinedefined = LoadInt(S);
-  f->numparams = LoadByte(S);
-  f->is_vararg = LoadByte(S);
-  f->maxstacksize = LoadByte(S);
-  LoadCode(S, f);
-  LoadConstants(S, f);
-  LoadUpvalues(S, f);
-  LoadProtos(S, f);
-  LoadDebug(S, f);
+  f->linedefined = loadInt(S);
+  f->lastlinedefined = loadInt(S);
+  f->numparams = loadByte(S);
+  f->is_vararg = loadByte(S);
+  f->maxstacksize = loadByte(S);
+  loadCode(S, f);
+  loadConstants(S, f);
+  loadUpvalues(S, f);
+  loadProtos(S, f);
+  loadDebug(S, f);
 }
 
 
 static void checkliteral (LoadState *S, const char *s, const char *msg) {
   char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
   size_t len = strlen(s);
-  LoadVector(S, buff, len);
+  loadVector(S, buff, len);
   if (memcmp(s, buff, len) != 0)
     error(S, msg);
 }
 
 
 static void fchecksize (LoadState *S, size_t size, const char *tname) {
-  if (LoadByte(S) != size)
+  if (loadByte(S) != size)
     error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
 }
 
@@ -276,23 +276,23 @@
 static void checkHeader (LoadState *S) {
   /* skip 1st char (already read and checked) */
   checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
-  if (LoadInt(S) != LUAC_VERSION)
+  if (loadInt(S) != LUAC_VERSION)
     error(S, "version mismatch");
-  if (LoadByte(S) != LUAC_FORMAT)
+  if (loadByte(S) != LUAC_FORMAT)
     error(S, "format mismatch");
   checkliteral(S, LUAC_DATA, "corrupted chunk");
   checksize(S, Instruction);
   checksize(S, lua_Integer);
   checksize(S, lua_Number);
-  if (LoadInteger(S) != LUAC_INT)
+  if (loadInteger(S) != LUAC_INT)
     error(S, "integer format mismatch");
-  if (LoadNumber(S) != LUAC_NUM)
+  if (loadNumber(S) != LUAC_NUM)
     error(S, "float format mismatch");
 }
 
 
 /*
-** load precompiled chunk
+** Load precompiled chunk.
 */
 LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
   LoadState S;
@@ -306,11 +306,11 @@
   S.L = L;
   S.Z = Z;
   checkHeader(&S);
-  cl = luaF_newLclosure(L, LoadByte(&S));
+  cl = luaF_newLclosure(L, loadByte(&S));
   setclLvalue2s(L, L->top, cl);
   luaD_inctop(L);
   cl->p = luaF_newproto(L);
-  LoadFunction(&S, cl->p, NULL);
+  loadFunction(&S, cl->p, NULL);
   lua_assert(cl->nupvalues == cl->p->sizeupvalues);
   luai_verifycode(L, buff, cl->p);
   return cl;