diff --git a/lauxlib.h b/lauxlib.h
index b34b380..59fef6a 100644
--- a/lauxlib.h
+++ b/lauxlib.h
@@ -16,7 +16,7 @@
 
 
 /* global table */
-#define	LUA_GNAME	"_G"
+#define LUA_GNAME	"_G"
 
 
 typedef struct luaL_Buffer luaL_Buffer;
diff --git a/lgc.c b/lgc.c
index e788843..f26c921 100644
--- a/lgc.c
+++ b/lgc.c
@@ -152,7 +152,7 @@
 ** and its key is not marked, mark its entry as dead. This allows the
 ** collection of the key, but keeps its entry in the table (its removal
 ** could break a chain). The main feature of a dead key is that it must
-** be different from any other value, to do not disturb searches. 
+** be different from any other value, to do not disturb searches.
 ** Other places never manipulate dead keys, because its associated empty
 ** value is enough to signal that the entry is logically empty.
 */
diff --git a/lopcodes.h b/lopcodes.h
index d755870..d3a3f08 100644
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -195,7 +195,7 @@
 
 typedef enum {
 /*----------------------------------------------------------------------
-name		args	description
+  name		args	description
 ------------------------------------------------------------------------*/
 OP_MOVE,/*	A B	R[A] := R[B]					*/
 OP_LOADI,/*	A sBx	R[A] := sBx					*/
diff --git a/lutf8lib.c b/lutf8lib.c
index e63a5a7..3b36a60 100644
--- a/lutf8lib.c
+++ b/lutf8lib.c
@@ -29,7 +29,7 @@
 ** Integer type for decoded UTF-8 values; MAXUTF needs 31 bits.
 */
 #if (UINT_MAX >> 30) >= 1
-typedef	unsigned int utfint;
+typedef unsigned int utfint;
 #else
 typedef unsigned long utfint;
 #endif
diff --git a/manual/manual.of b/manual/manual.of
index 3ba82b0..b237ad4 100644
--- a/manual/manual.of
+++ b/manual/manual.of
@@ -59,8 +59,12 @@
 @C{-------------------------------------------------------------------------}
 @sect1{basic| @title{Basic Concepts}
 
+@simplesect{
+
 This section describes the basic concepts of the language.
 
+}
+
 @sect2{TypesSec| @title{Values and Types}
 
 Lua is a dynamically typed language.
@@ -570,6 +574,8 @@
 
 @sect2{GC| @title{Garbage Collection}
 
+@simplesect{
+
 Lua performs automatic memory management.
 This means that
 you do not have to worry about allocating memory for new objects
@@ -597,6 +603,8 @@
 You can also use these functions to control
 the collector directly (e.g., to stop and restart it).
 
+}
+
 @sect3{incmode| @title{Incremental Garbage Collection}
 
 In incremental mode,
@@ -934,6 +942,8 @@
 @C{-------------------------------------------------------------------------}
 @sect1{language| @title{The Language}
 
+@simplesect{
+
 This section describes the lexis, the syntax, and the semantics of Lua.
 In other words,
 this section describes
@@ -951,6 +961,8 @@
 The complete syntax of Lua can be found in @refsec{BNF}
 at the end of this manual.
 
+}
+
 @sect2{lexical| @title{Lexical Conventions}
 
 Lua is a @x{free-form} language.
@@ -1175,12 +1187,16 @@
 
 @sect2{stats| @title{Statements}
 
+@simplesect{
+
 Lua supports an almost conventional set of @x{statements},
 similar to those in other conventional languages.
 This set includes
 blocks, assignments, control structures, function calls,
 and variable declarations.
 
+}
+
 @sect3{@title{Blocks}
 
 A @x{block} is a list of statements,
@@ -1607,6 +1623,8 @@
 
 @sect2{expressions| @title{Expressions}
 
+@simplesect{
+
 The basic expressions in Lua are the following:
 @Produc{
 @producname{exp}@producbody{prefixexp}
@@ -1681,6 +1699,7 @@
 (The value of @T{(f(x,y,z))} is the first value returned by @id{f}
 or @nil if @id{f} does not return any values.)
 
+}
 
 
 @sect3{arith| @title{Arithmetic Operators}
@@ -2301,6 +2320,8 @@
 @C{-------------------------------------------------------------------------}
 @sect1{API| @title{The Application Program Interface}
 
+@simplesect{
+
 @index{C API}
 This section describes the @N{C API} for Lua, that is,
 the set of @N{C functions} available to the host program to communicate
@@ -2337,9 +2358,13 @@
 which creates a Lua state from scratch and returns a pointer
 to the @emph{main thread} in the new state.
 
+}
+
 
 @sect2{@title{The Stack}
 
+@simplesect{
+
 Lua uses a @emph{virtual stack} to pass values to and from C.
 Each element in this stack represents a Lua value
 (@nil, number, string, etc.).
@@ -2370,6 +2395,7 @@
 (that is, the element at @N{the top})
 and index @M{-n} represents the first element.
 
+}
 
 @sect3{stacksize| @title{Stack Size}
 
@@ -2511,6 +2537,8 @@
 
 @sect2{C-error|@title{Error Handling in C}
 
+@simplesect{
+
 Internally, Lua uses the C @id{longjmp} facility to handle errors.
 (Lua will use exceptions if you compile it as C++;
 search for @id{LUAI_THROW} in the source code for details.)
@@ -2559,6 +2587,8 @@
 To push anything on the stack,
 the panic function must first check the available space @see{stacksize}.
 
+}
+
 
 @sect3{statuscodes|@title{Status Codes}
 
@@ -3621,8 +3651,6 @@
 
 }
 
-}
-
 @APIEntry{
 int lua_pcallk (lua_State *L,
                 int nargs,
@@ -4975,6 +5003,8 @@
 @C{-------------------------------------------------------------------------}
 @sect1{@title{The Auxiliary Library}
 
+@simplesect{
+
 @index{lauxlib.h}
 The @def{auxiliary library} provides several convenient functions
 to interface C with Lua.
@@ -5009,6 +5039,9 @@
 Functions called @id{luaL_check*}
 always raise an error if the check is not satisfied.
 
+}
+
+
 @sect2{@title{Functions and Types}
 
 Here we list all functions and types from the auxiliary library
@@ -5933,6 +5966,8 @@
 @C{-------------------------------------------------------------------------}
 @sect1{libraries| @title{The Standard Libraries}
 
+@simplesect{
+
 The standard Lua libraries provide useful functions
 that are implemented @N{in C} through the @N{C API}.
 Some of these functions provide essential services to the language
@@ -6004,6 +6039,9 @@
 and @defid{luaopen_debug} (for the debug library).
 These functions are declared in @defid{lualib.h}.
 
+}
+
+
 @sect2{predefined| @title{Basic Functions}
 
 The basic library provides core functions to Lua.
@@ -6834,6 +6872,8 @@
 
 @sect2{strlib| @title{String Manipulation}
 
+@simplesect{
+
 This library provides generic functions for string manipulation,
 such as finding and extracting substrings, and pattern matching.
 When indexing a string in Lua, the first character is at @N{position 1}
@@ -7187,9 +7227,13 @@
 
 }
 
+}
+
 
 @sect3{pm| @title{Patterns}
 
+@simplesect{
+
 Patterns in Lua are described by regular strings,
 which are interpreted as patterns by the pattern-matching functions
 @Lid{string.find},
@@ -7199,6 +7243,8 @@
 This section describes the syntax and the meaning
 (that is, what they match) of these strings.
 
+}
+
 @sect4{@title{Character Class:}
 A @def{character class} is used to represent a set of characters.
 The following combinations are allowed in describing a character class:
@@ -8910,6 +8956,8 @@
 
 @sect1{incompat| @title{Incompatibilities with the Previous Version}
 
+@simplesect{
+
 Here we list the incompatibilities that you may find when moving a program
 from @N{Lua 5.3} to @N{Lua 5.4}.
 
@@ -8942,6 +8990,8 @@
 The standard paths in the official distribution may
 change between versions.
 
+}
+
 @sect2{@title{Incompatibilities in the Language}
 @itemize{