diff --git a/obj/tools/MGtool/toolcmd.c b/obj/tools/MGtool/toolcmd.c
new file mode 100644
index 0000000..83504b4
--- /dev/null
+++ b/obj/tools/MGtool/toolcmd.c
@@ -0,0 +1,2033 @@
+/*
+ * MGtool-1.0
+ * File: toolcmds.c
+ * Maintainer: Kirk@MorgenGrauen
+ */
+
+/*------------------------------------------*/
+/* the original Xtool is copyrighted by Hyp */
+/*------------------------------------------*/
+
+#include "tool.h"
+
+/*----------------------------------------------------------------------
+ * command functions
+ */
+
+int Xcall(string str)
+{
+  object obj, callobj;
+  string file, callstr, callfun, callexpr, error, errlog;
+  int *ru1, *ru2, xtime;
+  mixed res;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xcall <object>-><function>(<arguments>)");
+  TK("Xcall: str: "+(str?str:"(NULL)"));
+  if(sscanf(str, "%s->%s(%s", callstr, callfun, callexpr)!=3)
+    return FALSE;
+  if(!(callobj=XFindObj(callstr)))
+    return TRUE;
+  else
+  {
+#if 0
+    write_file(TOOL_LOG,
+	       sprintf("%s (%s) xcall %s (env: %s)\n",ctime(time()),
+		       getuid(cloner),str,object_name(environment(cloner))));
+#endif
+    file=LPC_FILE+".c";
+    if(file_size(file)>0)
+      rm(file);
+    if(obj=find_object(LPC_FILE))
+      Destruct(obj);
+    obj=0;
+    write_file(file,
+	       "#include <properties.h>\n"+
+	       "#include <thing/properties.h>\n"+
+	       "#include <defines.h>\n"+
+	       "#include <wizlist.h>\n"+
+	       "#include <moving.h>\n"+
+	       "#include \"/secure/wizlevels.h\"\n"+
+	       (file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+
+	       "mixed get(string str){return previous_object()->XFindObj(str);}\n"+
+	       "mixed eval(object obj,mixed me,mixed here){return obj->"+callfun+"("+callexpr+";}\n");
+    errlog = ERR_FILE;
+    if(file_size(errlog)>0)
+      rm(errlog);
+    if(error=catch((LPC_FILE)->__nixgibts__()))
+      W("Error: "+error[1..]);
+    else
+    {
+      obj=find_object(LPC_FILE);
+      ru1=rusage();
+      error=catch(res=(mixed)obj->eval(callobj, cloner, ENV(cloner)));
+      ru2=rusage();
+      if(error)
+	W("Error: "+error[1..]);
+      else
+      {
+	xtime=ru2[0]-ru1[0]+ru2[1]-ru1[1];
+	WDLN("Evaluation time: "+(xtime<0 ? 0 : xtime)+" ms");
+	PIPE_DELETE(pipe_of);
+	if(pipe_out&&pipe_of)
+	  write_file(pipe_of,mixed_to_string(res, MAX_RECURSION)+"\n");
+	else
+	WLN("Result: "+mixed_to_string(res, MAX_RECURSION));
+	if(objectp(res))
+    m_add(variable, "result", res);
+      }
+    }
+    rm(file);
+  }
+  if(obj) Destruct(obj);
+  return TRUE;
+}
+
+int Xcallouts(string str)
+{
+  object obj;
+  mixed callouts, args;
+  string fun, tmp, file;
+  int delay, i, s;
+  
+  SECURE2(TRUE);
+  TK("Xcallouts: str: "+(str?str:"(NULL)"));
+  if(!pipe_out)
+  {
+    USAGE1(str, "xcallo(uts) [search pattern]");
+    file=TMP_FILE;
+    if(file_size(file)>0)
+      rm(file);
+    if(!str)
+      str="^\\[~/";
+    else if(!regexp(({"dummy"}), str))
+    {
+      WDLN("Bad regular expression");
+      return TRUE;
+    } 
+  }
+  else
+  {
+    USAGE1(str, "xcallo(uts)");
+    if(str&&str!="")
+    {
+      WDLN("More arguments than expected");
+      return TRUE;
+    }
+  }
+  callouts=call_out_info();
+  s=sizeof(callouts);
+  PIPE_DELETE(pipe_of);
+  for(i=0; i<s; i++)
+  {
+    if(callouts[i]&&pointerp(callouts[i]))
+    {
+      tmp=sprintf("%O %Os %O (%s)",callouts[i][0],callouts[i][2],
+		  callouts[i][1],(sizeof(callouts[i])>3?
+				  mixed_to_string(callouts[i][3],
+						  MAX_RECURSION):"0"));
+      if(pipe_out&&pipe_of)
+	write_file(pipe_of,tmp+"\n");
+      else
+	if(sizeof(regexp(({tmp}), str)))
+	  WLN(tmp);
+    }
+  }
+  return TRUE;
+}
+
+int Xcat(string str)
+{
+  string *tmp,file;
+  int s;
+
+  SECURE2(TRUE);
+  TK("Xcat: str: "+str);
+  if(!pipe_in)
+  {
+    USAGE2(str, "xcat <file>");
+    if(!(file=XFindFile(str)))
+    {
+      WDLN("Can't find file");
+      return TRUE;
+    }
+  }
+  else
+  {
+    if(str&&str!="-")
+      USAGE3("xcat -");
+
+    if (file_size(file=pipe_if)<0)
+    {
+      WDLN("Missing input to xcat");
+      return TRUE;
+    }
+  }
+  tmp=old_explode(read_file(file,0,PIPE_MAX),"\n");
+  if(pipe_in&&pipe_if==PIPE_FILE)
+    rm(PIPE_FILE);
+  if (pipe_out&&pipe_of)
+    write_file(pipe_of,implode(tmp,"\n")+"\n");
+  else
+    WLN(implode(tmp,"\n"));
+  return TRUE;
+}
+
+int Xcd(string str)
+{
+  object dest;
+  string path;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xcd [object]");
+  TK("Xcd: str: "+(str?str:"(NULL)"));
+  if(!str)
+  {
+    if(!(path=(string)cloner->QueryProp("start_home")))
+      path="/";
+  }
+  else if((dest=XFindObj(str,1)))
+    path="/"+implode(old_explode(object_name(dest),"/")[0..<2],"/");
+  else
+    path="";
+
+  TK("Xcd: path: "+(path?path:"(NULL)"));
+  if(!sizeof(path))
+    path=str;
+  PL->_cd(path);
+
+  return TRUE;
+}
+
+int Xclean(string str)
+{
+  object env;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xcle(an) [object]");
+  TK("Xclean: str: "+(str?str:"(NULL)"));
+  if(!str)
+    env=ENV(cloner);
+  if(env||(env=XFindObj(str)))
+  {
+    PrintShort("Cleaning: ", env);
+    filter(filter(all_inventory(env), #'is_not_player),//'
+		 "Destruct", ME);
+  }
+  return TRUE;
+}
+
+int Xclone(string str)
+{
+  object obj;
+  string file, errlog, error;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xclo(ne) <filename>");
+  if(!(file=XFindFile(str))) return TRUE;
+  errlog=ERR_FILE;
+  if(file_size(errlog)>0) rm(errlog);
+  WLN("Clone: "+short_path(file));
+  if(!(error=catch(obj=clone_object(file))))
+  { 
+    m_add(variable, "clone", obj);
+    if(!MoveObj(obj, ENV(cloner), TRUE))
+      WDLN("Cannot move object into this room");
+    else if(!obj->QueryNoGet())
+    {
+      if(!MoveObj(obj, cloner, TRUE))
+	WDLN("Cannot move object into your inventory");
+    }
+  }
+  else
+    W("Error: "+error[1..]);
+  return TRUE;
+}
+
+int Xuclone(string str)
+{
+  object obj;
+  string file, errlog, error;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xuclo(ne) <filename>");
+  if(!(file=XFindFile(str))) return TRUE;
+  errlog=ERR_FILE;
+  if(file_size(errlog)>0) rm(errlog);
+  if(obj=find_object(file)) {
+    Destruct(obj);
+    WLN("Update and clone: "+short_path(file));
+  }
+  else
+    WLN("Clone: "+short_path(file));
+  if(!(error=catch(obj=clone_object(file))))
+  {
+    variable["clone"] = obj;
+    if(!MoveObj(obj, ENV(cloner), TRUE))
+      WDLN("Cannot move object into this room");
+    else if(!obj->QueryNoGet())
+    {
+      if(!MoveObj(obj, cloner, TRUE))
+	WDLN("Cannot move object into your inventory");
+    }
+  }
+  else
+    W("Error: "+error[1..]);
+  return TRUE;
+}
+
+int Xcmds(string str)
+{
+  object obj;
+  mixed *cmds;
+  int i, s;
+
+  SECURE2(TRUE);
+  USAGE1(str, "xcm(ds) [object]");
+  TK("Xcmds: str: "+(str?str:"(NULL)"));
+  if(!str)
+    obj=ENV(cloner);
+  else if(!(obj=XFindObj(str)))
+  {
+    WDLN("Can't find object");
+    return TRUE;
+  }
+  s=sizeof(cmds=query_actions(cloner,1|2|4|8|16));
+  PIPE_DELETE(pipe_of);
+  for(i=0; i<s; i+=5)
+    if(cmds[i+3]==obj)
+      if(pipe_out&&pipe_of)
+	write_file(pipe_of,ALEFT(cmds[i]+" ", 15, ".")+
+		   (cmds[i+2] ? " * " : " . ")+cmds[i+4]+"()\n");
+      else
+	WLN(ALEFT(cmds[i]+" ", 15, ".")+
+	    (cmds[i+2] ? " * " : " . ")+cmds[i+4]+"()");
+  return TRUE;
+}
+  
+int Xdbg(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xdb(g) <object>");
+  TK("Xdbg: str: "+(str?str:"(NULL)"));
+  if((obj=XFindObj(str)))
+  {
+    debug_info(1, obj);
+    debug_info(0, obj);
+  }
+  return TRUE;
+}
+
+int Xdclean(string str)
+{
+  object env;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xdc(lean) [object]");
+  TK("Xdclean: str: "+(str?str:"(NULL)"));
+  if(!str)
+    env=ENV(cloner);
+  if(env||(env=XFindObj(str)))
+  {
+    PrintShort("Deep cleaning: ", env);
+    filter(filter(all_inventory(env), #'is_not_player, ME),//'
+		 "DeepClean", ME);
+  }
+  return TRUE;
+}
+
+int Xddes(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xdd(es) <object>");
+  TK("Xddes: str: "+(str?str:"(NULL)"));
+  if((obj=XFindObj(str)))
+  {
+    PrintShort("Deep destruct: ", obj);
+    filter(deep_inventory(obj), "Destruct", ME);
+    Destruct(obj);
+  }
+  return TRUE;
+}
+
+int Xdes(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xde(s) <object>");
+  TK("Xdes: str: "+(str?str:"(NULL)"));
+  if((obj=XFindObj(str)))
+  {
+    PrintShort("Destruct: ",obj);
+    Destruct(obj);
+  }
+  return TRUE;
+}
+
+int Xdlook(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xdl(ook) [object]");
+  TK("Xdlook: str: "+(str?str:"(NULL)"));
+  if(!str)
+    obj=cloner;
+  if(obj||(obj=XFindObj(str)))
+  {
+    PIPE_DELETE(pipe_of);
+    DeepPrintShort(obj,NULL,NULL,(pipe_out&&pipe_of)?pipe_of:"");
+  }
+  return TRUE;
+}
+
+int Xdo(string str)
+{
+  int i, n, s;
+  string *strs, cmd;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xdo [<number1>#]<command1>[;[<number2>#]<command2>] ...");
+  if(!str||str==""||!(s=sizeof(strs=strip_explode(str, ";"))))
+    return FALSE;
+  for(i=0; i<s; i++)
+  {
+    if(strs[i])
+    {
+      switch(sscanf(strs[i], "%d#%s", n, cmd))
+      {
+	case 0:
+	if(!Command(strs[i])) return TRUE;
+	break;
+	case 1:
+	if(cmd&&(!Command(cmd))) return TRUE;
+	break;
+	case 2:
+	n= n<1 ? 1 : n;
+	if(cmd)
+	{
+	  while(n--)
+	    if(!Command(cmd)) return TRUE;
+	}
+	break;
+      }
+    }
+  }
+  return TRUE;
+}
+
+int Xdupdate(string str)
+{
+  int i, s;
+  object obj;
+  string file, *list;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xdu(pdate) <filename>");
+  if(!(file=XFindFile(str)))
+    return TRUE;
+  if(file[<2..<1]==".c")
+    file=file[0..<3];
+  if(obj=XFindObj(file))
+  {
+    PrintShort("Deep updating: ", obj);
+    list=inherit_list(obj);
+    for(s=sizeof(list); i<s; i++)
+    {
+      if(obj=find_object(list[i]))
+	Destruct(obj);
+    }
+  }
+  return TRUE;
+}
+
+int Xecho(string str)
+{
+  TK("Xecho: str: "+(str?str:"(NULL)"));
+  WLN(str);
+  return TRUE;
+}
+
+int Xeval(string str)
+{
+  object obj;
+  string file, error;
+  int *ru1, *ru2, xtime;
+  mixed res;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xev(al) <expression>");
+  file=LPC_FILE+".c";
+  if(file_size(file)>0)
+    rm(file);
+  if(obj=find_object(LPC_FILE))
+    Destruct(obj);
+#if 0
+  write_file(TOOL_LOG,
+	     sprintf("%s (%s) xeval %s\n",
+		     ctime(time()),getuid(cloner),str));
+#endif
+  write_file(file,
+	     "#include <properties.h>\n"+
+	     "#include <thing/properties.h>\n"+
+	     "#include <defines.h>\n"+
+             "#include <wizlist.h>\n"+
+	     "#include <moving.h>\n"+
+	     "#include \"/secure/wizlevels.h\"\n"+
+	     (file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+
+	     "get(str){return previous_object()->XFindObj(str);}\n"+
+	     "eval(me,here){return "+str+";}");
+  if(error=catch(obj=clone_object(file)))
+    W("Error: "+error[1..]);
+  else
+  {
+    ru1=rusage();
+    error=catch(res=(mixed)obj->eval(cloner, ENV(cloner)));
+    ru2=rusage();
+    if(error)
+      W("Error: "+error[1..]);
+    else
+    {
+      xtime=ru2[0]-ru1[0]+ru2[1]-ru1[1];
+      WDLN("Evaluation time: "+(xtime<0 ? 0 : xtime)+" ms");
+      PIPE_DELETE(pipe_of);
+      if(pipe_out&&pipe_of)
+        write_file(pipe_of,mixed_to_string(res,MAX_RECURSION)+"\n");
+      else
+        WLN("Result: "+mixed_to_string(res, MAX_RECURSION));
+      if(objectp(res))
+        variable["result"] = res;
+    }
+  }
+  rm(file);
+  if(obj)
+    Destruct(obj);
+  return TRUE;
+}
+
+int Xforall(string str)
+{
+  int i, s, t, u;
+  string pat, cmd, arg, *strs, *files, fh, fr, fe, ft, ff;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xfo(rall) <filepattern> <command>");
+  if(sscanf(str, "%s %s", pat, arg)!=2)
+    return FALSE;
+  files=long_get_dir(pat, FALSE);
+  if(!(s=sizeof(files)))
+  {
+    WDLN("No matching files found");
+    return TRUE;
+  }
+  strs=old_explode(files[0], "/");
+  fh="/";
+  if(t=sizeof(strs)-1)
+    fh+=implode(strs[0..t-1], "/");
+  for(i=0; i<s; i++)
+  {
+    ft=old_explode(files[i], "/")[t];
+    if((u=sizeof(strs=old_explode(ft, ".")))&&--u)
+    {
+      ff=implode(strs[0..u-1], ".");
+      fr=fh+"/"+ff;
+      fe=strs[u];
+    }
+    else
+    {
+      fe="";
+      ff=ft;
+      fr=files[i];
+    }
+    cmd=string_replace(arg, "!!", files[i]);
+    cmd=string_replace(cmd, "!e", fe);
+    cmd=string_replace(cmd, "!f", ff);
+    cmd=string_replace(cmd, "!h", fh);
+    cmd=string_replace(cmd, "!r", fr);
+    cmd=string_replace(cmd, "!t", ft);
+    if(!(Command(cmd)))
+      break;
+  }
+  return TRUE;
+}
+
+int Xgoto(string str)
+{
+  object obj, tmp;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xgo(to) [object]");
+  if(!str) str="~/workroom";
+  if(!(obj=XFindObj(str)))
+  {
+    if(!(str=XFindFile(str)))
+      return TRUE;
+    if(catch(call_other(str, "???")))
+      return TRUE;
+    obj=find_object(str);
+  }
+  tmp=obj;
+  while(obj&&living(obj))
+    obj=ENV(obj);
+  cloner->move(obj ? obj : tmp, M_TPORT);
+  return TRUE;
+}
+
+int Xgrep(string str)
+{
+  int i, s, t, mode;
+  string *files, *ts;
+  
+  SECURE2(TRUE);
+  TK("Xgrep: str: "+(str?str:"(NULL)"));
+  mode=0;
+  if(!pipe_in)
+  {
+    USAGE2(str, "xgr(ep) [-i] [-v] <regexp> <filepattern>");
+    if(!(ts=old_explode(str, " "))||!(s=sizeof(ts)))
+      return FALSE;
+    while(ts[0][0]=='-')
+    {
+      if(s<3)
+      {
+	WDLN("Too few arguments to xgrep");
+	return FALSE;
+      }
+      switch(ts[0])
+      {
+	case "-v":
+	  mode|=XGREP_REVERT;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	case "-i":
+	  mode|=XGREP_ICASE;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	case "-vi":
+	case "-iv":
+	  mode|=XGREP_REVERT;
+	  mode|=XGREP_ICASE;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	default:
+	  WDLN("Unknown option "+ts[0]+" given to xgrep");
+	  return FALSE;
+      }
+    }
+    str=implode(ts[0..s-2], " ");
+  }
+  else
+  {
+    if(!((ts=old_explode(str, " "))&&(s=sizeof(ts))))
+      USAGE3("xgr(ep) [-i] [-v] <regexp>");
+    while(ts[0][0]=='-')
+    {
+      if(s<2)
+      {
+	WDLN("Too few arguments to xgrep");
+	return FALSE;
+      }
+      switch(ts[0])
+      {
+	case "-v":
+	  mode|=XGREP_REVERT;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	case "-i":
+	  mode|=XGREP_ICASE;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	case "-iv":
+	case "-vi":
+	  mode|=XGREP_REVERT;
+	  mode|=XGREP_ICASE;
+	  ts=ts[1..];
+	  s--;
+	  break;
+	default:
+	  WDLN("Unknown option "+ts[0]+" given to xgrep");
+	  return FALSE;
+      }
+    }
+    str=implode(ts[0..s-1], " ");
+  }
+  
+  if(mode&XGREP_ICASE)
+    str=lower_case(str);
+  if(!(regexp(({"dummy"}), str)))
+  {
+    WDLN("Bad regular expression");
+    return TRUE;
+  }
+  if(!pipe_in)
+  {
+    if(file_size(TMP_FILE)>0)
+      rm(TMP_FILE);
+    if((t=sizeof(files=long_get_dir(XFile(ts[s-1]), FALSE)))&&
+       (file_size(files[0])>=0))
+    {
+      for(i=0; i<t; i++)
+	XGrepFile(str, files[i], mode);
+      if(pipe_out&&pipe_of)
+      {
+	PIPE_DELETE(pipe_of);
+	if(!pipe_ovr)
+	{
+	  write_file(pipe_of,read_file(TMP_FILE,0,PIPE_MAX));
+	  rm(TMP_FILE);
+	}
+	else
+	  rename(TMP_FILE,pipe_of);
+      }
+      else
+      {
+	W(read_file(TMP_FILE,0,PIPE_MAX));
+	rm(TMP_FILE);
+      }
+    }
+    else
+      WDLN("Cannot read file(s)");
+  }
+  else
+  {
+    string *tmp;
+    if(file_size(pipe_if)<0)
+    {
+      WDLN("Missing input to xgrep");
+      return TRUE;
+    }
+    TK("Xgrep: str: "+str+" mode: "+mode);
+    s=sizeof(tmp=old_explode(read_file(pipe_if,0,PIPE_MAX),"\n"));
+    PIPE_DELETE(pipe_of);
+    for(i=0;i<s;i++)
+    {
+      // TK(tmp[i]+"<->"+str);
+      if(sizeof(regexp(({(mode&XGREP_ICASE?lower_case(tmp[i]):tmp[i])}),str)))
+      {
+	// TK("Xgrep: matched!");
+	if(!(mode&XGREP_REVERT))
+	  if(pipe_out&&pipe_of)
+	    write_file(pipe_of,tmp[i]+"\n");
+	  else
+	    WLN(tmp[i]);
+      }
+      else
+	if(mode&XGREP_REVERT)
+	  if(pipe_out&&pipe_of)
+	    write_file(pipe_of,tmp[i]+"\n");
+	  else
+	    WLN(tmp[i]);
+    }
+  }
+  return TRUE;
+}
+
+int Xhbeats(string str)
+{
+  object obj;
+  object *hbeatinfo;
+  string tmp, file;
+  int i, s;
+  
+  SECURE2(TRUE);
+  TK("Xhbeats: str: "+(str?str:"(NULL)"));
+  if(!pipe_out)
+  {
+    USAGE1(str, "xhb(eats) [search pattern]");
+    if(!str)
+      str=RNAME(cloner);
+    else if(!regexp(({"dummy"}), str))
+    {
+      WDLN("Bad regular expression");
+      return TRUE;
+    }
+  }
+  else
+  {
+    USAGE1(str,"xhb(eats)");
+    if(str&&str!="")
+    {
+      WDLN("More arguments than expected");
+      return TRUE;
+    }
+  }
+  s=sizeof(hbeatinfo=heart_beat_info());
+  PIPE_DELETE(pipe_of);
+  for(i=0; i<s; i++)
+    if(hbeatinfo[i]&&objectp(hbeatinfo[i]))
+    {
+      tmp=ObjFile(hbeatinfo[i]);
+      if(sizeof(regexp(({tmp}), str)))
+	if(pipe_out&&pipe_of)
+	  write_file(pipe_of, tmp+"\n");
+	else
+	  WLN(tmp);
+    }
+  return TRUE;
+}
+
+int Xhead(string str)
+{
+  int lines;
+  string *tmp, file;
+
+  SECURE2(TRUE);
+  TK("Xhead: str: "+(str?str:"(NULL)"));
+  if(!pipe_in)
+  {
+    USAGE2(str, "xhead <-#> <file>");
+    if(sscanf(str,"-%d %s",lines,file)!=2)
+	return FALSE;
+    if(!(file=XFindFile(file)))
+      return FALSE;
+  }
+  else
+  {
+    USAGE2(str, "xhead <-#>");
+    if(sscanf(str,"-%d",lines)!=1)
+      return FALSE;
+    if (file_size(file=pipe_if)<0)
+    {
+      WDLN("Missing input to xhead");
+      return TRUE;
+    }
+  }
+  tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[0..lines-1];
+  if(pipe_in&&pipe_if==PIPE_FILE)
+    rm(PIPE_FILE);
+  if (pipe_out&&pipe_of)
+  {
+    PIPE_DELETE(pipe_of);
+    write_file(pipe_of,implode(tmp,"\n")+"\n");
+  }
+  else
+    WDLN(implode(tmp,"\n"));
+  return TRUE;
+}
+
+int Xhelp(string str)
+{
+  SECURE2(TRUE);
+  USAGE1(str, "xhe(lp)");
+  XMoreFile(TOOL_MANPAGE, FALSE);
+  return TRUE;
+}
+
+int Xids(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xid(s) <object>");
+  TK("Xids: str: "+(str?str:"(NULL)"));
+  if((obj=XFindObj(str)))
+    WLN("UID=\""+getuid(obj)+"\" / EUID=\""+geteuid(obj)+"\"");
+  return TRUE;
+}
+
+int Xinfo(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xinf(o) <object>");
+  TK("Xinfo: str: "+(str?str:"(NULL)"));
+  if((obj=XFindObj(str)))
+  {
+    if(is_player(obj))
+    {
+      WLN(PlayerWho(obj));
+      WLN(PlayerMail(obj, FALSE));
+      WLN(PlayerIP(obj, FALSE));
+      WLN(PlayerRace(obj, FALSE));
+      WLN(PlayerDomain(obj, FALSE));
+      WLN(PlayerStats(obj, FALSE));
+      WLN(PlayerSnoop(obj, FALSE));
+    }
+    else
+      WDLN("Sorry, this is not a player");
+  }
+  return TRUE;
+}
+
+int Xinherit(string str)
+{
+  int s;
+  object obj;
+  string *strs, *inlist;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xinh(erit) <object> [function]");
+  TK("Xinherit: str: "+str);
+  if(!(strs=strip_explode(str, " ")))
+    return FALSE;
+  if(obj=XFindObj(strs[0]))
+  {
+    inlist=inherit_list(obj);
+    s=sizeof(inlist);
+    while(s--)
+    {
+      if(catch(call_other(inlist[s], "???")))
+      {
+	WDLN("Failed to load all inheritance objects");
+	return TRUE;
+      }
+    }
+    obj=find_object(inlist[0]);
+    PIPE_DELETE(pipe_of);
+    if(sizeof(strs)==1)
+      Inheritance(obj ,0 ,"");
+    else
+      Inheritance(obj, strs[1], "");
+  }
+  return TRUE;
+}
+
+int Xinventory(string str)
+{
+  int i, short;
+  object item;
+  mixed who;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xi [-s] [player]");
+  TK("Xinventory: str: "+str);
+  short=0;
+  who=cloner;
+  if(str&&str!="")
+  {
+    if(str=="-s")
+    {
+      short=1;
+      who=cloner;
+    }
+    else if(sscanf(str,"-s %s",who))
+    {
+      short=1;
+      who=XFindObj(who);
+    }
+    else if(sscanf(str,"%s",who))
+    {
+      short=0;
+      who=XFindObj(who);
+    }
+    else
+      who=cloner;
+  }
+  if(!who)
+    return FALSE;
+  PIPE_DELETE(pipe_of);
+  if(!(pipe_out&&pipe_of))
+    WLN(who->name(WESSEN)+" Inventory:"+(short?" (short)":""));
+  if(!short)
+    if(pipe_out&&pipe_of)
+      FORALL(item, who) PrintShort(ARIGHT(++i+". ", 4, " "), item, pipe_of);
+    else
+      FORALL(item, who) PrintShort(ARIGHT(++i+". ", 4, " "), item);
+  else
+    if(pipe_out&&pipe_of)
+      FORALL(item, who) write_file(pipe_of,++i+". ["+object_name(item)+"]\n");
+    else
+      FORALL(item, who) WLN(++i+". ["+object_name(item)+"]");
+  return TRUE;
+}
+
+int Xlag(string str)
+{
+  int i;
+  float *lag;
+  object daemon;
+  string lags;
+
+  if(file_size(LAG_O_DAEMON+".c")<=0)
+  {
+    WLN("Sorry, lag-o-daemon is missing!");
+    return TRUE;
+  }
+  
+  LAG_O_DAEMON->MachHin();
+  if(!(daemon=find_object(LAG_O_DAEMON)))
+    lag=({-1.0,-1.0,-1.0});
+  else
+    lag=(float *)daemon->read_lag_data();
+  lags="Letzte 60 min: ";
+  if(lag[0]>=0.0)
+  {
+    for(i=round(lag[0])-1;i>=0;i--)
+      lags+="#";
+    lags+=" ("+sprintf("%.1f",lag[0])+"%)";
+  }
+  else
+    lags+="N/A";
+  lags+="\nLetzte 15 min: ";
+  if(lag[1]>=0.0)
+  {
+    for(i=round(lag[1])-1;i>=0;i--)
+      lags+="#";
+    lags+=" ("+sprintf("%.1f",lag[1])+"%)";
+  }
+  else
+    lags+="N/A";
+  lags+="\nLetzte Minute: ";
+  if(lag[2]>=0.0)
+  {
+    for(i=round(lag[2])-1;i>=0;i--)
+      lags+="#";
+    lags+=" ("+sprintf("%.1f",lag[2])+"%)";
+  }
+  else
+    lags+="N/A";
+  WLN(lags);
+  return TRUE;
+}
+
+int Xlight(string str)
+{
+  int s, addlight;
+
+  SECURE2(TRUE);
+  USAGE1(str, "xli(ght) [light]");
+  if(str)
+  {
+    if(!sscanf(str, "%d", addlight))
+      return FALSE;
+    xlight+=addlight;
+    cloner->AddIntLight(addlight);
+  }
+  WDLN("Current light levels: "+TOOL_NAME+"="+xlight+", room="+
+       ENV(cloner)->QueryIntLight());
+  return TRUE;
+}
+
+int Xload(string str)
+{
+  int i, f;
+  object obj, *inv, vroom;
+  string file, errlog, error, *strs;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xloa(d) <filename>");
+  if(!(file=XFindFile(str)))
+    return TRUE;
+  errlog=ERR_FILE;
+  if(file_size(errlog)>0)
+    rm(errlog);
+  if(obj=find_object(file))
+  {
+    if(catch(call_other(VOID, "???")))
+    {
+      WDLN("Error: cannot find "+VOID+" to rescue players");
+      return TRUE;
+    }
+    else
+      vroom = find_object(VOID);
+    if(inv=filter(all_inventory(obj), #'is_player, ME))//'
+      for(i=0; i<sizeof(inv); i++)
+	MoveObj(inv[i], vroom, TRUE);
+    Destruct(obj);
+    WLN("Update and load: "+file);
+  }
+  else
+    WLN("Load: "+file);
+  if(error=catch(call_other(file, "???")))
+  {
+    W("Error: "+error[1..]);
+    if(vroom)
+      tell_object(vroom, "*** Failed to load room. You are in the void!\n");
+  }
+  else if(inv)
+  {
+    obj=find_object(file);
+    for(i=0; i<sizeof(inv); i++)
+      if(inv[i])
+	MoveObj(inv[i], obj, TRUE);
+  }
+  return TRUE;
+}
+
+int Xlook(string str)
+{
+  object obj;
+  string st;
+  string file;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xloo(k) [object]");
+  TK("Xlook: str: "+str);
+  PIPE_DELETE(pipe_of);
+  file = pipe_out&&pipe_of ? pipe_of : "";
+  if(str&&str!="")
+  {
+    if((obj=XFindObj(str)))
+      PrintObj(obj,file);
+  }
+  else
+  {
+    obj=ENV(cloner);
+    PrintObj(obj,file);
+  }
+  return TRUE;
+}
+
+int Xlpc(string str)
+{
+  object obj;
+  string file, error;
+  int *ru1, *ru2, time;
+  mixed res;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xlp(c) <lpc code>");
+  file=LPC_FILE+".c";
+  if(file_size(file)>0)
+    rm(file);
+  if(obj=find_object(LPC_FILE))
+    Destruct(obj);
+  write_file(file,
+      "#pragma no_warn_missing_return,strong_types,warn_deprecated,rtt_checks\n"
+      "#include <properties.h>\n"
+      "#include <thing/properties.h>\n"
+      "#include <defines.h>\n"
+      "#include <wizlist.h>\n"
+      "#include <moving.h>\n"
+      "#include \"/secure/wizlevels.h\"\n"
+      +(file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+
+      "object get(string str){return previous_object()->XFindObj(str);}\n"+
+      "mixed eval(mixed me, mixed here){"+str+"}");
+  if(error=catch(obj=clone_object(file)))
+    W("Error: "+error[1..0]);
+  else
+  {
+    ru1=rusage();
+    error=catch(res=(mixed)obj->eval(cloner, ENV(cloner)));
+    ru2=rusage();
+    if(error)
+      W("Error: "+error[1..]);
+    else
+    {
+      time=ru2[0]-ru1[0]+ru2[1]-ru1[1];
+      WDLN("Evaluation time: "+(time<0 ? 0 : time)+" ms");
+      WLN("Result: "+mixed_to_string(res, MAX_RECURSION));
+      if(objectp(res))
+        variable["result"] = res;
+    }
+  }
+  rm(file);
+  if(obj)
+    Destruct(obj);
+  return TRUE;
+}
+
+int Xman(string str)
+{
+  string manpage;
+  int i, found;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xma(n) <manpage>");
+  W("Man: ");
+  for(i=0, found=0; i<sizeof(manpath); i++)
+  {
+    manpage=manpath[i]+str;
+    if(file_size(manpage)>=0)
+    {
+      WLN(manpage);
+      XMoreFile(manpage, FALSE);
+      found=1;
+      break;
+    }
+  }
+  if(!found)
+    WLN("- no help available -");
+  return TRUE;
+}
+
+int Xmore(string str)
+{
+  string *args, file;
+  int line;
+  
+  SECURE2(TRUE);
+  TK("Xmore: str: "+str);
+  if (!pipe_in)
+  {
+    USAGE2(str, "xmor(e) <filename> [start]");
+    switch(sizeof(args=strip_explode(str, " ")))
+    {
+      case 1:
+      moreoffset=1;
+      break;
+      case 2:
+      sscanf(args[1], "%d", line);
+      moreoffset= line>0 ? line : 1;
+      break;
+      default:
+      return FALSE;
+    }
+    if(file=XFindFile(args[0]))
+      XMoreFile(file, TRUE);
+  }
+  else
+  {
+    if(file_size(pipe_if)<0)
+    {
+      WDLN("Missing input to xmore");
+      return TRUE;
+    }
+    if (!str||str=="")
+      line=1;
+    else if (sscanf(str, "%d", line)!=1)
+      USAGE3("xmor(e) [start]");
+    moreoffset= line>0 ? line : 1;
+    XMoreFile(pipe_if, TRUE);
+  }
+  return TRUE;
+}
+
+int Xmove(string str)
+{
+  object obj1, obj2;
+  string what, into;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xmov(e) <object> into <object>");
+  if((sscanf(str, "%s into %s", what, into)==2)&&
+     (obj1=XFindObj(what))&&(obj2=XFindObj(into)))
+    MoveObj(obj1, obj2, FALSE);
+  return TRUE;
+}
+
+int Xmsg(string str)
+{
+  string tmp;
+  
+  SECURE2(TRUE);
+  TK("Xmsg: str: "+str);
+  USAGE1(str, "xms(g) [to <object>|all]");
+  if(!str||str=="")
+  {
+    WDLN("Send message into room");
+    say("Message from "+CRNAME(cloner)+":\n");
+    if(pipe_in&&pipe_if)
+      say(read_file(pipe_if,0,PIPE_MAX));
+    else
+    {
+      WDLN("End message with \".\" or \"**\"");
+      input_to("XMsgSay");
+    }
+    return TRUE;
+  }
+  else if(sscanf(str, "to %s", tmp))
+  {
+    if(msgto=XFindObj(tmp))
+    {
+      PrintShort("Send message to: ", msgto);
+      tell_object(msgto, "Message from "+CRNAME(cloner)+" to you:\n");
+      if(pipe_in&&pipe_if)
+	tell_object(msgto,read_file(pipe_if,0,PIPE_MAX));
+      else
+      {
+	WDLN("End message with \".\" or \"**\"");
+	input_to("XMsgTell");
+      }
+    }
+    return TRUE;
+  }
+  else if(str=="all")
+  {
+    WDLN("Send message to all players");
+    shout("Message from "+CRNAME(cloner)+" to all:\n");
+    if(pipe_in&&pipe_if)
+      shout(read_file(pipe_if,0,PIPE_MAX));
+    else
+    {
+      WDLN("End message with \".\" or \"**\"");
+      input_to("XMsgShout");
+    }
+    return TRUE;
+  }
+  return FALSE;
+}
+
+int Xmtp(string str)
+{
+  int s;
+  string *strs, opt, dir, file;
+
+  SECURE2(TRUE);
+  USAGE2(str, "xmt(p) [options] <directory> <filename>");
+  s=sizeof(strs=old_explode(str, " "));
+  if(s<2)
+    return FALSE;
+  else if(s==2)
+    opt="";
+  else
+    opt=implode(strs[0..s-3], " ");
+  if(!(dir="/"+(string)MASTER->valid_read(strs[s-2], geteuid(),
+					  "get_dir", ME))) {
+    WDLN("No permission to open directory for reading");
+    return TRUE;
+  }
+  if(!(file="/"+(string)MASTER->valid_write(strs[s-1], geteuid(),
+					    "write_file", ME))) {
+    WDLN("No permission to open script file for writing");
+    return TRUE;
+  }
+  if(file_size(dir)!=-2 || file_size(file)==-2)
+    return FALSE;
+  XmtpScript(dir, file, opt);
+  WDLN("Done");
+  return TRUE;
+}
+
+int Xproc(string str)
+{
+  int s;
+  string *strs;
+
+  SECURE2(TRUE);
+  USAGE1(str, "xproc [-c] [-l] [-m] [-u] [-v]");
+
+  if(file_size(TOOL_PATH+"/proc")!=-2)
+  {
+    WLN("Sorry, no /proc information available!");
+    return TRUE;
+  }
+  
+  if(!str||str==""||!(s=sizeof(strs=old_explode(str, " "))))
+  {
+    WLN("Load averages:");
+    cat(TOOL_PATH+"/proc/loadavg");
+    return TRUE;
+  }
+  
+  while(s=sizeof(strs))
+  {
+    switch(strs[0])
+    {
+      case "-c":
+      WLN("CPU info:");
+      cat(TOOL_PATH+"/proc/cpuinfo");
+      break;
+      case "-l":
+      WLN("Load averages:");
+      cat(TOOL_PATH+"/proc/loadavg");
+      break;
+      case "-m":
+      WLN("Memory usage:");
+      cat(TOOL_PATH+"/proc/meminfo");
+      break;
+      case "-u":
+      WLN("Uptime:");
+      cat(TOOL_PATH+"/proc/uptime");
+      break;
+      case "-v":
+      WLN("Version:");
+      cat(TOOL_PATH+"/proc/version");
+      break;
+      default:
+      WLN("Unknown option: "+strs[0]);
+    }
+    strs=strs[1..];
+  }
+  return TRUE;
+}
+
+int Xprof(string str)
+{
+  string *funcs, inh, tmp;
+  mixed *data, *d;
+  mapping xpr;
+  object obj;
+  int i, rn;
+
+  SECURE2(TRUE);
+  USAGE2(str, "xprof <<-c>|<-C> <file>>|<object>");
+  if(str[0..2]=="-c "||str[0..2]=="-C ")
+  {
+    rn=(str[1]=='C');
+    if(str=XFindFile(str[3..]))
+    {
+      inh=str=str[0..<3];
+      if(obj=find_object(inh))
+	Destruct(obj);
+      if(catch(call_other(inh,"???")))
+	return TRUE;
+      obj=find_object(inh);
+      if(rn)
+      {
+	inh+=".xprof.c";
+	rm(inh);
+	str+=".c";
+	rename(str, inh);
+      }
+      else
+      {
+	str=XPROF_FILE;
+	rm(str);
+      }
+      tmp="inherit \""+inh+"\";\n#include \""+XPROF_MACRO+"\"\n";
+      funcs=m_indices(mkmapping(functionlist(obj, 0x08000001)))-({"__INIT"});
+      for(i=sizeof(funcs); i--;)
+	tmp+="F("+funcs[i]+",\""+funcs[i]+"\","+
+	  "(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9))\n";
+      write_file(str, tmp);
+      WDLN("Done");
+    }
+  }
+  else if(obj=XFindObj(str))
+  {
+    if(xpr=(mapping)obj->__query_xprof_data__())
+    {
+      funcs=m_indices(xpr);
+      data=m_values(xpr);
+      rm(TMP_FILE);
+      str="Evaluation cost per function:\nNAME			   "+
+	" CALLS |  TOT.EXCL.  TOT.INCL. | REL.EXCL. REL.INCL.\n";
+      for(i=sizeof(funcs); i--;)
+      {
+	if(d=data[i]) {
+	  funcs[i]=ALEFT(""+funcs[i]+" ",25,".")+ARIGHT(" "+d[0], 6,".")+" | "+
+	    ARIGHT(" "+d[1],10,".")	+" "+ARIGHT(" "+d[3],10,".")+" | "+
+	    ARIGHT(" "+d[1]/d[0],9,".") +" "+ARIGHT(" "+d[3]/d[0],9,".");
+	}
+      }
+      str+=implode(sort_array(funcs, "string_compare", ME),"\n")+"\n";
+      write_file(TMP_FILE,str);
+      str="\nElapsed time per function:\nNAME			  "+
+	" CALLS |  TOT.EXCL.  TOT.INCL. | REL.EXCL. REL.INCL.\n";
+      funcs=m_indices(xpr);
+      for(i=sizeof(funcs); i--;)
+      {
+	if(d=data[i])
+	{
+	  funcs[i]=ALEFT(""+funcs[i]+" ",25,".")+ARIGHT(" "+d[0], 6,".")+" | "+
+	    ARIGHT(" "+(d[2]+5)/10+"ms",10,".")+" "+
+	    ARIGHT(" "+(d[4]+5)/10+"ms",10,".")+" | "+
+	    ARIGHT(" "+d[2]/d[0]+"us",9,".")+" "+
+	    ARIGHT(" "+d[4]/d[0]+"us",9,".");
+	}
+      }
+      str+=implode(sort_array(funcs, "string_compare", ME),"\n")+"\n";
+      write_file(TMP_FILE,str);
+      XMoreFile(TMP_FILE, FALSE);
+    }
+    else
+      WDLN("No profiling information available");
+  }
+  return TRUE;
+}
+
+int Xprops(string str)
+{
+  int i, s, flag;
+  object obj;
+  string *tmp;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xprop(s) [-f|-m] <object>");
+  TK("Xprops: str: "+str);
+  tmp=old_explode(str," ");
+  switch(tmp[0])
+  {
+    case "-f":
+    {
+      flag = 1;
+      tmp=tmp[1..];
+      break;
+    }
+    case "-m":
+    {
+      flag = 2;
+      tmp=tmp[1..];
+      break;
+    }
+  }
+  str=implode(tmp," ");
+  if((obj=XFindObj(str)))
+    DumpProperties(obj,flag);
+  return TRUE;
+}
+
+int Xquit(string str)
+{
+  SECURE2(TRUE);
+  USAGE1(str, "xqu(it)");
+  str=object_name(ENV(cloner));
+  if(member(str, '#')<0)
+    cloner->set_home(str);
+  cloner->quit();
+  return TRUE;
+}
+
+int Xscan(string str)
+{  
+  SECURE2(TRUE);
+  USAGE1(str, "xsc(an)");
+  W("Destructed variable(s): ");
+  string* oldvars=m_indices(variable);
+  VarCheck(FALSE);
+  string* desvars=oldvars-m_indices(variable);
+  desvars = map(desvars, function string (string k)
+      {return "$"+k;} );
+  W(CountUp(desvars));
+  WLN("");
+  return TRUE;
+}
+
+int Xset(string str)
+{
+  int i;
+  mixed obj;
+  string name, tmp;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xse(t) [$<name>=<object>]");
+  if(str) {
+    if(member(({"$me","$m","$here","$h"}),str)!=-1)
+      WDLN("Sorry, this is a reserved variable ["+str+"]");
+    else if(sscanf(str, "$%s=%s", name, tmp))
+    {
+      if(obj=XFindObj(tmp))
+      {
+        variable[name] = obj;
+        WLN(" $"+name+"="+ObjFile(obj));
+      }
+    }
+    else
+      return FALSE;
+  }
+  else
+  {
+    VarCheck(FALSE);
+    WLN("Current settings:");
+    foreach(string key, mixed val : variable)
+    {
+      if (val)
+        WLN(" $"+key+"="+ObjFile(val));
+      else
+        m_delete(variable, key);
+    }
+    WLN(" $me="+ObjFile(cloner));
+    WLN(" $here="+ObjFile(ENV(cloner)));
+  }
+  return TRUE;
+}
+
+int Xsh(string str)
+{
+  SECURE2(TRUE);
+  USAGE1(str, "xsh <filename>");
+  if(scriptline)
+  {
+    WDLN("Cannot execute another script file until last execution has ended");
+    return TRUE;
+  }
+  if(!(str=XFindFile(str)))
+    return TRUE;
+  str=read_file(str, 1, 1000);
+  if(!(scriptline=old_explode(str, "\n")))
+  {
+    WDLN("Bad script file");
+    return TRUE;
+  }
+  scriptsize=sizeof(scriptline);
+  XExecFile(NULL);
+  return TRUE;
+}
+
+int Xsort(string str)
+{
+  string *tmp,file;
+  int s,reverse;
+
+  SECURE2(TRUE);
+  TK("Xsort: str: "+str);
+  if(!pipe_in)
+  {
+    USAGE2(str, "xso(rt) [-r] [file]");
+    if(!(tmp=old_explode(str, " "))||(s=sizeof(tmp))>2)
+      return FALSE;
+    if(tmp[0]=="-r")
+      if(s==1)
+	return FALSE;
+      else
+      {
+	reverse=TRUE;
+	tmp=tmp[1..];
+      }
+    else if(s>1)
+      return FALSE;
+    if(!(file=XFindFile(tmp[0])))
+    {
+      WDLN("Can't find file");
+      return TRUE;
+    }
+  }
+  else
+  {
+    if(str&&str!="")
+      if(str=="-r")
+	reverse=TRUE;
+      else
+	USAGE3("xso(rt) [-r]");
+    if (file_size(file=pipe_if)<0)
+    {
+      WDLN("Missing input to xsort");
+      return TRUE;
+    }
+  }
+  tmp=old_explode(read_file(file,0,PIPE_MAX),"\n");
+  if(pipe_in&&pipe_if==PIPE_FILE)
+    rm(PIPE_FILE);
+  tmp=sort_array(tmp,reverse?#'<:#'>);
+    if (pipe_out&&pipe_of)
+      write_file(pipe_of,implode(tmp,"\n")+"\n");
+    else
+      WDLN(implode(tmp,"\n"));
+  return TRUE;
+}
+
+int Xtail(string str)
+{
+  string *tmp,file,sign;
+  int lines;
+
+  if (!str) {
+    WDLN("Missing input to xtail");
+    return TRUE;
+  }
+
+  sign="-";
+  lines=10;
+  SECURE2(TRUE);
+  TK("Xtail: str: "+str);
+  if(!pipe_in)
+  {
+    if(sscanf(str,"-%d %s",lines,file)==2)
+      sign="-";
+    else if(sscanf(str,"+%d %s",lines,file)==2)
+      sign="+";
+    else
+      file=str;
+
+    if(!(file=XFindFile(file)))
+    {
+      WDLN("Can't find file");
+      return TRUE;
+    }
+  }
+  else
+  {
+    if(sscanf(str,"-%d",lines)==1)
+      sign="-";
+    else if(sscanf(str,"+%d",lines)==1)
+      sign="+";
+    if (file_size(file=pipe_if)<0)
+    {
+      WDLN("Missing input to xtail");
+      return TRUE;
+    }
+  }
+
+  if(sign=="-")
+  {
+    if(!lines)
+      return TRUE;
+  }
+
+  if(file_size(file)>50000)
+  {
+    WDLN("File too large");
+    return TRUE;
+  }
+
+  if(sign=="+")
+    tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[lines..];
+  else
+    tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[<lines..];
+  if(pipe_in&&pipe_if==PIPE_FILE)
+    rm(PIPE_FILE);
+  if (pipe_out&&pipe_of)
+    write_file(pipe_of,implode(tmp,"\n")+"\n");
+  else
+    WLN(implode(tmp,"\n"));
+  return TRUE;
+}
+
+int Xtool(string str)
+{
+  int m;
+  string tmp;
+  object obj;
+  
+  SECURE2(TRUE);
+  TK("Xtool: str: "+str);
+  USAGE1(str, "xto(ol) [update|first=<on|off>|protect=<on|off>|"+
+	 "invcheck=<on|off>|\n"+
+	 "\t\tvarcheck=<on|off>|scanchk=<on|off>|short=<on|off>|\n"+
+	 "\t\techo=<on|off>|more=<amount>|kill|news|save|load|reset]");
+  if(str&&str!="")
+  {
+    if(sscanf(str, "more=%d", m))
+    {
+      if(m<5)
+	WDLN("Sorry, amount of lines should be more then 5");
+      else
+      {
+	WDLN("Setting amount of displayed lines to "+m);
+	morelines=m;
+      }
+    }
+    else
+      switch(str)
+      {
+	case "update":
+	if(obj=find_object(TOOL_PATH))
+	  Destruct(obj);
+	if(catch(obj=clone_object(TOOL_PATH)))
+	  WLN("Updating "+TOOL_TITLE+" failed!");
+	else
+	  obj->update_tool(AUTOLOAD_ARGS, cloner);
+	return TRUE;
+	break;
+	case "first=on":
+	MODE_ON(MODE_FIRST);
+	move(cloner);
+	WDLN("Automatic moving into pole position of inventory turned on");
+	break;
+	case "first=off":
+	MODE_OFF(MODE_FIRST);
+	WDLN("Automatic moving into pole position of inventory turned off");
+	break;
+	case "protect=on":
+	MODE_ON(MODE_PROTECT);
+	WDLN("Protection from forces and illegal moves turned on");
+	break;
+	case "protect=off":
+	MODE_OFF(MODE_PROTECT);
+	WDLN("Protection from forces and illegal moves turned off");
+	break;
+	case "invcheck=on":
+	MODE_ON(MODE_INVCHECK);
+	WDLN("Automatic checking for new objects in inventory turned on");
+	break;
+	case "invcheck=off":
+	MODE_OFF(MODE_INVCHECK);
+	WDLN("Automatic checking for new objects in inventory turned off");
+	break;
+	case "varcheck=on":
+	MODE_ON(MODE_VARCHECK);
+	VarCheck(TRUE);
+	WDLN("Automatic variable checking turned on");
+	break;
+	case "varcheck=off":
+	MODE_OFF(MODE_VARCHECK);
+	WDLN("Automatic variable checking turned off");
+	break;
+	case "scanchk=on":
+	MODE_ON(MODE_SCANCHK);
+	WDLN("Scan check turned on");
+	break;
+	case "scanchk=off":
+	MODE_OFF(MODE_SCANCHK);
+	WDLN("Scan check turned off");
+	break;
+	case "echo=on":
+	MODE_ON(MODE_ECHO);
+	WDLN("Echoing of multiple command execution turned on");
+	break;
+	case "echo=off":
+	MODE_OFF(MODE_ECHO);
+	WDLN("Echoing of multiple command execution turned off");
+	break;
+	case "short=on":
+	MODE_ON(MODE_SHORT);
+	WDLN("Use of short descriptions turned on");
+	break;
+	case "short=off":
+	MODE_OFF(MODE_SHORT);
+	WDLN("Use of short descriptions turned off");
+	break;
+	case "kill":
+	WDLN(TOOL_NAME+" selfdestructs");
+	destruct(ME);
+	break;
+	case "news":
+	XMoreFile(TOOL_NEWS, FALSE);
+	break;
+	case "reset":
+	WDLN("Resetting "+TOOL_TITLE);
+	ME->__INIT();
+	break;
+	case "load":
+	if(file_size(SAVE_FILE+".o")>0)
+	{
+	  WDLN("Loading "+TOOL_TITLE+" settings");
+	  restore_object(SAVE_FILE);
+	}
+	else
+	  WDLN("Sorry, cannot find file to load settings");
+	break;
+	case "save":
+	WDLN("Saving "+TOOL_TITLE+" settings");
+	save_object(SAVE_FILE);
+	break;
+	default:
+	return FALSE;
+      }
+  }
+  else
+  {
+    WLN(TOOL_TITLE+" settings:");
+    tmp= (" first .... = "+(MODE(MODE_FIRST) ? "on\n" : "off\n"));
+    tmp+=(" protect .. = "+(MODE(MODE_PROTECT) ? "on\n" : "off\n"));
+    tmp+=(" invcheck . = "+(MODE(MODE_INVCHECK) ? "on\n" : "off\n"));
+    tmp+=(" varcheck . = "+(MODE(MODE_VARCHECK) ? "on\n" : "off\n"));
+    tmp+=(" scanchk .. = "+(MODE(MODE_SCANCHK) ? "on\n" : "off\n"));
+    tmp+=(" echo ..... = "+(MODE(MODE_ECHO) ? "on\n" : "off\n"));
+    tmp+=(" short .... = "+(MODE(MODE_SHORT) ? "on\n" : "off\n"));
+    tmp+=(" more ..... = "+morelines);
+    WLN(sprintf("%-80#s", tmp));
+  }
+  return TRUE;
+}
+
+int Xtrace(string str)
+{
+  string file;
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE1(str, "xtrac(e) <object>");
+  if(!str||str=="")
+  {
+    trace(0);
+    WDLN("Ending trace ["+short_path("/"+traceprefix(0))+"]");
+  }
+  else if(obj=XFindObj(str))
+  {
+    PrintShort("Tracing: ", obj);
+    file=object_name(obj);
+    file=file[1..<1];
+    traceprefix(file);
+    trace(TRACE_LEVEL);
+  }
+  return TRUE;
+}
+
+int Xtrans(string str)
+{
+  object obj;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xtran(s) <object>");
+  if((obj=XFindObj(str))&&ENV(obj))
+  {
+    tell_room(ENV(obj), CRNAME(obj)+" vanishes.\n");
+    tell_room(ENV(cloner), CRNAME(obj)+
+	      " is teleported into this room by "+CRNAME(cloner)+".\n");
+    MoveObj(obj, ENV(cloner), TRUE);
+    tell_object(obj, "You've been teleported to "+CRNAME(cloner)+".\n");
+  }
+  else
+    WDLN("Failed to teleport object");
+  return TRUE;
+}
+
+int Xupdate(string str)
+{
+  object obj;
+  string file;
+  
+  SECURE2(TRUE);
+  USAGE2(str, "xup(date) <filename>");
+  if(!(file=XFindFile(str)))
+    return TRUE;
+  if(file[<2.. <1]==".c")
+    file=file[0.. <3];
+  if((obj=XFindObj(file))&&(obj=find_object(pure_file_name(obj))))
+  {
+    PrintShort("Updating: ", obj);
+    Destruct(obj);
+  }
+  else
+    WDLN("Object not found");
+  return TRUE;
+}
+
+int Xuptime(string str)
+{
+  return TRUE;
+}
+
+int Xwc(string str)
+{
+  string file;
+  string tmp, *tmp2;
+  int i, chars, words, lines, nchars, nwords, nlines;
+  
+  SECURE2(TRUE);
+  TK("Xwc: str: "+str);
+  chars=words=lines=FALSE;
+  if(!pipe_in)
+  {
+    USAGE2(str, "xwc [-cwl] <file>");
+    if(str[0]=='-')
+    {
+      while((str=str[1..])[0]!=' '&&sizeof(str))
+	switch(str[0])
+	{
+	  case 'c':
+	  chars=TRUE;
+	  break;
+	  case 'w':
+	  words=TRUE;
+	  break;
+	  case 'l':
+	  lines=TRUE;
+	  break;
+	  default:
+	  return FALSE;
+	}
+      str=str[1..];
+    }
+    if(!(file=XFindFile(str)))
+    {
+      WDLN("Can't find file");
+      return TRUE;
+    }
+  }
+  else
+  {
+    USAGE1(str,"xwc [-cwl]");
+    if(str)
+      if(str[0]=='-')
+      {
+	while((str=str[1..])[0]!=' '&&sizeof(str))
+	  switch(str[0])
+	  {
+	    case 'c':
+	    chars=TRUE;
+	    break;
+	    case 'w':
+	    words=TRUE;
+	    break;
+	    case 'l':
+	    lines=TRUE;
+	    break;
+	    default:
+	    return FALSE;
+	  }
+      }
+      else
+	return FALSE;
+    if(file_size(file=pipe_if)<0)
+    {
+      WDLN("Missing input to xwc");
+      return TRUE;
+    }
+  }
+  if(!(chars|words|lines))
+    chars=words=lines=TRUE;
+  nlines=nwords=nchars=0;
+  tmp=read_file(file,0,PIPE_MAX);
+  tmp2=explode(tmp,"\n");
+  if(lines)
+  {
+    nlines=sizeof(tmp2);
+    if(tmp2[<1]==""&&nlines>1)
+      nlines--;
+  }
+  if(words)
+    for(i=sizeof(tmp2)-1;i>=0;i--)
+    {
+      TK(sprintf("%O",tmp2[i]));
+      if(tmp2[i]!="")
+	nwords+=sizeof(regexplode(tmp2[i],"[	]")-({""," ","	"}));
+      TK(sprintf("%O",regexplode(tmp2[i],"[	]")-({""," ","	"})));
+      TK("nwords: "+nwords);
+    }
+  if(chars)
+    for(i=sizeof(tmp2)-1;i>=0;i--)
+      nchars+=sizeof(tmp2[i])+1;
+  tmp2=0;
+  tmp="";
+  if(lines)
+    tmp+=sprintf("%7d",nlines)+" ";
+  if(words)
+    tmp+=sprintf("%7d",nwords)+" ";
+  if(chars)
+    tmp+=sprintf("%7d",nchars)+" ";
+  if(file!=pipe_if)
+    tmp+=file;
+  WLN(tmp);
+  return TRUE;
+}
+
+int cmdavg_compare(string a, string b)
+{
+  int x,y;
+  string dum;
+  sscanf(a,"%s cmdavg: %d",dum,x);
+  sscanf(b,"%s cmdavg: %d",dum,y);
+  return x==y?0:(x>y?1:-1);
+}
+
+int Xwho(string opt)
+{
+  string *strs,str,func;
+  
+  SECURE2(TRUE);
+  TK("Xwho: opt: \""+opt+"\"");
+  USAGE1(opt, "xwh(o) [mail|ip|race|guild|domain|stats|snoop]");
+  func="string_compare";
+  if(!opt||opt=="")
+    strs=map(users(), "PlayerWho", ME);
+  else
+    switch(opt)
+    {
+      case "mail":
+      strs=map(users(), "PlayerMail", ME, TRUE);
+      break;
+      case "ip":
+      strs=map(users(), "PlayerIP", ME, TRUE);
+      break;
+      case "race":
+      case "guild":
+      strs=map(users(), "PlayerRace", ME, TRUE);
+      break;
+      case "domain":
+      strs=map(users(), "PlayerDomain", ME, TRUE);
+      break;
+      case "stat":
+      case "stats":
+      strs=map(users(), "PlayerStats", ME, TRUE);
+      break;
+      case "snoop":
+      strs=map(users(), "PlayerSnoop", ME, TRUE);
+      break;
+      case "cmdavg":
+      strs=map(users(), "PlayerCmdAvg", ME, TRUE);
+      func="cmdavg_compare";
+      break;
+      default:
+      return FALSE;
+    }
+  strs=sort_array(strs, func, ME);
+  if(pipe_out&&pipe_of)
+    write_file(pipe_of,implode(strs,"\n")+"\n");
+  else
+    WLN(implode(strs,"\n"));
+  return TRUE;
+}