diff --git a/items/kraeuter/virtual_compiler.c b/items/kraeuter/virtual_compiler.c
index d48370e..caf2324 100644
--- a/items/kraeuter/virtual_compiler.c
+++ b/items/kraeuter/virtual_compiler.c
@@ -111,7 +111,7 @@
    {
       // Welches Objekt clont das File?
       string cloner = get_cloner();
-      string rooms = arr[1];
+      mapping rooms = arr[1];
       mixed props = arr[0];
       // Wird das Kraut legal von einem eingetragenen Cloner erzeugt? Nur dann
       // bekommt es eine gueltige Plant-ID.
diff --git a/secure/memory.c b/secure/memory.c
index 797ad1c..efc3c1f 100644
--- a/secure/memory.c
+++ b/secure/memory.c
@@ -58,15 +58,17 @@
 /* Function definition */ 
 /*! Objekt initialisieren */
 void create() {
-  mapping info;
   seteuid(getuid(this_object()));
 
   // Wizinfo-Pointer holen
-  if(!pointerp(info=get_extra_wizinfo(0)))
-    raise_error("WIZINFO nicht lesbar. secure/simul_efun muss neu geladen werden.!\n");
+  mixed *info = get_extra_wizinfo(0);
+  if(!pointerp(info))
+    raise_error("WIZINFO nicht lesbar. secure/simul_efun muss neu "
+                "geladen werden.\n");
 
+  mapping memory = info[MEMORY_BUFF];
   // Mein Feld der Wizinfo bei Bedarf initialisieren
-  if(!mappingp(info[MEMORY_BUFF]))
+  if(!mappingp(memory))
     info[MEMORY_BUFF]=([]);
 
   RereadProgramLists(1);
@@ -128,11 +130,11 @@
 
 /*! Zeiger auf den Speicher holen */
 private mapping get_memory_pointer(){
-  mixed info;
+  mixed *info = get_extra_wizinfo(0);
 
   // Die Fehlermeldungen sind etwas ausfuehrlicher, um dem Debugger
   // einen Hinweis auf Reparaturmoeglichkeiten zu geben
-  if(!pointerp(info=get_extra_wizinfo(0)))
+  if(!pointerp(info))
     raise_error("Wizinfo nicht ladbar. Entweder ich hab keine Rechte "
                 "oder das Mud hat ein echtes Problem!\n");
 
@@ -143,7 +145,7 @@
   // Da info[MEMORY_BUFF] immer ein Mapping ist (siehe Create), wird hier ein 
   // Pointer uebergeben. Dadurch werden Details zum Aufbau der extra_wizinfo
   // nur in dieser Funktion benoetigt.
-  return info[MEMORY_BUFF]; 
+  return info[MEMORY_BUFF];
 }
 
 /*!
diff --git a/std/living/description.c b/std/living/description.c
index 04e65e2..4802a1b 100644
--- a/std/living/description.c
+++ b/std/living/description.c
@@ -326,13 +326,15 @@
   return Query(P_REAL_RACE,F_VALUE)||QueryProp(P_RACE);
 }
 
-static mixed _set_name(mixed nm )
+static <string|string*> _set_name(<string|string*> nm )
 {
   string lvnam;
-  lvnam = nm;
-  if(pointerp(nm)) lvnam = nm[0];
+  if (pointerp(nm))
+    lvnam = nm[WER];
+  else
+    lvnam = nm;
   set_living_name(lower_case(lvnam));
-  return Set(P_NAME, nm);
+  return Set(P_NAME, nm, F_VALUE);
 }
 
 int _query_container()
@@ -340,7 +342,7 @@
   return 0;
 }
 
-int is_class_member(mixed str) {
+int is_class_member(<string|string*> str) {
   // Keine Klasse, keine Mitgliedschaft ...
   if (!str || (!stringp(str) && !pointerp(str)) || str=="") 
       return 0;
diff --git a/std/player/base.c b/std/player/base.c
index 61815a2..95d70c0 100644
--- a/std/player/base.c
+++ b/std/player/base.c
@@ -1503,7 +1503,6 @@
   * @see short_score()
   */
 static int score(string arg) {
-  string tmp, gender;
   int i,sz,val;
   mixed ind;
   object *enem1, *enem2, *inv;
@@ -1514,12 +1513,13 @@
   }
 
   int plev = LEPMASTER->QueryLevel();
- 
-  switch(tmp = QueryProp(P_GENDER)) {
+  <string|int> tmp = QueryProp(P_GENDER);
+  string gender;
+  switch(tmp) {
   case MALE: gender = "maennlich"; break;
   case FEMALE: gender = "weiblich"; break;
   case NEUTER: gender = "neutral"; break;
-  default: gender = lower_case(tmp);
+  default: gender = "unbekannt";
   }
 
   ind = m_indices(QueryProp(P_ATTRIBUTES));
diff --git a/std/room/description.c b/std/room/description.c
index 47390e4..9aa0971 100644
--- a/std/room/description.c
+++ b/std/room/description.c
@@ -61,12 +61,10 @@
 
 static void WriteRoomMessage()
 {
-  int tim, msgid;
-  string *room_msg,func;
-  mixed *func_msg;
+  int msgid;
 
-  room_msg = (string *)QueryProp(P_ROOM_MSG);
-  func_msg = QueryProp(P_FUNC_MSG);
+  string *room_msg = QueryProp(P_ROOM_MSG);
+  <string|string*> func_msg = QueryProp(P_FUNC_MSG);
   if ((!room_msg || !sizeof(room_msg)) && !func_msg)
     return;
 
@@ -81,6 +79,7 @@
 
   if (func_msg)
   {
+    string func;
     if (stringp(func_msg))
       func=(string)func_msg;
     else
@@ -90,10 +89,9 @@
   }
 
   while (remove_call_out("WriteRoomMessage")!=-1);
-  tim=QueryProp(P_MSG_PROB);
   if(this_object() && sizeof(filter(
        deep_inventory(this_object()), #'interactive))) //')))
-    call_out("WriteRoomMessage", (tim<15 ? 15 : tim));
+    call_out("WriteRoomMessage", max(15, QueryProp(P_MSG_PROB)));
 }
 
 varargs string int_long(mixed viewer,mixed viewpoint,int flags)
diff --git a/std/unit.c b/std/unit.c
index ae715f2..fd3820a 100644
--- a/std/unit.c
+++ b/std/unit.c
@@ -176,10 +176,9 @@
 
 void AddSingularId(mixed str)
 {
-  string *ids;
+  string **ids=Query(U_IDS);
   if (!pointerp(str))
     str=({str});
-  ids=Query(U_IDS);
   Set(U_IDS,({ids[0]+str,ids[1]}));
 }
 
@@ -193,8 +192,7 @@
  
 void AddPluralId(mixed str)
 {
-  string *ids;
-  
+  string **ids;
   if (!pointerp(str))
     str=({str});
   ids=Query(U_IDS);
@@ -317,7 +315,7 @@
 varargs int id(string str,int lvl)
 {
 
-  string s1,s2,*ids;
+  string s1,s2,**ids;
   int i;
 
   if (!str) return 0;
@@ -333,31 +331,28 @@
     return 1;
   }
 
- ids=Query(U_IDS);
+  ids=Query(U_IDS);
   if (!ids)
     return 0;
- 
-  //die casts auf 'mixed' sind absicht. Sonst geht der Driver offenbar davon
-  //aus, dass ids[1] ein String ist. Es ist aber aber ein Array von Strings
-  //und genau das will auch match_item() haben. ;-) Zesstra
-  if (match_item(str,(mixed)ids[1] )) {
+
+  if (match_item(str, ids[1] )) {
     SetProp(U_REQ, amount);
     return 1;
   }
-  if (match_item(str,(mixed)ids[0] )) {
+  if (match_item(str, ids[0] )) {
     SetProp(U_REQ,1);
     return 1;
   }
   if (sscanf(str,"%s %s",s1,s2) && s1[0..3]=="alle" && 
-    match_item(s2,(mixed)ids[1] )) {
+    match_item(s2, ids[1] )) {
     SetProp(U_REQ, amount);
     return 1;
   }
-  if (sscanf(str,"%d %s",i,s1)==2 && i==1 && match_item(s1,(mixed)ids[0] )) {
+  if (sscanf(str,"%d %s",i,s1)==2 && i==1 && match_item(s1, ids[0] )) {
     SetProp(U_REQ,1);
     return 1;
   }
-  if (sscanf(str,"%d %s",i,s1)==2 && match_item(s1,(mixed)ids[1] ) && 
+  if (sscanf(str,"%d %s",i,s1)==2 && match_item(s1, ids[1] ) && 
       i<=amount && i>0) {
     SetProp(U_REQ,i);
     return 1;
