diff --git a/doc/KURS/LPC-KURS2/chapter5 b/doc/KURS/LPC-KURS2/chapter5
new file mode 100644
index 0000000..f45b6fa
--- /dev/null
+++ b/doc/KURS/LPC-KURS2/chapter5
@@ -0,0 +1,186 @@
+Intermediate LPC
+Descartes of Borg
+November 1993
+
+                     Chapter 5: Advanced String Handling
+
+5.1 What a String Is
+The LPC Basics textbook taught strings as simple data types.  LPC
+generally deals with strings in such a matter.  The underlying driver
+program, however, is written in C, which has no string data type.  The
+driver in fact sees strings as a complex data type made up of an array of
+characters, a simple C data type.  LPC, on the other hand does not
+recognize a character data type (there may actually be a driver or two out
+there which do recognize the character as a data type, but in general not). 
+The net effect is that there are some array-like things you can do with
+strings that you cannot do with other LPC data types.
+
+The first efun regarding strings you should learn is the strlen() efun. 
+This efun returns the length in characters of an LPC string, and is thus
+the string equivalent to sizeof() for arrays.  Just from the behaviour of
+this efun, you can see that the driver treats a string as if it were made up
+of smaller elements.  In this chapter, you will learn how to deal with
+strings on a more basic level, as characters and sub strings.
+
+5.2 Strings as Character Arrays
+You can do nearly anything with strings that you can do with arrays,
+except assign values on a character basis.  At the most basic, you can
+actually refer to character constants by enclosing them in '' (single
+quotes).  'a' and "a" are therefore very different things in LPC.  'a'
+represents a character which cannot be used in assignment statements or
+any other operations except comparison evaluations.  "a" on the other
+hand is a string made up of a single character.  You can add and subtract
+other strings to it and assign it as a value to a variable.
+
+With string variables, you can access the individual characters to run
+comparisons against character constants using exactly the same syntax
+that is used with arrays.  In other words, the statement:
+    if(str[2] == 'a')
+is a valid LPC statement comparing the second character in the str string
+to the character 'a'.  You have to be very careful that you are not
+comparing elements of arrays to characters, nor are you comparing
+characters of strings to strings.
+
+LPC also allows you to access several characters together using LPC's
+range operator ..:
+    if(str[0..1] == "ab")
+In other words, you can look for the string which is formed by the
+characters 0 through 1 in the string str.  As with arrays, you must be
+careful when using indexing or range operators so that you do not try to
+reference an index number larger than the last index.  Doing so will
+result in an error.
+
+Now you can see a couple of similarities between strings and arrays:
+1) You may index on both to access the values of individual elements.
+	a) The individual elements of strings are characters
+	b) The individual elements of arrays match the data type of the
+array.
+2) You may operate on a range of values
+	a) Ex: "abcdef"[1..3] is the string "bcd"
+	b) Ex: ({ 1, 2, 3, 4, 5 })[1..3] is the int array ({ 2, 3, 4 })
+<* NOTE Highlander@MorgenGrauen
+	Also possible in MorgenGrauen (in common: Amylaar-driver LPMuds):
+	"abcdef"[2..]    -> "cdef" and
+	"abcdef"[1..<2]  -> "bcde"  (< means start counting from the end and with 1)
+*>
+
+And of course, you should always keep in mind the fundamental
+difference: a string is not made up of a more fundamental LPC data type. 
+In other words, you may not act on the individual characters by
+assigning them values.
+
+5.3 The Efun sscanf()
+You cannot do any decent string handling in LPC without using
+sscanf().  Without it, you are left trying to play with the full strings
+passed by command statements to the command functions.  In other
+words, you could not handle a command like: "give sword to leo", since
+you would have no way of separating "sword to leo" into its constituent
+parts.  Commands such as these therefore use this efun in order to use
+commands with multiple arguments or to make commands more
+"English-like".
+
+Most people find the manual entries for sscanf() to be rather difficult
+reading.  The function does not lend itself well to the format used by
+manual entries.  As I said above, the function is used to take a string and
+break it into usable parts.  Technically it is supposed to take a string and
+scan it into one or more variables of varying types.  Take the example
+above:
+
+int give(string str) {
+    string what, whom;
+
+    if(!str) return notify_fail("Give what to whom?\n");
+    if(sscanf(str, "%s to %s", what, whom) != 2) 
+      return notify_fail("Give what to whom?\n");
+    ... rest of give code ...
+}
+
+The efun sscanf() takes three or more arguments.  The first argument is
+the string you want scanned.  The second argument is called a control
+string.  The control string is a model which demonstrates in what form
+the original string is written, and how it should be divided up.  The rest
+of the arguments are variables to which you will assign values based
+upon the control string.
+
+The control string is made up of three different types of elements: 1)
+constants, 2) variable arguments to be scanned, and 3) variable
+arguments to be discarded.  You must have as many of the variable
+arguments in sscanf() as you have elements of type 2 in your control
+string.  In the above example, the control string was "%s to %s", which
+is a three element control string made up of one constant part (" to "),
+and two variable arguments to be scanned ("%s").  There were no
+variables to be discarded.
+
+The control string basically indicates that the function should find the
+string " to " in the string str.  Whatever comes before that constant will
+be placed into the first variable argument as a string.  The same thing
+will happen to whatever comes after the constant.
+
+Variable elements are noted by a "%" sign followed by a code for
+decoding them.  If the variable element is to be discarded, the "%" sign
+is followed by the "*" as well as the code for decoding the variable. 
+Common codes for variable element decoding are "s" for strings and "d"
+for integers.  In addition, your mudlib may support other conversion
+codes, such as "f" for float.  So in the two examples above, the "%s" in
+the control string indicates that whatever lies in the original string in the
+corresponding place will be scanned into a new variable as a string.
+
+A simple exercise.  How would you turn the string "145" into an
+integer?
+
+Answer:
+int x;
+sscanf("145", "%d", x);
+
+After the sscanf() function, x will equal the integer 145.
+
+Whenever you scan a string against a control string, the function
+searches the original string for the first instance of the first constant in
+the original string.  For example, if your string is "magic attack 100" and
+you have the following:
+int improve(string str) {
+    string skill;
+    int x;
+
+    if(sscanf(str, "%s %d", skill, x) != 2) return 0;
+    ...
+}
+you would find that you have come up with the wrong return value for
+sscanf() (more on the return values later).  The control string, "%s %d",
+is made up of to variables to be scanned and one constant.  The constant
+is " ".  So the function searches the original string for the first instance
+of " ", placing whatever comes before the " " into skill, and trying to
+place whatever comes after the " " into x.  This separates "magic attack
+100" into the components "magic" and "attack 100".  The function,
+however, cannot make heads or tales of "attack 100" as an integer, so it
+returns 1, meaning that 1 variable value was successfully scanned
+("magic" into skill).
+
+Perhaps you guessed from the above examples, but the efun sscanf()
+returns an int, which is the number of variables into which values from
+the original string were successfully scanned.  Some examples with
+return values for you to examine:
+
+sscanf("swo  rd descartes", "%s to %s", str1, str2)           return: 0
+sscanf("swo  rd descartes", "%s %s", str1, str2)              return: 2
+sscanf("200 gold to descartes", "%d %s to %s", x, str1, str2) return: 3
+sscanf("200 gold to descartes", "%d %*s to %s", x, str1)      return: 2
+where x is an int and str1 and str2 are string
+
+5.4 Summary
+LPC strings can be thought of as arrays of characters, yet always
+keeping in mind that LPC does not have the character data type (with
+most, but not all drivers).  Since the character is not a true LPC data
+type, you cannot act upon individual characters in an LPC string in the
+same manner you would act upon different data types.  Noticing the
+intimate relationship between strings and arrays nevertheless makes it
+easier to understand such concepts as the range operator and indexing on
+strings.
+
+There are efuns other than sscanf() which involve advanced string
+handling, however, they are not needed nearly as often.  You should
+check on your mud for man or help files on the efuns: explode(),
+implode(), replace_string(), sprintf().  All of these are very valuable
+tools, especially if you intend to do coding at the mudlib level.
+
+Copyright (c) George Reese 1993