* Applied patch from Melanie, mantis issue #1581 - "Refactor LSL language, api and compiler out of XEngine"

"First stage in a major Script Engine refactor, that will result in the LSL implementaions ebing reconverged. Not there yet, but one major part is done."
Thank you, Melanie!

35 files changed, 25639 insertions, 0 deletions

diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs
new file mode 100644
index 0000000..f7f2676
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/ApiManager.cs
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Region.ScriptEngine.Interfaces;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api
+{
+    public class ApiManager
+    {
+        private Dictionary<string,Type> m_Apis = new Dictionary<string,Type>();
+
+        public string[] GetApis()
+        {
+            if(m_Apis.Count > 0)
+            {
+                List<string> l = new List<string>(m_Apis.Keys);
+                return l.ToArray();
+            }
+
+            Assembly a = Assembly.GetExecutingAssembly();
+
+            Type[] types = a.GetExportedTypes();
+
+            foreach (Type t in types)
+            {
+                string name = t.ToString();
+                int idx = name.LastIndexOf('.');
+                if(idx != -1)
+                    name = name.Substring(idx+1);
+
+                if(name.EndsWith("_Api"))
+                {
+                    name = name.Substring(0, name.Length - 4);
+                    m_Apis[name] = t;
+                }
+            }
+
+            List<string> ret = new List<string>(m_Apis.Keys);
+            return ret.ToArray();
+        }
+
+        public IScriptApi CreateApi(string api)
+        {
+            if(!m_Apis.ContainsKey(api))
+                return null;
+
+            IScriptApi ret = (IScriptApi)(Activator.CreateInstance(m_Apis[api]));
+            return ret;
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs
new file mode 100644
index 0000000..8c967a2
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/AsyncCommandManager.cs
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api.Plugins;
+using Timer=OpenSim.Region.ScriptEngine.Shared.Api.Plugins.Timer;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api
+{
+    /// <summary>
+    /// Handles LSL commands that takes long time and returns an event, for example timers, HTTP requests, etc.
+    /// </summary>
+    public class AsyncCommandManager
+    {
+        private static Thread cmdHandlerThread;
+        private static int cmdHandlerThreadCycleSleepms;
+
+        private static List<AsyncCommandManager> m_Managers = new List<AsyncCommandManager>();
+        public IScriptEngine m_ScriptEngine;
+
+        private Dataserver m_Dataserver;
+        private Timer m_Timer;
+        private HttpRequest m_HttpRequest;
+        private Listener m_Listener;
+        private SensorRepeat m_SensorRepeat;
+        private XmlRequest m_XmlRequest;
+
+        public Dataserver DataserverPlugin
+        {
+            get { return m_Dataserver; }
+        }
+
+        public Timer TimerPlugin
+        {
+            get { return m_Timer; }
+        }
+
+        public HttpRequest HttpRequestPlugin
+        {
+            get { return m_HttpRequest; }
+        }
+
+        public Listener ListenerPlugin
+        {
+            get { return m_Listener; }
+        }
+
+        public SensorRepeat SensorRepeatPlugin
+        {
+            get { return m_SensorRepeat; }
+        }
+
+        public XmlRequest XmlRequestPlugin
+        {
+            get { return m_XmlRequest; }
+        }
+
+        public AsyncCommandManager[] Managers
+        {
+            get { return m_Managers.ToArray(); }
+        }
+
+        public AsyncCommandManager(IScriptEngine _ScriptEngine)
+        {
+            m_ScriptEngine = _ScriptEngine;
+            if(!m_Managers.Contains(this))
+                m_Managers.Add(this);
+
+            ReadConfig();
+
+            // Create instances of all plugins
+            m_Dataserver = new Dataserver(this);
+            m_Timer = new Timer(this);
+            m_HttpRequest = new HttpRequest(this);
+            m_Listener = new Listener(this);
+            m_SensorRepeat = new SensorRepeat(this);
+            m_XmlRequest = new XmlRequest(this);
+
+            StartThread();
+        }
+
+        private static void StartThread()
+        {
+            if (cmdHandlerThread == null)
+            {
+                // Start the thread that will be doing the work
+                cmdHandlerThread = new Thread(CmdHandlerThreadLoop);
+                cmdHandlerThread.Name = "AsyncLSLCmdHandlerThread";
+                cmdHandlerThread.Priority = ThreadPriority.BelowNormal;
+                cmdHandlerThread.IsBackground = true;
+                cmdHandlerThread.Start();
+                ThreadTracker.Add(cmdHandlerThread);
+            }
+        }
+
+        public void ReadConfig()
+        {
+            cmdHandlerThreadCycleSleepms = m_ScriptEngine.Config.GetInt("AsyncLLCommandLoopms", 100);
+        }
+
+        ~AsyncCommandManager()
+        {
+            // Shut down thread
+            try
+            {
+                if (cmdHandlerThread != null)
+                {
+                    if (cmdHandlerThread.IsAlive == true)
+                    {
+                        cmdHandlerThread.Abort();
+                        //cmdHandlerThread.Join();
+                    }
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        private static void CmdHandlerThreadLoop()
+        {
+            while (true)
+            {
+                try
+                {
+                    while (true)
+                    {
+                        Thread.Sleep(cmdHandlerThreadCycleSleepms);
+
+                        foreach (AsyncCommandManager m in m_Managers)
+                        {
+                            m.DoOneCmdHandlerPass();
+                        }
+                    }
+                }
+                catch
+                {
+                }
+            }
+        }
+
+        public void DoOneCmdHandlerPass()
+        {
+            // Check timers
+            m_Timer.CheckTimerEvents();
+            // Check HttpRequests
+            m_HttpRequest.CheckHttpRequests();
+            // Check XMLRPCRequests
+            m_XmlRequest.CheckXMLRPCRequests();
+            // Check Listeners
+            m_Listener.CheckListeners();
+            // Check Sensors
+            m_SensorRepeat.CheckSenseRepeaterEvents();
+            // Check dataserver
+            m_Dataserver.ExpireRequests();
+        }
+
+        /// <summary>
+        /// Remove a specific script (and all its pending commands)
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="itemID"></param>
+        public void RemoveScript(uint localID, LLUUID itemID)
+        {
+            // Remove a specific script
+
+            // Remove dataserver events
+            m_Dataserver.RemoveEvents(localID, itemID);
+
+            // Remove from: Timers
+            m_Timer.UnSetTimerEvents(localID, itemID);
+
+            // Remove from: HttpRequest
+            IHttpRequests iHttpReq =
+                m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+            iHttpReq.StopHttpRequest(localID, itemID);
+
+            IWorldComm comms = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            comms.DeleteListener(itemID);
+
+            IXMLRPC xmlrpc = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            xmlrpc.DeleteChannels(itemID);
+            xmlrpc.CancelSRDRequests(itemID);
+
+            // Remove Sensors
+            m_SensorRepeat.UnSetSenseRepeaterEvents(localID, itemID);
+
+        }
+
+        public Object[] GetSerializationData(LLUUID itemID)
+        {
+            List<Object> data = new List<Object>();
+
+            Object[] listeners=m_Listener.GetSerializationData(itemID);
+            if (listeners.Length > 0)
+            {
+                data.Add("listener");
+                data.Add(listeners.Length);
+                data.AddRange(listeners);
+            }
+
+            Object[] timers=m_Timer.GetSerializationData(itemID);
+            if (timers.Length > 0)
+            {
+                data.Add("timer");
+                data.Add(timers.Length);
+                data.AddRange(timers);
+            }
+
+            Object[] sensors=m_SensorRepeat.GetSerializationData(itemID);
+            if (sensors.Length > 0)
+            {
+                data.Add("sensor");
+                data.Add(sensors.Length);
+                data.AddRange(sensors);
+            }
+
+            return data.ToArray();
+        }
+
+        public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID,
+                                   Object[] data)
+        {
+            int idx = 0;
+            int len;
+
+            while (idx < data.Length)
+            {
+                string type = data[idx].ToString();
+                len = (int)data[idx+1];
+                idx+=2;
+
+                if (len > 0)
+                {
+                    Object[] item = new Object[len];
+                    Array.Copy(data, idx, item, 0, len);
+
+                    idx+=len;
+
+                    switch (type)
+                    {
+                    case "listener":
+                        m_Listener.CreateFromData(localID, itemID, hostID,
+                                                  item);
+                        break;
+                    case "timer":
+                        m_Timer.CreateFromData(localID, itemID, hostID, item);
+                        break;
+                    case "sensor":
+                        m_SensorRepeat.CreateFromData(localID, itemID, hostID,
+                                                      item);
+                        break;
+                    }
+                }
+            }
+        }
+
+        #region Check llRemoteData channels
+
+        #endregion
+
+        #region Check llListeners
+
+        #endregion
+
+        /// <summary>
+        /// If set to true then threads and stuff should try to make a graceful exit
+        /// </summary>
+        public bool PleaseShutdown
+        {
+            get { return _PleaseShutdown; }
+            set { _PleaseShutdown = value; }
+        }
+        private bool _PleaseShutdown = false;
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
new file mode 100644
index 0000000..7832633
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -0,0 +1,6583 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Lifetime;
+using System.Text;
+using System.Threading;
+using Nini.Config;
+using Axiom.Math;
+using libsecondlife;
+using OpenSim;
+using OpenSim.Framework;
+using OpenSim.Region.Environment;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Modules.Avatar.Currency.SampleMoney;
+using OpenSim.Region.Environment.Modules.World.Land;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api.Plugins;
+using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api
+{
+    /// <summary>
+    /// Contains all LSL ll-functions. This class will be in Default AppDomain.
+    /// </summary>
+    public class LSL_Api : MarshalByRefObject, ILSL_Api, IScriptApi
+    {
+        // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        internal IScriptEngine m_ScriptEngine;
+        internal SceneObjectPart m_host;
+        internal uint m_localID;
+        internal LLUUID m_itemID;
+        internal bool throwErrorOnNotImplemented = true;
+        internal static AsyncCommandManager AsyncCommands = null;
+
+        public void Initialize(IScriptEngine ScriptEngine, SceneObjectPart host, uint localID, LLUUID itemID)
+        {
+            m_ScriptEngine = ScriptEngine;
+            m_host = host;
+            m_localID = localID;
+            m_itemID = itemID;
+
+            AsyncCommands = (AsyncCommandManager)ScriptEngine.AsyncCommands;
+        }
+
+        private DateTime m_timer = DateTime.Now;
+        private bool m_waitingForScriptAnswer=false;
+
+
+        // Object never expires
+        public override Object InitializeLifetimeService()
+        {
+            ILease lease = (ILease)base.InitializeLifetimeService();
+
+            if (lease.CurrentState == LeaseState.Initial)
+            {
+                lease.InitialLeaseTime = TimeSpan.Zero;
+            }
+            return lease;
+        }
+
+        public Scene World
+        {
+            get { return m_ScriptEngine.World; }
+        }
+
+        public void state(string newState)
+        {
+            m_ScriptEngine.SetState(m_itemID, newState);
+        }
+
+        public void llSay(int channelID, string text)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (text.Length > 1023)
+                text = text.Substring(0, 1023);
+
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Say, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
+
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text);
+        }
+
+        // Extension commands use this:
+        public ICommander GetCommander(string name)
+        {
+            return World.GetCommander(name);
+        }
+
+        private LLUUID InventorySelf()
+        {
+            LLUUID invItemID = new LLUUID();
+
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID)
+                {
+                    invItemID = inv.Key;
+                    break;
+                }
+            }
+
+            return invItemID;
+        }
+
+        private LLUUID InventoryKey(string name, int type)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == name)
+                {
+                    if (inv.Value.Type != type)
+                        return LLUUID.Zero;
+
+                    return inv.Value.AssetID.ToString();
+                }
+            }
+            return LLUUID.Zero;
+        }
+
+        private LLUUID InventoryKey(string name)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == name)
+                {
+                    return inv.Value.AssetID.ToString();
+                }
+            }
+            return LLUUID.Zero;
+        }
+
+
+        /// <summary>
+        /// accepts a valid LLUUID, -or- a name of an inventory item.
+        /// Returns a valid LLUUID or LLUUID.Zero if key invalid and item not found
+        /// in prim inventory.
+        /// </summary>
+        /// <param name="k"></param>
+        /// <returns></returns>
+        private LLUUID KeyOrName(string k)
+        {
+            LLUUID key = LLUUID.Zero;
+
+            // if we can parse the string as a key, use it.
+            if (LLUUID.TryParse(k, out key))
+            {
+                return key;
+            }
+            // else try to locate the name in inventory of object. found returns key,
+            // not found returns LLUUID.Zero which will translate to the default particle texture
+            else
+            {
+                return InventoryKey(k);
+            }
+        }
+
+        public void osSetRegionWaterHeight(double height)
+        {
+            m_host.AddScriptLPS(1);
+            //Check to make sure that the script's owner is the estate manager/master
+            //World.Permissions.GenericEstatePermission(
+            if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID))
+            {
+                World.EventManager.TriggerRequestChangeWaterHeight((float)height);
+            }
+        }
+
+        //These are the implementations of the various ll-functions used by the LSL scripts.
+        //starting out, we use the System.Math library for trig functions. - ckrinke 8-14-07
+        public double llSin(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Sin(f);
+        }
+
+        public double llCos(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Cos(f);
+        }
+
+        public double llTan(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Tan(f);
+        }
+
+        public double llAtan2(double x, double y)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Atan2(y, x);
+        }
+
+        public double llSqrt(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Sqrt(f);
+        }
+
+        public double llPow(double fbase, double fexponent)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Pow(fbase, fexponent);
+        }
+
+        public LSL_Types.LSLInteger llAbs(int i)
+        {
+            m_host.AddScriptLPS(1);
+            return (int)Math.Abs(i);
+        }
+
+        public double llFabs(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Abs(f);
+        }
+
+        public double llFrand(double mag)
+        {
+            m_host.AddScriptLPS(1);
+            lock (Util.RandomClass)
+            {
+                return Util.RandomClass.NextDouble() * mag;
+            }
+        }
+
+        public LSL_Types.LSLInteger llFloor(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (int)Math.Floor(f);
+        }
+
+        public LSL_Types.LSLInteger llCeil(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (int)Math.Ceiling(f);
+        }
+
+        // Xantor 01/May/2008 fixed midpointrounding (2.5 becomes 3.0 instead of 2.0, default = ToEven)
+        public LSL_Types.LSLInteger llRound(double f)
+        {
+            m_host.AddScriptLPS(1);
+            return (int)Math.Round(f, MidpointRounding.AwayFromZero);
+        }
+
+        //This next group are vector operations involving squaring and square root. ckrinke
+        public double llVecMag(LSL_Types.Vector3 v)
+        {
+            m_host.AddScriptLPS(1);
+            return LSL_Types.Vector3.Mag(v);
+        }
+
+        public LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v)
+        {
+            m_host.AddScriptLPS(1);
+            double mag = LSL_Types.Vector3.Mag(v);
+            LSL_Types.Vector3 nor = new LSL_Types.Vector3();
+            nor.x = v.x / mag;
+            nor.y = v.y / mag;
+            nor.z = v.z / mag;
+            return nor;
+        }
+
+        public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
+        {
+            m_host.AddScriptLPS(1);
+            double dx = a.x - b.x;
+            double dy = a.y - b.y;
+            double dz = a.z - b.z;
+            return Math.Sqrt(dx * dx + dy * dy + dz * dz);
+        }
+
+        //Now we start getting into quaternions which means sin/cos, matrices and vectors. ckrinke
+
+        // Utility function for llRot2Euler
+
+        // normalize an angle between 0 - 2*PI (0 and 360 degrees)
+        private double NormalizeAngle(double angle)
+        {
+            angle = angle % (Math.PI * 2);
+            if (angle < 0) angle = angle + Math.PI * 2;
+            return angle;
+        }
+
+        // Old implementation of llRot2Euler, now normalized
+
+        public LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r)
+        {
+            m_host.AddScriptLPS(1);
+            //This implementation is from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions. ckrinke
+            LSL_Types.Quaternion t = new LSL_Types.Quaternion(r.x * r.x, r.y * r.y, r.z * r.z, r.s * r.s);
+            double m = (t.x + t.y + t.z + t.s);
+            if (m == 0) return new LSL_Types.Vector3();
+            double n = 2 * (r.y * r.s + r.x * r.z);
+            double p = m * m - n * n;
+            if (p > 0)
+                return new LSL_Types.Vector3(NormalizeAngle(Math.Atan2(2.0 * (r.x * r.s - r.y * r.z), (-t.x - t.y + t.z + t.s))),
+                                             NormalizeAngle(Math.Atan2(n, Math.Sqrt(p))),
+                                             NormalizeAngle(Math.Atan2(2.0 * (r.z * r.s - r.x * r.y), (t.x - t.y - t.z + t.s))));
+            else if (n > 0)
+                return new LSL_Types.Vector3(0.0, Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z)));
+            else
+                return new LSL_Types.Vector3(0.0, -Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z)));
+        }
+
+        // Xantor's newer llEuler2Rot() *try the second* inverted quaternions (-x,-y,-z,w) as LL seems to like
+        // New and improved, now actually works as described. Prim rotates as expected as does llRot2Euler.
+
+        /* From wiki:
+        The Euler angle vector (in radians) is converted to a rotation by doing the rotations around the 3 axes
+        in Z, Y, X order. So llEuler2Rot(<1.0, 2.0, 3.0> * DEG_TO_RAD) generates a rotation by taking the zero rotation,
+        a vector pointing along the X axis, first rotating it 3 degrees around the global Z axis, then rotating the resulting
+        vector 2 degrees around the global Y axis, and finally rotating that 1 degree around the global X axis.
+        */
+
+        public LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v)
+        {
+            m_host.AddScriptLPS(1);
+
+            double x,y,z,s,s_i;
+
+            double cosX = Math.Cos(v.x);
+            double cosY = Math.Cos(v.y);
+            double cosZ = Math.Cos(v.z);
+            double sinX = Math.Sin(v.x);
+            double sinY = Math.Sin(v.y);
+            double sinZ = Math.Sin(v.z);
+
+            s = Math.Sqrt(cosY * cosZ - sinX * sinY * sinZ + cosX * cosZ + cosX * cosY + 1.0f) * 0.5f;
+            if (Math.Abs(s) < 0.00001) // null rotation
+            {
+                   x = 0.0f;
+                y = 1.0f;
+                z = 0.0f;
+            }
+            else
+            {
+                s_i = 1.0f / (4.0f * s);
+                x = - (-sinX * cosY - cosX * sinY * sinZ - sinX * cosZ) * s_i;
+                y = - (-cosX * sinY * cosZ + sinX * sinZ - sinY) * s_i;
+                z = - (-cosY * sinZ - sinX * sinY * cosZ - cosX * sinZ) * s_i;
+            }
+            return new LSL_Types.Quaternion(x, y, z, s);
+        }
+
+        public LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llAxes2Rot");
+            return new LSL_Types.Quaternion();
+        }
+
+        public LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r)
+        {
+            m_host.AddScriptLPS(1);
+            return (new LSL_Types.Vector3(1,0,0) * r);
+        }
+
+        public LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r)
+        {
+            m_host.AddScriptLPS(1);
+            return (new LSL_Types.Vector3(0, 1, 0) * r);
+        }
+
+        public LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r)
+        {
+            m_host.AddScriptLPS(1);
+            return (new LSL_Types.Vector3(0, 0, 1) * r);
+        }
+
+        public LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
+        {
+            //A and B should both be normalized
+            m_host.AddScriptLPS(1);
+            double dotProduct = LSL_Types.Vector3.Dot(a, b);
+            LSL_Types.Vector3 crossProduct = LSL_Types.Vector3.Cross(a, b);
+            double magProduct = LSL_Types.Vector3.Mag(a) * LSL_Types.Vector3.Mag(b);
+            double angle = Math.Acos(dotProduct / magProduct);
+            LSL_Types.Vector3 axis = LSL_Types.Vector3.Norm(crossProduct);
+            double s = Math.Sin(angle / 2);
+
+            return new LSL_Types.Quaternion(axis.x * s, axis.y * s, axis.z * s, (float)Math.Cos(angle / 2));
+        }
+
+        public void llWhisper(int channelID, string text)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (text.Length > 1023)
+                text = text.Substring(0, 1023);
+
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Whisper, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
+
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text);
+        }
+
+        public void llShout(int channelID, string text)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (text.Length > 1023)
+                text = text.Substring(0, 1023);
+
+            World.SimChat(Helpers.StringToField(text),
+                          ChatTypeEnum.Shout, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, true);
+
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text);
+        }
+
+        public void llRegionSay(int channelID, string text)
+        {
+            if (channelID == 0)
+            {
+                LSLError("Cannot use llRegionSay() on channel 0");
+                return;
+            }
+
+            if (text.Length > 1023)
+                text = text.Substring(0, 1023);
+
+            m_host.AddScriptLPS(1);
+
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text);
+        }
+
+        public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID keyID;
+            LLUUID.TryParse(ID, out keyID);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg);
+        }
+
+        public void llListenControl(int number, int active)
+        {
+            m_host.AddScriptLPS(1);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.ListenControl(m_itemID, number, active);
+        }
+
+        public void llListenRemove(int number)
+        {
+            m_host.AddScriptLPS(1);
+            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+            wComm.ListenRemove(m_itemID, number);
+        }
+
+        public void llSensor(string name, string id, int type, double range, double arc)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID keyID = LLUUID.Zero;
+            LLUUID.TryParse(id, out keyID);
+
+            AsyncCommands.SensorRepeatPlugin.SenseOnce(m_localID, m_itemID, name, keyID, type, range, arc, m_host);
+       }
+
+        public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID keyID = LLUUID.Zero;
+            LLUUID.TryParse(id, out keyID);
+
+            AsyncCommands.SensorRepeatPlugin.SetSenseRepeatEvent(m_localID, m_itemID, name, keyID, type, range, arc, rate, m_host);
+        }
+
+        public void llSensorRemove()
+        {
+            m_host.AddScriptLPS(1);
+            AsyncCommands.SensorRepeatPlugin.UnSetSenseRepeaterEvents(m_localID, m_itemID);
+        }
+
+        public string resolveName(LLUUID objecUUID)
+        {
+            // try avatar username surname
+            UserProfileData profile = World.CommsManager.UserService.GetUserProfile(objecUUID);
+            if (profile != null)
+            {
+                string avatarname = profile.FirstName + " " + profile.SurName;
+                return avatarname;
+            }
+            // try an scene object
+            SceneObjectPart SOP = World.GetSceneObjectPart(objecUUID);
+            if (SOP != null)
+            {
+                string objectname = SOP.Name;
+                return objectname;
+            }
+
+            EntityBase SensedObject;
+            lock (World.Entities)
+            {
+                World.Entities.TryGetValue(objecUUID, out SensedObject);
+            }
+
+            if (SensedObject == null)
+                return String.Empty;
+            return SensedObject.Name;
+        }
+
+        public string llDetectedName(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return String.Empty;
+            return d.Name;
+        }
+
+        public string llDetectedKey(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return String.Empty;
+            return d.Key.ToString();
+        }
+
+        public string llDetectedOwner(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return String.Empty;
+            return d.Owner.ToString();
+        }
+
+        public LSL_Types.LSLInteger llDetectedType(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return 0;
+            return new LSL_Types.LSLInteger(d.Type);
+        }
+
+        public LSL_Types.Vector3 llDetectedPos(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return new LSL_Types.Vector3();
+            return d.Position;
+        }
+
+        public LSL_Types.Vector3 llDetectedVel(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return new LSL_Types.Vector3();
+            return d.Velocity;
+        }
+
+        public LSL_Types.Vector3 llDetectedGrab(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (parms == null)
+                return new LSL_Types.Vector3(0, 0, 0);
+
+            return parms.OffsetPos;
+        }
+
+        public LSL_Types.Quaternion llDetectedRot(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return new LSL_Types.Quaternion();
+            return d.Rotation;
+        }
+
+        public LSL_Types.LSLInteger llDetectedGroup(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams d = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (d == null)
+                return new LSL_Types.LSLInteger(0);
+            if (m_host.GroupID == d.Group)
+                return new LSL_Types.LSLInteger(1);
+            return new LSL_Types.LSLInteger(0);
+        }
+
+        public LSL_Types.LSLInteger llDetectedLinkNumber(int number)
+        {
+            m_host.AddScriptLPS(1);
+            DetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number);
+            if (parms == null)
+                return new LSL_Types.LSLInteger(0);
+
+            return new LSL_Types.LSLInteger(parms.LinkNum);
+        }
+
+        public void llDie()
+        {
+            m_host.AddScriptLPS(1);
+            World.DeleteSceneObject(m_host.ParentGroup);
+        }
+
+        public double llGround(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            int x = (int)(m_host.AbsolutePosition.X + offset.x);
+            int y = (int)(m_host.AbsolutePosition.Y + offset.y);
+            return World.GetLandHeight(x, y);
+        }
+
+        public double llCloud(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llCloud");
+            return 0;
+        }
+
+        public LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llWind");
+            return new LSL_Types.Vector3();
+        }
+
+        public void llSetStatus(int status, int value)
+        {
+            m_host.AddScriptLPS(1);
+
+            int statusrotationaxis = 0;
+
+            if ((status & ScriptBaseClass.STATUS_PHYSICS) == ScriptBaseClass.STATUS_PHYSICS)
+            {
+                if (value == 1)
+                    m_host.ScriptSetPhysicsStatus(true);
+                else
+                    m_host.ScriptSetPhysicsStatus(false);
+            }
+
+            if ((status & ScriptBaseClass.STATUS_PHANTOM) == ScriptBaseClass.STATUS_PHANTOM)
+            {
+                if (value == 1)
+                    m_host.ScriptSetPhantomStatus(true);
+                else
+                    m_host.ScriptSetPhantomStatus(false);
+            }
+
+            if ((status & ScriptBaseClass.STATUS_CAST_SHADOWS) == ScriptBaseClass.STATUS_CAST_SHADOWS)
+            {
+                m_host.AddFlag(LLObject.ObjectFlags.CastShadows);
+            }
+
+            if ((status & ScriptBaseClass.STATUS_ROTATE_X) == ScriptBaseClass.STATUS_ROTATE_X)
+            {
+                statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_X;
+            }
+
+            if ((status & ScriptBaseClass.STATUS_ROTATE_Y) == ScriptBaseClass.STATUS_ROTATE_Y)
+            {
+                statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_Y;
+            }
+
+            if ((status & ScriptBaseClass.STATUS_ROTATE_Z) == ScriptBaseClass.STATUS_ROTATE_Z)
+            {
+                statusrotationaxis |= ScriptBaseClass.STATUS_ROTATE_Z;
+            }
+
+            if ((status & ScriptBaseClass.STATUS_BLOCK_GRAB) == ScriptBaseClass.STATUS_BLOCK_GRAB)
+            {
+                NotImplemented("llSetStatus - STATUS_BLOCK_GRAB");
+            }
+
+            if ((status & ScriptBaseClass.STATUS_DIE_AT_EDGE) == ScriptBaseClass.STATUS_DIE_AT_EDGE)
+            {
+                if (value == 1)
+                    m_host.SetDieAtEdge(true);
+                else
+                    m_host.SetDieAtEdge(false);
+            }
+
+            if ((status & ScriptBaseClass.STATUS_RETURN_AT_EDGE) == ScriptBaseClass.STATUS_RETURN_AT_EDGE)
+            {
+                NotImplemented("llSetStatus - STATUS_RETURN_AT_EDGE");
+            }
+
+            if ((status & ScriptBaseClass.STATUS_SANDBOX) == ScriptBaseClass.STATUS_SANDBOX)
+            {
+                NotImplemented("llSetStatus - STATUS_SANDBOX");
+            }
+
+            if (statusrotationaxis != 0)
+            {
+                m_host.SetAxisRotation(statusrotationaxis, value);
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetStatus(int status)
+        {
+            m_host.AddScriptLPS(1);
+            // Console.WriteLine(m_host.UUID.ToString() + " status is " + m_host.GetEffectiveObjectFlags().ToString());
+            switch (status)
+            {
+                case ScriptBaseClass.STATUS_PHYSICS:
+                    if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) == (uint)LLObject.ObjectFlags.Physics)
+                    {
+                        return 1;
+                    }
+                    return 0;
+
+                case ScriptBaseClass.STATUS_PHANTOM:
+                    if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) == (uint)LLObject.ObjectFlags.Phantom)
+                    {
+                        return 1;
+                    }
+                    return 0;
+
+                case ScriptBaseClass.STATUS_CAST_SHADOWS:
+                    if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.CastShadows) == (uint)LLObject.ObjectFlags.CastShadows)
+                    {
+                        return 1;
+                    }
+                    return 0;
+
+                case ScriptBaseClass.STATUS_BLOCK_GRAB:
+                    NotImplemented("llGetStatus - STATUS_BLOCK_GRAB");
+                    return 0;
+
+                case ScriptBaseClass.STATUS_DIE_AT_EDGE:
+                    if (m_host.GetDieAtEdge())
+                        return 1;
+                    else
+                        return 0;
+
+                case ScriptBaseClass.STATUS_RETURN_AT_EDGE:
+                    NotImplemented("llGetStatus - STATUS_RETURN_AT_EDGE");
+                    return 0;
+
+                case ScriptBaseClass.STATUS_ROTATE_X:
+                    NotImplemented("llGetStatus - STATUS_ROTATE_X");
+                    return 0;
+
+                case ScriptBaseClass.STATUS_ROTATE_Y:
+                    NotImplemented("llGetStatus - STATUS_ROTATE_Y");
+                    return 0;
+
+                case ScriptBaseClass.STATUS_ROTATE_Z:
+                    NotImplemented("llGetStatus - STATUS_ROTATE_Z");
+                    return 0;
+
+                case ScriptBaseClass.STATUS_SANDBOX:
+                    NotImplemented("llGetStatus - STATUS_SANDBOX");
+                    return 0;
+            }
+            return 0;
+        }
+
+        public void llSetScale(LSL_Types.Vector3 scale)
+        {
+            m_host.AddScriptLPS(1);
+            SetScale(m_host, scale);
+        }
+
+        private void SetScale(SceneObjectPart part, LSL_Types.Vector3 scale)
+        {
+            // TODO: this needs to trigger a persistance save as well
+            LLVector3 tmp = part.Scale;
+            tmp.X = (float)scale.x;
+            tmp.Y = (float)scale.y;
+            tmp.Z = (float)scale.z;
+            part.Scale = tmp;
+            part.SendFullUpdateToAllClients();
+        }
+
+        public LSL_Types.Vector3 llGetScale()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.Scale.X, m_host.Scale.Y, m_host.Scale.Z);
+        }
+
+        public void llSetColor(LSL_Types.Vector3 color, int face)
+        {
+            m_host.AddScriptLPS(1);
+
+            SetColor(m_host, color, face);
+        }
+
+        private void SetColor(SceneObjectPart part, LSL_Types.Vector3 color, int face)
+        {
+            LLObject.TextureEntry tex = part.Shape.Textures;
+            LLColor texcolor;
+            if (face > -1)
+            {
+                texcolor = tex.CreateFace((uint)face).RGBA;
+                texcolor.R = (float)Math.Abs(color.x - 1);
+                texcolor.G = (float)Math.Abs(color.y - 1);
+                texcolor.B = (float)Math.Abs(color.z - 1);
+                tex.FaceTextures[face].RGBA = texcolor;
+                part.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (uint i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        texcolor = tex.FaceTextures[i].RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.FaceTextures[i].RGBA = texcolor;
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                }
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        public double llGetAlpha(int face)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
+            {
+                return (double)((tex.DefaultTexture.RGBA.A * 255) / 255);
+            }
+            if (face > -1)
+            {
+                return (double)((tex.GetFace((uint)face).RGBA.A * 255) / 255);
+            }
+            return 0;
+        }
+
+        public void llSetAlpha(double alpha, int face)
+        {
+            m_host.AddScriptLPS(1);
+
+            SetAlpha(m_host, alpha, face);
+        }
+
+        private void SetAlpha(SceneObjectPart part, double alpha, int face)
+        {
+            LLObject.TextureEntry tex = part.Shape.Textures;
+            LLColor texcolor;
+            if (face > -1)
+            {
+                texcolor = tex.CreateFace((uint)face).RGBA;
+                texcolor.A = (float)Math.Abs(alpha - 1);
+                tex.FaceTextures[face].RGBA = texcolor;
+                part.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        texcolor = tex.FaceTextures[i].RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.FaceTextures[i].RGBA = texcolor;
+                    }
+                }
+                texcolor = tex.DefaultTexture.RGBA;
+                texcolor.A = (float)Math.Abs(alpha - 1);
+                tex.DefaultTexture.RGBA = texcolor;
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        private void SetFlexi(SceneObjectPart part, bool flexi, int softness, float gravity, float friction,
+            float wind, float tension, LSL_Types.Vector3 Force)
+        {
+            if (part == null)
+                return;
+
+            bool needs_fakedelete = false;
+            if (flexi)
+            {
+                if (!part.Shape.FlexiEntry)
+                {
+                    needs_fakedelete = true;
+                }
+                part.Shape.FlexiEntry = true;   // this setting flexi true isn't working, but the below parameters do
+                                                // work once the prim is already flexi
+                part.Shape.FlexiSoftness = softness;
+                part.Shape.FlexiGravity = gravity;
+                part.Shape.FlexiDrag = friction;
+                part.Shape.FlexiWind = wind;
+                part.Shape.FlexiTension = tension;
+                part.Shape.FlexiForceX = (float)Force.x;
+                part.Shape.FlexiForceY = (float)Force.y;
+                part.Shape.FlexiForceZ = (float)Force.z;
+                part.Shape.PathCurve = 0x80;
+
+            }
+            else
+            {
+                if (part.Shape.FlexiEntry)
+                {
+                    needs_fakedelete = true;
+                }
+                part.Shape.FlexiEntry = false;
+            }
+
+            needs_fakedelete = false;
+            if (needs_fakedelete)
+            {
+                if (part.ParentGroup != null)
+                {
+                    part.ParentGroup.FakeDeleteGroup();
+                }
+            }
+
+            part.ScheduleFullUpdate();
+        }
+
+        private void SetPointLight(SceneObjectPart part, bool light, LSL_Types.Vector3 color, float intensity, float radius, float falloff)
+        {
+            if (part == null)
+                return;
+
+            if (light)
+            {
+                part.Shape.LightEntry = true;
+                part.Shape.LightColorR = (float)color.x;
+                part.Shape.LightColorG = (float)color.y;
+                part.Shape.LightColorB = (float)color.z;
+                part.Shape.LightIntensity = intensity;
+                part.Shape.LightRadius = radius;
+                part.Shape.LightFalloff = falloff;
+            }
+            else
+            {
+                part.Shape.LightEntry = false;
+            }
+
+            part.ScheduleFullUpdate();
+        }
+
+
+
+        public LSL_Types.Vector3 llGetColor(int face)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LLColor texcolor;
+            LSL_Types.Vector3 rgb;
+            if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
+            {
+                texcolor = tex.DefaultTexture.RGBA;
+                rgb.x = (255 - (texcolor.R * 255)) / 255;
+                rgb.y = (255 - (texcolor.G * 255)) / 255;
+                rgb.z = (255 - (texcolor.B * 255)) / 255;
+                return rgb;
+            }
+            if (face > -1)
+            {
+                texcolor = tex.GetFace((uint)face).RGBA;
+                rgb.x = (255 - (texcolor.R * 255)) / 255;
+                rgb.y = (255 - (texcolor.G * 255)) / 255;
+                rgb.z = (255 - (texcolor.B * 255)) / 255;
+                return rgb;
+            }
+            else
+            {
+                return new LSL_Types.Vector3();
+            }
+        }
+
+        public void llSetTexture(string texture, int face)
+        {
+            m_host.AddScriptLPS(1);
+            SetTexture(m_host, texture, face);
+        }
+
+        private void SetTexture(SceneObjectPart part, string texture, int face)
+        {
+            LLUUID textureID=new LLUUID();
+
+            if (!LLUUID.TryParse(texture, out textureID))
+            {
+                textureID=InventoryKey(texture, (int)AssetType.Texture);
+            }
+
+            if (textureID == LLUUID.Zero)
+                return;
+
+            LLObject.TextureEntry tex = part.Shape.Textures;
+
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.TextureID = textureID;
+                tex.FaceTextures[face] = texface;
+                part.UpdateTexture(tex);
+                return;
+            }
+            else if (face == -1)
+            {
+                for (uint i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].TextureID = textureID;
+                    }
+                }
+                tex.DefaultTexture.TextureID = textureID;
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        public void llScaleTexture(double u, double v, int face)
+        {
+            m_host.AddScriptLPS(1);
+
+            ScaleTexture(m_host, u, v, face);
+        }
+
+        private void ScaleTexture(SceneObjectPart part, double u, double v, int face)
+        {
+            LLObject.TextureEntry tex = part.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.RepeatU = (float)u;
+                texface.RepeatV = (float)v;
+                tex.FaceTextures[face] = texface;
+                part.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].RepeatU = (float)u;
+                        tex.FaceTextures[i].RepeatV = (float)v;
+                    }
+                }
+                tex.DefaultTexture.RepeatU = (float)u;
+                tex.DefaultTexture.RepeatV = (float)v;
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        public void llOffsetTexture(double u, double v, int face)
+        {
+            m_host.AddScriptLPS(1);
+            OffsetTexture(m_host, u, v, face);
+        }
+
+        private void OffsetTexture(SceneObjectPart part, double u, double v, int face)
+        {
+            LLObject.TextureEntry tex = part.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.OffsetU = (float)u;
+                texface.OffsetV = (float)v;
+                tex.FaceTextures[face] = texface;
+                part.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].OffsetU = (float)u;
+                        tex.FaceTextures[i].OffsetV = (float)v;
+                    }
+                }
+                tex.DefaultTexture.OffsetU = (float)u;
+                tex.DefaultTexture.OffsetV = (float)v;
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        public void llRotateTexture(double rotation, int face)
+        {
+            m_host.AddScriptLPS(1);
+            RotateTexture(m_host, rotation, face);
+        }
+
+        private void RotateTexture(SceneObjectPart part, double rotation, int face)
+        {
+            LLObject.TextureEntry tex = part.Shape.Textures;
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
+                texface.Rotation = (float)rotation;
+                tex.FaceTextures[face] = texface;
+                part.UpdateTexture(tex);
+                return;
+            }
+            if (face == -1)
+            {
+                for (int i = 0; i < 32; i++)
+                {
+                    if (tex.FaceTextures[i] != null)
+                    {
+                        tex.FaceTextures[i].Rotation = (float)rotation;
+                    }
+                }
+                tex.DefaultTexture.Rotation = (float)rotation;
+                part.UpdateTexture(tex);
+                return;
+            }
+        }
+
+        public string llGetTexture(int face)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            if (face > -1)
+            {
+                LLObject.TextureEntryFace texface;
+                texface = tex.GetFace((uint)face);
+                return texface.TextureID.ToString();
+            }
+            else
+            {
+                return String.Empty;
+            }
+        }
+
+        public void llSetPos(LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+
+            SetPos(m_host, pos);
+        }
+
+        private void SetPos(SceneObjectPart part, LSL_Types.Vector3 pos)
+        {
+            if (part.ParentID != 0)
+            {
+                part.UpdateOffSet(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
+            }
+            else
+            {
+                part.UpdateGroupPosition(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
+            }
+        }
+
+        public LSL_Types.Vector3 llGetPos()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
+                                         m_host.AbsolutePosition.Y,
+                                         m_host.AbsolutePosition.Z);
+        }
+
+        public LSL_Types.Vector3 llGetLocalPos()
+        {
+            m_host.AddScriptLPS(1);
+            if (m_host.ParentID != 0)
+            {
+                return new LSL_Types.Vector3(m_host.OffsetPosition.X,
+                                             m_host.OffsetPosition.Y,
+                                             m_host.OffsetPosition.Z);
+            }
+            else
+            {
+                return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
+                                             m_host.AbsolutePosition.Y,
+                                             m_host.AbsolutePosition.Z);
+            }
+        }
+
+        public void llSetRot(LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+
+            SetRot(m_host, rot);
+        }
+
+        private void SetRot(SceneObjectPart part, LSL_Types.Quaternion rot)
+        {
+            part.UpdateRotation(new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s));
+            // Update rotation does not move the object in the physics scene if it's a linkset.
+            part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition;
+        }
+
+        public LSL_Types.Quaternion llGetRot()
+        {
+            m_host.AddScriptLPS(1);
+            LLQuaternion q = m_host.RotationOffset;
+            return new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W);
+        }
+
+        public LSL_Types.Quaternion llGetLocalRot()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Quaternion(m_host.RotationOffset.X, m_host.RotationOffset.Y, m_host.RotationOffset.Z, m_host.RotationOffset.W);
+        }
+
+        public void llSetForce(LSL_Types.Vector3 force, int local)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetForce");
+        }
+
+        public LSL_Types.Vector3 llGetForce()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetForce");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range)
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.registerTargetWaypoint(new LLVector3((float)position.x, (float)position.y, (float)position.z), (float)range);
+
+        }
+
+        public void llTargetRemove(int number)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.unregisterTargetWaypoint(number);
+        }
+
+        public LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRotTarget");
+            return 0;
+        }
+
+        public void llRotTargetRemove(int number)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRotTargetRemove");
+        }
+
+        public void llMoveToTarget(LSL_Types.Vector3 target, double tau)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.MoveToTarget(new LLVector3((float)target.x, (float)target.y, (float)target.z), (float)tau);
+        }
+
+        public void llStopMoveToTarget()
+        {
+            m_host.AddScriptLPS(1);
+            m_host.StopMoveToTarget();
+        }
+
+        public void llApplyImpulse(LSL_Types.Vector3 force, int local)
+        {
+            m_host.AddScriptLPS(1);
+            //No energy force yet
+
+            if (force.x > 20000)
+                    force.x = 20000;
+            if (force.y > 20000)
+                    force.y = 20000;
+            if (force.z > 20000)
+                    force.z = 20000;
+
+            if (local == 1)
+            {
+                m_host.ApplyImpulse(new LLVector3((float)force.x, (float)force.y, (float)force.z), true);
+            }
+            else
+            {
+
+                m_host.ApplyImpulse(new LLVector3((float)force.x,(float)force.y,(float)force.z), false);
+            }
+        }
+
+        public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llApplyRotationalImpulse");
+        }
+
+        public void llSetTorque(LSL_Types.Vector3 torque, int local)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetTorque");
+        }
+
+        public LSL_Types.Vector3 llGetTorque()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetTorque");
+            return new LSL_Types.Vector3();
+        }
+
+        public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetForceAndTorque");
+        }
+
+        public LSL_Types.Vector3 llGetVel()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.Velocity.X, m_host.Velocity.Y, m_host.Velocity.Z);
+        }
+
+        public LSL_Types.Vector3 llGetAccel()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.Acceleration.X, m_host.Acceleration.Y, m_host.Acceleration.Z);
+        }
+
+        public LSL_Types.Vector3 llGetOmega()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.RotationalVelocity.X, m_host.RotationalVelocity.Y, m_host.RotationalVelocity.Z);
+        }
+
+        public double llGetTimeOfDay()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetTimeOfDay");
+            return 0;
+        }
+
+        public double llGetWallclock()
+        {
+            m_host.AddScriptLPS(1);
+            return DateTime.Now.TimeOfDay.TotalSeconds;
+        }
+
+        public double llGetTime()
+        {
+            m_host.AddScriptLPS(1);
+            TimeSpan ScriptTime = DateTime.Now - m_timer;
+            return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation);
+        }
+
+        public void llResetTime()
+        {
+            m_host.AddScriptLPS(1);
+            m_timer = DateTime.Now;
+        }
+
+        public double llGetAndResetTime()
+        {
+            m_host.AddScriptLPS(1);
+            TimeSpan ScriptTime = DateTime.Now - m_timer;
+            m_timer = DateTime.Now;
+            return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation);
+        }
+
+        public void llSound()
+        {
+            m_host.AddScriptLPS(1);
+            // This function has been deprecated
+            // see http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSound
+            Deprecated("llSound");
+        }
+
+        // Xantor 20080528 PlaySound updated so it accepts an objectinventory name -or- a key to a sound
+        // 20080530 Updated to remove code duplication
+        public void llPlaySound(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+
+            // send the sound, once, to all clients in range
+            m_host.SendSound(KeyOrName(sound).ToString(), volume, false, 0);
+        }
+
+        // Xantor 20080528 we should do this differently.
+        // 1) apply the sound to the object
+        // 2) schedule full update
+        // just sending the sound out once doesn't work so well when other avatars come in view later on
+        // or when the prim gets moved, changed, sat on, whatever
+        // see large number of mantises (mantes?)
+        // 20080530 Updated to remove code duplication
+        // 20080530 Stop sound if there is one, otherwise volume only changes don't work
+        public void llLoopSound(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (m_host.Sound != LLUUID.Zero)
+                llStopSound();
+
+            m_host.Sound = KeyOrName(sound);
+            m_host.SoundGain = volume;
+            m_host.SoundFlags = 1;      // looping
+            m_host.SoundRadius = 20;    // Magic number, 20 seems reasonable. Make configurable?
+
+            m_host.ScheduleFullUpdate();
+            m_host.SendFullUpdateToAllClients();
+        }
+
+        public void llLoopSoundMaster(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llLoopSoundMaster");
+        }
+
+        public void llLoopSoundSlave(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llLoopSoundSlave");
+        }
+
+        public void llPlaySoundSlave(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llPlaySoundSlave");
+        }
+
+        public void llTriggerSound(string sound, double volume)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.SendSound(sound, volume, true, 0);
+        }
+
+        // Xantor 20080528: Clear prim data of sound instead
+        public void llStopSound()
+        {
+            m_host.AddScriptLPS(1);
+
+            m_host.Sound = LLUUID.Zero;
+            m_host.SoundGain = 0;
+            m_host.SoundFlags = 0;
+            m_host.SoundRadius = 0;
+
+            m_host.ScheduleFullUpdate();
+            m_host.SendFullUpdateToAllClients();
+
+            // m_host.SendSound(LLUUID.Zero.ToString(), 1.0, false, 2);
+        }
+
+        public void llPreloadSound(string sound)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.PreloadSound(sound);
+        }
+
+        /// <summary>
+        /// Return a portion of the designated string bounded by
+        /// inclusive indices (start and end). As usual, the negative
+        /// indices, and the tolerance for out-of-bound values, makes
+        /// this more complicated than it might otherwise seem.
+        /// </summary>
+
+        public string llGetSubString(string src, int start, int end)
+        {
+
+            m_host.AddScriptLPS(1);
+
+            // Normalize indices (if negative).
+            // After normlaization they may still be
+            // negative, but that is now relative to
+            // the start, rather than the end, of the
+            // sequence.
+
+            if (start < 0)
+            {
+                start = src.Length+start;
+            }
+            if (end < 0)
+            {
+                end = src.Length+end;
+            }
+
+            // Conventional substring
+            if (start <= end)
+            {
+                // Implies both bounds are out-of-range.
+                if (end < 0 || start >= src.Length)
+                {
+                    return String.Empty;
+                }
+                // If end is positive, then it directly
+                // corresponds to the lengt of the substring
+                // needed (plus one of course). BUT, it
+                // must be within bounds.
+                if (end >= src.Length)
+                {
+                    end = src.Length-1;
+                }
+
+                if (start < 0)
+                {
+                    return src.Substring(0,end+1);
+                }
+                // Both indices are positive
+                return src.Substring(start, (end+1) - start);
+            }
+
+            // Inverted substring (end < start)
+            else
+            {
+                // Implies both indices are below the
+                // lower bound. In the inverted case, that
+                // means the entire string will be returned
+                // unchanged.
+                if (start < 0)
+                {
+                    return src;
+                }
+                // If both indices are greater than the upper
+                // bound the result may seem initially counter
+                // intuitive.
+                if (end >= src.Length)
+                {
+                    return src;
+                }
+
+                if (end < 0)
+                {
+                    if (start < src.Length)
+                    {
+                        return src.Substring(start);
+                    }
+                    else
+                    {
+                        return String.Empty;
+                    }
+                }
+                else
+                {
+                    if (start < src.Length)
+                    {
+                        return src.Substring(0,end+1) + src.Substring(start);
+                    }
+                    else
+                    {
+                        return src.Substring(0,end+1);
+                    }
+                }
+            }
+         }
+
+        /// <summary>
+        /// Delete substring removes the specified substring bounded
+        /// by the inclusive indices start and end. Indices may be
+        /// negative (indicating end-relative) and may be inverted,
+        /// i.e. end < start.
+        /// </summary>
+
+        public string llDeleteSubString(string src, int start, int end)
+        {
+
+            m_host.AddScriptLPS(1);
+
+            // Normalize indices (if negative).
+            // After normlaization they may still be
+            // negative, but that is now relative to
+            // the start, rather than the end, of the
+            // sequence.
+            if (start < 0)
+            {
+                start = src.Length+start;
+            }
+            if (end < 0)
+            {
+                end = src.Length+end;
+            }
+            // Conventionally delimited substring
+            if (start <= end)
+            {
+                // If both bounds are outside of the existing
+                // string, then return unchanges.
+                if (end < 0 || start >= src.Length)
+                {
+                    return src;
+                }
+                // At least one bound is in-range, so we
+                // need to clip the out-of-bound argument.
+                if (start < 0)
+                {
+                    start = 0;
+                }
+
+                if (end >= src.Length)
+                {
+                    end = src.Length-1;
+                }
+
+                return src.Remove(start,end-start+1);
+            }
+            // Inverted substring
+            else
+            {
+                // In this case, out of bounds means that
+                // the existing string is part of the cut.
+                if (start < 0 || end >= src.Length)
+                {
+                    return String.Empty;
+                }
+
+                if (end > 0)
+                {
+                    if (start < src.Length)
+                    {
+                        return src.Remove(start).Remove(0,end+1);
+                    }
+                    else
+                    {
+                        return src.Remove(0,end+1);
+                    }
+                }
+                else
+                {
+                    if (start < src.Length)
+                    {
+                        return src.Remove(start);
+                    }
+                    else
+                    {
+                        return src;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Insert string inserts the specified string identified by src
+        /// at the index indicated by index. Index may be negative, in
+        /// which case it is end-relative. The index may exceed either
+        /// string bound, with the result being a concatenation.
+        /// </summary>
+
+        public string llInsertString(string dest, int index, string src)
+        {
+
+            m_host.AddScriptLPS(1);
+
+            // Normalize indices (if negative).
+            // After normlaization they may still be
+            // negative, but that is now relative to
+            // the start, rather than the end, of the
+            // sequence.
+            if (index < 0)
+            {
+                index = dest.Length+index;
+
+                // Negative now means it is less than the lower
+                // bound of the string.
+
+                if (index < 0)
+                {
+                    return src+dest;
+                }
+
+            }
+
+            if (index >= dest.Length)
+            {
+                return dest+src;
+            }
+
+            // The index is in bounds.
+            // In this case the index refers to the index that will
+            // be assigned to the first character of the inserted string.
+            // So unlike the other string operations, we do not add one
+            // to get the correct string length.
+            return dest.Substring(0,index)+src+dest.Substring(index);
+
+        }
+
+        public string llToUpper(string src)
+        {
+            m_host.AddScriptLPS(1);
+            return src.ToUpper();
+        }
+
+        public string llToLower(string src)
+        {
+            m_host.AddScriptLPS(1);
+            return src.ToLower();
+        }
+
+        public LSL_Types.LSLInteger llGiveMoney(string destination, int amount)
+        {
+            LLUUID invItemID=InventorySelf();
+            if (invItemID == LLUUID.Zero)
+                return 0;
+
+            m_host.AddScriptLPS(1);
+
+            if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
+                return 0;
+
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_DEBIT) == 0)
+            {
+                LSLError("No permissions to give money");
+                return 0;
+            }
+
+            LLUUID toID=new LLUUID();
+
+            if (!LLUUID.TryParse(destination, out toID))
+            {
+                LSLError("Bad key in llGiveMoney");
+                return 0;
+            }
+
+            IMoneyModule money=World.RequestModuleInterface<IMoneyModule>();
+
+            if (money == null)
+            {
+                NotImplemented("llGiveMoney");
+                return 0;
+            }
+
+            bool result=money.ObjectGiveMoney(m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount);
+
+            if (result)
+                return 1;
+
+            return 0;
+        }
+
+        public void llMakeExplosion()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMakeExplosion");
+        }
+
+        public void llMakeFountain()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMakeFountain");
+        }
+
+        public void llMakeSmoke()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMakeSmoke");
+        }
+
+        public void llMakeFire()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMakeFire");
+        }
+
+        public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param)
+        {
+            m_host.AddScriptLPS(1);
+            //NotImplemented("llRezObject");
+            bool found = false;
+
+            // Instead of using return;, I'm using continue; because in our TaskInventory implementation
+            // it's possible to have two items with the same task inventory name.
+            // this is an easter egg of sorts.
+
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == inventory)
+                {
+                    // make sure we're an object.
+                    if (inv.Value.InvType != (int)InventoryType.Object)
+                    {
+                        llSay(0, "Unable to create requested object. Object is missing from database.");
+                        continue;
+                    }
+
+                    LLVector3 llpos = new LLVector3((float)pos.x, (float)pos.y, (float)pos.z);
+
+                    // test if we're further away then 10m
+                    if (Util.GetDistanceTo(llpos, m_host.AbsolutePosition) > 10)
+                        return; // wiki says, if it's further away then 10m, silently fail.
+
+                    LLVector3 llvel = new LLVector3((float)vel.x, (float)vel.y, (float)vel.z);
+
+                    // need the magnitude later
+                    float velmag = (float)Util.GetMagnitude(llvel);
+
+                    SceneObjectGroup new_group = World.RezObject(inv.Value, llpos, new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s), llvel, param);
+
+                    // If either of these are null, then there was an unknown error.
+                    if (new_group == null)
+                        continue;
+                    if (new_group.RootPart == null)
+                        continue;
+
+                    // objects rezzed with this method are die_at_edge by default.
+                    new_group.RootPart.SetDieAtEdge(true);
+
+                    m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                            "object_rez", new Object[] {
+                            new LSL_Types.LSLString(
+                            new_group.RootPart.UUID.ToString()) },
+                            new DetectParams[0]));
+
+                    float groupmass = new_group.GetMass();
+
+                    //Recoil.
+                    llApplyImpulse(new LSL_Types.Vector3(llvel.X * groupmass, llvel.Y * groupmass, llvel.Z * groupmass), 0);
+                    found = true;
+                    //script delay
+                    System.Threading.Thread.Sleep((int)((groupmass * velmag) / 10));
+                    break;
+                }
+            }
+            if (!found)
+                llSay(0, "Could not find object " + inventory);
+        }
+
+        public void llLookAt(LSL_Types.Vector3 target, double strength, double damping)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llLookAt");
+        }
+
+        public void llStopLookAt()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llStopLookAt");
+        }
+
+        public void llSetTimerEvent(double sec)
+        {
+            m_host.AddScriptLPS(1);
+            // Setting timer repeat
+            AsyncCommands.TimerPlugin.SetTimerEvent(m_localID, m_itemID, sec);
+        }
+
+        public void llSleep(double sec)
+        {
+            m_host.AddScriptLPS(1);
+            Thread.Sleep((int)(sec * 1000));
+        }
+
+        public double llGetMass()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.GetMass();
+        }
+
+        public void llCollisionFilter(string name, string id, int accept)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llCollisionFilter");
+        }
+
+        public void llTakeControls(int controls, int accept, int pass_on)
+        {
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
+            {
+                return;
+            }
+
+            if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero)
+            {
+                ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter);
+
+                if (presence != null)
+                {
+                    if ((m_host.TaskInventory[InventorySelf()].PermsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0)
+                    {
+                        presence.RegisterControlEventsToScript(controls, accept, pass_on, m_localID, m_itemID);
+
+                    }
+                }
+            }
+
+            m_host.AddScriptLPS(1);
+            //NotImplemented("llTakeControls");
+        }
+
+        public void llReleaseControls()
+        {
+            m_host.AddScriptLPS(1);
+
+            if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
+            {
+                return;
+            }
+
+            if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero)
+            {
+                ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter);
+
+                if (presence != null)
+                {
+                    if ((m_host.TaskInventory[InventorySelf()].PermsMask & ScriptBaseClass.PERMISSION_TAKE_CONTROLS) != 0)
+                    {
+                        // Unregister controls from Presence
+                        presence.UnRegisterControlEventsToScript(m_localID, m_itemID);
+                        // Remove Take Control permission.
+                        m_host.TaskInventory[InventorySelf()].PermsMask &= ~ScriptBaseClass.PERMISSION_TAKE_CONTROLS;
+                    }
+                }
+            }
+        }
+
+        public void llAttachToAvatar(int attachment)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llAttachToAvatar");
+        }
+
+        public void llDetachFromAvatar()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llDetachFromAvatar");
+        }
+
+        public void llTakeCamera()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llTakeCamera");
+        }
+
+        public void llReleaseCamera()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llReleaseCamera");
+        }
+
+        public string llGetOwner()
+        {
+            m_host.AddScriptLPS(1);
+
+            return m_host.ObjectOwner.ToString();
+        }
+
+        public void llInstantMessage(string user, string message)
+        {
+            m_host.AddScriptLPS(1);
+
+            // We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
+            // InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent,
+            // but I don't think we have a list of scenes available from here.
+            // (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.)
+
+            // user is a UUID
+
+            // TODO: figure out values for client, fromSession, and imSessionID
+            // client.SendInstantMessage(m_host.UUID, fromSession, message, user, imSessionID, m_host.Name, AgentManager.InstantMessageDialog.MessageFromAgent, (uint)Util.UnixTimeSinceEpoch());
+            LLUUID friendTransactionID = LLUUID.Random();
+
+            //m_pendingFriendRequests.Add(friendTransactionID, fromAgentID);
+
+            GridInstantMessage msg = new GridInstantMessage();
+            msg.fromAgentID = new Guid(m_host.UUID.ToString()); // fromAgentID.UUID;
+            msg.fromAgentSession = new Guid(friendTransactionID.ToString());// fromAgentSession.UUID;
+            msg.toAgentID = new Guid(user); // toAgentID.UUID;
+            msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here
+//            Console.WriteLine("[Scripting IM]: From:" + msg.fromAgentID.ToString() + " To: " + msg.toAgentID.ToString() + " Session:" + msg.imSessionID.ToString() + " Message:" + message);
+//            Console.WriteLine("[Scripting IM]: Filling Session: " + msg.imSessionID.ToString());
+            msg.timestamp = (uint)Util.UnixTimeSinceEpoch();// timestamp;
+            //if (client != null)
+            //{
+                msg.fromAgentName = m_host.Name;//client.FirstName + " " + client.LastName;// fromAgentName;
+            //}
+            //else
+            //{
+            //    msg.fromAgentName = "(hippos)";// Added for posterity.  This means that we can't figure out who sent it
+            //}
+            msg.message = message;
+            msg.dialog = (byte)19; // messgage from script ??? // dialog;
+            msg.fromGroup = false;// fromGroup;
+            msg.offline = (byte)0; //offline;
+            msg.ParentEstateID = 0; //ParentEstateID;
+            msg.Position = new sLLVector3();// new sLLVector3(m_host.AbsolutePosition);
+            msg.RegionID = World.RegionInfo.RegionID.UUID;//RegionID.UUID;
+            msg.binaryBucket = new byte[0];// binaryBucket;
+            World.TriggerGridInstantMessage(msg, InstantMessageReceiver.IMModule);
+            //  NotImplemented("llInstantMessage");
+      }
+
+        public void llEmail(string address, string subject, string message)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llEmail");
+        }
+
+        public void llGetNextEmail(string address, string subject)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetNextEmail");
+        }
+
+        public string llGetKey()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.UUID.ToString();
+        }
+
+        public void llSetBuoyancy(double buoyancy)
+        {
+            m_host.AddScriptLPS(1);
+            if (m_host.ParentGroup != null)
+            {
+                if (m_host.ParentGroup.RootPart != null)
+                {
+                    m_host.ParentGroup.RootPart.SetBuoyancy((float)buoyancy);
+                }
+            }
+        }
+
+
+
+        public void llSetHoverHeight(double height, int water, double tau)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetHoverHeight");
+        }
+
+        public void llStopHover()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llStopHover");
+        }
+
+        public void llMinEventDelay(double delay)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMinEventDelay");
+        }
+
+        public void llSoundPreload()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSoundPreload");
+        }
+
+        public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRotLookAt");
+        }
+
+        public LSL_Types.LSLInteger llStringLength(string str)
+        {
+            m_host.AddScriptLPS(1);
+            if (str.Length > 0)
+            {
+                return str.Length;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public void llStartAnimation(string anim)
+        {
+            m_host.AddScriptLPS(1);
+
+            LLUUID invItemID=InventorySelf();
+            if (invItemID == LLUUID.Zero)
+                return;
+
+            if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
+                return;
+
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION) != 0)
+            {
+                ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter);
+
+                if (presence != null)
+                {
+                    // Do NOT try to parse LLUUID, animations cannot be triggered by ID
+                    LLUUID animID=InventoryKey(anim, (int)AssetType.Animation);
+                    if (animID == LLUUID.Zero)
+                        presence.AddAnimation(anim);
+                    else
+                        presence.AddAnimation(animID);
+                }
+            }
+        }
+
+        public void llStopAnimation(string anim)
+        {
+            m_host.AddScriptLPS(1);
+
+            LLUUID invItemID=InventorySelf();
+            if (invItemID == LLUUID.Zero)
+                return;
+
+            if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
+                return;
+
+            if ((m_host.TaskInventory[invItemID].PermsMask & ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION) != 0)
+            {
+                LLUUID animID = new LLUUID();
+
+                if (!LLUUID.TryParse(anim, out animID))
+                {
+                    animID=InventoryKey(anim);
+                }
+
+                if (animID == LLUUID.Zero)
+                    return;
+
+                ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter);
+
+                if (presence != null)
+                {
+                    if (animID == LLUUID.Zero)
+                        presence.RemoveAnimation(anim);
+                    else
+                        presence.RemoveAnimation(animID);
+                }
+            }
+        }
+
+        public void llPointAt()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llPointAt");
+        }
+
+        public void llStopPointAt()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llStopPointAt");
+        }
+
+        public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.RotationalVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
+            m_host.AngularVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
+            m_host.ScheduleTerseUpdate();
+            m_host.SendTerseUpdateToAllClients();
+        }
+
+        public LSL_Types.LSLInteger llGetStartParameter()
+        {
+            m_host.AddScriptLPS(1);
+            // NotImplemented("llGetStartParameter");
+            return m_host.ParentGroup.StartParameter;
+        }
+
+        public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGodLikeRezObject");
+        }
+
+        public void llRequestPermissions(string agent, int perm)
+        {
+            LLUUID agentID=new LLUUID();
+
+            if (!LLUUID.TryParse(agent, out agentID))
+                return;
+
+            LLUUID invItemID=InventorySelf();
+
+            if (invItemID == LLUUID.Zero)
+                return; // Not in a prim? How??
+
+            if (agentID == LLUUID.Zero || perm == 0) // Releasing permissions
+            {
+                m_host.TaskInventory[invItemID].PermsGranter=LLUUID.Zero;
+                m_host.TaskInventory[invItemID].PermsMask=0;
+
+                m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                        "run_time_permissions", new Object[] {
+                        new LSL_Types.LSLInteger(0) },
+                        new DetectParams[0]));
+
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+
+            if (m_host.ParentGroup.RootPart.m_IsAttachment && agent == m_host.ParentGroup.RootPart.m_attachedAvatar)
+            {
+                // When attached, certain permissions are implicit if requested from owner
+                int implicitPerms = ScriptBaseClass.PERMISSION_TAKE_CONTROLS |
+                        ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION |
+                        ScriptBaseClass.PERMISSION_ATTACH;
+
+                if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
+                {
+                    m_host.TaskInventory[invItemID].PermsGranter=agentID;
+                    m_host.TaskInventory[invItemID].PermsMask=perm;
+
+                    m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                            "run_time_permissions", new Object[] {
+                            new LSL_Types.LSLInteger(perm) },
+                            new DetectParams[0]));
+
+                    return;
+                }
+            }
+            else if (m_host.m_sitTargetAvatar == agentID) // Sitting avatar
+            {
+                // When agent is sitting, certain permissions are implicit if requested from sitting agent
+                int implicitPerms = ScriptBaseClass.PERMISSION_TRIGGER_ANIMATION |
+                        ScriptBaseClass.PERMISSION_TRACK_CAMERA;
+
+                if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
+                {
+                    m_host.TaskInventory[invItemID].PermsGranter=agentID;
+                    m_host.TaskInventory[invItemID].PermsMask=perm;
+
+                    m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                            "run_time_permissions", new Object[] {
+                            new LSL_Types.LSLInteger(perm) },
+                            new DetectParams[0]));
+
+                    return;
+                }
+            }
+
+            ScenePresence presence = World.GetScenePresence(agentID);
+
+            if (presence != null)
+            {
+                string ownerName=resolveName(m_host.ParentGroup.RootPart.OwnerID);
+                if (ownerName == String.Empty)
+                    ownerName="(hippos)";
+
+                if (!m_waitingForScriptAnswer)
+                {
+                    m_host.TaskInventory[invItemID].PermsGranter=agentID;
+                    m_host.TaskInventory[invItemID].PermsMask=0;
+                    presence.ControllingClient.OnScriptAnswer+=handleScriptAnswer;
+                    m_waitingForScriptAnswer=true;
+                }
+
+                presence.ControllingClient.SendScriptQuestion(m_host.UUID, m_host.ParentGroup.RootPart.Name, ownerName, invItemID, perm);
+                return;
+            }
+
+            // Requested agent is not in range, refuse perms
+            m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                    "run_time_permissions", new Object[] {
+                    new LSL_Types.LSLInteger(0) },
+                    new DetectParams[0]));
+        }
+
+        void handleScriptAnswer(IClientAPI client, LLUUID taskID, LLUUID itemID, int answer)
+        {
+            if (taskID != m_host.UUID)
+                return;
+
+            LLUUID invItemID=InventorySelf();
+
+            if (invItemID == LLUUID.Zero)
+                return;
+
+            client.OnScriptAnswer-=handleScriptAnswer;
+            m_waitingForScriptAnswer=false;
+
+            m_host.TaskInventory[invItemID].PermsMask=answer;
+            m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                    "run_time_permissions", new Object[] {
+                    new LSL_Types.LSLInteger(answer) },
+                    new DetectParams[0]));
+        }
+
+        public string llGetPermissionsKey()
+        {
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 10 && item.ItemID == m_itemID)
+                {
+                    return item.PermsGranter.ToString();
+                }
+            }
+
+            return LLUUID.Zero.ToString();
+        }
+
+        public LSL_Types.LSLInteger llGetPermissions()
+        {
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 10 && item.ItemID == m_itemID)
+                {
+                    return item.PermsMask;
+                }
+            }
+
+            return 0;
+        }
+
+        public LSL_Types.LSLInteger llGetLinkNumber()
+        {
+            m_host.AddScriptLPS(1);
+
+            if (m_host.ParentGroup.Children.Count > 0)
+            {
+                return m_host.LinkNum + 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face)
+        {
+            m_host.AddScriptLPS(1);
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+            if (linknumber > -1)
+            {
+                LLObject.TextureEntry tex = part.Shape.Textures;
+                LLColor texcolor;
+                if (face > -1)
+                {
+                    texcolor = tex.CreateFace((uint)face).RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.FaceTextures[face].RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                else if (face == -1)
+                {
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    for (uint i = 0; i < 32; i++)
+                    {
+                        if (tex.FaceTextures[i] != null)
+                        {
+                            texcolor = tex.FaceTextures[i].RGBA;
+                            texcolor.R = (float)Math.Abs(color.x - 1);
+                            texcolor.G = (float)Math.Abs(color.y - 1);
+                            texcolor.B = (float)Math.Abs(color.z - 1);
+                            tex.FaceTextures[i].RGBA = texcolor;
+                        }
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.R = (float)Math.Abs(color.x - 1);
+                    texcolor.G = (float)Math.Abs(color.y - 1);
+                    texcolor.B = (float)Math.Abs(color.z - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                return;
+            }
+            else if (linknumber == -1)
+            {
+                int num = m_host.ParentGroup.PrimCount;
+                for (int w = 0; w < num; w++)
+                {
+                    linknumber = w;
+                    part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+                    LLObject.TextureEntry tex = part.Shape.Textures;
+                    LLColor texcolor;
+                    if (face > -1)
+                    {
+                        texcolor = tex.CreateFace((uint)face).RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.FaceTextures[face].RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                    else if (face == -1)
+                    {
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        for (uint i = 0; i < 32; i++)
+                        {
+                            if (tex.FaceTextures[i] != null)
+                            {
+                                texcolor = tex.FaceTextures[i].RGBA;
+                                texcolor.R = (float)Math.Abs(color.x - 1);
+                                texcolor.G = (float)Math.Abs(color.y - 1);
+                                texcolor.B = (float)Math.Abs(color.z - 1);
+                                tex.FaceTextures[i].RGBA = texcolor;
+                            }
+                        }
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.R = (float)Math.Abs(color.x - 1);
+                        texcolor.G = (float)Math.Abs(color.y - 1);
+                        texcolor.B = (float)Math.Abs(color.z - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                }
+                return;
+            }
+        }
+
+        public void llCreateLink(string target, int parent)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llCreateLink");
+        }
+
+        public void llBreakLink(int linknum)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llBreakLink");
+        }
+
+        public void llBreakAllLinks()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llBreakAllLinks");
+        }
+
+        public string llGetLinkKey(int linknum)
+        {
+            m_host.AddScriptLPS(1);
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
+            if (part != null)
+            {
+                return part.UUID.ToString();
+            }
+            else
+            {
+                return LLUUID.Zero.ToString();
+            }
+        }
+
+        public string llGetLinkName(int linknum)
+        {
+            m_host.AddScriptLPS(1);
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
+            if (part != null)
+            {
+                return part.Name;
+            }
+            else
+            {
+                return LLUUID.Zero.ToString();
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryNumber(int type)
+        {
+            m_host.AddScriptLPS(1);
+            int count = 0;
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Type == type || type == -1)
+                {
+                    count = count + 1;
+                }
+            }
+            return count;
+        }
+
+        public string llGetInventoryName(int type, int number)
+        {
+            m_host.AddScriptLPS(1);
+            ArrayList keys = new ArrayList();
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Type == type || type == -1)
+                {
+                    keys.Add(inv.Value.Name);
+                }
+            }
+            if (keys.Count == 0)
+            {
+                return String.Empty;
+            }
+            keys.Sort();
+            if (keys.Count > number)
+            {
+                return (string)keys[number];
+            }
+            return String.Empty;
+        }
+
+        public void llSetScriptState(string name, int run)
+        {
+            LLUUID item;
+
+            m_host.AddScriptLPS(1);
+
+            // These functions are supposed to be robust,
+            // so get the state one step at a time.
+
+            if ((item = ScriptByName(name)) != LLUUID.Zero)
+            {
+                m_ScriptEngine.SetScriptState(item, run == 0 ? false : true);
+            }
+            else
+            {
+                ShoutError("llSetScriptState: script "+name+" not found");
+            }
+        }
+
+        public double llGetEnergy()
+        {
+            m_host.AddScriptLPS(1);
+            // TODO: figure out real energy value
+            return 1.0f;
+        }
+
+        public void llGiveInventory(string destination, string inventory)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGiveInventory");
+        }
+
+        public void llRemoveInventory(string item)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRemoveInventory");
+        }
+
+        public void llSetText(string text, LSL_Types.Vector3 color, double alpha)
+        {
+            m_host.AddScriptLPS(1);
+            Vector3 av3 = new Vector3((float)color.x, (float)color.y, (float)color.z);
+            m_host.SetText(text, av3, alpha);
+        }
+
+        public double llWater(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            return World.RegionInfo.EstateSettings.waterHeight;
+        }
+
+        public void llPassTouches(int pass)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llPassTouches");
+        }
+
+        public string llRequestAgentData(string id, int data)
+        {
+            m_host.AddScriptLPS(1);
+
+            UserProfileData userProfile =
+                    World.CommsManager.UserService.GetUserProfile(id);
+
+            UserAgentData userAgent =
+                    World.CommsManager.UserService.GetAgentByUUID(id);
+
+            if (userProfile == null || userAgent == null)
+                return LLUUID.Zero.ToString();
+
+            string reply = String.Empty;
+
+            switch (data)
+            {
+            case 1: // DATA_ONLINE (0|1)
+                // TODO: implement fetching of this information
+                if (userProfile.CurrentAgent.AgentOnline)
+                    reply = "1";
+                else
+                    reply = "0";
+                break;
+            case 2: // DATA_NAME (First Last)
+                reply = userProfile.FirstName + " " + userProfile.SurName;
+                break;
+            case 3: // DATA_BORN (YYYY-MM-DD)
+                DateTime born = new DateTime(1970, 1, 1, 0, 0, 0, 0);
+                born = born.AddSeconds(userProfile.Created);
+                reply = born.ToString("yyyy-MM-dd");
+                break;
+            case 4: // DATA_RATING (0,0,0,0,0,0)
+                reply = "0,0,0,0,0,0";
+                break;
+            case 8: // DATA_PAYINFO (0|1|2|3)
+                reply = "0";
+                break;
+            default:
+                return LLUUID.Zero.ToString(); // Raise no event
+            }
+
+            LLUUID rq = LLUUID.Random();
+
+            LLUUID tid = AsyncCommands.
+                DataserverPlugin.RegisterRequest(m_localID,
+                                             m_itemID, rq.ToString());
+
+            AsyncCommands.
+            DataserverPlugin.DataserverReply(rq.ToString(), reply);
+
+            return tid.ToString();
+        }
+
+        public string llRequestInventoryData(string name)
+        {
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 3 && item.Name == name)
+                {
+                    LLUUID tid = AsyncCommands.
+                        DataserverPlugin.RegisterRequest(m_localID,
+                                                     m_itemID, item.AssetID.ToString());
+
+                    LLVector3 region = new LLVector3(
+                        World.RegionInfo.RegionLocX * Constants.RegionSize,
+                        World.RegionInfo.RegionLocY * Constants.RegionSize,
+                        0);
+
+                    World.AssetCache.GetAsset(item.AssetID,
+                        delegate(LLUUID i, AssetBase a)
+                        {
+                            AssetLandmark lm = new AssetLandmark(a);
+
+                            region += lm.Position;
+
+                            string reply = region.ToString();
+
+                            AsyncCommands.
+                                DataserverPlugin.DataserverReply(i.ToString(),
+                                                             reply);
+                        }, false);
+
+                    return tid.ToString();
+                }
+            }
+
+            return String.Empty;
+        }
+
+        public void llSetDamage(double damage)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetDamage");
+        }
+
+        public void llTeleportAgentHome(string agent)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llTeleportAgentHome");
+        }
+
+        public void llModifyLand(int action, int brush)
+        {
+            m_host.AddScriptLPS(1);
+            World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, 0));
+        }
+
+        public void llCollisionSound(string impact_sound, double impact_volume)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llCollisionSound");
+        }
+
+        public void llCollisionSprite(string impact_sprite)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llCollisionSprite");
+        }
+
+        public string llGetAnimation(string id)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetAnimation");
+            return String.Empty;
+        }
+
+        public void llResetScript()
+        {
+            m_host.AddScriptLPS(1);
+            m_ScriptEngine.ResetScript(m_itemID);
+        }
+
+        public void llMessageLinked(int linknum, int num, string msg, string id)
+        {
+
+            m_host.AddScriptLPS(1);
+
+            uint partLocalID;
+            LLUUID partItemID;
+
+            switch ((int)linknum)
+            {
+
+                case (int)ScriptBaseClass.LINK_ROOT:
+
+                    SceneObjectPart part = m_host.ParentGroup.RootPart;
+
+                    foreach (TaskInventoryItem item in part.TaskInventory.Values)
+                    {
+                        if (item.Type == 10)
+                        {
+                            partLocalID = part.LocalId;
+                            partItemID = item.ItemID;
+
+                            object[] resobj = new object[]
+                            {
+                                new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                            };
+
+                            m_ScriptEngine.PostScriptEvent(partItemID,
+                                    new EventParams("link_message",
+                                    resobj, new DetectParams[0]));
+                        }
+                    }
+
+                    break;
+
+                case (int)ScriptBaseClass.LINK_SET:
+
+                    foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
+                    {
+
+                        foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
+                        {
+                            if (item.Type == 10)
+                            {
+                                partLocalID = partInst.LocalId;
+                                partItemID = item.ItemID;
+                                Object[] resobj = new object[]
+                                {
+                                    new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                                };
+
+                                m_ScriptEngine.PostScriptEvent(partItemID,
+                                        new EventParams("link_message",
+                                        resobj, new DetectParams[0]));
+                            }
+                        }
+                    }
+
+                    break;
+
+                case (int)ScriptBaseClass.LINK_ALL_OTHERS:
+
+                    foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
+                    {
+
+                        if (partInst.LocalId != m_host.LocalId)
+                        {
+
+                            foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
+                            {
+                                if (item.Type == 10)
+                                {
+                                    partLocalID = partInst.LocalId;
+                                    partItemID = item.ItemID;
+                                    Object[] resobj = new object[]
+                                    {
+                                        new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                                    };
+
+                                    m_ScriptEngine.PostScriptEvent(partItemID,
+                                            new EventParams("link_message",
+                                            resobj, new DetectParams[0]));
+                                }
+                            }
+
+                        }
+                    }
+
+                    break;
+
+                case (int)ScriptBaseClass.LINK_ALL_CHILDREN:
+
+                    foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
+                    {
+
+                        if (partInst.LocalId != m_host.ParentGroup.RootPart.LocalId)
+                        {
+
+                            foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
+                            {
+                                if (item.Type == 10)
+                                {
+                                    partLocalID = partInst.LocalId;
+                                    partItemID = item.ItemID;
+                                    Object[] resobj = new object[]
+                                    {
+                                        new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                                    };
+
+                                    m_ScriptEngine.PostScriptEvent(partItemID,
+                                            new EventParams("link_message",
+                                            resobj, new DetectParams[0]));
+                                }
+                            }
+
+                        }
+                    }
+
+                    break;
+
+                case (int)ScriptBaseClass.LINK_THIS:
+
+                    foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+                    {
+                        if (item.Type == 10)
+                        {
+                            partItemID = item.ItemID;
+
+                            object[] resobj = new object[]
+                            {
+                                new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                            };
+
+                            m_ScriptEngine.PostScriptEvent(partItemID,
+                                    new EventParams("link_message",
+                                    resobj, new DetectParams[0]));
+                        }
+                    }
+
+                    break;
+
+                default:
+
+                    foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
+                    {
+
+                        if ((partInst.LinkNum + 1) == linknum)
+                        {
+
+                            foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
+                            {
+                                if (item.Type == 10)
+                                {
+                                    partLocalID = partInst.LocalId;
+                                    partItemID = item.ItemID;
+                                    Object[] resObjDef = new object[]
+                                    {
+                                        new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
+                                    };
+
+                                    m_ScriptEngine.PostScriptEvent(partItemID,
+                                            new EventParams("link_message",
+                                            resObjDef, new DetectParams[0]));
+                                }
+                            }
+
+                        }
+                    }
+
+                    break;
+
+            }
+
+        }
+
+        public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llPushObject");
+        }
+
+        public void llPassCollisions(int pass)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llPassCollisions");
+        }
+
+        public string llGetScriptName()
+        {
+
+            string result = String.Empty;
+
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 10 && item.ItemID == m_itemID)
+                {
+                    result =  item.Name!=null?item.Name:String.Empty;
+                    break;
+                }
+            }
+
+            return result;
+
+        }
+
+        public LSL_Types.LSLInteger llGetNumberOfSides()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetNumberOfSides");
+            return 0;
+        }
+
+
+        /* The new / changed functions were tested with the following LSL script:
+
+        default
+        {
+            state_entry()
+            {
+                rotation rot = llEuler2Rot(<0,70,0> * DEG_TO_RAD);
+
+                llOwnerSay("to get here, we rotate over: "+ (string) llRot2Axis(rot));
+                llOwnerSay("and we rotate for: "+ (llRot2Angle(rot) * RAD_TO_DEG));
+
+                // convert back and forth between quaternion <-> vector and angle
+
+                rotation newrot = llAxisAngle2Rot(llRot2Axis(rot),llRot2Angle(rot));
+
+                llOwnerSay("Old rotation was: "+(string) rot);
+                llOwnerSay("re-converted rotation is: "+(string) newrot);
+
+                llSetRot(rot);  // to check the parameters in the prim
+            }
+        }
+        */
+
+
+
+        // Xantor 29/apr/2008
+        // Returns rotation described by rotating angle radians about axis.
+        // q = cos(a/2) + i (x * sin(a/2)) + j (y * sin(a/2)) + k (z * sin(a/2))
+        public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle)
+        {
+            m_host.AddScriptLPS(1);
+
+            double x, y, z, s, t;
+
+            s = Math.Cos(angle / 2);
+            t = Math.Sin(angle / 2); // temp value to avoid 2 more sin() calcs
+            x = axis.x * t;
+            y = axis.y * t;
+            z = axis.z * t;
+
+            return new LSL_Types.Quaternion(x,y,z,s);
+        }
+
+
+        // Xantor 29/apr/2008
+        // converts a Quaternion to X,Y,Z axis rotations
+        public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+            double x,y,z;
+
+            if (rot.s > 1) // normalization needed
+            {
+                double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y +
+                        rot.z * rot.z + rot.s * rot.s);
+
+                rot.x /= length;
+                rot.y /= length;
+                rot.z /= length;
+                rot.s /= length;
+
+            }
+
+            double angle = 2 * Math.Acos(rot.s);
+            double s = Math.Sqrt(1 - rot.s * rot.s);
+            if (s < 0.001)
+            {
+                x = 1;
+                y = z = 0;
+            }
+            else
+            {
+                x = rot.x / s; // normalise axis
+                y = rot.y / s;
+                z = rot.z / s;
+            }
+
+
+            return new LSL_Types.Vector3(x,y,z);
+
+
+//            NotImplemented("llRot2Axis");
+        }
+
+
+        // Returns the angle of a quaternion (see llRot2Axis for the axis)
+        public double llRot2Angle(LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (rot.s > 1) // normalization needed
+            {
+                double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y +
+                        rot.z * rot.z + rot.s * rot.s);
+
+                rot.x /= length;
+                rot.y /= length;
+                rot.z /= length;
+                rot.s /= length;
+
+            }
+
+            double angle = 2 * Math.Acos(rot.s);
+
+            return angle;
+
+//            NotImplemented("llRot2Angle");
+        }
+
+        public double llAcos(double val)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Acos(val);
+        }
+
+        public double llAsin(double val)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Asin(val);
+        }
+
+        // Xantor 30/apr/2008
+        public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b)
+        {
+            m_host.AddScriptLPS(1);
+
+           return (double) Math.Acos(a.x * b.x + a.y * b.y + a.z * b.z + a.s * b.s) * 2;
+        }
+
+        public string llGetInventoryKey(string name)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == name)
+                {
+                    if ((inv.Value.OwnerMask & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify))
+                    {
+                        return inv.Value.AssetID.ToString();
+                    }
+                    else
+                    {
+                        return LLUUID.Zero.ToString();
+                    }
+                }
+            }
+            return LLUUID.Zero.ToString();
+        }
+
+        public void llAllowInventoryDrop(int add)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llAllowInventoryDrop");
+        }
+
+        public LSL_Types.Vector3 llGetSunDirection()
+        {
+            m_host.AddScriptLPS(1);
+
+            LSL_Types.Vector3 SunDoubleVector3;
+            LLVector3 SunFloatVector3;
+
+            // sunPosition estate setting is set in OpenSim.Region.Environment.Modules.SunModule
+            // have to convert from LLVector3 (float) to LSL_Types.Vector3 (double)
+            SunFloatVector3 = World.RegionInfo.EstateSettings.sunPosition;
+            SunDoubleVector3.x = (double)SunFloatVector3.X;
+            SunDoubleVector3.y = (double)SunFloatVector3.Y;
+            SunDoubleVector3.z = (double)SunFloatVector3.Z;
+
+            return SunDoubleVector3;
+        }
+
+        public LSL_Types.Vector3 llGetTextureOffset(int face)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LSL_Types.Vector3 offset;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            offset.x = tex.GetFace((uint)face).OffsetU;
+            offset.y = tex.GetFace((uint)face).OffsetV;
+            offset.z = 0.0;
+            return offset;
+        }
+
+        public LSL_Types.Vector3 llGetTextureScale(int side)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            LSL_Types.Vector3 scale;
+            if (side == -1)
+            {
+                side = 0;
+            }
+            scale.x = tex.GetFace((uint)side).RepeatU;
+            scale.y = tex.GetFace((uint)side).RepeatV;
+            scale.z = 0.0;
+            return scale;
+        }
+
+        public double llGetTextureRot(int face)
+        {
+            m_host.AddScriptLPS(1);
+            LLObject.TextureEntry tex = m_host.Shape.Textures;
+            if (face == -1)
+            {
+                face = 0;
+            }
+            return tex.GetFace((uint)face).Rotation;
+        }
+
+        public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern)
+        {
+            m_host.AddScriptLPS(1);
+            return source.IndexOf(pattern);
+        }
+
+        public string llGetOwnerKey(string id)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id, out key))
+            {
+                return World.GetSceneObjectPart(World.Entities[key].LocalId).OwnerID.ToString();
+            }
+            else
+            {
+                return LLUUID.Zero.ToString();
+            }
+        }
+
+        public LSL_Types.Vector3 llGetCenterOfMass()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetCenterOfMass");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending)
+        {
+            m_host.AddScriptLPS(1);
+            return src.Sort(stride, ascending);
+        }
+
+        public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src)
+        {
+            m_host.AddScriptLPS(1);
+            return src.Length;
+        }
+
+        public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0;
+            }
+            try
+            {
+                return Convert.ToInt32(src.Data[index]);
+            }
+            catch (FormatException)
+            {
+                return 0;
+            }
+        }
+
+        public double osList2Double(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0.0;
+            }
+            return Convert.ToDouble(src.Data[index]);
+        }
+
+        public double llList2Float(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0.0;
+            }
+            try
+            {
+                return Convert.ToDouble(src.Data[index]);
+            }
+            catch (FormatException)
+            {
+                return 0.0;
+            }
+        }
+
+        public string llList2String(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return String.Empty;
+            }
+            return src.Data[index].ToString();
+        }
+
+        public string llList2Key(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return "";
+            }
+            return src.Data[index].ToString();
+        }
+
+        public LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return new LSL_Types.Vector3(0, 0, 0);
+            }
+            if (src.Data[index].GetType() == typeof(LSL_Types.Vector3))
+            {
+                return (LSL_Types.Vector3)src.Data[index];
+            }
+            else
+            {
+                return new LSL_Types.Vector3(src.Data[index].ToString());
+            }
+        }
+
+        public LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return new LSL_Types.Quaternion(0, 0, 0, 1);
+            }
+            if (src.Data[index].GetType() == typeof(LSL_Types.Quaternion))
+            {
+                return (LSL_Types.Quaternion)src.Data[index];
+            }
+            else
+            {
+                return new LSL_Types.Quaternion(src.Data[index].ToString());
+            }
+        }
+
+        public LSL_Types.list llList2List(LSL_Types.list src, int start, int end)
+        {
+            m_host.AddScriptLPS(1);
+            return src.GetSublist(start, end);
+        }
+
+        public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end)
+        {
+            return src.DeleteSublist(end, start);
+        }
+
+        public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index)
+        {
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0;
+            }
+
+            if (src.Data[index] is Int32)
+                return 1;
+            if (src.Data[index] is Double)
+                return 2;
+            if (src.Data[index] is String)
+            {
+                LLUUID tuuid;
+                if (LLUUID.TryParse(src.Data[index].ToString(), out tuuid))
+                {
+                    return 3;
+                }
+                else
+                {
+                    return 4;
+                }
+            }
+            if (src.Data[index] is LSL_Types.Vector3)
+                return 5;
+            if (src.Data[index] is LSL_Types.Quaternion)
+                return 6;
+            if (src.Data[index] is LSL_Types.list)
+                return 7;
+            return 0;
+
+        }
+
+        /// <summary>
+        /// Process the supplied list and return the
+        /// content of the list formatted as a comma
+        /// separated list. There is a space after
+        /// each comma.
+        /// </summary>
+
+        public string llList2CSV(LSL_Types.list src)
+        {
+
+            string ret = String.Empty;
+            int    x   = 0;
+
+            m_host.AddScriptLPS(1);
+
+            if (src.Data.Length > 0)
+            {
+                ret = src.Data[x++].ToString();
+                for (; x < src.Data.Length; x++)
+                {
+                    ret += ", "+src.Data[x].ToString();
+                }
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// The supplied string is scanned for commas
+        /// and converted into a list. Commas are only
+        /// effective if they are encountered outside
+        /// of '<' '>' delimiters. Any whitespace
+        /// before or after an element is trimmed.
+        /// </summary>
+
+        public LSL_Types.list llCSV2List(string src)
+        {
+
+            LSL_Types.list result = new LSL_Types.list();
+            int parens = 0;
+            int start  = 0;
+            int length = 0;
+
+            m_host.AddScriptLPS(1);
+
+            for (int i = 0; i < src.Length; i++)
+            {
+                switch (src[i])
+                {
+                    case '<':
+                        parens++;
+                        length++;
+                        break;
+                    case '>':
+                        if (parens > 0)
+                            parens--;
+                        length++;
+                        break;
+                    case ',':
+                        if (parens == 0)
+                        {
+                            result.Add(src.Substring(start,length).Trim());
+                            start += length+1;
+                            length = 0;
+                        }
+                        else
+                        {
+                            length++;
+                        }
+                        break;
+                    default:
+                        length++;
+                        break;
+                }
+            }
+
+            result.Add(src.Substring(start,length).Trim());
+
+            return result;
+        }
+
+        ///  <summary>
+        ///  Randomizes the list, be arbitrarily reordering
+        ///  sublists of stride elements. As the stride approaches
+        ///  the size of the list, the options become very
+        ///  limited.
+        ///  </summary>
+        ///  <remarks>
+        ///  This could take a while for very large list
+        ///  sizes.
+        ///  </remarks>
+
+        public LSL_Types.list llListRandomize(LSL_Types.list src, int stride)
+        {
+
+            LSL_Types.list result;
+            Random rand           = new Random();
+
+            int   chunkk;
+            int[] chunks;
+            int   index1;
+            int   index2;
+            int   tmp;
+
+            m_host.AddScriptLPS(1);
+
+            if (stride == 0)
+                stride = 1;
+
+            // Stride MUST be a factor of the list length
+            // If not, then return the src list. This also
+            // traps those cases where stride > length.
+
+            if (src.Length != stride && src.Length%stride == 0)
+            {
+                chunkk = src.Length/stride;
+
+                chunks = new int[chunkk];
+
+                for (int i = 0; i < chunkk; i++)
+                    chunks[i] = i;
+
+                for (int i = 0; i < chunkk - 1; i++)
+                {
+                    //  randomly select 2 chunks
+                    index1 = rand.Next(rand.Next(65536));
+                    index1 = index1%chunkk;
+                    index2 = rand.Next(rand.Next(65536));
+                    index2 = index2%chunkk;
+
+                    //  and swap their relative positions
+                    tmp = chunks[index1];
+                    chunks[index1] = chunks[index2];
+                    chunks[index2] = tmp;
+                }
+
+                // Construct the randomized list
+
+                result = new LSL_Types.list();
+
+                for (int i = 0; i < chunkk; i++)
+                {
+                    for (int j = 0; j < stride; j++)
+                    {
+                        result.Add(src.Data[chunks[i]*stride+j]);
+                    }
+                }
+            }
+            else {
+                object[] array = new object[src.Length];
+                Array.Copy(src.Data, 0, array, 0, src.Length);
+                result = new LSL_Types.list(array);
+            }
+
+            return result;
+
+        }
+
+        /// <summary>
+        /// Elements in the source list starting with 0 and then
+        /// every i+stride. If the stride is negative then the scan
+        /// is backwards producing an inverted result.
+        /// Only those elements that are also in the specified
+        /// range are included in the result.
+        /// </summary>
+
+        public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride)
+        {
+
+            LSL_Types.list result = new LSL_Types.list();
+            int[] si = new int[2];
+            int[] ei = new int[2];
+            bool twopass = false;
+
+            m_host.AddScriptLPS(1);
+
+            //  First step is always to deal with negative indices
+
+            if (start < 0)
+                start = src.Length+start;
+            if (end   < 0)
+                end   = src.Length+end;
+
+            //  Out of bounds indices are OK, just trim them
+            //  accordingly
+
+            if (start > src.Length)
+                start = src.Length;
+
+            if (end > src.Length)
+                end = src.Length;
+
+            //  There may be one or two ranges to be considered
+
+            if (start != end)
+            {
+
+                if (start <= end)
+                {
+                   si[0] = start;
+                   ei[0] = end;
+                }
+                else
+                {
+                   si[1] = start;
+                   ei[1] = src.Length;
+                   si[0] = 0;
+                   ei[0] = end;
+                   twopass = true;
+                }
+
+                //  The scan always starts from the beginning of the
+                //  source list, but members are only selected if they
+                //  fall within the specified sub-range. The specified
+                //  range values are inclusive.
+                //  A negative stride reverses the direction of the
+                //  scan producing an inverted list as a result.
+
+                if (stride == 0)
+                    stride = 1;
+
+                if (stride > 0)
+                {
+                    for (int i = 0; i < src.Length; i += stride)
+                    {
+                        if (i<=ei[0] && i>=si[0])
+                            result.Add(src.Data[i]);
+                        if (twopass && i>=si[1] && i<=ei[1])
+                            result.Add(src.Data[i]);
+                    }
+                }
+                else if (stride < 0)
+                {
+                    for (int i = src.Length - 1; i >= 0; i += stride)
+                    {
+                        if (i <= ei[0] && i >= si[0])
+                            result.Add(src.Data[i]);
+                        if (twopass && i >= si[1] && i <= ei[1])
+                            result.Add(src.Data[i]);
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        public LSL_Types.Vector3 llGetRegionCorner()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * Constants.RegionSize, World.RegionInfo.RegionLocY * Constants.RegionSize, 0);
+        }
+
+        /// <summary>
+        /// Insert the list identified by <src> into the
+        /// list designated by <dest> such that the first
+        /// new element has the index specified by <index>
+        /// </summary>
+
+        public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int index)
+        {
+
+            LSL_Types.list pref = null;
+            LSL_Types.list suff = null;
+
+            m_host.AddScriptLPS(1);
+
+            if (index < 0)
+            {
+                index = index+dest.Length;
+                if (index < 0)
+                {
+                    index = 0;
+                }
+            }
+
+            if (index != 0)
+            {
+                pref = dest.GetSublist(0,index-1);
+                if (index < dest.Length)
+                {
+                    suff = dest.GetSublist(index,-1);
+                    return pref + src + suff;
+                }
+                else
+                {
+                    return pref + src;
+                }
+            }
+            else
+            {
+                if (index < dest.Length)
+                {
+                    suff = dest.GetSublist(index,-1);
+                    return src + suff;
+                }
+                else
+                {
+                    return src;
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Returns the index of the first occurrence of test
+        /// in src.
+        /// </summary>
+
+        public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test)
+        {
+
+            int index  = -1;
+            int length = src.Length - test.Length + 1;
+
+            m_host.AddScriptLPS(1);
+
+            // If either list is empty, do not match
+
+            if (src.Length != 0 && test.Length != 0)
+            {
+                for (int i = 0; i < length; i++)
+                {
+                   if (src.Data[i].Equals(test.Data[0]))
+                   {
+                       int j;
+                       for (j = 1; j < test.Length; j++)
+                           if (!src.Data[i+j].Equals(test.Data[j]))
+                               break;
+                       if (j == test.Length)
+                       {
+                           index = i;
+                           break;
+                       }
+                   }
+                }
+            }
+
+            return index;
+
+        }
+
+        public string llGetObjectName()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.Name!=null?m_host.Name:String.Empty;
+        }
+
+        public void llSetObjectName(string name)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.Name = name!=null?name:String.Empty;
+        }
+
+        public string llGetDate()
+        {
+            m_host.AddScriptLPS(1);
+            DateTime date = DateTime.Now.ToUniversalTime();
+            string result = date.ToString("yyyy-MM-dd");
+            return result;
+        }
+
+        public LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llEdgeOfWorld");
+            return 0;
+        }
+
+        public LSL_Types.LSLInteger llGetAgentInfo(string id)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetAgentInfo");
+            return 0;
+        }
+
+        public void llAdjustSoundVolume(double volume)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.AdjustSoundGain(volume);
+        }
+
+        public void llSetSoundQueueing(int queue)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetSoundQueueing");
+        }
+
+        public void llSetSoundRadius(double radius)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetSoundRadius");
+        }
+
+        public string llKey2Name(string id)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id,out key))
+            {
+                ScenePresence presence = World.GetScenePresence(key);
+
+                if (presence != null)
+                {
+                    return presence.ControllingClient.Name;
+                    //return presence.Name;
+                }
+
+                if (World.GetSceneObjectPart(key) != null)
+                {
+                    return World.GetSceneObjectPart(key).Name;
+                }
+            }
+            return String.Empty;
+        }
+
+
+
+        public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate)
+        {
+            m_host.AddScriptLPS(1);
+            Primitive.TextureAnimation pTexAnim = new Primitive.TextureAnimation();
+            pTexAnim.Flags =(uint) mode;
+
+            //ALL_SIDES
+            if (face == -1)
+                    face = 255;
+
+            pTexAnim.Face = (uint)face;
+            pTexAnim.Length = (float)length;
+            pTexAnim.Rate = (float)rate;
+            pTexAnim.SizeX = (uint)sizex;
+            pTexAnim.SizeY = (uint)sizey;
+            pTexAnim.Start = (float)start;
+
+            m_host.AddTextureAnimation(pTexAnim);
+            m_host.SendFullUpdateToAllClients();
+        }
+
+        public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east,
+                                          LSL_Types.Vector3 bottom_south_west)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llTriggerSoundLimited");
+        }
+
+        public void llEjectFromLand(string pest)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llEjectFromLand");
+        }
+
+        public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers)
+        {
+            m_host.AddScriptLPS(1);
+            LSL_Types.list ret = new LSL_Types.list();
+            object[] delimiters = new object[separators.Length + spacers.Length];
+            separators.Data.CopyTo(delimiters, 0);
+            spacers.Data.CopyTo(delimiters, separators.Length);
+            bool dfound = false;
+            do
+            {
+                dfound = false;
+                int cindex = -1;
+                string cdeli = "";
+                for (int i = 0; i < delimiters.Length; i++)
+                {
+                    int index = str.IndexOf(delimiters[i].ToString());
+                    bool found = index != -1;
+                    if (found)
+                    {
+                        if ((cindex > index) || (cindex == -1))
+                        {
+                            cindex = index;
+                            cdeli = (string)delimiters[i];
+                        }
+                        dfound = dfound || found;
+                    }
+                }
+                if (cindex != -1)
+                {
+                    if (cindex > 0)
+                    {
+                        ret.Add(str.Substring(0, cindex));
+                        if (spacers.Contains(cdeli))
+                        {
+                            ret.Add(cdeli);
+                        }
+                    }
+                    if (cindex == 0 && spacers.Contains(cdeli))
+                    {
+                        ret.Add(cdeli);
+                    }
+                    str = str.Substring(cindex + cdeli.Length);
+                }
+            } while (dfound);
+            if (str != "")
+            {
+                ret.Add(str);
+            }
+            return ret;
+        }
+
+        public LSL_Types.LSLInteger llOverMyLand(string id)
+        {
+
+            m_host.AddScriptLPS(1);
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id,out key))
+            {
+                SceneObjectPart obj = new SceneObjectPart();
+                obj = World.GetSceneObjectPart(World.Entities[key].LocalId);
+                if (obj.OwnerID == World.GetLandOwner(obj.AbsolutePosition.X, obj.AbsolutePosition.Y))
+                {
+                    return 1;
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public string llGetLandOwnerAt(LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+            return World.GetLandOwner((float)pos.x, (float)pos.y).ToString();
+        }
+
+        public LSL_Types.Vector3 llGetAgentSize(string id)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetAgentSize");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.LSLInteger llSameGroup(string agent)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSameGroup");
+            return 0;
+        }
+
+        public void llUnSit(string id)
+        {
+            m_host.AddScriptLPS(1);
+
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id, out key))
+            {
+                ScenePresence av = World.GetScenePresence(key);
+
+                if (av != null)
+                {
+                    if (llAvatarOnSitTarget() == id)
+                    {
+                        // if the avatar is sitting on this object, then
+                        // we can unsit them.  We don't want random scripts unsitting random people
+                        // Lets avoid the popcorn avatar scenario.
+                        av.StandUp();
+                    }
+                    else
+                    {
+                        // If the object owner also owns the parcel
+                        // or
+                        // if the land is group owned and the object is group owned by the same group
+                        // or
+                        // if the object is owned by a person with estate access.
+
+                        ILandObject parcel = World.LandChannel.GetLandObject(av.AbsolutePosition.X, av.AbsolutePosition.Y);
+                        if (parcel != null)
+                        {
+                            if (m_host.ObjectOwner == parcel.landData.ownerID ||
+                                (m_host.OwnerID == m_host.GroupID && m_host.GroupID == parcel.landData.groupID
+                                && parcel.landData.isGroupOwned) || World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID))
+                            {
+                                av.StandUp();
+                            }
+                        }
+                    }
+                }
+
+            }
+
+        }
+
+        public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGroundSlope");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGroundNormal");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGroundContour");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.LSLInteger llGetAttached()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetAttached");
+            return 0;
+        }
+
+        public LSL_Types.LSLInteger llGetFreeMemory()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetFreeMemory");
+            return 0;
+        }
+
+        public string llGetRegionName()
+        {
+            m_host.AddScriptLPS(1);
+            return World.RegionInfo.RegionName;
+        }
+
+        public double llGetRegionTimeDilation()
+        {
+            m_host.AddScriptLPS(1);
+            return (double)World.TimeDilation;
+        }
+
+        public double llGetRegionFPS()
+        {
+            m_host.AddScriptLPS(1);
+            //TODO: return actual FPS
+            return 10.0f;
+        }
+
+        /* particle system rules should be coming into this routine as doubles, that is
+        rule[0] should be an integer from this list and rule[1] should be the arg
+        for the same integer. wiki.secondlife.com has most of this mapping, but some
+        came from http://www.caligari-designs.com/p4u2
+
+        We iterate through the list for 'Count' elements, incrementing by two for each
+        iteration and set the members of Primitive.ParticleSystem, one at a time.
+        */
+
+        public enum PrimitiveRule : int
+        {
+            PSYS_PART_FLAGS = 0,
+            PSYS_PART_START_COLOR = 1,
+            PSYS_PART_START_ALPHA = 2,
+            PSYS_PART_END_COLOR = 3,
+            PSYS_PART_END_ALPHA = 4,
+            PSYS_PART_START_SCALE = 5,
+            PSYS_PART_END_SCALE = 6,
+            PSYS_PART_MAX_AGE = 7,
+            PSYS_SRC_ACCEL = 8,
+            PSYS_SRC_PATTERN = 9,
+            PSYS_SRC_TEXTURE = 12,
+            PSYS_SRC_BURST_RATE = 13,
+            PSYS_SRC_BURST_PART_COUNT = 15,
+            PSYS_SRC_BURST_RADIUS = 16,
+            PSYS_SRC_BURST_SPEED_MIN = 17,
+            PSYS_SRC_BURST_SPEED_MAX = 18,
+            PSYS_SRC_MAX_AGE = 19,
+            PSYS_SRC_TARGET_KEY = 20,
+            PSYS_SRC_OMEGA = 21,
+            PSYS_SRC_ANGLE_BEGIN = 22,
+            PSYS_SRC_ANGLE_END = 23
+        }
+
+        internal Primitive.ParticleSystem.ParticleDataFlags ConvertUINTtoFlags(uint flags)
+        {
+            Primitive.ParticleSystem.ParticleDataFlags returnval = Primitive.ParticleSystem.ParticleDataFlags.None;
+
+            return returnval;
+        }
+
+
+        public void llParticleSystem(LSL_Types.list rules)
+        {
+            m_host.AddScriptLPS(1);
+            Primitive.ParticleSystem prules = new Primitive.ParticleSystem();
+            LSL_Types.Vector3 tempv = new LSL_Types.Vector3();
+
+            float tempf = 0;
+
+            for (int i = 0; i < rules.Length; i += 2)
+            {
+                switch ((int)rules.Data[i])
+                {
+                    case (int)ScriptBaseClass.PSYS_PART_FLAGS:
+                        prules.PartDataFlags = (Primitive.ParticleSystem.ParticleDataFlags)((uint)Convert.ToInt32(rules.Data[i + 1].ToString()));
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_START_COLOR:
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        prules.PartStartColor.R = (float)tempv.x;
+                        prules.PartStartColor.G = (float)tempv.y;
+                        prules.PartStartColor.B = (float)tempv.z;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_START_ALPHA:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.PartStartColor.A = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_END_COLOR:
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        //prules.PartEndColor = new LLColor(tempv.x,tempv.y,tempv.z,1);
+
+                        prules.PartEndColor.R = (float)tempv.x;
+                        prules.PartEndColor.G = (float)tempv.y;
+                        prules.PartEndColor.B = (float)tempv.z;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_END_ALPHA:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.PartEndColor.A = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_START_SCALE:
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        prules.PartStartScaleX = (float)tempv.x;
+                        prules.PartStartScaleY = (float)tempv.y;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_END_SCALE:
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        prules.PartEndScaleX = (float)tempv.x;
+                        prules.PartEndScaleY = (float)tempv.y;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_PART_MAX_AGE:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.PartMaxAge = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_ACCEL:
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        prules.PartAcceleration.X = (float)tempv.x;
+                        prules.PartAcceleration.Y = (float)tempv.y;
+                        prules.PartAcceleration.Z = (float)tempv.z;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_PATTERN:
+                        int tmpi = int.Parse(rules.Data[i + 1].ToString());
+                        prules.Pattern = (Primitive.ParticleSystem.SourcePattern)tmpi;
+                        break;
+
+                    // Xantor 20080503
+                    // Wiki:    PSYS_SRC_TEXTURE      string      inventory item name or key of the particle texture
+                    //          "" = default texture.
+                    // 20080530 Updated to remove code duplication
+                    case (int)ScriptBaseClass.PSYS_SRC_TEXTURE:
+                        prules.Texture = KeyOrName(rules.Data[i + 1].ToString());
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_BURST_RATE:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.BurstRate = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_BURST_PART_COUNT:
+                        prules.BurstPartCount = (byte)Convert.ToByte(rules.Data[i + 1].ToString());
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_BURST_RADIUS:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.BurstRadius = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MIN:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.BurstSpeedMin = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MAX:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.BurstSpeedMax = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_MAX_AGE:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.MaxAge = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_TARGET_KEY:
+                        LLUUID key = LLUUID.Zero;
+                        if (LLUUID.TryParse(rules.Data[i + 1].ToString(), out key))
+                        {
+                            prules.Target = key;
+                        }
+                        else
+                        {
+                            prules.Target = m_host.UUID;
+                        }
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_OMEGA:
+                        // AL: This is an assumption, since it is the only thing that would match.
+                        tempv = (LSL_Types.Vector3)rules.Data[i + 1];
+                        prules.AngularVelocity.X = (float)tempv.x;
+                        prules.AngularVelocity.Y = (float)tempv.y;
+                        prules.AngularVelocity.Z = (float)tempv.z;
+                        //cast??                    prules.MaxAge = (float)rules[i + 1];
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_ANGLE_BEGIN:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.InnerAngle = (float)tempf;
+                        break;
+
+                    case (int)ScriptBaseClass.PSYS_SRC_ANGLE_END:
+                        tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
+                        prules.OuterAngle = (float)tempf;
+                        break;
+                }
+
+            }
+            prules.CRC = 1;
+
+            m_host.AddNewParticleSystem(prules);
+            m_host.SendFullUpdateToAllClients();
+        }
+
+        public void llGroundRepel(double height, int water, double tau)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGroundRepel");
+        }
+
+        public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGiveInventoryList");
+        }
+
+        public void llSetVehicleType(int type)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicleType");
+        }
+
+        public void llSetVehicledoubleParam(int param, double value)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicledoubleParam");
+        }
+
+        public void llSetVehicleFloatParam(int param, float value)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicleFloatParam");
+        }
+
+        public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicleVectorParam");
+        }
+
+        public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicleRotationParam");
+        }
+
+        public void llSetVehicleFlags(int flags)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetVehicleFlags");
+        }
+
+        public void llRemoveVehicleFlags(int flags)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRemoveVehicleFlags");
+        }
+
+        public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+            // LSL quaternions can normalize to 0, normal Quaternions can't.
+            if (rot.s == 0 && rot.x == 0 && rot.y == 0 && rot.z == 0)
+                rot.z = 1; // ZERO_ROTATION = 0,0,0,1
+
+            m_host.SetSitTarget(new Vector3((float)offset.x, (float)offset.y, (float)offset.z), new Quaternion((float)rot.s, (float)rot.x, (float)rot.y, (float)rot.z));
+        }
+
+        public string llAvatarOnSitTarget()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.GetAvatarOnSitTarget().ToString();
+        }
+
+        public void llAddToLandPassList(string avatar, double hours)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key;
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+                if (LLUUID.TryParse(avatar, out key))
+                {
+                    entry.AgentID = key;
+                    entry.Flags = ParcelManager.AccessList.Access;
+                    entry.Time = DateTime.Now.AddHours(hours);
+                    land.parcelAccessList.Add(entry);
+                }
+            }
+        }
+
+        public void llSetTouchText(string text)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.TouchName = text;
+        }
+
+        public void llSetSitText(string text)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.SitName = text;
+        }
+
+        public void llSetCameraEyeOffset(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetCameraEyeOffset");
+        }
+
+        public void llSetCameraAtOffset(LSL_Types.Vector3 offset)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetCameraAtOffset");
+        }
+
+        public string llDumpList2String(LSL_Types.list src, string seperator)
+        {
+            m_host.AddScriptLPS(1);
+            if (src.Length == 0)
+            {
+                return String.Empty;
+            }
+            string ret = String.Empty;
+            foreach (object o in src.Data)
+            {
+                ret = ret + o.ToString() + seperator;
+            }
+            ret = ret.Substring(0, ret.Length - seperator.Length);
+            return ret;
+        }
+
+        public LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+            bool result = World.scriptDanger(m_host.LocalId, new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
+            if (result)
+            {
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+
+        }
+
+        public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID av = new LLUUID();
+            if (!LLUUID.TryParse(avatar,out av))
+            {
+                LSLError("First parameter to llDialog needs to be a key");
+                return;
+            }
+            if (buttons.Length > 12)
+            {
+                LSLError("No more than 12 buttons can be shown");
+                return;
+            }
+            string[] buts = new string[buttons.Length];
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                if (buttons.Data[i].ToString() == String.Empty)
+                {
+                    LSLError("button label cannot be blank");
+                    return;
+                }
+                if (buttons.Data[i].ToString().Length > 24)
+                {
+                    LSLError("button label cannot be longer than 24 characters");
+                    return;
+                }
+                buts[i] = buttons.Data[i].ToString();
+            }
+            World.SendDialogToUser(av, m_host.Name, m_host.UUID, m_host.OwnerID, message, new LLUUID("00000000-0000-2222-3333-100000001000"), chat_channel, buts);
+        }
+
+        public void llVolumeDetect(int detect)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llVolumeDetect");
+        }
+
+        /// <summary>
+        /// Reset the named script. The script must be present
+        /// in the same prim.
+        /// </summary>
+
+        public void llResetOtherScript(string name)
+        {
+            LLUUID item;
+
+            m_host.AddScriptLPS(1);
+
+            if ((item = ScriptByName(name)) != LLUUID.Zero)
+                m_ScriptEngine.ResetScript(item);
+            else
+                ShoutError("llResetOtherScript: script "+name+" not found");
+        }
+
+        public LSL_Types.LSLInteger llGetScriptState(string name)
+        {
+            LLUUID item;
+
+            m_host.AddScriptLPS(1);
+
+            if ((item = ScriptByName(name)) != LLUUID.Zero)
+            {
+                return m_ScriptEngine.GetScriptState(item) ?1:0;
+            }
+
+            ShoutError("llGetScriptState: script "+name+" not found");
+
+            // If we didn't find it, then it's safe to
+            // assume it is not running.
+
+            return 0;
+        }
+
+        public void llRemoteLoadScript()
+        {
+            m_host.AddScriptLPS(1);
+            Deprecated("llRemoteLoadScript");
+        }
+
+        public void llSetRemoteScriptAccessPin(int pin)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetRemoteScriptAccessPin");
+        }
+
+        public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRemoteLoadScriptPin");
+        }
+
+        //  remote_data(integer type, key channel, key message_id, string sender, integer ival, string sval)
+        // Not sure where these constants should live:
+        // REMOTE_DATA_CHANNEL = 1
+        // REMOTE_DATA_REQUEST = 2
+        // REMOTE_DATA_REPLY = 3
+        public void llOpenRemoteDataChannel()
+        {
+            m_host.AddScriptLPS(1);
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            if (xmlrpcMod.IsEnabled())
+            {
+                LLUUID channelID = xmlrpcMod.OpenXMLRPCChannel(m_localID, m_itemID, LLUUID.Zero);
+                object[] resobj = new object[] { new LSL_Types.LSLInteger(1), new LSL_Types.LSLString(channelID.ToString()), new LSL_Types.LSLString(LLUUID.Zero.ToString()), new LSL_Types.LSLString(String.Empty), new LSL_Types.LSLInteger(0), new LSL_Types.LSLString(String.Empty) };
+                m_ScriptEngine.PostScriptEvent(m_itemID, new EventParams(
+                        "remote_data", resobj,
+                        new DetectParams[0]));
+            }
+        }
+
+        public string llSendRemoteData(string channel, string dest, int idata, string sdata)
+        {
+            m_host.AddScriptLPS(1);
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            return (xmlrpcMod.SendRemoteData(m_localID, m_itemID, channel, dest, idata, sdata)).ToString();
+        }
+
+        public void llRemoteDataReply(string channel, string message_id, string sdata, int idata)
+        {
+            m_host.AddScriptLPS(1);
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            xmlrpcMod.RemoteDataReply(channel, message_id, sdata, idata);
+        }
+
+        public void llCloseRemoteDataChannel(string channel)
+        {
+            m_host.AddScriptLPS(1);
+            IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+            xmlrpcMod.CloseXMLRPCChannel(channel);
+        }
+
+        public string llMD5String(string src, int nonce)
+        {
+            m_host.AddScriptLPS(1);
+            return Util.Md5Hash(src + ":" + nonce.ToString());
+        }
+
+        public void llSetPrimitiveParams(LSL_Types.list rules)
+        {
+            llSetLinkPrimitiveParams(m_host.LinkNum+1, rules);
+        }
+
+        public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules)
+        {
+            m_host.AddScriptLPS(1);
+
+            SceneObjectPart part=null;
+
+            if (m_host.LinkNum+1 != linknumber)
+            {
+                foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
+                {
+                    if ((partInst.LinkNum + 1) == linknumber)
+                    {
+                        part = partInst;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                part = m_host;
+            }
+
+            if (part == null)
+                return;
+
+            int idx = 0;
+
+            while (idx < rules.Length)
+            {
+                int code = Convert.ToInt32(rules.Data[idx++]);
+
+                int remain = rules.Length - idx;
+
+                int face;
+                LSL_Types.Vector3 v;
+
+                switch (code)
+                {
+                    case 6: // PRIM_POSITION
+                        if (remain < 1)
+                            return;
+
+                        v=new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        SetPos(part, v);
+
+                        break;
+                    case 7: // PRIM_SIZE
+                        if (remain < 1)
+                            return;
+
+                        v=new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        SetScale(part, v);
+
+                        break;
+                    case 8: // PRIM_ROTATION
+                        if (remain < 1)
+                            return;
+
+                        LSL_Types.Quaternion q = new LSL_Types.Quaternion(rules.Data[idx++].ToString());
+                        SetRot(part, q);
+
+                        break;
+
+                    case 17: // PRIM_TEXTURE
+                        if (remain < 5)
+                            return;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+                        string tex=rules.Data[idx++].ToString();
+                        LSL_Types.Vector3 repeats=new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        LSL_Types.Vector3 offsets=new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        double rotation=Convert.ToDouble(rules.Data[idx++]);
+
+                        SetTexture(part, tex, face);
+                        ScaleTexture(part, repeats.x, repeats.y, face);
+                        OffsetTexture(part, offsets.x, offsets.y, face);
+                        RotateTexture(part, rotation, face);
+
+                        break;
+
+                    case 18: // PRIM_COLOR
+                        if (remain < 3)
+                            return;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+                        LSL_Types.Vector3 color=new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        double alpha=Convert.ToDouble(rules.Data[idx++]);
+
+                        SetColor(part, color, face);
+                        SetAlpha(part, alpha, face);
+
+                        break;
+                    case 21: // PRIM_FLEXI
+                        if (remain < 7)
+                            return;
+
+                        int flexi = Convert.ToInt32(rules.Data[idx++]);
+                        int softness = Convert.ToInt32(rules.Data[idx++]);
+                        float gravity = (float)Convert.ToDouble(rules.Data[idx++]);
+                        float friction = (float)Convert.ToDouble(rules.Data[idx++]);
+                        float wind = (float)Convert.ToDouble(rules.Data[idx++]);
+                        float tension = (float)Convert.ToDouble(rules.Data[idx++]);
+                        LSL_Types.Vector3 force =new LSL_Types.Vector3(rules.Data[idx++].ToString());
+
+                        SetFlexi(part, (flexi == 1), softness, gravity, friction, wind, tension, force);
+
+                        break;
+                    case 23: // PRIM_POINT_LIGHT
+                        if (remain < 5)
+                            return;
+                        int light = Convert.ToInt32(rules.Data[idx++]);
+                        LSL_Types.Vector3 lightcolor =new LSL_Types.Vector3(rules.Data[idx++].ToString());
+                        float intensity = (float)Convert.ToDouble(rules.Data[idx++]);
+                        float radius = (float)Convert.ToDouble(rules.Data[idx++]);
+                        float falloff = (float)Convert.ToDouble(rules.Data[idx++]);
+
+                        SetPointLight(part, (light == 1), lightcolor, intensity, radius, falloff);
+
+                        break;
+                }
+            }
+        }
+
+        public string llStringToBase64(string str)
+        {
+            m_host.AddScriptLPS(1);
+            try
+            {
+                byte[] encData_byte = new byte[str.Length];
+                encData_byte = Encoding.UTF8.GetBytes(str);
+                string encodedData = Convert.ToBase64String(encData_byte);
+                return encodedData;
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error in base64Encode" + e.Message);
+            }
+        }
+
+        public string llBase64ToString(string str)
+        {
+            m_host.AddScriptLPS(1);
+            UTF8Encoding encoder = new UTF8Encoding();
+            Decoder utf8Decode = encoder.GetDecoder();
+            try
+            {
+                byte[] todecode_byte = Convert.FromBase64String(str);
+                int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
+                char[] decoded_char = new char[charCount];
+                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
+                string result = new String(decoded_char);
+                return result;
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error in base64Decode" + e.Message);
+            }
+        }
+
+        public void llXorBase64Strings()
+        {
+            m_host.AddScriptLPS(1);
+            Deprecated("llXorBase64Strings");
+        }
+
+        public void llRemoteDataSetRegion()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRemoteDataSetRegion");
+        }
+
+        public double llLog10(double val)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Log10(val);
+        }
+
+        public double llLog(double val)
+        {
+            m_host.AddScriptLPS(1);
+            return (double)Math.Log(val);
+        }
+
+        public LSL_Types.list llGetAnimationList(string id)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetAnimationList");
+            return new LSL_Types.list();
+        }
+
+        public void llSetParcelMusicURL(string url)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
+            if (landowner == LLUUID.Zero)
+            {
+                return;
+            }
+            if (landowner != m_host.ObjectOwner)
+            {
+                return;
+            }
+            World.SetLandMusicURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
+        }
+
+        public void osSetParcelMediaURL(string url)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
+
+            if (landowner == LLUUID.Zero)
+            {
+                return;
+            }
+
+            if (landowner != m_host.ObjectOwner)
+            {
+                return;
+            }
+
+            World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
+        }
+
+        public LSL_Types.Vector3 llGetRootPosition()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Vector3(m_host.ParentGroup.AbsolutePosition.X, m_host.ParentGroup.AbsolutePosition.Y, m_host.ParentGroup.AbsolutePosition.Z);
+        }
+
+        public LSL_Types.Quaternion llGetRootRotation()
+        {
+            m_host.AddScriptLPS(1);
+            return new LSL_Types.Quaternion(m_host.ParentGroup.GroupRotation.X, m_host.ParentGroup.GroupRotation.Y, m_host.ParentGroup.GroupRotation.Z, m_host.ParentGroup.GroupRotation.W);
+        }
+
+        public string llGetObjectDesc()
+        {
+            return m_host.Description!=null?m_host.Description:String.Empty;
+        }
+
+        public void llSetObjectDesc(string desc)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.Description = desc!=null?desc:String.Empty;
+        }
+
+        public string llGetCreator()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.ObjectCreator.ToString();
+        }
+
+        public string llGetTimestamp()
+        {
+            m_host.AddScriptLPS(1);
+            return DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ");
+        }
+
+        public void llSetLinkAlpha(int linknumber, double alpha, int face)
+        {
+            m_host.AddScriptLPS(1);
+            SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+            if (linknumber > -1)
+            {
+                LLObject.TextureEntry tex = part.Shape.Textures;
+                LLColor texcolor;
+                if (face > -1)
+                {
+                    texcolor = tex.CreateFace((uint)face).RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.FaceTextures[face].RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                else if (face == -1)
+                {
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    for (uint i = 0; i < 32; i++)
+                    {
+                        if (tex.FaceTextures[i] != null)
+                        {
+                            texcolor = tex.FaceTextures[i].RGBA;
+                            texcolor.A = (float)Math.Abs(alpha - 1);
+                            tex.FaceTextures[i].RGBA = texcolor;
+                        }
+                    }
+                    texcolor = tex.DefaultTexture.RGBA;
+                    texcolor.A = (float)Math.Abs(alpha - 1);
+                    tex.DefaultTexture.RGBA = texcolor;
+                    part.UpdateTexture(tex);
+                    return;
+                }
+                return;
+            }
+            else if (linknumber == -1)
+            {
+                int num = m_host.ParentGroup.PrimCount;
+                for (int w = 0; w < num; w++)
+                {
+                    linknumber = w;
+                    part = m_host.ParentGroup.GetLinkNumPart(linknumber);
+                    LLObject.TextureEntry tex = part.Shape.Textures;
+                    LLColor texcolor;
+                    if (face > -1)
+                    {
+                        texcolor = tex.CreateFace((uint)face).RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.FaceTextures[face].RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                    else if (face == -1)
+                    {
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        for (uint i = 0; i < 32; i++)
+                        {
+                            if (tex.FaceTextures[i] != null)
+                            {
+                                texcolor = tex.FaceTextures[i].RGBA;
+                                texcolor.A = (float)Math.Abs(alpha - 1);
+                                tex.FaceTextures[i].RGBA = texcolor;
+                            }
+                        }
+                        texcolor = tex.DefaultTexture.RGBA;
+                        texcolor.A = (float)Math.Abs(alpha - 1);
+                        tex.DefaultTexture.RGBA = texcolor;
+                        part.UpdateTexture(tex);
+                    }
+                }
+                return;
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetNumberOfPrims()
+        {
+            m_host.AddScriptLPS(1);
+            return m_host.ParentGroup.PrimCount;
+        }
+
+        public LSL_Types.list llGetBoundingBox(string obj)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetBoundingBox");
+            return new LSL_Types.list();
+        }
+
+        public LSL_Types.Vector3 llGetGeometricCenter()
+        {
+            return new LSL_Types.Vector3(m_host.GetGeometricCenter().X, m_host.GetGeometricCenter().Y, m_host.GetGeometricCenter().Z);
+        }
+
+        public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules)
+        {
+            m_host.AddScriptLPS(1);
+
+            LSL_Types.list res = new LSL_Types.list();
+            int idx=0;
+            while (idx < rules.Length)
+            {
+                int code=Convert.ToInt32(rules.Data[idx++]);
+                int remain=rules.Length-idx;
+
+                switch (code)
+                {
+                    case 2: // PRIM_MATERIAL
+                        res.Add(new LSL_Types.LSLInteger(m_host.Material));
+                        break;
+
+                    case 3: // PRIM_PHYSICS
+                        if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) != 0)
+                            res.Add(new LSL_Types.LSLInteger(1));
+                        else
+                            res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 4: // PRIM_TEMP_ON_REZ
+                        if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.TemporaryOnRez) != 0)
+                            res.Add(new LSL_Types.LSLInteger(1));
+                        else
+                            res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 5: // PRIM_PHANTOM
+                        if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) != 0)
+                            res.Add(new LSL_Types.LSLInteger(1));
+                        else
+                            res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 6: // PRIM_POSITION
+                        res.Add(new LSL_Types.Vector3(m_host.AbsolutePosition.X,
+                                                      m_host.AbsolutePosition.Y,
+                                                      m_host.AbsolutePosition.Z));
+                        break;
+
+                    case 7: // PRIM_SIZE
+                        res.Add(new LSL_Types.Vector3(m_host.Scale.X,
+                                                      m_host.Scale.Y,
+                                                      m_host.Scale.Z));
+                        break;
+
+                    case 8: // PRIM_ROTATION
+                        res.Add(new LSL_Types.Quaternion(m_host.RotationOffset.X,
+                                                         m_host.RotationOffset.Y,
+                                                         m_host.RotationOffset.Z,
+                                                         m_host.RotationOffset.W));
+                        break;
+
+                    case 9: // PRIM_TYPE
+                        // TODO--------------
+                        res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 17: // PRIM_TEXTURE
+                        if (remain < 1)
+                            return res;
+
+                        int face=Convert.ToInt32(rules.Data[idx++]);
+                        if (face == -1)
+                            face = 0;
+
+                        LLObject.TextureEntry tex = m_host.Shape.Textures;
+                        LLObject.TextureEntryFace texface = tex.GetFace((uint)face);
+
+                        res.Add(new LSL_Types.LSLString(texface.TextureID.ToString()));
+                        res.Add(new LSL_Types.Vector3(texface.RepeatU,
+                                                      texface.RepeatV,
+                                                      0));
+                        res.Add(new LSL_Types.Vector3(texface.OffsetU,
+                                                      texface.OffsetV,
+                                                      0));
+                        res.Add(new LSL_Types.LSLFloat(texface.Rotation));
+                        break;
+
+                    case 18: // PRIM_COLOR
+                        if (remain < 1)
+                            return res;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+
+                        tex = m_host.Shape.Textures;
+                        LLColor texcolor;
+                        if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
+                            texcolor = tex.DefaultTexture.RGBA;
+                        else
+                            texcolor = tex.GetFace((uint)face).RGBA;
+                        res.Add(new LSL_Types.Vector3((255 - (texcolor.R * 255)) / 255,
+                                                      (255 - (texcolor.G * 255)) / 255,
+                                                      (255 - (texcolor.B * 255)) / 255));
+                        res.Add(new LSL_Types.LSLFloat((texcolor.A * 255) / 255));
+                        break;
+
+                    case 19: // PRIM_BUMP_SHINY
+                        // TODO--------------
+                        if (remain < 1)
+                            return res;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+
+                        res.Add(new LSL_Types.LSLInteger(0));
+                        res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 20: // PRIM_FULLBRIGHT
+                        // TODO--------------
+                        if (remain < 1)
+                            return res;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+
+                        res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 21: // PRIM_FLEXIBLE
+                        PrimitiveBaseShape shape = m_host.Shape;
+
+                        if (shape.FlexiEntry)
+                            res.Add(new LSL_Types.LSLInteger(1));              // active
+                        else
+                            res.Add(new LSL_Types.LSLInteger(0));
+                        res.Add(new LSL_Types.LSLInteger(shape.FlexiSoftness));// softness
+                        res.Add(new LSL_Types.LSLFloat(shape.FlexiGravity));   // gravity
+                        res.Add(new LSL_Types.LSLFloat(shape.FlexiDrag));      // friction
+                        res.Add(new LSL_Types.LSLFloat(shape.FlexiWind));      // wind
+                        res.Add(new LSL_Types.LSLFloat(shape.FlexiTension));   // tension
+                        res.Add(new LSL_Types.Vector3(shape.FlexiForceX,       // force
+                                                      shape.FlexiForceY,
+                                                      shape.FlexiForceZ));
+                        break;
+
+                    case 22: // PRIM_TEXGEN
+                        // TODO--------------
+                        // (PRIM_TEXGEN_DEFAULT, PRIM_TEXGEN_PLANAR)
+                        if (remain < 1)
+                            return res;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+
+                        res.Add(new LSL_Types.LSLInteger(0));
+                        break;
+
+                    case 23: // PRIM_POINT_LIGHT:
+                        shape = m_host.Shape;
+
+                        if (shape.LightEntry)
+                            res.Add(new LSL_Types.LSLInteger(1));              // active
+                        else
+                            res.Add(new LSL_Types.LSLInteger(0));
+                        res.Add(new LSL_Types.Vector3(shape.LightColorR,       // color
+                                                      shape.LightColorG,
+                                                      shape.LightColorB));
+                        res.Add(new LSL_Types.LSLFloat(shape.LightIntensity)); // intensity
+                        res.Add(new LSL_Types.LSLFloat(shape.LightRadius));    // radius
+                        res.Add(new LSL_Types.LSLFloat(shape.LightFalloff));   // falloff
+                        break;
+
+                    case 24: // PRIM_GLOW
+                        // TODO--------------
+                        if (remain < 1)
+                            return res;
+
+                        face=Convert.ToInt32(rules.Data[idx++]);
+
+                        res.Add(new LSL_Types.LSLFloat(0));
+                        break;
+                }
+            }
+            return res;
+        }
+
+        //  <remarks>
+        //  <para>
+        //  The .NET definition of base 64 is:
+        //  <list>
+        //  <item>
+        //  Significant: A-Z a-z 0-9 + -
+        //  </item>
+        //  <item>
+        //  Whitespace: \t \n \r ' '
+        //  </item>
+        //  <item>
+        //  Valueless: =
+        //  </item>
+        //  <item>
+        //  End-of-string: \0 or '=='
+        //  </item>
+        //  </list>
+        //  </para>
+        //  <para>
+        //  Each point in a base-64 string represents
+        //  a 6 bit value. A 32-bit integer can be
+        //  represented using 6 characters (with some
+        //  redundancy).
+        //  </para>
+        //  <para>
+        //  LSL requires a base64 string to be 8
+        //  characters in length. LSL also uses '/'
+        //  rather than '-' (MIME compliant).
+        //  </para>
+        //  <para>
+        //  RFC 1341 used as a reference (as specified
+        //  by the SecondLife Wiki).
+        //  </para>
+        //  <para>
+        //  SL do not record any kind of exception for
+        //  these functions, so the string to integer
+        //  conversion returns '0' if an invalid
+        //  character is encountered during conversion.
+        //  </para>
+        //  <para>
+        //  References
+        //  <list>
+        //  <item>
+        //  http://lslwiki.net/lslwiki/wakka.php?wakka=Base64
+        //  </item>
+        //  <item>
+        //  </item>
+        //  </list>
+        //  </para>
+        //  </remarks>
+
+        //  <summary>
+        //  Table for converting 6-bit integers into
+        //  base-64 characters
+        //  </summary>
+
+        private static readonly char[] i2ctable =
+        {
+            'A','B','C','D','E','F','G','H',
+            'I','J','K','L','M','N','O','P',
+            'Q','R','S','T','U','V','W','X',
+            'Y','Z',
+            'a','b','c','d','e','f','g','h',
+            'i','j','k','l','m','n','o','p',
+            'q','r','s','t','u','v','w','x',
+            'y','z',
+            '0','1','2','3','4','5','6','7',
+            '8','9',
+            '+','/'
+        };
+
+        //  <summary>
+        //  Table for converting base-64 characters
+        //  into 6-bit integers.
+        //  </summary>
+
+        private static readonly int[] c2itable =
+        {
+            -1,-1,-1,-1,-1,-1,-1,-1,    // 0x
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // 1x
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // 2x
+            -1,-1,-1,63,-1,-1,-1,64,
+            53,54,55,56,57,58,59,60,    // 3x
+            61,62,-1,-1,-1,0,-1,-1,
+            -1,1,2,3,4,5,6,7,           // 4x
+            8,9,10,11,12,13,14,15,
+            16,17,18,19,20,21,22,23,    // 5x
+            24,25,26,-1,-1,-1,-1,-1,
+            -1,27,28,29,30,31,32,33,    // 6x
+            34,35,36,37,38,39,40,41,
+            42,43,44,45,46,47,48,49,    // 7x
+            50,51,52,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // 8x
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // 9x
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Ax
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Bx
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Cx
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Dx
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Ex
+            -1,-1,-1,-1,-1,-1,-1,-1,
+            -1,-1,-1,-1,-1,-1,-1,-1,    // Fx
+            -1,-1,-1,-1,-1,-1,-1,-1
+        };
+
+        //  <summary>
+        //  Converts a 32-bit integer into a Base64
+        //  character string. Base64 character strings
+        //  are always 8 characters long. All iinteger
+        //  values are acceptable.
+        //  </summary>
+        //  <param name="number">
+        //  32-bit integer to be converted.
+        //  </param>
+        //  <returns>
+        //  8 character string. The 1st six characters
+        //  contain the encoded number, the last two
+        //  characters are padded with "=".
+        //  </returns>
+
+        public string llIntegerToBase64(int number)
+        {
+            // uninitialized string
+
+            char[] imdt = new char[8];
+
+            m_host.AddScriptLPS(1);
+
+            // Manually unroll the loop
+
+            imdt[7] = '=';
+            imdt[6] = '=';
+            imdt[5] = i2ctable[number<<4  & 0x3F];
+            imdt[4] = i2ctable[number>>2  & 0x3F];
+            imdt[3] = i2ctable[number>>8  & 0x3F];
+            imdt[2] = i2ctable[number>>14 & 0x3F];
+            imdt[1] = i2ctable[number>>20 & 0x3F];
+            imdt[0] = i2ctable[number>>26 & 0x3F];
+
+            return new string(imdt);
+        }
+
+        //  <summary>
+        //  Converts an eight character base-64 string
+        //  into a 32-bit integer.
+        //  </summary>
+        //  <param name="str">
+        //  8 characters string to be converted. Other
+        //  length strings return zero.
+        //  </param>
+        //  <returns>
+        //  Returns an integer representing the
+        //  encoded value providedint he 1st 6
+        //  characters of the string.
+        //  </returns>
+        //  <remarks>
+        //  This is coded to behave like LSL's
+        //  implementation (I think), based upon the
+        //  information available at the Wiki.
+        //  If more than 8 characters are supplied,
+        //  zero is returned.
+        //  If a NULL string is supplied, zero will
+        //  be returned.
+        //  If fewer than 6 characters are supplied, then
+        //  the answer will reflect a partial
+        //  accumulation.
+        //  <para>
+        //  The 6-bit segments are
+        //  extracted left-to-right in big-endian mode,
+        //  which means that segment 6 only contains the
+        //  two low-order bits of the 32 bit integer as
+        //  its high order 2 bits. A short string therefore
+        //  means loss of low-order information. E.g.
+        //
+        //  |<---------------------- 32-bit integer ----------------------->|<-Pad->|
+        //  |<--Byte 0----->|<--Byte 1----->|<--Byte 2----->|<--Byte 3----->|<-Pad->|
+        //  |3|3|2|2|2|2|2|2|2|2|2|2|1|1|1|1|1|1|1|1|1|1| | | | | | | | | | |P|P|P|P|
+        //  |1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|P|P|P|P|
+        //  |  str[0]   |  str[1]   |  str[2]   |  str[3]   |  str[4]   |  str[6]   |
+        //
+        //  </para>
+        //  </remarks>
+
+        public LSL_Types.LSLInteger llBase64ToInteger(string str)
+        {
+            int number = 0;
+            int digit;
+
+            m_host.AddScriptLPS(1);
+
+            //    Require a well-fromed base64 string
+
+            if (str.Length > 8)
+                return 0;
+
+            //    The loop is unrolled in the interests
+            //    of performance and simple necessity.
+            //
+            //    MUST find 6 digits to be well formed
+            //      -1 == invalid
+            //       0 == padding
+
+            if ((digit=c2itable[str[0]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit<<26;
+
+            if ((digit=c2itable[str[1]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit<<20;
+
+            if ((digit=c2itable[str[2]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit<<14;
+
+            if ((digit=c2itable[str[3]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit<<8;
+
+            if ((digit=c2itable[str[4]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit<<2;
+
+            if ((digit=c2itable[str[5]])<=0)
+            {
+                return digit<0?(int)0:number;
+            }
+            number += --digit>>4;
+
+            // ignore trailing padding
+
+            return number;
+        }
+
+        public double llGetGMTclock()
+        {
+            m_host.AddScriptLPS(1);
+            return DateTime.UtcNow.TimeOfDay.TotalSeconds;
+        }
+
+        public string llGetSimulatorHostname()
+        {
+            m_host.AddScriptLPS(1);
+            return System.Environment.MachineName;
+        }
+
+        public void llSetLocalRot(LSL_Types.Quaternion rot)
+        {
+            m_host.AddScriptLPS(1);
+            m_host.RotationOffset = new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s);
+        }
+
+        //  <summary>
+        //  Scan the string supplied in 'src' and
+        //  tokenize it based upon two sets of
+        //  tokenizers provided in two lists,
+        //  separators and spacers.
+        //  </summary>
+        //
+        //  <remarks>
+        //  Separators demarcate tokens and are
+        //  elided as they are encountered. Spacers
+        //  also demarcate tokens, but are themselves
+        //  retained as tokens.
+        //
+        //  Both separators and spacers may be arbitrarily
+        //  long strings. i.e. ":::".
+        //
+        //  The function returns an ordered list
+        //  representing the tokens found in the supplied
+        //  sources string. If two successive tokenizers
+        //  are encountered, then a NULL entry is added
+        //  to the list.
+        //
+        //  It is a precondition that the source and
+        //  toekizer lisst are non-null. If they are null,
+        //  then a null pointer exception will be thrown
+        //  while their lengths are being determined.
+        //
+        //  A small amount of working memoryis required
+        //  of approximately 8*#tokenizers.
+        //
+        //  There are many ways in which this function
+        //  can be implemented, this implementation is
+        //  fairly naive and assumes that when the
+        //  function is invooked with a short source
+        //  string and/or short lists of tokenizers, then
+        //  performance will not be an issue.
+        //
+        //  In order to minimize the perofrmance
+        //  effects of long strings, or large numbers
+        //  of tokeizers, the function skips as far as
+        //  possible whenever a toekenizer is found,
+        //  and eliminates redundant tokenizers as soon
+        //  as is possible.
+        //
+        //  The implementation tries to avoid any copying
+        //  of arrays or other objects.
+        //  </remarks>
+
+        public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list separators, LSL_Types.list spacers)
+        {
+            int         beginning = 0;
+            int         srclen    = src.Length;
+            int         seplen    = separators.Length;
+            object[]    separray  = separators.Data;
+            int         spclen    = spacers.Length;
+            object[]    spcarray  = spacers.Data;
+            int         mlen      = seplen+spclen;
+
+            int[]       offset    = new int[mlen+1];
+            bool[]      active    = new bool[mlen];
+
+            int         best;
+            int         j;
+
+            //    Initial capacity reduces resize cost
+
+            LSL_Types.list tokens = new LSL_Types.list();
+
+            m_host.AddScriptLPS(1);
+
+            //    All entries are initially valid
+
+            for (int i = 0; i < mlen; i++)
+                active[i] = true;
+
+            offset[mlen] = srclen;
+
+            while (beginning < srclen)
+            {
+
+                best = mlen;    // as bad as it gets
+
+                //    Scan for separators
+
+                for (j = 0; j < seplen; j++)
+                {
+                    if (active[j])
+                    {
+                        // scan all of the markers
+                        if ((offset[j] = src.IndexOf((string)separray[j],beginning)) == -1)
+                        {
+                            // not present at all
+                            active[j] = false;
+                        }
+                        else
+                        {
+                            // present and correct
+                            if (offset[j] < offset[best])
+                            {
+                                // closest so far
+                                best = j;
+                                if (offset[best] == beginning)
+                                    break;
+                            }
+                        }
+                    }
+                }
+
+                //    Scan for spacers
+
+                if (offset[best] != beginning)
+                {
+                    for (j = seplen; (j < mlen) && (offset[best] > beginning); j++)
+                    {
+                        if (active[j])
+                        {
+                            // scan all of the markers
+                            if ((offset[j] = src.IndexOf((string)spcarray[j-seplen], beginning)) == -1)
+                            {
+                                // not present at all
+                                active[j] = false;
+                            }
+                            else
+                            {
+                                // present and correct
+                                if (offset[j] < offset[best])
+                                {
+                                    // closest so far
+                                    best = j;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                //    This is the normal exit from the scanning loop
+
+                if (best == mlen)
+                {
+                    // no markers were found on this pass
+                    // so we're pretty much done
+                    tokens.Add(src.Substring(beginning, srclen - beginning));
+                    break;
+                }
+
+                //    Otherwise we just add the newly delimited token
+                //    and recalculate where the search should continue.
+
+                tokens.Add(src.Substring(beginning,offset[best]-beginning));
+
+                if (best < seplen)
+                {
+                    beginning = offset[best] + ((string)separray[best]).Length;
+                }
+                else
+                {
+                    beginning = offset[best] + ((string)spcarray[best - seplen]).Length;
+                    tokens.Add(spcarray[best - seplen]);
+                }
+            }
+
+            //    This an awkward an not very intuitive boundary case. If the
+            //    last substring is a tokenizer, then there is an implied trailing
+            //    null list entry. Hopefully the single comparison will not be too
+            //    arduous. Alternatively the 'break' could be replced with a return
+            //    but that's shabby programming.
+
+            if (beginning == srclen)
+            {
+                if (srclen != 0)
+                    tokens.Add("");
+            }
+
+            return tokens;
+        }
+
+        public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity,
+                                LSL_Types.Quaternion rot, int param)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRezAtRoot");
+        }
+
+        public LSL_Types.LSLInteger llGetObjectPermMask(int mask)
+        {
+            m_host.AddScriptLPS(1);
+
+            int permmask = 0;
+
+            if (mask == ScriptBaseClass.MASK_BASE)//0
+            {
+                permmask = (int)m_host.BaseMask;
+            }
+
+            else if (mask == ScriptBaseClass.MASK_OWNER)//1
+            {
+                permmask = (int)m_host.OwnerMask;
+            }
+
+            else if (mask == ScriptBaseClass.MASK_GROUP)//2
+            {
+                permmask = (int)m_host.GroupMask;
+            }
+
+            else if (mask == ScriptBaseClass.MASK_EVERYONE)//3
+            {
+                permmask = (int)m_host.EveryoneMask;
+            }
+
+            else if (mask == ScriptBaseClass.MASK_NEXT)//4
+            {
+                permmask = (int)m_host.NextOwnerMask;
+            }
+
+            return permmask;
+        }
+
+        public void llSetObjectPermMask(int mask, int value)
+        {
+            m_host.AddScriptLPS(1);
+            IConfigSource config = new IniConfigSource(Application.iniFilePath);
+            if (config.Configs["XEngine"] == null)
+                config.AddConfig("XEngine");
+
+            if (config.Configs["XEngine"].GetBoolean("AllowGodFunctions", false))
+            {
+                if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID))
+                {
+                    if (mask == ScriptBaseClass.MASK_BASE)//0
+                    {
+                        m_host.BaseMask = (uint)value;
+                    }
+
+                    else if (mask == ScriptBaseClass.MASK_OWNER)//1
+                    {
+                        m_host.OwnerMask = (uint)value;
+                    }
+
+                    else if (mask == ScriptBaseClass.MASK_GROUP)//2
+                    {
+                        m_host.GroupMask = (uint)value;
+                    }
+
+                    else if (mask == ScriptBaseClass.MASK_EVERYONE)//3
+                    {
+                        m_host.EveryoneMask = (uint)value;
+                    }
+
+                    else if (mask == ScriptBaseClass.MASK_NEXT)//4
+                    {
+                        m_host.NextOwnerMask = (uint)value;
+                    }
+                }
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == item)
+                {
+                    switch (mask)
+                    {
+                        case 0:
+                            return (int)inv.Value.BaseMask;
+                        case 1:
+                            return (int)inv.Value.OwnerMask;
+                        case 2:
+                            return (int)inv.Value.GroupMask;
+                        case 3:
+                            return (int)inv.Value.EveryoneMask;
+                        case 4:
+                            return (int)inv.Value.NextOwnerMask;
+                    }
+                }
+            }
+            return -1;
+        }
+
+        public void llSetInventoryPermMask(string item, int mask, int value)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetInventoryPermMask");
+        }
+
+        public string llGetInventoryCreator(string item)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == item)
+                {
+                    return inv.Value.CreatorID.ToString();
+                }
+            }
+            llSay(0, "No item name '" + item + "'");
+            return String.Empty;
+        }
+
+        public void llOwnerSay(string msg)
+        {
+            m_host.AddScriptLPS(1);
+
+            World.SimChatBroadcast(Helpers.StringToField(msg), ChatTypeEnum.Owner, 0, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
+//            IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+//            wComm.DeliverMessage(ChatTypeEnum.Owner, 0, m_host.Name, m_host.UUID, msg);
+        }
+
+        public string llRequestSimulatorData(string simulator, int data)
+        {
+            try
+            {
+                m_host.AddScriptLPS(1);
+
+                string reply = String.Empty;
+
+                RegionInfo info = m_ScriptEngine.World.RequestClosestRegion(simulator);
+
+                switch (data)
+                {
+                    case 5: // DATA_SIM_POS
+                        if (info == null)
+                            return LLUUID.Zero.ToString();
+                        reply = new LSL_Types.Vector3(
+                            info.RegionLocX * Constants.RegionSize,
+                            info.RegionLocY * Constants.RegionSize,
+                            0).ToString();
+                        break;
+                    case 6: // DATA_SIM_STATUS
+                        if (info != null)
+                            reply = "up"; // Duh!
+                        else
+                            reply = "unknown";
+                        break;
+                    case 7: // DATA_SIM_RATING
+                        if (info == null)
+                            return LLUUID.Zero.ToString();
+                        int access = (int)info.EstateSettings.simAccess;
+                        if (access == 21)
+                            reply = "MATURE";
+                        else if (access == 13)
+                            reply = "MATURE";
+                        else
+                            reply = "UNKNOWN";
+                        break;
+                    default:
+                        return LLUUID.Zero.ToString(); // Raise no event
+                }
+                LLUUID rq = LLUUID.Random();
+
+                LLUUID tid = AsyncCommands.
+                    DataserverPlugin.RegisterRequest(m_localID,
+                                                 m_itemID, rq.ToString());
+
+                AsyncCommands.
+                    DataserverPlugin.DataserverReply(rq.ToString(), reply);
+
+                return tid.ToString();
+            }
+            catch(Exception e)
+            {
+                Console.WriteLine(e.ToString());
+                return LLUUID.Zero.ToString();
+            }
+        }
+
+        public void llForceMouselook(int mouselook)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llForceMouselook");
+        }
+
+        public double llGetObjectMass(string id)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id,out key))
+            {
+                return (double) World.GetSceneObjectPart(World.Entities[key].LocalId).GetMass();
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// illListReplaceList removes the sub-list defined by the inclusive indices
+        /// start and end and inserts the src list in its place. The inclusive
+        /// nature of the indices means that at least one element must be deleted
+        /// if the indices are within the bounds of the existing list. I.e. 2,2
+        /// will remove the element at index 2 and replace it with the source
+        /// list. Both indices may be negative, with the usual interpretation. An
+        /// interesting case is where end is lower than start. As these indices
+        /// bound the list to be removed, then 0->end, and start->lim are removed
+        /// and the source list is added as a suffix.
+        /// </summary>
+
+        public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end)
+        {
+            LSL_Types.list pref = null;
+
+            m_host.AddScriptLPS(1);
+
+            // Note that although we have normalized, both
+            // indices could still be negative.
+            if (start < 0)
+            {
+                start = start+dest.Length;
+            }
+
+            if (end < 0)
+            {
+                end = end+dest.Length;
+            }
+            // The comventional case, remove a sequence starting with
+            // start and ending with end. And then insert the source
+            // list.
+            if (start <= end)
+            {
+                // If greater than zero, then there is going to be a
+                // surviving prefix. Otherwise the inclusive nature
+                // of the indices mean that we're going to add the
+                // source list as a prefix.
+                if (start > 0)
+                {
+                    pref = dest.GetSublist(0,start-1);
+                    // Only add a suffix if there is something
+                    // beyond the end index (it's inclusive too).
+                    if (end + 1 < dest.Length)
+                    {
+                        return pref + src + dest.GetSublist(end + 1, -1);
+                    }
+                    else
+                    {
+                        return pref + src;
+                    }
+                }
+                // If start is less than or equal to zero, then
+                // the new list is simply a prefix. We still need to
+                // figure out any necessary surgery to the destination
+                // based upon end. Note that if end exceeds the upper
+                // bound in this case, the entire destination list
+                // is removed.
+                else
+                {
+                    if (end + 1 < dest.Length)
+                    {
+                        return src + dest.GetSublist(end + 1, -1);
+                    }
+                    else
+                    {
+                        return src;
+                    }
+                }
+            }
+            // Finally, if start > end, we strip away a prefix and
+            // a suffix, to leave the list that sits <between> ens
+            // and start, and then tag on the src list. AT least
+            // that's my interpretation. We can get sublist to do
+            // this for us. Note that one, or both of the indices
+            // might have been negative.
+            else
+            {
+                return dest.GetSublist(end + 1, start - 1) + src;
+            }
+        }
+
+        public void llLoadURL(string avatar_id, string message, string url)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID avatarId = new LLUUID(avatar_id);
+            m_ScriptEngine.World.SendUrlToUser(avatarId, m_host.Name, m_host.UUID, m_host.ObjectOwner, false, message,
+                                               url);
+        }
+
+        public void llParcelMediaCommandList(LSL_Types.list commandList)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llParcelMediaCommandList");
+        }
+
+        public void llParcelMediaQuery()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llParcelMediaQuery");
+        }
+
+        public LSL_Types.LSLInteger llModPow(int a, int b, int c)
+        {
+            m_host.AddScriptLPS(1);
+            Int64 tmp = 0;
+            Math.DivRem(Convert.ToInt64(Math.Pow(a, b)), c, out tmp);
+            return Convert.ToInt32(tmp);
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryType(string name)
+        {
+            m_host.AddScriptLPS(1);
+            foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
+            {
+                if (inv.Value.Name == name)
+                {
+                    return inv.Value.InvType;
+                }
+            }
+            return -1;
+        }
+
+        public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons)
+        {
+            m_host.AddScriptLPS(1);
+
+            if (quick_pay_buttons.Data.Length != 4)
+            {
+                LSLError("List must have 4 elements");
+                return;
+            }
+            m_host.ParentGroup.RootPart.PayPrice[0]=price;
+            m_host.ParentGroup.RootPart.PayPrice[1]=(int)quick_pay_buttons.Data[0];
+            m_host.ParentGroup.RootPart.PayPrice[2]=(int)quick_pay_buttons.Data[1];
+            m_host.ParentGroup.RootPart.PayPrice[3]=(int)quick_pay_buttons.Data[2];
+            m_host.ParentGroup.RootPart.PayPrice[4]=(int)quick_pay_buttons.Data[3];
+        }
+
+        public LSL_Types.Vector3 llGetCameraPos()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetCameraPos");
+            return new LSL_Types.Vector3();
+        }
+
+        public LSL_Types.Quaternion llGetCameraRot()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llGetCameraRot");
+            return new LSL_Types.Quaternion();
+        }
+
+        public void llSetPrimURL()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetPrimURL");
+        }
+
+        public void llRefreshPrimURL()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llRefreshPrimURL");
+        }
+
+        public string llEscapeURL(string url)
+        {
+            m_host.AddScriptLPS(1);
+            try
+            {
+                return Uri.EscapeUriString(url);
+            }
+            catch (Exception ex)
+            {
+                return "llEscapeURL: " + ex.ToString();
+            }
+        }
+
+        public string llUnescapeURL(string url)
+        {
+            m_host.AddScriptLPS(1);
+            try
+            {
+                return Uri.UnescapeDataString(url);
+            }
+            catch (Exception ex)
+            {
+                return "llUnescapeURL: " + ex.ToString();
+            }
+        }
+
+        public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llMapDestination");
+        }
+
+        public void llAddToLandBanList(string avatar, double hours)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key;
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+                if (LLUUID.TryParse(avatar, out key))
+                {
+                    entry.AgentID = key;
+                    entry.Flags = ParcelManager.AccessList.Ban;
+                    entry.Time = DateTime.Now.AddHours(hours);
+                    land.parcelAccessList.Add(entry);
+                }
+            }
+        }
+
+        public void llRemoveFromLandPassList(string avatar)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key;
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                if (LLUUID.TryParse(avatar, out key))
+                {
+                    foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
+                    {
+                        if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Access)
+                        {
+                            land.parcelAccessList.Remove(entry);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void llRemoveFromLandBanList(string avatar)
+        {
+            m_host.AddScriptLPS(1);
+            LLUUID key;
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                if (LLUUID.TryParse(avatar, out key))
+                {
+                    foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
+                    {
+                        if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Ban)
+                        {
+                            land.parcelAccessList.Remove(entry);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void llSetCameraParams(LSL_Types.list rules)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetCameraParams");
+        }
+
+        public void llClearCameraParams()
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llClearCameraParams");
+        }
+
+        public double llListStatistics(int operation, LSL_Types.list src)
+        {
+            m_host.AddScriptLPS(1);
+            LSL_Types.list nums = LSL_Types.list.ToDoubleList(src);
+            switch (operation)
+            {
+                case ScriptBaseClass.LIST_STAT_RANGE:
+                    return nums.Range();
+                case ScriptBaseClass.LIST_STAT_MIN:
+                    return nums.Min();
+                case ScriptBaseClass.LIST_STAT_MAX:
+                    return nums.Max();
+                case ScriptBaseClass.LIST_STAT_MEAN:
+                    return nums.Mean();
+                case ScriptBaseClass.LIST_STAT_MEDIAN:
+                    return nums.Median();
+                case ScriptBaseClass.LIST_STAT_NUM_COUNT:
+                    return nums.NumericLength();
+                case ScriptBaseClass.LIST_STAT_STD_DEV:
+                    return nums.StdDev();
+                case ScriptBaseClass.LIST_STAT_SUM:
+                    return nums.Sum();
+                case ScriptBaseClass.LIST_STAT_SUM_SQUARES:
+                    return nums.SumSqrs();
+                case ScriptBaseClass.LIST_STAT_GEOMETRIC_MEAN:
+                    return nums.GeometricMean();
+                case ScriptBaseClass.LIST_STAT_HARMONIC_MEAN:
+                    return nums.HarmonicMean();
+                default:
+                    return 0.0;
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetUnixTime()
+        {
+            m_host.AddScriptLPS(1);
+            return Util.UnixTimeSinceEpoch();
+        }
+
+        public LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+            return (int)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y).landData.landFlags;
+        }
+
+        public LSL_Types.LSLInteger llGetRegionFlags()
+        {
+            m_host.AddScriptLPS(1);
+            return (int)World.RegionInfo.EstateSettings.regionFlags;
+        }
+
+        public string llXorBase64StringsCorrect(string str1, string str2)
+        {
+            m_host.AddScriptLPS(1);
+            string ret = String.Empty;
+            string src1 = llBase64ToString(str1);
+            string src2 = llBase64ToString(str2);
+            int c = 0;
+            for (int i = 0; i < src1.Length; i++)
+            {
+                ret += src1[i] ^ src2[c];
+
+                c++;
+                if (c > src2.Length)
+                    c = 0;
+            }
+            return llStringToBase64(ret);
+        }
+
+        public string llHTTPRequest(string url, LSL_Types.list parameters, string body)
+        {
+            // Partial implementation: support for parameter flags needed
+            //   see http://wiki.secondlife.com/wiki/LlHTTPRequest
+            // parameter flags support are implemented in ScriptsHttpRequests.cs
+            //   in StartHttpRequest
+
+            m_host.AddScriptLPS(1);
+            IHttpRequests httpScriptMod =
+                m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+            List<string> param = new List<string>();
+            foreach (object o in parameters.Data)
+            {
+                param.Add(o.ToString());
+            }
+            LLUUID reqID = httpScriptMod.
+                StartHttpRequest(m_localID, m_itemID, url, param, body);
+
+            if (reqID != LLUUID.Zero)
+                return reqID.ToString();
+            else
+                return null;
+        }
+
+        public void llResetLandBanList()
+        {
+            m_host.AddScriptLPS(1);
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
+                {
+                    if (entry.Flags == ParcelManager.AccessList.Ban)
+                    {
+                        land.parcelAccessList.Remove(entry);
+                    }
+                }
+            }
+        }
+
+        public void llResetLandPassList()
+        {
+            m_host.AddScriptLPS(1);
+            LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
+            if (land.ownerID == m_host.OwnerID)
+            {
+                foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
+                {
+                    if (entry.Flags == ParcelManager.AccessList.Access)
+                    {
+                        land.parcelAccessList.Remove(entry);
+                    }
+                }
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide)
+        {
+            m_host.AddScriptLPS(1);
+
+            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+
+            if (land == null)
+            {
+                return 0;
+            }
+
+            else
+            {
+                if (sim_wide == 1)
+                {
+                    if (category == 0)
+                    {
+                        return land.simwidePrims;
+                    }
+
+                    else
+                    {
+                        //public int simwideArea = 0;
+                        return 0;
+                    }
+                }
+
+                else
+                {
+                    if (category == 0)//Total Prims
+                    {
+                        return 0;//land.
+                    }
+
+                    else if (category == 1)//Owner Prims
+                    {
+                        return land.ownerPrims;
+                    }
+
+                    else if (category == 2)//Group Prims
+                    {
+                        return land.groupPrims;
+                    }
+
+                    else if (category == 3)//Other Prims
+                    {
+                        return land.otherPrims;
+                    }
+
+                    else if (category == 4)//Selected
+                    {
+                        return land.selectedPrims;
+                    }
+
+                    else if (category == 5)//Temp
+                    {
+                        return 0;//land.
+                    }
+                }
+            }
+            return 0;
+        }
+
+        public LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos)
+        {
+            m_host.AddScriptLPS(1);
+            LandObject land = (LandObject)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y);
+            LSL_Types.list ret = new LSL_Types.list();
+            if (land != null)
+            {
+                foreach (KeyValuePair<LLUUID, int> d in land.getLandObjectOwners())
+                {
+                    ret.Add(d.Key.ToString());
+                    ret.Add(d.Value);
+                }
+            }
+            return ret;
+        }
+
+        public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id)
+        {
+            m_host.AddScriptLPS(1);
+            SceneObjectPart part = World.GetSceneObjectPart(new LLUUID(object_id));
+            if (part == null)
+            {
+                return 0;
+            }
+            else
+            {
+                return part.ParentGroup.Children.Count;
+            }
+        }
+
+        public LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide)
+        {
+            m_host.AddScriptLPS(1);
+            // Alondria: This currently just is utilizing the normal grid's 0.22 prims/m2 calculation
+            // Which probably will be irrelevent in OpenSim....
+            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+
+            float bonusfactor = World.RegionInfo.EstateSettings.objectBonusFactor;
+
+            if (land == null)
+            {
+                return 0;
+            }
+
+            if (sim_wide == 1)
+            {
+                decimal v = land.simwideArea * (decimal)(0.22) * (decimal)bonusfactor;
+
+                return (int)v;
+            }
+
+            else
+            {
+                decimal v = land.area * (decimal)(0.22) * (decimal)bonusfactor;
+
+                return (int)v;
+            }
+
+        }
+
+        public LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param)
+        {
+            m_host.AddScriptLPS(1);
+            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+            if (land == null)
+            {
+                return new LSL_Types.list(0);
+            }
+            LSL_Types.list ret = new LSL_Types.list();
+            foreach (object o in param.Data)
+            {
+                switch (o.ToString())
+                {
+                    case "0":
+                        ret = ret + new LSL_Types.list(land.landName);
+                        break;
+                    case "1":
+                        ret = ret + new LSL_Types.list(land.landDesc);
+                        break;
+                    case "2":
+                        ret = ret + new LSL_Types.list(land.ownerID.ToString());
+                        break;
+                    case "3":
+                        ret = ret + new LSL_Types.list(land.groupID.ToString());
+                        break;
+                    case "4":
+                        ret = ret + new LSL_Types.list(land.area);
+                        break;
+                    default:
+                        ret = ret + new LSL_Types.list(0);
+                        break;
+                }
+            }
+            return ret;
+        }
+
+        public void llSetLinkTexture(int linknumber, string texture, int face)
+        {
+            m_host.AddScriptLPS(1);
+            NotImplemented("llSetLinkTexture");
+        }
+
+        public string llStringTrim(string src, int type)
+        {
+            m_host.AddScriptLPS(1);
+            if (type == (int)ScriptBaseClass.STRING_TRIM_HEAD) { return src.TrimStart(); }
+            if (type == (int)ScriptBaseClass.STRING_TRIM_TAIL) { return src.TrimEnd(); }
+            if (type == (int)ScriptBaseClass.STRING_TRIM) { return src.Trim(); }
+            return src;
+        }
+
+        public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args)
+        {
+            m_host.AddScriptLPS(1);
+            LSL_Types.list ret = new LSL_Types.list();
+            LLUUID key = new LLUUID();
+            if (LLUUID.TryParse(id, out key))
+            {
+                ScenePresence av = World.GetScenePresence(key);
+
+                if (av != null)
+                {
+                    foreach (object o in args.Data)
+                    {
+                        switch (o.ToString())
+                        {
+                            case "1":
+                                ret.Add(av.Firstname + " " + av.Lastname);
+                                break;
+                            case "2":
+                                ret.Add("");
+                                break;
+                            case "3":
+                                ret.Add(new LSL_Types.Vector3((double)av.AbsolutePosition.X, (double)av.AbsolutePosition.Y, (double)av.AbsolutePosition.Z));
+                                break;
+                            case "4":
+                                ret.Add(new LSL_Types.Quaternion((double)av.Rotation.x, (double)av.Rotation.y, (double)av.Rotation.z, (double)av.Rotation.w));
+                                break;
+                            case "5":
+                                ret.Add(new LSL_Types.Vector3(av.Velocity.X,av.Velocity.Y,av.Velocity.Z));
+                                break;
+                            case "6":
+                                ret.Add(id);
+                                break;
+                            case "7":
+                                ret.Add(LLUUID.Zero.ToString());
+                                break;
+                            case "8":
+                                ret.Add(LLUUID.Zero.ToString());
+                                break;
+                        }
+                    }
+                    return ret;
+                }
+                SceneObjectPart obj = World.GetSceneObjectPart(key);
+                if (obj != null)
+                {
+                    foreach (object o in args.Data)
+                    {
+                        switch (o.ToString())
+                        {
+                            case "1":
+                                ret.Add(obj.Name);
+                                break;
+                            case "2":
+                                ret.Add(obj.Description);
+                                break;
+                            case "3":
+                                ret.Add(new LSL_Types.Vector3(obj.AbsolutePosition.X,obj.AbsolutePosition.Y,obj.AbsolutePosition.Z));
+                                break;
+                            case "4":
+                                ret.Add(new LSL_Types.Quaternion(obj.RotationOffset.X, obj.RotationOffset.Y, obj.RotationOffset.Z, obj.RotationOffset.W));
+                                break;
+                            case "5":
+                                ret.Add(new LSL_Types.Vector3(obj.Velocity.X, obj.Velocity.Y, obj.Velocity.Z));
+                                break;
+                            case "6":
+                                ret.Add(obj.OwnerID.ToString());
+                                break;
+                            case "7":
+                                ret.Add(obj.GroupID.ToString());
+                                break;
+                            case "8":
+                                ret.Add(obj.CreatorID.ToString());
+                                break;
+                        }
+                    }
+                    return ret;
+                }
+            }
+            return new LSL_Types.list();
+        }
+
+
+        internal LLUUID ScriptByName(string name)
+        {
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 10 && item.Name == name)
+                    return item.ItemID;
+            }
+            return LLUUID.Zero;
+        }
+
+        internal void ShoutError(string msg)
+        {
+            llShout(ScriptBaseClass.DEBUG_CHANNEL, msg);
+        }
+
+
+
+        internal void NotImplemented(string command)
+        {
+            if (throwErrorOnNotImplemented)
+                throw new NotImplementedException("Command not implemented: " + command);
+        }
+
+        internal void Deprecated(string command)
+        {
+            throw new Exception("Command deprecated: " + command);
+        }
+
+        internal void LSLError(string msg)
+        {
+            throw new Exception("LSL Runtime Error: " + msg);
+        }
+
+        public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset);
+        private void WithNotecard(LLUUID assetID, AssetRequestCallback cb)
+        {
+            World.AssetCache.GetAsset(assetID, delegate(LLUUID i, AssetBase a) { cb(i, a); }, false);
+        }
+
+        public string llGetNumberOfNotecardLines(string name)
+        {
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 7 && item.Name == name)
+                {
+                    LLUUID tid = AsyncCommands.
+                            DataserverPlugin.RegisterRequest(m_localID,
+                            m_itemID, item.AssetID.ToString());
+                    if (NotecardCache.IsCached(item.AssetID))
+                    {
+                        AsyncCommands.
+                        DataserverPlugin.DataserverReply(item.AssetID.ToString(),
+                                NotecardCache.GetLines(item.AssetID).ToString());
+                        return tid.ToString();
+                    }
+                    WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a)
+                    {
+                        System.Text.ASCIIEncoding enc =
+                            new System.Text.ASCIIEncoding();
+                        string data = enc.GetString(a.Data);
+                        //Console.WriteLine(data);
+                        NotecardCache.Cache(id, data);
+                        AsyncCommands.
+                                DataserverPlugin.DataserverReply(id.ToString(),
+                                NotecardCache.GetLines(id).ToString());
+                    });
+
+                    return tid.ToString();
+                }
+            }
+            return LLUUID.Zero.ToString();
+        }
+
+        public string llGetNotecardLine(string name, int line)
+        {
+            m_host.AddScriptLPS(1);
+
+            foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
+            {
+                if (item.Type == 7 && item.Name == name)
+                {
+                    LLUUID tid = AsyncCommands.
+                            DataserverPlugin.RegisterRequest(m_localID,
+                            m_itemID, item.AssetID.ToString());
+                    if (NotecardCache.IsCached(item.AssetID))
+                    {
+                        AsyncCommands.
+                        DataserverPlugin.DataserverReply(item.AssetID.ToString(),
+                                NotecardCache.GetLine(item.AssetID, line));
+                        return tid.ToString();
+                    }
+                    WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a)
+                    {
+                        System.Text.ASCIIEncoding enc =
+                            new System.Text.ASCIIEncoding();
+                        string data = enc.GetString(a.Data);
+                        //Console.WriteLine(data);
+                        NotecardCache.Cache(id, data);
+                        AsyncCommands.
+                                DataserverPlugin.DataserverReply(id.ToString(),
+                                NotecardCache.GetLine(id, line));
+                    });
+
+                    return tid.ToString();
+                }
+            }
+
+            return String.Empty;
+        }
+
+    }
+
+    public class NotecardCache
+    {
+        private class Notecard
+        {
+            public string[] text;
+            public DateTime lastRef;
+        }
+
+        private static Dictionary<LLUUID, Notecard> m_Notecards =
+                new Dictionary<LLUUID, Notecard>();
+
+        public static void Cache(LLUUID assetID, string text)
+        {
+            CacheCheck();
+
+            lock (m_Notecards)
+            {
+                if (m_Notecards.ContainsKey(assetID))
+                    return;
+
+                Notecard nc = new Notecard();
+                nc.lastRef = DateTime.Now;
+                nc.text = ParseText(text.Replace("\r", "").Split('\n'));
+                m_Notecards[assetID] = nc;
+            }
+        }
+
+        private static string[] ParseText(string[] input)
+        {
+            int idx = 0;
+            int level = 0;
+            List<string> output = new List<string>();
+            string[] words;
+
+            while (idx < input.Length)
+            {
+                if (input[idx] == "{")
+                {
+                    level++;
+                    idx++;
+                    continue;
+                }
+
+                if (input[idx]== "}")
+                {
+                    level--;
+                    idx++;
+                    continue;
+                }
+
+                switch (level)
+                {
+                case 0:
+                    words = input[idx].Split(' '); // Linden text ver
+                    int version = int.Parse(words[3]);
+                    if (version != 2)
+                        return new String[0];
+                    break;
+                case 1:
+                    words = input[idx].Split(' ');
+                    if (words[0] == "LLEmbeddedItems")
+                        break;
+                    if (words[0] == "Text")
+                    {
+                        int len = int.Parse(words[2]);
+                        idx++;
+
+                        int count = -1;
+
+                        while (count < len)
+                        {
+                            int l = input[idx].Length;
+                            string ln = input[idx];
+
+                            int need = len-count-1;
+                            if (ln.Length > need)
+                                ln = ln.Substring(0, need);
+
+                            output.Add(ln);
+                            count += ln.Length + 1;
+                            idx++;
+                        }
+
+                        return output.ToArray();
+                    }
+                    break;
+                case 2:
+                    words = input[idx].Split(' '); // count
+                    if (words[0] == "count")
+                    {
+                        int c = int.Parse(words[1]);
+                        if (c > 0)
+                            return new String[0];
+                        break;
+                    }
+                    break;
+                }
+                idx++;
+            }
+            return output.ToArray();
+        }
+
+        public static bool IsCached(LLUUID assetID)
+        {
+            lock (m_Notecards)
+            {
+                return m_Notecards.ContainsKey(assetID);
+            }
+        }
+
+        public static int GetLines(LLUUID assetID)
+        {
+            if (!IsCached(assetID))
+                return -1;
+
+            lock (m_Notecards)
+            {
+                m_Notecards[assetID].lastRef = DateTime.Now;
+                return m_Notecards[assetID].text.Length;
+            }
+        }
+
+        public static string GetLine(LLUUID assetID, int line)
+        {
+            if (line < 0)
+                return "";
+
+            string data;
+
+            if (!IsCached(assetID))
+                return "";
+
+            lock (m_Notecards)
+            {
+                m_Notecards[assetID].lastRef = DateTime.Now;
+
+                if (line >= m_Notecards[assetID].text.Length)
+                    return "\n\n\n";
+
+                data = m_Notecards[assetID].text[line];
+                if (data.Length > 255)
+                    data = data.Substring(0, 255);
+
+                return data;
+            }
+        }
+
+        public static void CacheCheck()
+        {
+            foreach (LLUUID key in new List<LLUUID>(m_Notecards.Keys))
+            {
+                Notecard nc = m_Notecards[key];
+                if (nc.lastRef.AddSeconds(30) < DateTime.Now)
+                    m_Notecards.Remove(key);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
new file mode 100644
index 0000000..dbb78a4
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -0,0 +1,553 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using Axiom.Math;
+using libsecondlife;
+using Nini.Config;
+using OpenSim.Framework.Console;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Shared; 
+using OpenSim.Region.ScriptEngine.Shared.Api.Plugins; 
+using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api
+{
+    [Serializable]
+    public class OSSL_Api : MarshalByRefObject, IOSSL_Api, IScriptApi
+    {
+        internal IScriptEngine m_ScriptEngine;
+        internal SceneObjectPart m_host;
+        internal uint m_localID;
+        internal LLUUID m_itemID;
+
+        public void Initialize(IScriptEngine ScriptEngine, SceneObjectPart host, uint localID, LLUUID itemID)
+        {
+            m_ScriptEngine = ScriptEngine;
+            m_host = host;
+            m_localID = localID;
+            m_itemID = itemID;
+        }
+
+
+        //
+        // OpenSim functions
+        //
+
+        public int osTerrainSetHeight(int x, int y, double val)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osTerrainSetHeight: permission denied");
+                return 0;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (x > 255 || x < 0 || y > 255 || y < 0)
+                OSSLError("osTerrainSetHeight: Coordinate out of bounds");
+
+            if (World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(x, y, 0)))
+            {
+                World.Heightmap[x, y] = val;
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public double osTerrainGetHeight(int x, int y)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osTerrainGetHeight: permission denied");
+                return 0.0;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (x > 255 || x < 0 || y > 255 || y < 0)
+                OSSLError("osTerrainGetHeight: Coordinate out of bounds");
+
+            return World.Heightmap[x, y];
+        }
+
+        public int osRegionRestart(double seconds)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osRegionRestart: permission denied");
+                return 0;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (World.ExternalChecks.ExternalChecksCanIssueEstateCommand(m_host.OwnerID))
+            {
+                World.Restart((float)seconds);
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public void osRegionNotice(string msg)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osRegionNotice: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            World.SendGeneralAlert(msg);
+        }
+
+        public void osSetRot(LLUUID target, Quaternion rotation)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetRot: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (World.Entities.ContainsKey(target))
+            {
+                World.Entities[target].Rotation = rotation;
+            }
+            else
+            {
+                OSSLError("osSetRot: Invalid target");
+            }
+        }
+
+        public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams,
+                                             int timer)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetDynamicTextureURL: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (dynamicID == String.Empty)
+            {
+                IDynamicTextureManager textureManager = World.RequestModuleInterface<IDynamicTextureManager>();
+                LLUUID createdTexture =
+                    textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url,
+                                                        extraParams, timer);
+                return createdTexture.ToString();
+            }
+            else
+            {
+                //TODO update existing dynamic textures
+            }
+
+            return LLUUID.Zero.ToString();
+        }
+
+        public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams,
+                                             int timer, int alpha)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetDynamicTextureURLBlend: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (dynamicID == String.Empty)
+            {
+                IDynamicTextureManager textureManager = World.RequestModuleInterface<IDynamicTextureManager>();
+                LLUUID createdTexture =
+                    textureManager.AddDynamicTextureURL(World.RegionInfo.RegionID, m_host.UUID, contentType, url,
+                                                        extraParams, timer, true, (byte) alpha);
+                return createdTexture.ToString();
+            }
+            else
+            {
+                //TODO update existing dynamic textures
+            }
+
+            return LLUUID.Zero.ToString();
+        }
+
+        public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams,
+                                           int timer)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetDynamicTextureData: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (dynamicID == String.Empty)
+            {
+                IDynamicTextureManager textureManager = World.RequestModuleInterface<IDynamicTextureManager>();
+                if (textureManager != null)
+                {
+                    LLUUID createdTexture =
+                        textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data,
+                                                            extraParams, timer);
+                    return createdTexture.ToString();
+                }
+            }
+            else
+            {
+                //TODO update existing dynamic textures
+            }
+
+            return LLUUID.Zero.ToString();
+        }
+
+        public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams,
+                                          int timer, int alpha)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetDynamicTextureDataBlend: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (dynamicID == String.Empty)
+            {
+                IDynamicTextureManager textureManager = World.RequestModuleInterface<IDynamicTextureManager>();
+                if (textureManager != null)
+                {
+                    LLUUID createdTexture =
+                        textureManager.AddDynamicTextureData(World.RegionInfo.RegionID, m_host.UUID, contentType, data,
+                                                            extraParams, timer, true, (byte) alpha);
+                    return createdTexture.ToString();
+                }
+            }
+            else
+            {
+                //TODO update existing dynamic textures
+            }
+
+            return LLUUID.Zero.ToString();
+        }
+
+        public bool osConsoleCommand(string command)
+        {
+            m_host.AddScriptLPS(1);
+            if (m_ScriptEngine.Config.GetBoolean("AllowosConsoleCommand", false))
+            {
+                if (World.ExternalChecks.ExternalChecksCanRunConsoleCommand(m_host.OwnerID))
+                {
+                    MainConsole.Instance.RunCommand(command);
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        }
+        public void osSetPrimFloatOnWater(int floatYN)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetPrimFloatOnWater: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (m_host.ParentGroup != null)
+            {
+                if (m_host.ParentGroup.RootPart != null)
+                {
+                    m_host.ParentGroup.RootPart.SetFloatOnWater(floatYN);
+                }
+            }
+        }
+
+        // Adam's super super custom animation functions
+        public void osAvatarPlayAnimation(string avatar, string animation)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osAvatarPlayAnimation: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence)
+            {
+                ScenePresence target = (ScenePresence)World.Entities[avatar];
+                target.AddAnimation(avatar);
+            }
+        }
+
+        public void osAvatarStopAnimation(string avatar, string animation)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osAvatarStopAnimation: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (World.Entities.ContainsKey(avatar) && World.Entities[avatar] is ScenePresence)
+            {
+                ScenePresence target = (ScenePresence)World.Entities[avatar];
+                target.RemoveAnimation(animation);
+            }
+        }
+
+        //Texture draw functions
+        public string osMovePen(string drawList, int x, int y)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osMovePen: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "MoveTo " + x + "," + y + ";";
+            return drawList;
+        }
+
+        public string osDrawLine(string drawList, int startX, int startY, int endX, int endY)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawLine: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "MoveTo "+ startX+","+ startY +"; LineTo "+endX +","+endY +"; ";
+            return drawList;
+        }
+
+        public string osDrawLine(string drawList, int endX, int endY)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawLine: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "LineTo " + endX + "," + endY + "; ";
+            return drawList;
+        }
+
+        public string osDrawText(string drawList, string text)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawText: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "Text " + text + "; ";
+            return drawList;
+        }
+
+        public string osDrawEllipse(string drawList, int width, int height)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawEllipse: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "Ellipse " + width + "," + height + "; ";
+            return drawList;
+        }
+
+        public string osDrawRectangle(string drawList, int width, int height)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawRectangle: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "Rectangle " + width + "," + height + "; ";
+            return drawList;
+        }
+
+        public string osDrawFilledRectangle(string drawList, int width, int height)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawFilledRectangle: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "FillRectangle " + width + "," + height + "; ";
+            return drawList;
+        }
+
+        public string osSetFontSize(string drawList, int fontSize)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetFontSize: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "FontSize "+ fontSize +"; ";
+            return drawList;
+        }
+
+        public string osSetPenSize(string drawList, int penSize)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetPenSize: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "PenSize " + penSize + "; ";
+            return drawList;
+        }
+
+        public string osSetPenColour(string drawList, string colour)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetPenColour: permission denied");
+                return String.Empty;
+            }
+
+            m_host.AddScriptLPS(1);
+            drawList += "PenColour " + colour + "; ";
+            return drawList;
+        }
+
+        public string osDrawImage(string drawList, int width, int height, string imageUrl)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osDrawImage: permission denied");
+                return String.Empty;
+            }
+
+           m_host.AddScriptLPS(1);
+           drawList +="Image " +width + "," + height+ ","+ imageUrl +"; " ;
+           return drawList;
+        }
+
+        public void osSetStateEvents(int events)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetStateEvents: permission denied");
+                return;
+            }
+
+            m_host.SetScriptEvents(m_itemID, events);
+        }
+
+        public void osSetRegionWaterHeight(double height)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetRegionWaterHeight: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            //Check to make sure that the script's owner is the estate manager/master
+            //World.Permissions.GenericEstatePermission(
+            if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID))
+            {
+                World.EventManager.TriggerRequestChangeWaterHeight((float)height);
+            }
+        }
+
+        public double osList2Double(LSL_Types.list src, int index)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osList2Double: permission denied");
+                return 0.0;
+            }
+
+            m_host.AddScriptLPS(1);
+            if (index < 0)
+            {
+                index = src.Length + index;
+            }
+            if (index >= src.Length)
+            {
+                return 0.0;
+            }
+            return Convert.ToDouble(src.Data[index]);
+        }
+
+        public void osSetParcelMediaURL(string url)
+        {
+            if (!m_ScriptEngine.Config.GetBoolean("AllowOSFunctions", false))
+            {
+                OSSLError("osSetParcelMediaURL: permission denied");
+                return;
+            }
+
+            m_host.AddScriptLPS(1);
+            LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
+
+            if (landowner == LLUUID.Zero)
+            {
+                return;
+            }
+
+            if (landowner != m_host.ObjectOwner)
+            {
+                return;
+            }
+
+            World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
+        }
+
+        public Scene World
+        {
+            get { return m_ScriptEngine.World; }
+        }
+
+        internal void OSSLError(string msg)
+        {
+            throw new Exception("OSSL Runtime Error: " + msg);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs
new file mode 100644
index 0000000..6c88ae86
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Dataserver.cs
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using libsecondlife;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class Dataserver
+    {
+        public AsyncCommandManager m_CmdManager;
+
+        private Dictionary<string, DataserverRequest> DataserverRequests =
+                new Dictionary<string, DataserverRequest>();
+
+        public Dataserver(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        private class DataserverRequest
+        {
+            public uint localID;
+            public LLUUID itemID;
+
+            public LLUUID ID;
+            public string handle;
+
+            public DateTime startTime;
+        }
+
+        public LLUUID RegisterRequest(uint localID, LLUUID itemID,
+                                      string identifier)
+        {
+            lock (DataserverRequests)
+            {
+                if (DataserverRequests.ContainsKey(identifier))
+                    return LLUUID.Zero;
+
+                DataserverRequest ds = new DataserverRequest();
+
+                ds.localID = localID;
+                ds.itemID = itemID;
+
+                ds.ID = LLUUID.Random();
+                ds.handle = identifier;
+
+                ds.startTime = DateTime.Now;
+
+                DataserverRequests[identifier]=ds;
+
+                return ds.ID;
+            }
+        }
+
+        public void DataserverReply(string identifier, string reply)
+        {
+            DataserverRequest ds;
+
+            lock (DataserverRequests)
+            {
+                if (!DataserverRequests.ContainsKey(identifier))
+                    return;
+                
+                ds=DataserverRequests[identifier];
+                DataserverRequests.Remove(identifier);
+            }
+
+            m_CmdManager.m_ScriptEngine.PostObjectEvent(ds.localID,
+                    new EventParams("dataserver", new Object[]
+                            { new LSL_Types.LSLString(ds.ID.ToString()),
+                            new LSL_Types.LSLString(reply)},
+                    new DetectParams[0]));
+        }
+
+        public void RemoveEvents(uint localID, LLUUID itemID)
+        {
+            lock (DataserverRequests)
+            {
+                foreach (DataserverRequest ds in new List<DataserverRequest>(DataserverRequests.Values))
+                {
+                    if (ds.itemID == itemID)
+                        DataserverRequests.Remove(ds.handle);
+                }
+            }
+        }
+
+        public void ExpireRequests()
+        {
+            lock (DataserverRequests)
+            {
+                foreach (DataserverRequest ds in new List<DataserverRequest>(DataserverRequests.Values))
+                {
+                    if (ds.startTime > DateTime.Now.AddSeconds(30))
+                        DataserverRequests.Remove(ds.handle);
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs
new file mode 100644
index 0000000..92f603d
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/HttpRequest.cs
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Modules.Scripting.HttpRequest;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class HttpRequest
+    {
+        public AsyncCommandManager m_CmdManager;
+
+        public HttpRequest(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        public void CheckHttpRequests()
+        {
+            if (m_CmdManager.m_ScriptEngine.World == null)
+                return;
+
+            IHttpRequests iHttpReq =
+                m_CmdManager.m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
+
+            HttpRequestClass httpInfo = null;
+
+            if (iHttpReq != null)
+                httpInfo = iHttpReq.GetNextCompletedRequest();
+
+            while (httpInfo != null)
+            {
+                //m_ScriptEngine.Log.Info("[AsyncLSL]:" + httpInfo.response_body + httpInfo.status);
+
+                // Deliver data to prim's remote_data handler
+                //
+                // TODO: Returning null for metadata, since the lsl function
+                // only returns the byte for HTTP_BODY_TRUNCATED, which is not
+                // implemented here yet anyway.  Should be fixed if/when maxsize
+                // is supported
+
+                iHttpReq.RemoveCompletedRequest(httpInfo.reqID);
+
+                object[] resobj = new object[]
+                {
+                    new LSL_Types.LSLString(httpInfo.reqID.ToString()),
+                    new LSL_Types.LSLInteger(httpInfo.status),
+                    new LSL_Types.list(),
+                    new LSL_Types.LSLString(httpInfo.response_body)
+                };
+
+                foreach (AsyncCommandManager m in m_CmdManager.Managers)
+                {
+                    if (m.m_ScriptEngine.PostObjectEvent(httpInfo.localID,
+                            new EventParams("http_response",
+                            resobj, new DetectParams[0])))
+                        break;
+                }
+                httpInfo = iHttpReq.GetNextCompletedRequest();
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs
new file mode 100644
index 0000000..11b45b1
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Listener.cs
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using libsecondlife;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Modules.Scripting.WorldComm;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class Listener
+    {
+        // private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        public AsyncCommandManager m_CmdManager;
+
+        public Listener(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        public void CheckListeners()
+        {
+            if (m_CmdManager.m_ScriptEngine.World == null)
+                return;
+            IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+
+            if (comms != null)
+            {
+                while (comms.HasMessages())
+                {
+                    ListenerInfo lInfo = comms.GetNextMessage();
+
+                    //Deliver data to prim's listen handler
+                    object[] resobj = new object[]
+                    {
+                        new LSL_Types.LSLInteger(lInfo.GetChannel()),
+                        new LSL_Types.LSLString(lInfo.GetName()),
+                        new LSL_Types.LSLString(lInfo.GetID().ToString()),
+                        new LSL_Types.LSLString(lInfo.GetMessage())
+                    };
+
+                    m_CmdManager.m_ScriptEngine.PostScriptEvent(
+                            lInfo.GetItemID(), new EventParams(
+                            "listen", resobj,
+                            new DetectParams[0]));
+                }
+            }
+        }
+
+        public Object[] GetSerializationData(LLUUID itemID)
+        {
+            IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+
+            return comms.GetSerializationData(itemID);
+        }
+
+        public void CreateFromData(uint localID, LLUUID itemID, LLUUID hostID,
+                Object[] data)
+        {
+            IWorldComm comms = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
+
+            comms.CreateFromData(localID, itemID, hostID, data);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
new file mode 100644
index 0000000..5833512
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
@@ -0,0 +1,389 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class SensorRepeat
+    {
+        public AsyncCommandManager m_CmdManager;
+
+        public SensorRepeat(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        public Dictionary<uint, Dictionary<LLUUID, LSL_Types.list>> SenseEvents =
+            new Dictionary<uint, Dictionary<LLUUID, LSL_Types.list>>();
+        private Object SenseLock = new Object();
+
+        //
+        // SenseRepeater and Sensors
+        //
+        private class SenseRepeatClass
+        {
+            public uint localID;
+            public LLUUID itemID;
+            public double interval;
+            public DateTime next;
+
+            public string name;
+            public LLUUID keyID;
+            public int type;
+            public double range;
+            public double arc;
+            public SceneObjectPart host;
+        }
+
+        private List<SenseRepeatClass> SenseRepeaters = new List<SenseRepeatClass>();
+        private object SenseRepeatListLock = new object();
+
+        public void SetSenseRepeatEvent(uint m_localID, LLUUID m_itemID,
+                                        string name, LLUUID keyID, int type, double range,
+                                        double arc, double sec, SceneObjectPart host)
+        {
+            // Always remove first, in case this is a re-set
+            UnSetSenseRepeaterEvents(m_localID, m_itemID);
+            if (sec == 0) // Disabling timer
+                return;
+
+            // Add to timer
+            SenseRepeatClass ts = new SenseRepeatClass();
+            ts.localID = m_localID;
+            ts.itemID = m_itemID;
+            ts.interval = sec;
+            ts.name = name;
+            ts.keyID = keyID;
+            ts.type = type;
+            ts.range = range;
+            ts.arc = arc;
+            ts.host = host;
+
+            ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+            lock (SenseRepeatListLock)
+            {
+                SenseRepeaters.Add(ts);
+            }
+        }
+
+        public void UnSetSenseRepeaterEvents(uint m_localID, LLUUID m_itemID)
+        {
+            // Remove from timer
+            lock (SenseRepeatListLock)
+            {
+                List<SenseRepeatClass> NewSensors = new List<SenseRepeatClass>();
+                foreach (SenseRepeatClass ts in SenseRepeaters)
+                {
+                    if (ts.localID != m_localID && ts.itemID != m_itemID)
+                    {
+                        NewSensors.Add(ts);
+                    }
+                }
+                SenseRepeaters.Clear();
+                SenseRepeaters = NewSensors;
+            }
+        }
+
+        public void CheckSenseRepeaterEvents()
+        {
+            // Nothing to do here?
+            if (SenseRepeaters.Count == 0)
+                return;
+
+            lock (SenseRepeatListLock)
+            {
+                // Go through all timers
+                foreach (SenseRepeatClass ts in SenseRepeaters)
+                {
+                    // Time has passed?
+                    if (ts.next.ToUniversalTime() < DateTime.Now.ToUniversalTime())
+                    {
+                        SensorSweep(ts);
+                        // set next interval
+                        ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+                    }
+                }
+            } // lock
+        }
+
+        public void SenseOnce(uint m_localID, LLUUID m_itemID,
+                              string name, LLUUID keyID, int type,
+                              double range, double arc, SceneObjectPart host)
+        {
+            // Add to timer
+            SenseRepeatClass ts = new SenseRepeatClass();
+            ts.localID = m_localID;
+            ts.itemID = m_itemID;
+            ts.interval = 0;
+            ts.name = name;
+            ts.keyID = keyID;
+            ts.type = type;
+            ts.range = range;
+            ts.arc = arc;
+            ts.host = host;
+            SensorSweep(ts);
+        }
+
+        public LSL_Types.list GetSensorList(uint m_localID, LLUUID m_itemID)
+        {
+            lock (SenseLock)
+            {
+                Dictionary<LLUUID, LSL_Types.list> Obj = null;
+                if (!SenseEvents.TryGetValue(m_localID, out Obj))
+                {
+                    return null;
+                }
+                lock (Obj)
+                {
+                    // Get script
+                    LSL_Types.list SenseList = null;
+                    if (!Obj.TryGetValue(m_itemID, out SenseList))
+                    {
+                        return null;
+                    }
+                    return SenseList;
+                }
+            }
+        }
+
+        private void SensorSweep(SenseRepeatClass ts)
+        {
+            SceneObjectPart SensePoint = ts.host;
+
+            if (SensePoint == null)
+            {
+                return;
+            }
+
+            LLVector3 sensorPos = SensePoint.AbsolutePosition;
+            LLVector3 regionPos = new LLVector3(m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocX * Constants.RegionSize, m_CmdManager.m_ScriptEngine.World.RegionInfo.RegionLocY * Constants.RegionSize, 0);
+            LLVector3 fromRegionPos = sensorPos + regionPos;
+
+            LLQuaternion q = SensePoint.RotationOffset;
+            LSL_Types.Quaternion r = new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W);
+            LSL_Types.Vector3 forward_dir = (new LSL_Types.Vector3(1, 0, 0) * r);
+            double mag_fwd = LSL_Types.Vector3.Mag(forward_dir);
+
+            // Here we should do some smart culling ...
+            // math seems quicker than strings so try that first
+            LSL_Types.list SensedObjects = new LSL_Types.list();
+            LSL_Types.Vector3 ZeroVector = new LSL_Types.Vector3(0, 0, 0);
+
+            foreach (EntityBase ent in m_CmdManager.m_ScriptEngine.World.Entities.Values)
+            {
+                LLVector3 toRegionPos = ent.AbsolutePosition + regionPos;
+                double dis = Math.Abs((double)Util.GetDistanceTo(toRegionPos, fromRegionPos));
+                if (dis <= ts.range)
+                {
+                    // In Range, is it the right Type ?
+                    int objtype = 0;
+
+                    if (m_CmdManager.m_ScriptEngine.World.GetScenePresence(ent.UUID) != null) objtype |= 0x01; // actor
+                    if (ent.Velocity.Equals(ZeroVector))
+                        objtype |= 0x04; // passive non-moving
+                    else
+                        objtype |= 0x02; // active moving
+
+                    SceneObjectPart part = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID);
+
+                    if (part != null && part.ContainsScripts()) objtype |= 0x08; // Scripted. It COULD have one hidden ...
+
+                    if (((ts.type & objtype) != 0) || ((ts.type & objtype) == ts.type))
+                    {
+                        // docs claim AGENT|ACTIVE should find agent objects OR active objects
+                        // so the bitwise AND with object type should be non-zero
+
+                        // Right type too, what about the other params , key and name ?
+                        bool keep = true;
+                        if (ts.arc < Math.PI)
+                        {
+                            // not omni-directional. Can you see it ?
+                            // vec forward_dir = llRot2Fwd(llGetRot())
+                            // vec obj_dir = toRegionPos-fromRegionPos
+                            // dot=dot(forward_dir,obj_dir)
+                            // mag_fwd = mag(forward_dir)
+                            // mag_obj = mag(obj_dir)
+                            // ang = acos(dot /(mag_fwd*mag_obj))
+                            double ang_obj = 0;
+                            try
+                            {
+                                LLVector3 diff = toRegionPos - fromRegionPos;
+                                LSL_Types.Vector3 obj_dir = new LSL_Types.Vector3(diff.X, diff.Y, diff.Z);
+                                double dot = LSL_Types.Vector3.Dot(forward_dir, obj_dir);
+                                double mag_obj = LSL_Types.Vector3.Mag(obj_dir);
+                                ang_obj = Math.Acos(dot / (mag_fwd * mag_obj));
+                            }
+                            catch
+                            {
+                            }
+
+                            if (ang_obj > ts.arc) keep = false;
+                        }
+
+                        if (keep && (ts.keyID != LLUUID.Zero) && (ts.keyID != ent.UUID))
+                        {
+                            keep = false;
+                        }
+
+                        if (keep && (ts.name.Length > 0))
+                        {
+                            string avatarname=null;
+                            string objectname=null;
+                            string entname =ent.Name;
+
+                            // try avatar username surname
+                            UserProfileData profile = m_CmdManager.m_ScriptEngine.World.CommsManager.UserService.GetUserProfile(ent.UUID);
+                            if (profile != null)
+                            {
+                               avatarname = profile.FirstName + " " + profile.SurName;
+                            }
+                            // try an scene object
+                            SceneObjectPart SOP = m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(ent.UUID);
+                            if (SOP != null)
+                            {
+                                objectname = SOP.Name;
+                            }
+
+                            if ((ts.name != entname) && (ts.name != avatarname) && (ts.name != objectname))
+                            {
+                               keep = false;
+                            }
+                        }
+
+                        if (keep == true) SensedObjects.Add(ent.UUID);
+                    }
+                }
+            }
+
+            lock (SenseLock)
+            {
+                // Create object if it doesn't exist
+                if (SenseEvents.ContainsKey(ts.localID) == false)
+                {
+                    SenseEvents.Add(ts.localID, new Dictionary<LLUUID, LSL_Types.list>());
+                }
+                // clear if previous traces exist
+                Dictionary<LLUUID, LSL_Types.list> Obj;
+                SenseEvents.TryGetValue(ts.localID, out Obj);
+                if (Obj.ContainsKey(ts.itemID) == true)
+                    Obj.Remove(ts.itemID);
+
+                // note list may be zero length
+                Obj.Add(ts.itemID, SensedObjects);
+
+                if (SensedObjects.Length == 0)
+                {
+                    // send a "no_sensor"
+                    // Add it to queue
+                    m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID,
+                            new EventParams("no_sensor", new Object[0],
+                            new DetectParams[0]));
+                }
+                else
+                {
+                    DetectParams[] detect =
+                            new DetectParams[SensedObjects.Length];
+
+                    int idx;
+                    for (idx = 0; idx < SensedObjects.Length; idx++)
+                    {
+                        detect[idx] = new DetectParams();
+                        detect[idx].Key=(LLUUID)(SensedObjects.Data[idx]);
+                        detect[idx].Populate(m_CmdManager.m_ScriptEngine.World);
+                    }
+
+                    m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID,
+                            new EventParams("sensor",
+                            new Object[] {
+                            new LSL_Types.LSLInteger(SensedObjects.Length) },
+                            detect));
+                }
+            }
+        }
+
+        public Object[] GetSerializationData(LLUUID itemID)
+        {
+            List<Object> data = new List<Object>();
+
+            foreach (SenseRepeatClass ts in SenseRepeaters)
+            {
+                if (ts.itemID == itemID)
+                {
+                    data.Add(ts.interval);
+                    data.Add(ts.name);
+                    data.Add(ts.keyID);
+                    data.Add(ts.type);
+                    data.Add(ts.range);
+                    data.Add(ts.arc);
+                }
+            }
+            return data.ToArray();
+        }
+
+        public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID,
+                                   Object[] data)
+        {
+            SceneObjectPart part =
+                m_CmdManager.m_ScriptEngine.World.GetSceneObjectPart(
+                    objectID);
+
+            if (part == null)
+                return;
+
+            int idx = 0;
+
+            while (idx < data.Length)
+            {
+                SenseRepeatClass ts = new SenseRepeatClass();
+
+                ts.localID = localID;
+                ts.itemID = itemID;
+
+                ts.interval = (double)data[idx];
+                ts.name = (string)data[idx+1];
+                ts.keyID = (LLUUID)data[idx+2];
+                ts.type = (int)data[idx+3];
+                ts.range = (double)data[idx+4];
+                ts.arc = (double)data[idx+5];
+                ts.host = part;
+
+                ts.next =
+                    DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+
+                SenseRepeaters.Add(ts);
+                idx += 6;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs
new file mode 100644
index 0000000..36e992b
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/Timer.cs
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using libsecondlife;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class Timer
+    {
+        public AsyncCommandManager m_CmdManager;
+
+        public Timer(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        //
+        // TIMER
+        //
+        private class TimerClass
+        {
+            public uint localID;
+            public LLUUID itemID;
+            //public double interval;
+            public long interval;
+            //public DateTime next;
+            public long next;
+        }
+
+        private List<TimerClass> Timers = new List<TimerClass>();
+        private object TimerListLock = new object();
+
+        public void SetTimerEvent(uint m_localID, LLUUID m_itemID, double sec)
+        {
+            // Always remove first, in case this is a re-set
+            UnSetTimerEvents(m_localID, m_itemID);
+            if (sec == 0) // Disabling timer
+                return;
+
+            // Add to timer
+            TimerClass ts = new TimerClass();
+            ts.localID = m_localID;
+            ts.itemID = m_itemID;
+            ts.interval = Convert.ToInt64(sec * 10000000); // How many 100 nanoseconds (ticks) should we wait
+            //       2193386136332921 ticks
+            //       219338613 seconds
+
+            //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+            ts.next = DateTime.Now.Ticks + ts.interval;
+            lock (TimerListLock)
+            {
+                Timers.Add(ts);
+            }
+        }
+
+        public void UnSetTimerEvents(uint m_localID, LLUUID m_itemID)
+        {
+            // Remove from timer
+            lock (TimerListLock)
+            {
+                foreach (TimerClass ts in new ArrayList(Timers))
+                {
+                    if (ts.localID == m_localID && ts.itemID == m_itemID)
+                        Timers.Remove(ts);
+                }
+            }
+        }
+
+        public void CheckTimerEvents()
+        {
+            // Nothing to do here?
+            if (Timers.Count == 0)
+                return;
+
+            lock (TimerListLock)
+            {
+                // Go through all timers
+                foreach (TimerClass ts in Timers)
+                {
+                    // Time has passed?
+                    if (ts.next < DateTime.Now.Ticks)
+                    {
+                        //                        Console.WriteLine("Time has passed: Now: " + DateTime.Now.Ticks + ", Passed: " + ts.next);
+                        // Add it to queue
+                        m_CmdManager.m_ScriptEngine.PostScriptEvent(ts.itemID,
+                                new EventParams("timer", new Object[0],
+                                new DetectParams[0]));
+                        // set next interval
+
+                        //ts.next = DateTime.Now.ToUniversalTime().AddSeconds(ts.interval);
+                        ts.next = DateTime.Now.Ticks + ts.interval;
+                    }
+                }
+            }
+        }
+
+        public Object[] GetSerializationData(LLUUID itemID)
+        {
+            List<Object> data = new List<Object>();
+
+            lock (TimerListLock)
+            {
+                foreach (TimerClass ts in Timers)
+                {
+                    if (ts.itemID == itemID)
+                    {
+                        data.Add(ts.interval);
+                        data.Add(ts.next-DateTime.Now.Ticks);
+                    }
+                }
+            }
+            return data.ToArray();
+        }
+
+        public void CreateFromData(uint localID, LLUUID itemID, LLUUID objectID,
+                                   Object[] data)
+        {
+            int idx = 0;
+
+            while (idx < data.Length)
+            {
+                TimerClass ts = new TimerClass();
+
+                ts.localID = localID;
+                ts.itemID = itemID;
+                ts.interval = (long)data[idx];
+                ts.next = DateTime.Now.Ticks + (long)data[idx+1];
+                idx += 2;
+
+                Timers.Add(ts);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs
new file mode 100644
index 0000000..89bf51c
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/XmlRequest.cs
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Modules.Scripting.XMLRPC;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Shared.Api;
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
+{
+    public class XmlRequest
+    {
+        public AsyncCommandManager m_CmdManager;
+
+        public XmlRequest(AsyncCommandManager CmdManager)
+        {
+            m_CmdManager = CmdManager;
+        }
+
+        public void CheckXMLRPCRequests()
+        {
+            if (m_CmdManager.m_ScriptEngine.World == null)
+                return;
+
+            IXMLRPC xmlrpc = m_CmdManager.m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
+
+            if (xmlrpc != null)
+            {
+                RPCRequestInfo rInfo = xmlrpc.GetNextCompletedRequest();
+
+                while (rInfo != null)
+                {
+                    xmlrpc.RemoveCompletedRequest(rInfo.GetMessageID());
+
+                    //Deliver data to prim's remote_data handler
+                    object[] resobj = new object[]
+                    {
+                        new LSL_Types.LSLInteger(2),
+                        new LSL_Types.LSLString(
+                                rInfo.GetChannelKey().ToString()),
+                        new LSL_Types.LSLString(
+                                rInfo.GetMessageID().ToString()),
+                        new LSL_Types.LSLString(String.Empty),
+                        new LSL_Types.LSLInteger(rInfo.GetIntValue()),
+                        new LSL_Types.LSLString(rInfo.GetStrVal())
+                    };
+                    
+                    foreach (AsyncCommandManager m in m_CmdManager.Managers)
+                    {
+                        if (m.m_ScriptEngine.PostScriptEvent(
+                                rInfo.GetItemID(), new EventParams(
+                                    "remote_data", resobj,
+                                    new DetectParams[0])))
+                            break;
+                    }
+
+                    rInfo = xmlrpc.GetNextCompletedRequest();
+                }
+
+                SendRemoteDataRequest srdInfo = xmlrpc.GetNextCompletedSRDRequest();
+
+                while (srdInfo != null)
+                {
+                    xmlrpc.RemoveCompletedSRDRequest(srdInfo.GetReqID());
+
+                    //Deliver data to prim's remote_data handler
+                    object[] resobj = new object[]
+                    {
+                        new LSL_Types.LSLInteger(3),
+                        new LSL_Types.LSLString(srdInfo.channel.ToString()),
+                        new LSL_Types.LSLString(srdInfo.GetReqID().ToString()),
+                        new LSL_Types.LSLString(String.Empty),
+                        new LSL_Types.LSLInteger(srdInfo.idata),
+                        new LSL_Types.LSLString(srdInfo.sdata)
+                    };
+
+                    foreach (AsyncCommandManager m in m_CmdManager.Managers)
+                    {
+                        if (m.m_ScriptEngine.PostScriptEvent(
+                                srdInfo.m_itemID, new EventParams(
+                                    "remote_data", resobj,
+                                    new DetectParams[0])))
+                            break;
+                    }
+
+                    srdInfo = xmlrpc.GetNextCompletedSRDRequest();
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
new file mode 100644
index 0000000..75672a1
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
@@ -0,0 +1,649 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
+{
+    public interface ILSL_Api
+    {
+        void state(string newState);
+        void llSay(int channelID, string text);
+        double llSin(double f);
+        double llCos(double f);
+        double llTan(double f);
+        double llAtan2(double x, double y);
+        double llSqrt(double f);
+        double llPow(double fbase, double fexponent);
+        LSL_Types.LSLInteger llAbs(int i);
+        double llFabs(double f);
+        double llFrand(double mag);
+        LSL_Types.LSLInteger llFloor(double f);
+        LSL_Types.LSLInteger llCeil(double f);
+        LSL_Types.LSLInteger llRound(double f);
+        double llVecMag(LSL_Types.Vector3 v);
+        LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v);
+        double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b);
+        LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r);
+        LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v);
+        LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up);
+        LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r);
+        LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r);
+        LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r);
+        LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 start, LSL_Types.Vector3 end);
+        void llWhisper(int channelID, string text);
+        //void llSay(int channelID, string text);
+        void llShout(int channelID, string text);
+        void llRegionSay(int channelID, string text);
+        LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg);
+        void llListenControl(int number, int active);
+        void llListenRemove(int number);
+        void llSensor(string name, string id, int type, double range, double arc);
+        void llSensorRepeat(string name, string id, int type, double range, double arc, double rate);
+        void llSensorRemove();
+        string llDetectedName(int number);
+        string llDetectedKey(int number);
+        string llDetectedOwner(int number);
+        LSL_Types.LSLInteger llDetectedType(int number);
+        LSL_Types.Vector3 llDetectedPos(int number);
+        LSL_Types.Vector3 llDetectedVel(int number);
+        LSL_Types.Vector3 llDetectedGrab(int number);
+        LSL_Types.Quaternion llDetectedRot(int number);
+        LSL_Types.LSLInteger llDetectedGroup(int number);
+        LSL_Types.LSLInteger llDetectedLinkNumber(int number);
+        void llDie();
+        double llGround(LSL_Types.Vector3 offset);
+        double llCloud(LSL_Types.Vector3 offset);
+        LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset);
+        void llSetStatus(int status, int value);
+        LSL_Types.LSLInteger llGetStatus(int status);
+        void llSetScale(LSL_Types.Vector3 scale);
+        LSL_Types.Vector3 llGetScale();
+        void llSetColor(LSL_Types.Vector3 color, int face);
+        double llGetAlpha(int face);
+        void llSetAlpha(double alpha, int face);
+        LSL_Types.Vector3 llGetColor(int face);
+        void llSetTexture(string texture, int face);
+        void llScaleTexture(double u, double v, int face);
+        void llOffsetTexture(double u, double v, int face);
+        void llRotateTexture(double rotation, int face);
+        string llGetTexture(int face);
+        void llSetPos(LSL_Types.Vector3 pos);
+
+        //wiki: vector llGetPos()
+        LSL_Types.Vector3 llGetPos();
+        //wiki: vector llGetLocalPos()
+        LSL_Types.Vector3 llGetLocalPos();
+        //wiki: llSetRot(rotation rot)
+        void llSetRot(LSL_Types.Quaternion rot);
+        //wiki: rotation llGetRot()
+        LSL_Types.Quaternion llGetRot();
+        //wiki: rotation llGetLocalRot()
+        LSL_Types.Quaternion llGetLocalRot();
+        //wiki: llSetForce(vector force, integer local)
+        void llSetForce(LSL_Types.Vector3 force, int local);
+        //wiki: vector llGetForce()
+        LSL_Types.Vector3 llGetForce();
+        //wiki: integer llTarget(vector position, double range)
+        LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range);
+        //wiki: llTargetRemove(integer number)
+        void llTargetRemove(int number);
+        //wiki: integer llRotTarget(rotation rot, double error)
+        LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error);
+        //wiki: integer llRotTargetRemove(integer number)
+        void llRotTargetRemove(int number);
+        //wiki: llMoveToTarget(vector target, double tau)
+        void llMoveToTarget(LSL_Types.Vector3 target, double tau);
+        //wiki: llStopMoveToTarget()
+        void llStopMoveToTarget();
+        //wiki: llApplyImpulse(vector force, integer local)
+        void llApplyImpulse(LSL_Types.Vector3 force, int local);
+        //wiki: llapplyRotationalImpulse(vector force, integer local)
+        void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local);
+        //wiki: llSetTorque(vector torque, integer local)
+        void llSetTorque(LSL_Types.Vector3 torque, int local);
+        //wiki: vector llGetTorque()
+        LSL_Types.Vector3 llGetTorque();
+        //wiki: llSeForceAndTorque(vector force, vector torque, integer local)
+        void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local);
+        //wiki: vector llGetVel()
+        LSL_Types.Vector3 llGetVel();
+        //wiki: vector llGetAccel()
+        LSL_Types.Vector3 llGetAccel();
+        //wiki: vector llGetOmega()
+        LSL_Types.Vector3 llGetOmega();
+        //wiki: double llGetTimeOfDay()
+        double llGetTimeOfDay();
+        //wiki: double llGetWallclock()
+        double llGetWallclock();
+        //wiki: double llGetTime()
+        double llGetTime();
+        //wiki: llResetTime()
+        void llResetTime();
+        //wiki: double llGetAndResetTime()
+        double llGetAndResetTime();
+        //wiki (deprecated) llSound(string sound, double volume, integer queue, integer loop)
+        void llSound();
+        //wiki: llPlaySound(string sound, double volume)
+        void llPlaySound(string sound, double volume);
+        //wiki: llLoopSound(string sound, double volume)
+        void llLoopSound(string sound, double volume);
+        //wiki: llLoopSoundMaster(string sound, double volume)
+        void llLoopSoundMaster(string sound, double volume);
+        //wiki: llLoopSoundSlave(string sound, double volume)
+        void llLoopSoundSlave(string sound, double volume);
+        //wiki llPlaySoundSlave(string sound, double volume)
+        void llPlaySoundSlave(string sound, double volume);
+        //wiki: llTriggerSound(string sound, double volume)
+        void llTriggerSound(string sound, double volume);
+        //wiki: llStopSound()
+        void llStopSound();
+        //wiki: llPreloadSound(string sound)
+        void llPreloadSound(string sound);
+        //wiki: string llGetSubString(string src, integer start, integer end)
+        string llGetSubString(string src, int start, int end);
+        //wiki: string llDeleteSubString(string src, integer start, integer end)
+        string llDeleteSubString(string src, int start, int end);
+        //wiki string llInsertString(string dst, integer position, string src)
+        string llInsertString(string dst, int position, string src);
+        //wiki: string llToUpper(string source)
+        string llToUpper(string source);
+        //wiki: string llToLower(string source)
+        string llToLower(string source);
+        //wiki: integer llGiveMoney(key destination, integer amount)
+        LSL_Types.LSLInteger llGiveMoney(string destination, int amount);
+        //wiki: (deprecated)
+        void llMakeExplosion();
+        //wiki: (deprecated)
+        void llMakeFountain();
+        //wiki: (deprecated)
+        void llMakeSmoke();
+        //wiki: (deprecated)
+        void llMakeFire();
+        //wiki: llRezObject(string inventory, vector pos, vector rel, rotation rot, integer param)
+        void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param);
+        //wiki: llLookAt(vector target, double strength, double damping)
+        void llLookAt(LSL_Types.Vector3 target, double strength, double damping);
+        //wiki: llStopLookAt()
+        void llStopLookAt();
+        //wiki: llSetTimerEvent(double sec)
+        void llSetTimerEvent(double sec);
+        //wiki: llSleep(double sec)
+        void llSleep(double sec);
+        //wiki: double llGetMass()
+        double llGetMass();
+        //wiki: llCollisionFilter(string name, key id, integer accept)
+        void llCollisionFilter(string name, string id, int accept);
+        //wiki: llTakeControls(integer controls, integer accept, integer pass_on)
+        void llTakeControls(int controls, int accept, int pass_on);
+        //wiki: llReleaseControls()
+        void llReleaseControls();
+        //wiki: llAttachToAvatar(integer attachment)
+        void llAttachToAvatar(int attachment);
+        //wiki: llDetachFromAvatar()
+        void llDetachFromAvatar();
+        //wiki: (deprecated) llTakeCamera()
+        void llTakeCamera();
+        //wiki: (deprecated) llReleaseCamera()
+        void llReleaseCamera();
+        //wiki: key llGetOwner()
+        string llGetOwner();
+        //wiki: llInstantMessage(key user, string message)
+        void llInstantMessage(string user, string message);
+        //wiki: llEmail(string address, string subject, string message)
+        void llEmail(string address, string subject, string message);
+        //wiki: llGetNextEmail(string address, string subject)
+        void llGetNextEmail(string address, string subject);
+        //wiki:    key llGetKey()
+        string llGetKey();
+        //wiki: llSetBuoyancy(double buoyancy)
+        void llSetBuoyancy(double buoyancy);
+        //wiki: llSetHoverHeight(double height, integer water, double tau)
+        void llSetHoverHeight(double height, int water, double tau);
+        //wiki: llStopHover
+        void llStopHover();
+        //wiki: llMinEventDelay(double delay)
+        void llMinEventDelay(double delay);
+        //wiki: (deprecated) llSoundPreload()
+        void llSoundPreload();
+        //wiki: llRotLookAt(rotation target, double strength, double damping)
+        void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping);
+        //wiki: integer llStringLength(string str)
+        LSL_Types.LSLInteger llStringLength(string str);
+        //wiki: llStartAnimation(string anim)
+        void llStartAnimation(string anim);
+        //wiki: llStopAnimation(string anim)
+        void llStopAnimation(string anim);
+        //wiki: (deprecated) llPointAt
+        void llPointAt();
+        //wiki: (deprecated) llStopPointAt
+        void llStopPointAt();
+        //wiki: llTargetOmega(vector axis, double spinrate, double gain)
+        void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain);
+        //wiki: integer llGetStartParameter()
+        LSL_Types.LSLInteger llGetStartParameter();
+        //wiki: llGodLikeRezObject(key inventory, vector pos)
+        void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos);
+        //wiki: llRequestPermissions(key agent, integer perm)
+        void llRequestPermissions(string agent, int perm);
+        //wiki: key llGetPermissionsKey()
+        string llGetPermissionsKey();
+        //wiki: integer llGetPermissions()
+        LSL_Types.LSLInteger llGetPermissions();
+        //wiki integer llGetLinkNumber()
+        LSL_Types.LSLInteger llGetLinkNumber();
+        //wiki: llSetLinkColor(integer linknumber, vector color, integer face)
+        void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face);
+        //wiki: llCreateLink(key target, integer parent)
+        void llCreateLink(string target, int parent);
+        //wiki: llBreakLink(integer linknum)
+        void llBreakLink(int linknum);
+        //wiki: llBreakAllLinks()
+        void llBreakAllLinks();
+        //wiki: key llGetLinkKey(integer linknum)
+        string llGetLinkKey(int linknum);
+        //wiki: llGetLinkName(integer linknum)
+        string llGetLinkName(int linknum);
+        //wiki: integer llGetInventoryNumber(integer type)
+        LSL_Types.LSLInteger llGetInventoryNumber(int type);
+        //wiki: string llGetInventoryName(integer type, integer number)
+        string llGetInventoryName(int type, int number);
+        //wiki: llSetScriptState(string name, integer run)
+        void llSetScriptState(string name, int run);
+        //wiki: double llGetEnergy()
+        double llGetEnergy();
+        //wiki: llGiveInventory(key destination, string inventory)
+        void llGiveInventory(string destination, string inventory);
+        //wiki: llRemoveInventory(string item)
+        void llRemoveInventory(string item);
+        //wiki: llSetText(string text, vector color, double alpha)
+        void llSetText(string text, LSL_Types.Vector3 color, double alpha);
+        //wiki: double llWater(vector offset)
+        double llWater(LSL_Types.Vector3 offset);
+        //wiki: llPassTouches(integer pass)
+        void llPassTouches(int pass);
+        //wiki: key llRequestAgentData(key id, integer data)
+        string llRequestAgentData(string id, int data);
+        //wiki: key llRequestInventoryData(string name)
+        string llRequestInventoryData(string name);
+        //wiki: llSetDamage(double damage)
+        void llSetDamage(double damage);
+        //wiki: llTeleportAgentHome(key agent)
+        void llTeleportAgentHome(string agent);
+        //wiki: llModifyLand(integer action, integer brush)
+        void llModifyLand(int action, int brush);
+        //wiki: llCollisionSound(string impact_sound, double impact_volume)
+        void llCollisionSound(string impact_sound, double impact_volume);
+        //wiki: llCollisionSprite(string impact_sprite)
+        void llCollisionSprite(string impact_sprite);
+        //wiki: string llGetAnimation(key id)
+        string llGetAnimation(string id);
+        //wiki: llResetScript()
+        void llResetScript();
+        //wiki: llMessageLinked(integer linknum, integer num, string str, key id)
+        void llMessageLinked(int linknum, int num, string str, string id);
+        //wiki: llPushObject(key target, vector impulse, vector ang_impulse, integer local)
+        void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local);
+        //wiki: llPassCollisions(integer pass)
+        void llPassCollisions(int pass);
+        //wiki: string llGetScriptName()
+        string llGetScriptName();
+        //wiki: integer llGetNumberOfSides()
+        LSL_Types.LSLInteger llGetNumberOfSides();
+        //wiki: rotation llAxisAngle2Rot(vector axis, double angle)
+        LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle);
+        //wiki: vector llRot2Axis(rotation rot)
+        LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot);
+        //wiki: double llRot2Angle(rotation rot);
+        double llRot2Angle(LSL_Types.Quaternion rot);
+        //wiki: double llAcos(double val)
+        double llAcos(double val);
+        //wiki: double llAsin(double val)
+        double llAsin(double val);
+        //wiki: double llAngleBetween(rotation a, rotation b)
+        double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b);
+        //wiki: string llGetInventoryKey(string name)
+        string llGetInventoryKey(string name);
+        //wiki: llAllowInventoryDrop(integer add)
+        void llAllowInventoryDrop(int add);
+        //wiki: vector llGetSunDirection()
+        LSL_Types.Vector3 llGetSunDirection();
+        //wiki: vector llGetTextureOffset(integer face)
+        LSL_Types.Vector3 llGetTextureOffset(int face);
+        //wiki: vector llGetTextureScale(integer side)
+        LSL_Types.Vector3 llGetTextureScale(int side);
+        //wiki: double llGetTextureRot(integer side)
+        double llGetTextureRot(int side);
+        //wiki: integer llSubStringIndex(string source, string pattern)
+        LSL_Types.LSLInteger llSubStringIndex(string source, string pattern);
+        //wiki: key llGetOwnerKey(key id)
+        string llGetOwnerKey(string id);
+        //wiki: vector llGetCenterOfMass()
+        LSL_Types.Vector3 llGetCenterOfMass();
+        //wiki: list llListSort(list src, integer stride, integer ascending)
+        LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending);
+        //integer llGetListLength(list src)
+        LSL_Types.LSLInteger llGetListLength(LSL_Types.list src);
+        //wiki: integer llList2Integer(list src, integer index)
+        LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index);
+        //wiki: double llList2double(list src, integer index)
+        double llList2Float(LSL_Types.list src, int index);
+        //wiki: string llList2String(list src, integer index)
+        string llList2String(LSL_Types.list src, int index);
+        //wiki: key llList2Key(list src, integer index)
+        string llList2Key(LSL_Types.list src, int index);
+        //wiki: vector llList2Vector(list src, integer index)
+        LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index);
+        //wiki rotation llList2Rot(list src, integer index)
+        LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index);
+        //wiki: list llList2List(list src, integer start, integer end)
+        LSL_Types.list llList2List(LSL_Types.list src, int start, int end);
+        //wiki: llDeleteSubList(list src, integer start, integer end)
+        LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end);
+        //wiki: integer llGetListEntryType(list src, integer index)
+        LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index);
+        //wiki: string llList2CSV(list src)
+        string llList2CSV(LSL_Types.list src);
+        //wiki: list llCSV2List(string src)
+        LSL_Types.list llCSV2List(string src);
+        //wiki: list llListRandomize(list src, integer stride)
+        LSL_Types.list llListRandomize(LSL_Types.list src, int stride);
+        //wiki: list llList2ListStrided(list src, integer start, integer end, integer stride)
+        LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride);
+        //wiki: vector llGetRegionCorner()
+        LSL_Types.Vector3 llGetRegionCorner();
+        //wiki: list llListInsertList(list dest, list src, integer start)
+        LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start);
+        //wiki: integer llListFindList(list src, list test)
+        LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test);
+        //wiki: string llGetObjectName()
+        string llGetObjectName();
+        //wiki: llSetObjectName(string name)
+        void llSetObjectName(string name);
+        //wiki: string llGetDate()
+        string llGetDate();
+        //wiki: integer llEdgeOfWorld(vector pos, vector dir)
+        LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir);
+        //wiki: integer llGetAgentInfo(key id)
+        LSL_Types.LSLInteger llGetAgentInfo(string id);
+        //wiki: llAdjustSoundVolume(double volume)
+        void llAdjustSoundVolume(double volume);
+        //wiki: llSetSoundQueueing(integer queue)
+        void llSetSoundQueueing(int queue);
+        //wiki: llSetSoundRadius(double radius)
+        void llSetSoundRadius(double radius);
+        //wiki: string llKey2Name(key id)
+        string llKey2Name(string id);
+        //wiki: llSetTextureAnim(integer mode, integer face, integer sizex, integer sizey, double start, double length, double rate)
+        void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate);
+        //wiki: llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west)
+        void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east,
+                                   LSL_Types.Vector3 bottom_south_west);
+
+        //wiki: llEjectFromLand(key pest)
+        void llEjectFromLand(string pest);
+        LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers);
+        //wiki: integer llOverMyLand(key id)
+        LSL_Types.LSLInteger llOverMyLand(string id);
+        //wiki: key llGetLandOwnerAt(vector pos)
+        string llGetLandOwnerAt(LSL_Types.Vector3 pos);
+        //wiki: key llGetNotecardLine(string name, integer line)
+        string llGetNotecardLine(string name, int line);
+        //wiki: vector llGetAgentSize(key id)
+        LSL_Types.Vector3 llGetAgentSize(string id);
+        //wiki: integer llSameGroup(key agent)
+        LSL_Types.LSLInteger llSameGroup(string agent);
+        //wiki: llUnSit(key id)
+        void llUnSit(string id);
+        //wiki: vector llGroundSlope(vector offset)
+        LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset);
+        //wiki: vector llGroundNormal(vector offset)
+        LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset);
+        //wiki: vector llGroundContour(vector offset)
+        LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset);
+        //wiki: integer llGetAttached()
+        LSL_Types.LSLInteger llGetAttached();
+        //wiki: integer llGetFreeMemory()
+        LSL_Types.LSLInteger llGetFreeMemory();
+        //wiki: string llGetRegionName()
+        string llGetRegionName();
+        //wiki: double llGetRegionTimeDilation()
+        double llGetRegionTimeDilation();
+        //wiki: double llGetRegionFPS()
+        double llGetRegionFPS();
+        //wiki: llParticleSystem(List<Object> rules
+        void llParticleSystem(LSL_Types.list rules);
+        //wiki: llGroundRepel(double height, integer water, double tau)
+        void llGroundRepel(double height, int water, double tau);
+        //wiki: llGiveInventoryList(string destination, string category, LSL_Types.list inventory)
+        void llGiveInventoryList(string destination, string category, LSL_Types.list inventory);
+        //wiki: llSetVehicleType(integer type)
+        void llSetVehicleType(int type);
+        //wiki: llSetVehicledoubleParam(integer param, double value)
+        void llSetVehicledoubleParam(int param, double value);
+        // wiki: llSetVehicleFloatParam(integer param, float value)
+        void llSetVehicleFloatParam(int param, float value);
+        //wiki: llSetVehicleVectorParam(integer param, vector vec)
+        void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec);
+        //wiki: llSetVehicleRotationParam(integer param, rotation rot)
+        void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot);
+        //wiki: llSetVehicleFlags(integer flags)
+        void llSetVehicleFlags(int flags);
+        //wiki: llRemoveVehicleFlags(integer flags)
+        void llRemoveVehicleFlags(int flags);
+        //wiki: llSitTarget(vector offset, rotation rot)
+        void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot);
+        //wiki key llAvatarOnSitTarget()
+        string llAvatarOnSitTarget();
+        //wiki: llAddToLandPassList(key avatar, double hours)
+        void llAddToLandPassList(string avatar, double hours);
+        //wiki: llSetTouchText(string text)
+        void llSetTouchText(string text);
+        //wiki: llSetSitText(string text)
+        void llSetSitText(string text);
+        //wiki: llSetCameraEyeOffset(vector offset)
+        void llSetCameraEyeOffset(LSL_Types.Vector3 offset);
+        //wiki: llSeteCameraAtOffset(vector offset)
+        void llSetCameraAtOffset(LSL_Types.Vector3 offset);
+        //
+        string llDumpList2String(LSL_Types.list src, string seperator);
+        //wiki: integer llScriptDanger(vector pos)
+        LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos);
+        //wiki: llDialog(key avatar, string message, list buttons, integer chat_channel)
+        void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel);
+        //wiki: llVolumeDetect(integer detect)
+        void llVolumeDetect(int detect);
+        //wiki: llResetOtherScript(string name)
+        void llResetOtherScript(string name);
+        //wiki: integer llGetScriptState(string name)
+        LSL_Types.LSLInteger llGetScriptState(string name);
+        //wiki: (deprecated)
+        void llRemoteLoadScript();
+        //wiki: llSetRemoteScriptAccessPin(integer pin)
+        void llSetRemoteScriptAccessPin(int pin);
+        //wiki: llRemoteLoadScriptPin(key target, string name, integer pin, integer running, integer start_param)
+        void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param);
+        //wiki: llOpenRemoteDataChannel()
+        void llOpenRemoteDataChannel();
+        //wiki: key llSendRemoteData(key channel, string dest, integer idata, string sdata)
+        string llSendRemoteData(string channel, string dest, int idata, string sdata);
+        //wiki: llRemoteDataReply(key channel, key message_id, string sdata, integer idata)
+        void llRemoteDataReply(string channel, string message_id, string sdata, int idata);
+        //wiki: llCloseRemoteDataChannel(key channel)
+        void llCloseRemoteDataChannel(string channel);
+        //wiki: string llMD5String(string src, integer nonce)
+        string llMD5String(string src, int nonce);
+        //wiki: llSetPrimitiveParams(list rules)
+        void llSetPrimitiveParams(LSL_Types.list rules);
+        //wiki: llSetLinkPrimitiveParams(integer linknumber, list rules)
+        void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules);
+        //wiki: string llStringToBase64(string str)
+        string llStringToBase64(string str);
+        //wiki: string llBase64ToString(string str)
+        string llBase64ToString(string str);
+        //wiki: (deprecated)
+        void llXorBase64Strings();
+        //wiki: llRemoteDataSetRegion()
+        void llRemoteDataSetRegion();
+        //wiki: double llLog10(double val)
+        double llLog10(double val);
+        //wiki: double llLog(double val)
+        double llLog(double val);
+        //wiki: list llGetAnimationList(key id)
+        LSL_Types.list llGetAnimationList(string id);
+        //wiki: llSetParcelMusicURL(string url)
+        void llSetParcelMusicURL(string url);
+        //wiki: vector llGetRootPosition()
+        LSL_Types.Vector3 llGetRootPosition();
+        //wiki: rotation llGetRootRotation()
+        LSL_Types.Quaternion llGetRootRotation();
+        //wiki: string llGetObjectDesc()
+        string llGetObjectDesc();
+        //wiki: llSetObjectDesc(string desc)
+        void llSetObjectDesc(string desc);
+        //wiki: key llGetCreator()
+        string llGetCreator();
+        //wiki: string llGetTimestamp()
+        string llGetTimestamp();
+        //wiki: llSetLinkAlpha(integer linknumber, double alpha, integer face)
+        void llSetLinkAlpha(int linknumber, double alpha, int face);
+        //wiki: integer llGetNumberOfPrims()
+        LSL_Types.LSLInteger llGetNumberOfPrims();
+        //wiki: key llGetNumberOfNotecardLines(string name)
+        string llGetNumberOfNotecardLines(string name);
+        //wiki: list llGetBoundingBox(key object)
+        LSL_Types.list llGetBoundingBox(string obj);
+        //wiki: vector llGetGeometricCenter()
+        LSL_Types.Vector3 llGetGeometricCenter();
+        //wiki: list llGetPrimitiveParams(list rules)
+        LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules);
+        //wiki: string llIntegerToBase64(integer number)
+        string llIntegerToBase64(int number);
+        //wiki integer llBase64ToInteger(string str)
+        LSL_Types.LSLInteger llBase64ToInteger(string str);
+        //wiki: double llGetGMTclock()
+        double llGetGMTclock();
+        //wiki: string llGetSimulatorHostname()
+        string llGetSimulatorHostname();
+        //llSetLocalRot(rotation rot)
+        void llSetLocalRot(LSL_Types.Quaternion rot);
+        //wiki: list llParseStringKeepNulls(string src, list separators, list spacers)
+        LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers);
+        //wiki: llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, integer param)
+        void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity,
+                         LSL_Types.Quaternion rot, int param);
+
+        //wiki: integer llGetObjectPermMask(integer mask)
+        LSL_Types.LSLInteger llGetObjectPermMask(int mask);
+        //wiki: llSetObjectPermMask(integer mask, integer value)
+        void llSetObjectPermMask(int mask, int value);
+        //wiki integer llGetInventoryPermMask(string item, integer mask)
+        LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask);
+        //wiki: llSetInventoryPermMask(string item, integer mask, integer value)
+        void llSetInventoryPermMask(string item, int mask, int value);
+        //wiki: key llGetInventoryCreator(string item)
+        string llGetInventoryCreator(string item);
+        //wiki: llOwnerSay(string msg)
+        void llOwnerSay(string msg);
+        //wiki: key llRequestSimulatorData(string simulator, integer data)
+        string llRequestSimulatorData(string simulator, int data);
+        //wiki: llForceMouselook(integer mouselook)
+        void llForceMouselook(int mouselook);
+        //wiki: double llGetObjectMass(key id)
+        double llGetObjectMass(string id);
+        LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end);
+        //wiki: llLoadURL(key avatar_id, string message, string url)
+        void llLoadURL(string avatar_id, string message, string url);
+        //wiki: llParcelMediaCommandList(list commandList)
+        void llParcelMediaCommandList(LSL_Types.list commandList);
+        void llParcelMediaQuery();
+        //wiki integer llModPow(integer a, integer b, integer c)
+        LSL_Types.LSLInteger llModPow(int a, int b, int c);
+        //wiki: integer llGetInventoryType(string name)
+        LSL_Types.LSLInteger llGetInventoryType(string name);
+        //wiki: llSetPayPrice(integer price, list quick_pay_buttons)
+        void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons);
+        //wiki: vector llGetCameraPos()
+        LSL_Types.Vector3 llGetCameraPos();
+        //wiki rotation llGetCameraRot()
+        LSL_Types.Quaternion llGetCameraRot();
+        //wiki: (deprecated)
+        void llSetPrimURL();
+        //wiki: (deprecated)
+        void llRefreshPrimURL();
+        //wiki: string llEscapeURL(string url)
+        string llEscapeURL(string url);
+        //wiki: string llUnescapeURL(string url)
+        string llUnescapeURL(string url);
+        //wiki: llMapDestination(string simname, vector pos, vector look_at)
+        void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at);
+        //wiki: llAddToLandBanList(key avatar, double hours)
+        void llAddToLandBanList(string avatar, double hours);
+        //wiki: llRemoveFromLandPassList(key avatar)
+        void llRemoveFromLandPassList(string avatar);
+        //wiki: llRemoveFromLandBanList(key avatar)
+        void llRemoveFromLandBanList(string avatar);
+        //wiki: llSetCameraParams(list rules)
+        void llSetCameraParams(LSL_Types.list rules);
+        //wiki: llClearCameraParams()
+        void llClearCameraParams();
+        //wiki: double llListStatistics(integer operation, list src)
+        double llListStatistics(int operation, LSL_Types.list src);
+        //wiki: integer llGetUnixTime()
+        LSL_Types.LSLInteger llGetUnixTime();
+        //wiki: integer llGetParcelFlags(vector pos)
+        LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos);
+        //wiki: integer llGetRegionFlags()
+        LSL_Types.LSLInteger llGetRegionFlags();
+        //wiki: string llXorBase64StringsCorrect(string str1, string str2)
+        string llXorBase64StringsCorrect(string str1, string str2);
+        string llHTTPRequest(string url, LSL_Types.list parameters, string body);
+        //wiki: llResetLandBanList()
+        void llResetLandBanList();
+        //wiki: llResetLandPassList()
+        void llResetLandPassList();
+        //wiki: integer llGetParcelPrimCount(vector pos, integer category, integer sim_wide)
+        LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide);
+        //wiki: list llGetParcelPrimOwners(vector pos)
+        LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos);
+        //wiki: integer llGetObjectPrimCount(key object_id)
+        LSL_Types.LSLInteger llGetObjectPrimCount(string object_id);
+        //wiki: integer llGetParcelMaxPrims(vector pos, integer sim_wide)
+        LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide);
+        //wiki: llGetParcelDetails(vector pos, list params)
+        LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param);
+        //wiki: llSetLinkTexture(integer linknumber, string texture, integer face)
+        void llSetLinkTexture(int linknumber, string texture, int face);
+        //wiki: string llStringTrim(string src, int type)
+        string llStringTrim(string src, int type);
+        //wiki: LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args)
+        LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args);
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
new file mode 100644
index 0000000..1e14c63
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/IOSSL_Api.cs
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
+{
+    public interface IOSSL_Api
+    {
+        //OpenSim functions
+        string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams, int timer);
+        string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams,
+                                           int timer, int alpha);
+        string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams, int timer);
+        string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams,
+                                            int timer, int alpha);
+        double osTerrainGetHeight(int x, int y);
+        int osTerrainSetHeight(int x, int y, double val);
+        int osRegionRestart(double seconds);
+        void osRegionNotice(string msg);
+        bool osConsoleCommand(string Command);
+        void osSetParcelMediaURL(string url);
+        void osSetPrimFloatOnWater(int floatYN);
+
+        // Animation commands
+        void osAvatarPlayAnimation(string avatar, string animation);
+        void osAvatarStopAnimation(string avatar, string animation);
+
+        //texture draw functions
+        string osMovePen(string drawList, int x, int y);
+        string osDrawLine(string drawList, int startX, int startY, int endX, int endY);
+        string osDrawLine(string drawList, int endX, int endY);
+        string osDrawText(string drawList, string text);
+        string osDrawEllipse(string drawList, int width, int height);
+        string osDrawRectangle(string drawList, int width, int height);
+        string osDrawFilledRectangle(string drawList, int width, int height);
+        string osSetFontSize(string drawList, int fontSize);
+        string osSetPenSize(string drawList, int penSize);
+        string osSetPenColour(string drawList, string colour);
+        string osDrawImage(string drawList, int width, int height, string imageUrl);
+        void osSetStateEvents(int events);
+
+        double osList2Double(LSL_Types.list src, int index);
+        void osSetRegionWaterHeight(double height);
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
new file mode 100644
index 0000000..69be69b
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
+{
+    public partial class ScriptBaseClass : MarshalByRefObject
+    {
+        // LSL CONSTANTS
+        public const int TRUE = 1;
+        public const int FALSE = 0;
+
+        public const int STATUS_PHYSICS = 1;
+        public const int STATUS_ROTATE_X = 2;
+        public const int STATUS_ROTATE_Y = 4;
+        public const int STATUS_ROTATE_Z = 8;
+        public const int STATUS_PHANTOM = 16;
+        public const int STATUS_SANDBOX = 32;
+        public const int STATUS_BLOCK_GRAB = 64;
+        public const int STATUS_DIE_AT_EDGE = 128;
+        public const int STATUS_RETURN_AT_EDGE = 256;
+        public const int STATUS_CAST_SHADOWS = 512;
+
+        public const int AGENT = 1;
+        public const int ACTIVE = 2;
+        public const int PASSIVE = 4;
+        public const int SCRIPTED = 8;
+
+        public const int CONTROL_FWD = 1;
+        public const int CONTROL_BACK = 2;
+        public const int CONTROL_LEFT = 4;
+        public const int CONTROL_RIGHT = 8;
+        public const int CONTROL_UP = 16;
+        public const int CONTROL_DOWN = 32;
+        public const int CONTROL_ROT_LEFT = 256;
+        public const int CONTROL_ROT_RIGHT = 512;
+        public const int CONTROL_LBUTTON = 268435456;
+        public const int CONTROL_ML_LBUTTON = 1073741824;
+
+        //Permissions
+        public const int PERMISSION_DEBIT = 2;
+        public const int PERMISSION_TAKE_CONTROLS = 4;
+        public const int PERMISSION_REMAP_CONTROLS = 8;
+        public const int PERMISSION_TRIGGER_ANIMATION = 16;
+        public const int PERMISSION_ATTACH = 32;
+        public const int PERMISSION_RELEASE_OWNERSHIP = 64;
+        public const int PERMISSION_CHANGE_LINKS = 128;
+        public const int PERMISSION_CHANGE_JOINTS = 256;
+        public const int PERMISSION_CHANGE_PERMISSIONS = 512;
+        public const int PERMISSION_TRACK_CAMERA = 1024;
+
+        public const int AGENT_FLYING = 1;
+        public const int AGENT_ATTACHMENTS = 2;
+        public const int AGENT_SCRIPTED = 4;
+        public const int AGENT_MOUSELOOK = 8;
+        public const int AGENT_SITTING = 16;
+        public const int AGENT_ON_OBJECT = 32;
+        public const int AGENT_AWAY = 64;
+        public const int AGENT_WALKING = 128;
+        public const int AGENT_IN_AIR = 256;
+        public const int AGENT_TYPING = 512;
+        public const int AGENT_CROUCHING = 1024;
+        public const int AGENT_BUSY = 2048;
+        public const int AGENT_ALWAYS_RUN = 4096;
+
+        //Particle Systems
+        public const int PSYS_PART_INTERP_COLOR_MASK = 1;
+        public const int PSYS_PART_INTERP_SCALE_MASK = 2;
+        public const int PSYS_PART_BOUNCE_MASK = 4;
+        public const int PSYS_PART_WIND_MASK = 8;
+        public const int PSYS_PART_FOLLOW_SRC_MASK = 16;
+        public const int PSYS_PART_FOLLOW_VELOCITY_MASK = 32;
+        public const int PSYS_PART_TARGET_POS_MASK = 64;
+        public const int PSYS_PART_TARGET_LINEAR_MASK = 128;
+        public const int PSYS_PART_EMISSIVE_MASK = 256;
+        public const int PSYS_PART_FLAGS = 0;
+        public const int PSYS_PART_START_COLOR = 1;
+        public const int PSYS_PART_START_ALPHA = 2;
+        public const int PSYS_PART_END_COLOR = 3;
+        public const int PSYS_PART_END_ALPHA = 4;
+        public const int PSYS_PART_START_SCALE = 5;
+        public const int PSYS_PART_END_SCALE = 6;
+        public const int PSYS_PART_MAX_AGE = 7;
+        public const int PSYS_SRC_ACCEL = 8;
+        public const int PSYS_SRC_PATTERN = 9;
+        public const int PSYS_SRC_INNERANGLE = 10;
+        public const int PSYS_SRC_OUTERANGLE = 11;
+        public const int PSYS_SRC_TEXTURE = 12;
+        public const int PSYS_SRC_BURST_RATE = 13;
+        public const int PSYS_SRC_BURST_PART_COUNT = 15;
+        public const int PSYS_SRC_BURST_RADIUS = 16;
+        public const int PSYS_SRC_BURST_SPEED_MIN = 17;
+        public const int PSYS_SRC_BURST_SPEED_MAX = 18;
+        public const int PSYS_SRC_MAX_AGE = 19;
+        public const int PSYS_SRC_TARGET_KEY = 20;
+        public const int PSYS_SRC_OMEGA = 21;
+        public const int PSYS_SRC_ANGLE_BEGIN = 22;
+        public const int PSYS_SRC_ANGLE_END = 23;
+        public const int PSYS_SRC_PATTERN_DROP = 1;
+        public const int PSYS_SRC_PATTERN_EXPLODE = 2;
+        public const int PSYS_SRC_PATTERN_ANGLE = 4;
+        public const int PSYS_SRC_PATTERN_ANGLE_CONE = 8;
+        public const int PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY = 16;
+
+        public const int VEHICLE_TYPE_NONE = 0;
+        public const int VEHICLE_TYPE_SLED = 1;
+        public const int VEHICLE_TYPE_CAR = 2;
+        public const int VEHICLE_TYPE_BOAT = 3;
+        public const int VEHICLE_TYPE_AIRPLANE = 4;
+        public const int VEHICLE_TYPE_BALLOON = 5;
+        public const int VEHICLE_LINEAR_FRICTION_TIMESCALE = 16;
+        public const int VEHICLE_ANGULAR_FRICTION_TIMESCALE = 17;
+        public const int VEHICLE_LINEAR_MOTOR_DIRECTION = 18;
+        public const int VEHICLE_LINEAR_MOTOR_OFFSET = 20;
+        public const int VEHICLE_ANGULAR_MOTOR_DIRECTION = 19;
+        public const int VEHICLE_HOVER_HEIGHT = 24;
+        public const int VEHICLE_HOVER_EFFICIENCY = 25;
+        public const int VEHICLE_HOVER_TIMESCALE = 26;
+        public const int VEHICLE_BUOYANCY = 27;
+        public const int VEHICLE_LINEAR_DEFLECTION_EFFICIENCY = 28;
+        public const int VEHICLE_LINEAR_DEFLECTION_TIMESCALE = 29;
+        public const int VEHICLE_LINEAR_MOTOR_TIMESCALE = 30;
+        public const int VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE = 31;
+        public const int VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY = 32;
+        public const int VEHICLE_ANGULAR_DEFLECTION_TIMESCALE = 33;
+        public const int VEHICLE_ANGULAR_MOTOR_TIMESCALE = 34;
+        public const int VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE = 35;
+        public const int VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY = 36;
+        public const int VEHICLE_VERTICAL_ATTRACTION_TIMESCALE = 37;
+        public const int VEHICLE_BANKING_EFFICIENCY = 38;
+        public const int VEHICLE_BANKING_MIX = 39;
+        public const int VEHICLE_BANKING_TIMESCALE = 40;
+        public const int VEHICLE_REFERENCE_FRAME = 44;
+        public const int VEHICLE_FLAG_NO_DEFLECTION_UP = 1;
+        public const int VEHICLE_FLAG_LIMIT_ROLL_ONLY = 2;
+        public const int VEHICLE_FLAG_HOVER_WATER_ONLY = 4;
+        public const int VEHICLE_FLAG_HOVER_TERRAIN_ONLY = 8;
+        public const int VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT = 16;
+        public const int VEHICLE_FLAG_HOVER_UP_ONLY = 32;
+        public const int VEHICLE_FLAG_LIMIT_MOTOR_UP = 64;
+        public const int VEHICLE_FLAG_MOUSELOOK_STEER = 128;
+        public const int VEHICLE_FLAG_MOUSELOOK_BANK = 256;
+        public const int VEHICLE_FLAG_CAMERA_DECOUPLED = 512;
+
+        public const int INVENTORY_ALL = -1;
+        public const int INVENTORY_NONE = -1;
+        public const int INVENTORY_TEXTURE = 0;
+        public const int INVENTORY_SOUND = 1;
+        public const int INVENTORY_LANDMARK = 3;
+        public const int INVENTORY_CLOTHING = 5;
+        public const int INVENTORY_OBJECT = 6;
+        public const int INVENTORY_NOTECARD = 7;
+        public const int INVENTORY_SCRIPT = 10;
+        public const int INVENTORY_BODYPART = 13;
+        public const int INVENTORY_ANIMATION = 20;
+        public const int INVENTORY_GESTURE = 21;
+
+        public const int ATTACH_CHEST = 1;
+        public const int ATTACH_HEAD = 2;
+        public const int ATTACH_LSHOULDER = 3;
+        public const int ATTACH_RSHOULDER = 4;
+        public const int ATTACH_LHAND = 5;
+        public const int ATTACH_RHAND = 6;
+        public const int ATTACH_LFOOT = 7;
+        public const int ATTACH_RFOOT = 8;
+        public const int ATTACH_BACK = 9;
+        public const int ATTACH_PELVIS = 10;
+        public const int ATTACH_MOUTH = 11;
+        public const int ATTACH_CHIN = 12;
+        public const int ATTACH_LEAR = 13;
+        public const int ATTACH_REAR = 14;
+        public const int ATTACH_LEYE = 15;
+        public const int ATTACH_REYE = 16;
+        public const int ATTACH_NOSE = 17;
+        public const int ATTACH_RUARM = 18;
+        public const int ATTACH_RLARM = 19;
+        public const int ATTACH_LUARM = 20;
+        public const int ATTACH_LLARM = 21;
+        public const int ATTACH_RHIP = 22;
+        public const int ATTACH_RULEG = 23;
+        public const int ATTACH_RLLEG = 24;
+        public const int ATTACH_LHIP = 25;
+        public const int ATTACH_LULEG = 26;
+        public const int ATTACH_LLLEG = 27;
+        public const int ATTACH_BELLY = 28;
+        public const int ATTACH_RPEC = 29;
+        public const int ATTACH_LPEC = 30;
+
+        public const int LAND_LEVEL = 0;
+        public const int LAND_RAISE = 1;
+        public const int LAND_LOWER = 2;
+        public const int LAND_SMOOTH = 3;
+        public const int LAND_NOISE = 4;
+        public const int LAND_REVERT = 5;
+        public const int LAND_SMALL_BRUSH = 1;
+        public const int LAND_MEDIUM_BRUSH = 2;
+        public const int LAND_LARGE_BRUSH = 3;
+
+        //Agent Dataserver
+        public const int DATA_ONLINE = 1;
+        public const int DATA_NAME = 2;
+        public const int DATA_BORN = 3;
+        public const int DATA_RATING = 4;
+        public const int DATA_SIM_POS = 5;
+        public const int DATA_SIM_STATUS = 6;
+        public const int DATA_SIM_RATING = 7;
+        public const int DATA_PAYINFO = 8;
+
+        public const int ANIM_ON = 1;
+        public const int LOOP = 2;
+        public const int REVERSE = 4;
+        public const int PING_PONG = 8;
+        public const int SMOOTH = 16;
+        public const int ROTATE = 32;
+        public const int SCALE = 64;
+        public const int ALL_SIDES = -1;
+        public const int LINK_SET = -1;
+        public const int LINK_ROOT = 1;
+        public const int LINK_ALL_OTHERS = -2;
+        public const int LINK_ALL_CHILDREN = -3;
+        public const int LINK_THIS = -4;
+        public const int CHANGED_INVENTORY = 1;
+        public const int CHANGED_COLOR = 2;
+        public const int CHANGED_SHAPE = 4;
+        public const int CHANGED_SCALE = 8;
+        public const int CHANGED_TEXTURE = 16;
+        public const int CHANGED_LINK = 32;
+        public const int CHANGED_ALLOWED_DROP = 64;
+        public const int CHANGED_OWNER = 128;
+        public const int CHANGED_REGION_RESTART = 256;
+        public const int TYPE_INVALID = 0;
+        public const int TYPE_INTEGER = 1;
+        public const int TYPE_double = 2;
+        public const int TYPE_STRING = 3;
+        public const int TYPE_KEY = 4;
+        public const int TYPE_VECTOR = 5;
+        public const int TYPE_ROTATION = 6;
+
+        //XML RPC Remote Data Channel
+        public const int REMOTE_DATA_CHANNEL = 1;
+        public const int REMOTE_DATA_REQUEST = 2;
+        public const int REMOTE_DATA_REPLY = 3;
+
+        //llHTTPRequest
+        public const int HTTP_METHOD = 0;
+        public const int HTTP_MIMETYPE = 1;
+        public const int HTTP_BODY_MAXLENGTH = 2;
+        public const int HTTP_VERIFY_CERT = 3;
+
+        public const int PRIM_MATERIAL = 2;
+        public const int PRIM_PHYSICS = 3;
+        public const int PRIM_TEMP_ON_REZ = 4;
+        public const int PRIM_PHANTOM = 5;
+        public const int PRIM_POSITION = 6;
+        public const int PRIM_SIZE = 7;
+        public const int PRIM_ROTATION = 8;
+        public const int PRIM_TYPE = 9;
+        public const int PRIM_TEXTURE = 17;
+        public const int PRIM_COLOR = 18;
+        public const int PRIM_BUMP_SHINY = 19;
+        public const int PRIM_FULLBRIGHT = 20;
+        public const int PRIM_FLEXIBLE = 21;
+        public const int PRIM_TEXGEN = 22;
+        public const int PRIM_CAST_SHADOWS = 24; // Not implemented, here for completeness sake
+        public const int PRIM_POINT_LIGHT = 23; // Huh?
+        public const int PRIM_TEXGEN_DEFAULT = 0;
+        public const int PRIM_TEXGEN_PLANAR = 1;
+
+        public const int PRIM_TYPE_BOX = 0;
+        public const int PRIM_TYPE_CYLINDER = 1;
+        public const int PRIM_TYPE_PRISM = 2;
+        public const int PRIM_TYPE_SPHERE = 3;
+        public const int PRIM_TYPE_TORUS = 4;
+        public const int PRIM_TYPE_TUBE = 5;
+        public const int PRIM_TYPE_RING = 6;
+        public const int PRIM_TYPE_SCULPT = 7;
+
+        public const int PRIM_HOLE_DEFAULT = 0;
+        public const int PRIM_HOLE_CIRCLE = 16;
+        public const int PRIM_HOLE_SQUARE = 32;
+        public const int PRIM_HOLE_TRIANGLE = 48;
+
+        public const int PRIM_MATERIAL_STONE = 0;
+        public const int PRIM_MATERIAL_METAL = 1;
+        public const int PRIM_MATERIAL_GLASS = 2;
+        public const int PRIM_MATERIAL_WOOD = 3;
+        public const int PRIM_MATERIAL_FLESH = 4;
+        public const int PRIM_MATERIAL_PLASTIC = 5;
+        public const int PRIM_MATERIAL_RUBBER = 6;
+        public const int PRIM_MATERIAL_LIGHT = 7;
+
+        public const int PRIM_SHINY_NONE = 0;
+        public const int PRIM_SHINY_LOW = 1;
+        public const int PRIM_SHINY_MEDIUM = 2;
+        public const int PRIM_SHINY_HIGH = 3;
+        public const int PRIM_BUMP_NONE = 0;
+        public const int PRIM_BUMP_BRIGHT = 1;
+        public const int PRIM_BUMP_DARK = 2;
+        public const int PRIM_BUMP_WOOD = 3;
+        public const int PRIM_BUMP_BARK = 4;
+        public const int PRIM_BUMP_BRICKS = 5;
+        public const int PRIM_BUMP_CHECKER = 6;
+        public const int PRIM_BUMP_CONCRETE = 7;
+        public const int PRIM_BUMP_TILE = 8;
+        public const int PRIM_BUMP_STONE = 9;
+        public const int PRIM_BUMP_DISKS = 10;
+        public const int PRIM_BUMP_GRAVEL = 11;
+        public const int PRIM_BUMP_BLOBS = 12;
+        public const int PRIM_BUMP_SIDING = 13;
+        public const int PRIM_BUMP_LARGETILE = 14;
+        public const int PRIM_BUMP_STUCCO = 15;
+        public const int PRIM_BUMP_SUCTION = 16;
+        public const int PRIM_BUMP_WEAVE = 17;
+
+        public const int PRIM_SCULPT_TYPE_SPHERE = 1;
+        public const int PRIM_SCULPT_TYPE_TORUS = 2;
+        public const int PRIM_SCULPT_TYPE_PLANE = 3;
+        public const int PRIM_SCULPT_TYPE_CYLINDER = 4;
+
+        public const int MASK_BASE = 0;
+        public const int MASK_OWNER = 1;
+        public const int MASK_GROUP = 2;
+        public const int MASK_EVERYONE = 3;
+        public const int MASK_NEXT = 4;
+
+        public const int PERM_TRANSFER = 8192;
+        public const int PERM_MODIFY = 16384;
+        public const int PERM_COPY = 32768;
+        public const int PERM_MOVE = 524288;
+        public const int PERM_ALL = 2147483647;
+
+        public const int PARCEL_MEDIA_COMMAND_STOP = 0;
+        public const int PARCEL_MEDIA_COMMAND_PAUSE = 1;
+        public const int PARCEL_MEDIA_COMMAND_PLAY = 2;
+        public const int PARCEL_MEDIA_COMMAND_LOOP = 3;
+        public const int PARCEL_MEDIA_COMMAND_TEXTURE = 4;
+        public const int PARCEL_MEDIA_COMMAND_URL = 5;
+        public const int PARCEL_MEDIA_COMMAND_TIME = 6;
+        public const int PARCEL_MEDIA_COMMAND_AGENT = 7;
+        public const int PARCEL_MEDIA_COMMAND_UNLOAD = 8;
+        public const int PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9;
+
+        public const int PAY_HIDE = -1;
+        public const int PAY_DEFAULT = -2;
+
+        public const string NULL_KEY = "00000000-0000-0000-0000-000000000000";
+        public const string EOF = "\n\n\n";
+        public const double PI = 3.14159274f;
+        public const double TWO_PI = 6.28318548f;
+        public const double PI_BY_TWO = 1.57079637f;
+        public const double DEG_TO_RAD = 0.01745329238f;
+        public const double RAD_TO_DEG = 57.29578f;
+        public const double SQRT2 = 1.414213538f;
+        public const int STRING_TRIM_HEAD = 1;
+        public const int STRING_TRIM_TAIL = 2;
+        public const int STRING_TRIM = 3;
+        public const int LIST_STAT_RANGE = 0;
+        public const int LIST_STAT_MIN = 1;
+        public const int LIST_STAT_MAX = 2;
+        public const int LIST_STAT_MEAN = 3;
+        public const int LIST_STAT_MEDIAN = 4;
+        public const int LIST_STAT_STD_DEV = 5;
+        public const int LIST_STAT_SUM = 6;
+        public const int LIST_STAT_SUM_SQUARES = 7;
+        public const int LIST_STAT_NUM_COUNT = 8;
+        public const int LIST_STAT_GEOMETRIC_MEAN = 9;
+        public const int LIST_STAT_HARMONIC_MEAN = 100;
+
+        //ParcelPrim Categories
+        public const int PARCEL_COUNT_TOTAL = 0;
+        public const int PARCEL_COUNT_OWNER = 1;
+        public const int PARCEL_COUNT_GROUP = 2;
+        public const int PARCEL_COUNT_OTHER = 3;
+        public const int PARCEL_COUNT_SELECTED = 4;
+        public const int PARCEL_COUNT_TEMP = 5;
+
+        public const int DEBUG_CHANNEL  = 0x7FFFFFFF;
+        public const int PUBLIC_CHANNEL = 0x00000000;
+
+        public const int OBJECT_NAME = 1;
+        public const int OBJECT_DESC = 2;
+        public const int OBJECT_POS = 3;
+        public const int OBJECT_ROT = 4;
+        public const int OBJECT_VELOCITY = 5;
+        public const int OBJECT_OWNER = 6;
+        public const int OBJECT_GROUP = 7;
+        public const int OBJECT_CREATOR = 8;
+
+        // Can not be public const?
+        public vector ZERO_VECTOR = new vector(0.0, 0.0, 0.0);
+        public rotation ZERO_ROTATION = new rotation(0.0, 0, 0.0, 1.0);
+
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
new file mode 100644
index 0000000..7b3907f
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
@@ -0,0 +1,1732 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+using integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+using key = System.String;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
+{
+    public partial class ScriptBaseClass : MarshalByRefObject
+    {
+        public ILSL_Api m_LSL_Functions;
+
+        public void ApiTypeLSL(IScriptApi api)
+        {
+            if(!(api is ILSL_Api))
+                return;
+
+            m_LSL_Functions = (ILSL_Api)api;
+        }
+
+        public void state(string newState)
+        {
+            m_LSL_Functions.state(newState);
+        }
+
+        //
+        // Script functions
+        //
+        public void llSay(int channelID, string text)
+        {
+            m_LSL_Functions.llSay(channelID, text);
+        }
+
+        public double llSin(double f)
+        {
+            return m_LSL_Functions.llSin(f);
+        }
+
+        public double llCos(double f)
+        {
+            return m_LSL_Functions.llCos(f);
+        }
+
+        public double llTan(double f)
+        {
+            return m_LSL_Functions.llTan(f);
+        }
+
+        public double llAtan2(double x, double y)
+        {
+            return m_LSL_Functions.llAtan2(x, y);
+        }
+
+        public double llSqrt(double f)
+        {
+            return m_LSL_Functions.llSqrt(f);
+        }
+
+        public double llPow(double fbase, double fexponent)
+        {
+            return m_LSL_Functions.llPow(fbase, fexponent);
+        }
+
+        public LSL_Types.LSLInteger llAbs(int i)
+        {
+            return m_LSL_Functions.llAbs(i);
+        }
+
+        public double llFabs(double f)
+        {
+            return m_LSL_Functions.llFabs(f);
+        }
+
+        public double llFrand(double mag)
+        {
+            return m_LSL_Functions.llFrand(mag);
+        }
+
+        public LSL_Types.LSLInteger llFloor(double f)
+        {
+            return m_LSL_Functions.llFloor(f);
+        }
+
+        public LSL_Types.LSLInteger llCeil(double f)
+        {
+            return m_LSL_Functions.llCeil(f);
+        }
+
+        public LSL_Types.LSLInteger llRound(double f)
+        {
+            return m_LSL_Functions.llRound(f);
+        }
+
+        public double llVecMag(vector v)
+        {
+            return m_LSL_Functions.llVecMag(v);
+        }
+
+        public vector llVecNorm(vector v)
+        {
+            return m_LSL_Functions.llVecNorm(v);
+        }
+
+        public double llVecDist(vector a, vector b)
+        {
+            return m_LSL_Functions.llVecDist(a, b);
+        }
+
+        public vector llRot2Euler(rotation r)
+        {
+            return m_LSL_Functions.llRot2Euler(r);
+        }
+
+        public rotation llEuler2Rot(vector v)
+        {
+            return m_LSL_Functions.llEuler2Rot(v);
+        }
+
+        public rotation llAxes2Rot(vector fwd, vector left, vector up)
+        {
+            return m_LSL_Functions.llAxes2Rot(fwd, left, up);
+        }
+
+        public vector llRot2Fwd(rotation r)
+        {
+            return m_LSL_Functions.llRot2Fwd(r);
+        }
+
+        public vector llRot2Left(rotation r)
+        {
+            return m_LSL_Functions.llRot2Left(r);
+        }
+
+        public vector llRot2Up(rotation r)
+        {
+            return m_LSL_Functions.llRot2Up(r);
+        }
+
+        public rotation llRotBetween(vector start, vector end)
+        {
+            return m_LSL_Functions.llRotBetween(start, end);
+        }
+
+        public void llWhisper(int channelID, string text)
+        {
+            m_LSL_Functions.llWhisper(channelID, text);
+        }
+
+        public void llShout(int channelID, string text)
+        {
+            m_LSL_Functions.llShout(channelID, text);
+        }
+
+        public void llRegionSay(int channelID, string text)
+        {
+            m_LSL_Functions.llRegionSay(channelID, text);
+        }
+
+        public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg)
+        {
+            return m_LSL_Functions.llListen(channelID, name, ID, msg);
+        }
+
+        public void llListenControl(int number, int active)
+        {
+            m_LSL_Functions.llListenControl(number, active);
+        }
+
+        public void llListenRemove(int number)
+        {
+            m_LSL_Functions.llListenRemove(number);
+        }
+
+        public void llSensor(string name, string id, int type, double range, double arc)
+        {
+            m_LSL_Functions.llSensor(name, id, type, range, arc);
+        }
+
+        public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate)
+        {
+            m_LSL_Functions.llSensorRepeat(name, id, type, range, arc, rate);
+        }
+
+        public void llSensorRemove()
+        {
+            m_LSL_Functions.llSensorRemove();
+        }
+
+        public string llDetectedName(int number)
+        {
+            return m_LSL_Functions.llDetectedName(number);
+        }
+
+        public string llDetectedKey(int number)
+        {
+            return m_LSL_Functions.llDetectedKey(number);
+        }
+
+        public string llDetectedOwner(int number)
+        {
+            return m_LSL_Functions.llDetectedOwner(number);
+        }
+
+        public LSL_Types.LSLInteger llDetectedType(int number)
+        {
+            return m_LSL_Functions.llDetectedType(number);
+        }
+
+        public vector llDetectedPos(int number)
+        {
+            return m_LSL_Functions.llDetectedPos(number);
+        }
+
+        public vector llDetectedVel(int number)
+        {
+            return m_LSL_Functions.llDetectedVel(number);
+        }
+
+        public vector llDetectedGrab(int number)
+        {
+            return m_LSL_Functions.llDetectedGrab(number);
+        }
+
+        public rotation llDetectedRot(int number)
+        {
+            return m_LSL_Functions.llDetectedRot(number);
+        }
+
+        public LSL_Types.LSLInteger llDetectedGroup(int number)
+        {
+            return m_LSL_Functions.llDetectedGroup(number);
+        }
+
+        public LSL_Types.LSLInteger llDetectedLinkNumber(int number)
+        {
+            return m_LSL_Functions.llDetectedLinkNumber(number);
+        }
+
+        public void llDie()
+        {
+            m_LSL_Functions.llDie();
+        }
+
+        public double llGround(vector offset)
+        {
+            return m_LSL_Functions.llGround(offset);
+        }
+
+        public double llCloud(vector offset)
+        {
+            return m_LSL_Functions.llCloud(offset);
+        }
+
+        public vector llWind(vector offset)
+        {
+            return m_LSL_Functions.llWind(offset);
+        }
+
+        public void llSetStatus(int status, int value)
+        {
+            m_LSL_Functions.llSetStatus(status, value);
+        }
+
+        public LSL_Types.LSLInteger llGetStatus(int status)
+        {
+            return m_LSL_Functions.llGetStatus(status);
+        }
+
+        public void llSetScale(vector scale)
+        {
+            m_LSL_Functions.llSetScale(scale);
+        }
+
+        public vector llGetScale()
+        {
+            return m_LSL_Functions.llGetScale();
+        }
+
+        public void llSetColor(vector color, int face)
+        {
+            m_LSL_Functions.llSetColor(color, face);
+        }
+
+        public double llGetAlpha(int face)
+        {
+            return m_LSL_Functions.llGetAlpha(face);
+        }
+
+        public void llSetAlpha(double alpha, int face)
+        {
+            m_LSL_Functions.llSetAlpha(alpha, face);
+        }
+
+        public vector llGetColor(int face)
+        {
+            return m_LSL_Functions.llGetColor(face);
+        }
+
+        public void llSetTexture(string texture, int face)
+        {
+            m_LSL_Functions.llSetTexture(texture, face);
+        }
+
+        public void llScaleTexture(double u, double v, int face)
+        {
+            m_LSL_Functions.llScaleTexture(u, v, face);
+        }
+
+        public void llOffsetTexture(double u, double v, int face)
+        {
+            m_LSL_Functions.llOffsetTexture(u, v, face);
+        }
+
+        public void llRotateTexture(double rotation, int face)
+        {
+            m_LSL_Functions.llRotateTexture(rotation, face);
+        }
+
+        public string llGetTexture(int face)
+        {
+            return m_LSL_Functions.llGetTexture(face);
+        }
+
+        public void llSetPos(vector pos)
+        {
+            m_LSL_Functions.llSetPos(pos);
+        }
+
+        public vector llGetPos()
+        {
+            return m_LSL_Functions.llGetPos();
+        }
+
+        public vector llGetLocalPos()
+        {
+            return m_LSL_Functions.llGetLocalPos();
+        }
+
+        public void llSetRot(rotation rot)
+        {
+            m_LSL_Functions.llSetRot(rot);
+        }
+
+        public rotation llGetRot()
+        {
+            return m_LSL_Functions.llGetRot();
+        }
+
+        public rotation llGetLocalRot()
+        {
+            return m_LSL_Functions.llGetLocalRot();
+        }
+
+        public void llSetForce(vector force, int local)
+        {
+            m_LSL_Functions.llSetForce(force, local);
+        }
+
+        public vector llGetForce()
+        {
+            return m_LSL_Functions.llGetForce();
+        }
+
+        public LSL_Types.LSLInteger llTarget(vector position, double range)
+        {
+            return m_LSL_Functions.llTarget(position, range);
+        }
+
+        public void llTargetRemove(int number)
+        {
+            m_LSL_Functions.llTargetRemove(number);
+        }
+
+        public LSL_Types.LSLInteger llRotTarget(rotation rot, double error)
+        {
+            return m_LSL_Functions.llRotTarget(rot, error);
+        }
+
+        public void llRotTargetRemove(int number)
+        {
+            m_LSL_Functions.llRotTargetRemove(number);
+        }
+
+        public void llMoveToTarget(vector target, double tau)
+        {
+            m_LSL_Functions.llMoveToTarget(target, tau);
+        }
+
+        public void llStopMoveToTarget()
+        {
+            m_LSL_Functions.llStopMoveToTarget();
+        }
+
+        public void llApplyImpulse(vector force, int local)
+        {
+            m_LSL_Functions.llApplyImpulse(force, local);
+        }
+
+        public void llApplyRotationalImpulse(vector force, int local)
+        {
+            m_LSL_Functions.llApplyRotationalImpulse(force, local);
+        }
+
+        public void llSetTorque(vector torque, int local)
+        {
+            m_LSL_Functions.llSetTorque(torque, local);
+        }
+
+        public vector llGetTorque()
+        {
+            return m_LSL_Functions.llGetTorque();
+        }
+
+        public void llSetForceAndTorque(vector force, vector torque, int local)
+        {
+            m_LSL_Functions.llSetForceAndTorque(force, torque, local);
+        }
+
+        public vector llGetVel()
+        {
+            return m_LSL_Functions.llGetVel();
+        }
+
+        public vector llGetAccel()
+        {
+            return m_LSL_Functions.llGetAccel();
+        }
+
+        public vector llGetOmega()
+        {
+            return m_LSL_Functions.llGetOmega();
+        }
+
+        public double llGetTimeOfDay()
+        {
+            return m_LSL_Functions.llGetTimeOfDay();
+        }
+
+        public double llGetWallclock()
+        {
+            return m_LSL_Functions.llGetWallclock();
+        }
+
+        public double llGetTime()
+        {
+            return m_LSL_Functions.llGetTime();
+        }
+
+        public void llResetTime()
+        {
+            m_LSL_Functions.llResetTime();
+        }
+
+        public double llGetAndResetTime()
+        {
+            return m_LSL_Functions.llGetAndResetTime();
+        }
+
+        public void llSound()
+        {
+            m_LSL_Functions.llSound();
+        }
+
+        public void llPlaySound(string sound, double volume)
+        {
+            m_LSL_Functions.llPlaySound(sound, volume);
+        }
+
+        public void llLoopSound(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSound(sound, volume);
+        }
+
+        public void llLoopSoundMaster(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSoundMaster(sound, volume);
+        }
+
+        public void llLoopSoundSlave(string sound, double volume)
+        {
+            m_LSL_Functions.llLoopSoundSlave(sound, volume);
+        }
+
+        public void llPlaySoundSlave(string sound, double volume)
+        {
+            m_LSL_Functions.llPlaySoundSlave(sound, volume);
+        }
+
+        public void llTriggerSound(string sound, double volume)
+        {
+            m_LSL_Functions.llTriggerSound(sound, volume);
+        }
+
+        public void llStopSound()
+        {
+            m_LSL_Functions.llStopSound();
+        }
+
+        public void llPreloadSound(string sound)
+        {
+            m_LSL_Functions.llPreloadSound(sound);
+        }
+
+        public string llGetSubString(string src, int start, int end)
+        {
+            return m_LSL_Functions.llGetSubString(src, start, end);
+        }
+
+        public string llDeleteSubString(string src, int start, int end)
+        {
+            return m_LSL_Functions.llDeleteSubString(src, start, end);
+        }
+
+        public string llInsertString(string dst, int position, string src)
+        {
+            return m_LSL_Functions.llInsertString(dst, position, src);
+        }
+
+        public string llToUpper(string source)
+        {
+            return m_LSL_Functions.llToUpper(source);
+        }
+
+        public string llToLower(string source)
+        {
+            return m_LSL_Functions.llToLower(source);
+        }
+
+        public LSL_Types.LSLInteger llGiveMoney(string destination, int amount)
+        {
+            return m_LSL_Functions.llGiveMoney(destination, amount);
+        }
+
+        public void llMakeExplosion()
+        {
+            m_LSL_Functions.llMakeExplosion();
+        }
+
+        public void llMakeFountain()
+        {
+            m_LSL_Functions.llMakeFountain();
+        }
+
+        public void llMakeSmoke()
+        {
+            m_LSL_Functions.llMakeSmoke();
+        }
+
+        public void llMakeFire()
+        {
+            m_LSL_Functions.llMakeFire();
+        }
+
+        public void llRezObject(string inventory, vector pos, vector vel, rotation rot, int param)
+        {
+            m_LSL_Functions.llRezObject(inventory, pos, vel, rot, param);
+        }
+
+        public void llLookAt(vector target, double strength, double damping)
+        {
+            m_LSL_Functions.llLookAt(target, strength, damping);
+        }
+
+        public void llStopLookAt()
+        {
+            m_LSL_Functions.llStopLookAt();
+        }
+
+        public void llSetTimerEvent(double sec)
+        {
+            m_LSL_Functions.llSetTimerEvent(sec);
+        }
+
+        public void llSleep(double sec)
+        {
+            m_LSL_Functions.llSleep(sec);
+        }
+
+        public double llGetMass()
+        {
+            return m_LSL_Functions.llGetMass();
+        }
+
+        public void llCollisionFilter(string name, string id, int accept)
+        {
+            m_LSL_Functions.llCollisionFilter(name, id, accept);
+        }
+
+        public void llTakeControls(int controls, int accept, int pass_on)
+        {
+            m_LSL_Functions.llTakeControls(controls, accept, pass_on);
+        }
+
+        public void llReleaseControls()
+        {
+            m_LSL_Functions.llReleaseControls();
+        }
+
+        public void llAttachToAvatar(int attachment)
+        {
+            m_LSL_Functions.llAttachToAvatar(attachment);
+        }
+
+        public void llDetachFromAvatar()
+        {
+            m_LSL_Functions.llDetachFromAvatar();
+        }
+
+        public void llTakeCamera()
+        {
+            m_LSL_Functions.llTakeCamera();
+        }
+
+        public void llReleaseCamera()
+        {
+            m_LSL_Functions.llReleaseCamera();
+        }
+
+        public string llGetOwner()
+        {
+            return m_LSL_Functions.llGetOwner();
+        }
+
+        public void llInstantMessage(string user, string message)
+        {
+            m_LSL_Functions.llInstantMessage(user, message);
+        }
+
+        public void llEmail(string address, string subject, string message)
+        {
+            m_LSL_Functions.llEmail(address, subject, message);
+        }
+
+        public void llGetNextEmail(string address, string subject)
+        {
+            m_LSL_Functions.llGetNextEmail(address, subject);
+        }
+
+        public string llGetKey()
+        {
+            return m_LSL_Functions.llGetKey();
+        }
+
+        public void llSetBuoyancy(double buoyancy)
+        {
+            m_LSL_Functions.llSetBuoyancy(buoyancy);
+        }
+
+        public void llSetHoverHeight(double height, int water, double tau)
+        {
+            m_LSL_Functions.llSetHoverHeight(height, water, tau);
+        }
+
+        public void llStopHover()
+        {
+            m_LSL_Functions.llStopHover();
+        }
+
+        public void llMinEventDelay(double delay)
+        {
+            m_LSL_Functions.llMinEventDelay(delay);
+        }
+
+        public void llSoundPreload()
+        {
+            m_LSL_Functions.llSoundPreload();
+        }
+
+        public void llRotLookAt(rotation target, double strength, double damping)
+        {
+            m_LSL_Functions.llRotLookAt(target, strength, damping);
+        }
+
+        public LSL_Types.LSLInteger llStringLength(string str)
+        {
+            return m_LSL_Functions.llStringLength(str);
+        }
+
+        public void llStartAnimation(string anim)
+        {
+            m_LSL_Functions.llStartAnimation(anim);
+        }
+
+        public void llStopAnimation(string anim)
+        {
+            m_LSL_Functions.llStopAnimation(anim);
+        }
+
+        public void llPointAt()
+        {
+            m_LSL_Functions.llPointAt();
+        }
+
+        public void llStopPointAt()
+        {
+            m_LSL_Functions.llStopPointAt();
+        }
+
+        public void llTargetOmega(vector axis, double spinrate, double gain)
+        {
+            m_LSL_Functions.llTargetOmega(axis, spinrate, gain);
+        }
+
+        public LSL_Types.LSLInteger llGetStartParameter()
+        {
+            return m_LSL_Functions.llGetStartParameter();
+        }
+
+        public void llGodLikeRezObject(string inventory, vector pos)
+        {
+            m_LSL_Functions.llGodLikeRezObject(inventory, pos);
+        }
+
+        public void llRequestPermissions(string agent, int perm)
+        {
+            m_LSL_Functions.llRequestPermissions(agent, perm);
+        }
+
+        public string llGetPermissionsKey()
+        {
+            return m_LSL_Functions.llGetPermissionsKey();
+        }
+
+        public LSL_Types.LSLInteger llGetPermissions()
+        {
+            return m_LSL_Functions.llGetPermissions();
+        }
+
+        public LSL_Types.LSLInteger llGetLinkNumber()
+        {
+            return m_LSL_Functions.llGetLinkNumber();
+        }
+
+        public void llSetLinkColor(int linknumber, vector color, int face)
+        {
+            m_LSL_Functions.llSetLinkColor(linknumber, color, face);
+        }
+
+        public void llCreateLink(string target, int parent)
+        {
+            m_LSL_Functions.llCreateLink(target, parent);
+        }
+
+        public void llBreakLink(int linknum)
+        {
+            m_LSL_Functions.llBreakLink(linknum);
+        }
+
+        public void llBreakAllLinks()
+        {
+            m_LSL_Functions.llBreakAllLinks();
+        }
+
+        public string llGetLinkKey(int linknum)
+        {
+            return m_LSL_Functions.llGetLinkKey(linknum);
+        }
+
+        public string llGetLinkName(int linknum)
+        {
+            return m_LSL_Functions.llGetLinkName(linknum);
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryNumber(int type)
+        {
+            return m_LSL_Functions.llGetInventoryNumber(type);
+        }
+
+        public string llGetInventoryName(int type, int number)
+        {
+            return m_LSL_Functions.llGetInventoryName(type, number);
+        }
+
+        public void llSetScriptState(string name, int run)
+        {
+            m_LSL_Functions.llSetScriptState(name, run);
+        }
+
+        public double llGetEnergy()
+        {
+            return m_LSL_Functions.llGetEnergy();
+        }
+
+        public void llGiveInventory(string destination, string inventory)
+        {
+            m_LSL_Functions.llGiveInventory(destination, inventory);
+        }
+
+        public void llRemoveInventory(string item)
+        {
+            m_LSL_Functions.llRemoveInventory(item);
+        }
+
+        public void llSetText(string text, vector color, double alpha)
+        {
+            m_LSL_Functions.llSetText(text, color, alpha);
+        }
+
+        public double llWater(vector offset)
+        {
+            return m_LSL_Functions.llWater(offset);
+        }
+
+        public void llPassTouches(int pass)
+        {
+            m_LSL_Functions.llPassTouches(pass);
+        }
+
+        public string llRequestAgentData(string id, int data)
+        {
+            return m_LSL_Functions.llRequestAgentData(id, data);
+        }
+
+        public string llRequestInventoryData(string name)
+        {
+            return m_LSL_Functions.llRequestInventoryData(name);
+        }
+
+        public void llSetDamage(double damage)
+        {
+            m_LSL_Functions.llSetDamage(damage);
+        }
+
+        public void llTeleportAgentHome(string agent)
+        {
+            m_LSL_Functions.llTeleportAgentHome(agent);
+        }
+
+        public void llModifyLand(int action, int brush)
+        {
+            m_LSL_Functions.llModifyLand(action, brush);
+        }
+
+        public void llCollisionSound(string impact_sound, double impact_volume)
+        {
+            m_LSL_Functions.llCollisionSound(impact_sound, impact_volume);
+        }
+
+        public void llCollisionSprite(string impact_sprite)
+        {
+            m_LSL_Functions.llCollisionSprite(impact_sprite);
+        }
+
+        public string llGetAnimation(string id)
+        {
+            return m_LSL_Functions.llGetAnimation(id);
+        }
+
+        public void llResetScript()
+        {
+            m_LSL_Functions.llResetScript();
+        }
+
+        public void llMessageLinked(int linknum, int num, string str, string id)
+        {
+            m_LSL_Functions.llMessageLinked(linknum, num, str, id);
+        }
+
+        public void llPushObject(string target, vector impulse, vector ang_impulse, int local)
+        {
+            m_LSL_Functions.llPushObject(target, impulse, ang_impulse, local);
+        }
+
+        public void llPassCollisions(int pass)
+        {
+            m_LSL_Functions.llPassCollisions(pass);
+        }
+
+        public string llGetScriptName()
+        {
+            return m_LSL_Functions.llGetScriptName();
+        }
+
+        public LSL_Types.LSLInteger llGetNumberOfSides()
+        {
+            return m_LSL_Functions.llGetNumberOfSides();
+        }
+
+        public rotation llAxisAngle2Rot(vector axis, double angle)
+        {
+            return m_LSL_Functions.llAxisAngle2Rot(axis, angle);
+        }
+
+        public vector llRot2Axis(rotation rot)
+        {
+            return m_LSL_Functions.llRot2Axis(rot);
+        }
+
+        public double llRot2Angle(rotation rot)
+        {
+            return m_LSL_Functions.llRot2Angle(rot);
+        }
+
+        public double llAcos(double val)
+        {
+            return m_LSL_Functions.llAcos(val);
+        }
+
+        public double llAsin(double val)
+        {
+            return m_LSL_Functions.llAsin(val);
+        }
+
+        public double llAngleBetween(rotation a, rotation b)
+        {
+            return m_LSL_Functions.llAngleBetween(a, b);
+        }
+
+        public string llGetInventoryKey(string name)
+        {
+            return m_LSL_Functions.llGetInventoryKey(name);
+        }
+
+        public void llAllowInventoryDrop(int add)
+        {
+            m_LSL_Functions.llAllowInventoryDrop(add);
+        }
+
+        public vector llGetSunDirection()
+        {
+            return m_LSL_Functions.llGetSunDirection();
+        }
+
+        public vector llGetTextureOffset(int face)
+        {
+            return m_LSL_Functions.llGetTextureOffset(face);
+        }
+
+        public vector llGetTextureScale(int side)
+        {
+            return m_LSL_Functions.llGetTextureScale(side);
+        }
+
+        public double llGetTextureRot(int side)
+        {
+            return m_LSL_Functions.llGetTextureRot(side);
+        }
+
+        public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern)
+        {
+            return m_LSL_Functions.llSubStringIndex(source, pattern);
+        }
+
+        public string llGetOwnerKey(string id)
+        {
+            return m_LSL_Functions.llGetOwnerKey(id);
+        }
+
+        public vector llGetCenterOfMass()
+        {
+            return m_LSL_Functions.llGetCenterOfMass();
+        }
+
+        public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending)
+        {
+            return m_LSL_Functions.llListSort(src, stride, ascending);
+        }
+
+        public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src)
+        {
+            return m_LSL_Functions.llGetListLength(src);
+        }
+
+        public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Integer(src, index);
+        }
+
+        public string llList2String(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2String(src, index);
+        }
+
+        public string llList2Key(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Key(src, index);
+        }
+
+        public vector llList2Vector(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Vector(src, index);
+        }
+
+        public rotation llList2Rot(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Rot(src, index);
+        }
+
+        public LSL_Types.list llList2List(LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llList2List(src, start, end);
+        }
+
+        public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llDeleteSubList(src, start, end);
+        }
+
+        public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llGetListEntryType(src, index);
+        }
+
+        public string llList2CSV(LSL_Types.list src)
+        {
+            return m_LSL_Functions.llList2CSV(src);
+        }
+
+        public LSL_Types.list llCSV2List(string src)
+        {
+            return m_LSL_Functions.llCSV2List(src);
+        }
+
+        public LSL_Types.list llListRandomize(LSL_Types.list src, int stride)
+        {
+            return m_LSL_Functions.llListRandomize(src, stride);
+        }
+
+        public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride)
+        {
+            return m_LSL_Functions.llList2ListStrided(src, start, end, stride);
+        }
+
+        public vector llGetRegionCorner()
+        {
+            return m_LSL_Functions.llGetRegionCorner();
+        }
+
+        public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int start)
+        {
+            return m_LSL_Functions.llListInsertList(dest, src, start);
+        }
+
+        public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test)
+        {
+            return m_LSL_Functions.llListFindList(src, test);
+        }
+
+        public string llGetObjectName()
+        {
+            return m_LSL_Functions.llGetObjectName();
+        }
+
+        public void llSetObjectName(string name)
+        {
+            m_LSL_Functions.llSetObjectName(name);
+        }
+
+        public string llGetDate()
+        {
+            return m_LSL_Functions.llGetDate();
+        }
+
+        public LSL_Types.LSLInteger llEdgeOfWorld(vector pos, vector dir)
+        {
+            return m_LSL_Functions.llEdgeOfWorld(pos, dir);
+        }
+
+        public LSL_Types.LSLInteger llGetAgentInfo(string id)
+        {
+            return m_LSL_Functions.llGetAgentInfo(id);
+        }
+
+        public void llAdjustSoundVolume(double volume)
+        {
+            m_LSL_Functions.llAdjustSoundVolume(volume);
+        }
+
+        public void llSetSoundQueueing(int queue)
+        {
+            m_LSL_Functions.llSetSoundQueueing(queue);
+        }
+
+        public void llSetSoundRadius(double radius)
+        {
+            m_LSL_Functions.llSetSoundRadius(radius);
+        }
+
+        public string llKey2Name(string id)
+        {
+            return m_LSL_Functions.llKey2Name(id);
+        }
+
+        public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate)
+        {
+            m_LSL_Functions.llSetTextureAnim(mode, face, sizex, sizey, start, length, rate);
+        }
+
+        public void llTriggerSoundLimited(string sound, double volume, vector top_north_east, vector bottom_south_west)
+        {
+            m_LSL_Functions.llTriggerSoundLimited(sound, volume, top_north_east, bottom_south_west);
+        }
+
+        public void llEjectFromLand(string pest)
+        {
+            m_LSL_Functions.llEjectFromLand(pest);
+        }
+
+        public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers)
+        {
+            return m_LSL_Functions.llParseString2List(str,separators,spacers);
+        }
+
+        public LSL_Types.LSLInteger llOverMyLand(string id)
+        {
+            return m_LSL_Functions.llOverMyLand(id);
+        }
+
+        public string llGetLandOwnerAt(vector pos)
+        {
+            return m_LSL_Functions.llGetLandOwnerAt(pos);
+        }
+
+        public string llGetNotecardLine(string name, int line)
+        {
+            return m_LSL_Functions.llGetNotecardLine(name, line);
+        }
+
+        public vector llGetAgentSize(string id)
+        {
+            return m_LSL_Functions.llGetAgentSize(id);
+        }
+
+        public LSL_Types.LSLInteger llSameGroup(string agent)
+        {
+            return m_LSL_Functions.llSameGroup(agent);
+        }
+
+        public void llUnSit(string id)
+        {
+            m_LSL_Functions.llUnSit(id);
+        }
+
+        public vector llGroundSlope(vector offset)
+        {
+            return m_LSL_Functions.llGroundSlope(offset);
+        }
+
+        public vector llGroundNormal(vector offset)
+        {
+            return m_LSL_Functions.llGroundNormal(offset);
+        }
+
+        public vector llGroundContour(vector offset)
+        {
+            return m_LSL_Functions.llGroundContour(offset);
+        }
+
+        public LSL_Types.LSLInteger llGetAttached()
+        {
+            return m_LSL_Functions.llGetAttached();
+        }
+
+        public LSL_Types.LSLInteger llGetFreeMemory()
+        {
+            return m_LSL_Functions.llGetFreeMemory();
+        }
+
+        public string llGetRegionName()
+        {
+            return m_LSL_Functions.llGetRegionName();
+        }
+
+        public double llGetRegionTimeDilation()
+        {
+            return m_LSL_Functions.llGetRegionTimeDilation();
+        }
+
+        public double llGetRegionFPS()
+        {
+            return m_LSL_Functions.llGetRegionFPS();
+        }
+
+        public void llParticleSystem(LSL_Types.list rules)
+        {
+            m_LSL_Functions.llParticleSystem(rules);
+        }
+
+        public void llGroundRepel(double height, int water, double tau)
+        {
+            m_LSL_Functions.llGroundRepel(height, water, tau);
+        }
+
+        public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory)
+        {
+            m_LSL_Functions.llGiveInventoryList(destination, category, inventory);
+        }
+
+        public void llSetVehicleType(int type)
+        {
+            m_LSL_Functions.llSetVehicleType(type);
+        }
+
+        public void llSetVehicledoubleParam(int param, double value)
+        {
+            m_LSL_Functions.llSetVehicledoubleParam(param, value);
+        }
+
+        public void llSetVehicleFloatParam(int param, float value)
+        {
+            m_LSL_Functions.llSetVehicleFloatParam(param, value);
+        }
+
+        public void llSetVehicleVectorParam(int param, vector vec)
+        {
+            m_LSL_Functions.llSetVehicleVectorParam(param, vec);
+        }
+
+        public void llSetVehicleRotationParam(int param, rotation rot)
+        {
+            m_LSL_Functions.llSetVehicleRotationParam(param, rot);
+        }
+
+        public void llSetVehicleFlags(int flags)
+        {
+            m_LSL_Functions.llSetVehicleFlags(flags);
+        }
+
+        public void llRemoveVehicleFlags(int flags)
+        {
+            m_LSL_Functions.llRemoveVehicleFlags(flags);
+        }
+
+        public void llSitTarget(vector offset, rotation rot)
+        {
+            m_LSL_Functions.llSitTarget(offset, rot);
+        }
+
+        public string llAvatarOnSitTarget()
+        {
+            return m_LSL_Functions.llAvatarOnSitTarget();
+        }
+
+        public void llAddToLandPassList(string avatar, double hours)
+        {
+            m_LSL_Functions.llAddToLandPassList(avatar, hours);
+        }
+
+        public void llSetTouchText(string text)
+        {
+            m_LSL_Functions.llSetTouchText(text);
+        }
+
+        public void llSetSitText(string text)
+        {
+            m_LSL_Functions.llSetSitText(text);
+        }
+
+        public void llSetCameraEyeOffset(vector offset)
+        {
+            m_LSL_Functions.llSetCameraEyeOffset(offset);
+        }
+
+        public void llSetCameraAtOffset(vector offset)
+        {
+            m_LSL_Functions.llSetCameraAtOffset(offset);
+        }
+
+        public string llDumpList2String(LSL_Types.list src, string seperator)
+        {
+            return m_LSL_Functions.llDumpList2String(src, seperator);
+        }
+
+        public LSL_Types.LSLInteger llScriptDanger(vector pos)
+        {
+            return m_LSL_Functions.llScriptDanger(pos);
+        }
+
+        public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel)
+        {
+            m_LSL_Functions.llDialog(avatar, message, buttons, chat_channel);
+        }
+
+        public void llVolumeDetect(int detect)
+        {
+            m_LSL_Functions.llVolumeDetect(detect);
+        }
+
+        public void llResetOtherScript(string name)
+        {
+            m_LSL_Functions.llResetOtherScript(name);
+        }
+
+        public LSL_Types.LSLInteger llGetScriptState(string name)
+        {
+            return m_LSL_Functions.llGetScriptState(name);
+        }
+
+        public void llRemoteLoadScript()
+        {
+            m_LSL_Functions.llRemoteLoadScript();
+        }
+
+        public void llSetRemoteScriptAccessPin(int pin)
+        {
+            m_LSL_Functions.llSetRemoteScriptAccessPin(pin);
+        }
+
+        public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param)
+        {
+            m_LSL_Functions.llRemoteLoadScriptPin(target, name, pin, running, start_param);
+        }
+
+        public void llOpenRemoteDataChannel()
+        {
+            m_LSL_Functions.llOpenRemoteDataChannel();
+        }
+
+        public string llSendRemoteData(string channel, string dest, int idata, string sdata)
+        {
+            return m_LSL_Functions.llSendRemoteData(channel, dest, idata, sdata);
+        }
+
+        public void llRemoteDataReply(string channel, string message_id, string sdata, int idata)
+        {
+            m_LSL_Functions.llRemoteDataReply(channel, message_id, sdata, idata);
+        }
+
+        public void llCloseRemoteDataChannel(string channel)
+        {
+            m_LSL_Functions.llCloseRemoteDataChannel(channel);
+        }
+
+        public string llMD5String(string src, int nonce)
+        {
+            return m_LSL_Functions.llMD5String(src, nonce);
+        }
+
+        public void llSetPrimitiveParams(LSL_Types.list rules)
+        {
+            m_LSL_Functions.llSetPrimitiveParams(rules);
+        }
+
+        public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules)
+        {
+            m_LSL_Functions.llSetLinkPrimitiveParams(linknumber, rules);
+        }
+        public string llStringToBase64(string str)
+        {
+            return m_LSL_Functions.llStringToBase64(str);
+        }
+
+        public string llBase64ToString(string str)
+        {
+            return m_LSL_Functions.llBase64ToString(str);
+        }
+
+        public void llXorBase64Strings()
+        {
+            m_LSL_Functions.llXorBase64Strings();
+        }
+
+        public void llRemoteDataSetRegion()
+        {
+            m_LSL_Functions.llRemoteDataSetRegion();
+        }
+
+        public double llLog10(double val)
+        {
+            return m_LSL_Functions.llLog10(val);
+        }
+
+        public double llLog(double val)
+        {
+            return m_LSL_Functions.llLog(val);
+        }
+
+        public LSL_Types.list llGetAnimationList(string id)
+        {
+            return m_LSL_Functions.llGetAnimationList(id);
+        }
+
+        public void llSetParcelMusicURL(string url)
+        {
+            m_LSL_Functions.llSetParcelMusicURL(url);
+        }
+
+        public vector llGetRootPosition()
+        {
+            return m_LSL_Functions.llGetRootPosition();
+        }
+
+        public rotation llGetRootRotation()
+        {
+            return m_LSL_Functions.llGetRootRotation();
+        }
+
+        public string llGetObjectDesc()
+        {
+            return m_LSL_Functions.llGetObjectDesc();
+        }
+
+        public void llSetObjectDesc(string desc)
+        {
+            m_LSL_Functions.llSetObjectDesc(desc);
+        }
+
+        public string llGetCreator()
+        {
+            return m_LSL_Functions.llGetCreator();
+        }
+
+        public string llGetTimestamp()
+        {
+            return m_LSL_Functions.llGetTimestamp();
+        }
+
+        public void llSetLinkAlpha(int linknumber, double alpha, int face)
+        {
+            m_LSL_Functions.llSetLinkAlpha(linknumber, alpha, face);
+        }
+
+        public LSL_Types.LSLInteger llGetNumberOfPrims()
+        {
+            return m_LSL_Functions.llGetNumberOfPrims();
+        }
+
+        public string llGetNumberOfNotecardLines(string name)
+        {
+            return m_LSL_Functions.llGetNumberOfNotecardLines(name);
+        }
+
+        public LSL_Types.list llGetBoundingBox(string obj)
+        {
+            return m_LSL_Functions.llGetBoundingBox(obj);
+        }
+
+        public vector llGetGeometricCenter()
+        {
+            return m_LSL_Functions.llGetGeometricCenter();
+        }
+
+        public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules)
+        {
+            return m_LSL_Functions.llGetPrimitiveParams(rules);
+        }
+
+        public string llIntegerToBase64(int number)
+        {
+            return m_LSL_Functions.llIntegerToBase64(number);
+        }
+
+        public LSL_Types.LSLInteger llBase64ToInteger(string str)
+        {
+            return m_LSL_Functions.llBase64ToInteger(str);
+        }
+
+        public double llGetGMTclock()
+        {
+            return m_LSL_Functions.llGetGMTclock();
+        }
+
+        public string llGetSimulatorHostname()
+        {
+            return m_LSL_Functions.llGetSimulatorHostname();
+        }
+
+        public void llSetLocalRot(rotation rot)
+        {
+            m_LSL_Functions.llSetLocalRot(rot);
+        }
+
+        public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list seperators, LSL_Types.list spacers)
+        {
+            return m_LSL_Functions.llParseStringKeepNulls(src, seperators, spacers);
+        }
+
+        public void llRezAtRoot(string inventory, vector position, vector velocity, rotation rot, int param)
+        {
+            m_LSL_Functions.llRezAtRoot(inventory, position, velocity, rot, param);
+        }
+
+        public LSL_Types.LSLInteger llGetObjectPermMask(int mask)
+        {
+            return m_LSL_Functions.llGetObjectPermMask(mask);
+        }
+
+        public void llSetObjectPermMask(int mask, int value)
+        {
+            m_LSL_Functions.llSetObjectPermMask(mask, value);
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask)
+        {
+            return m_LSL_Functions.llGetInventoryPermMask(item, mask);
+        }
+
+        public void llSetInventoryPermMask(string item, int mask, int value)
+        {
+            m_LSL_Functions.llSetInventoryPermMask(item, mask, value);
+        }
+
+        public string llGetInventoryCreator(string item)
+        {
+            return m_LSL_Functions.llGetInventoryCreator(item);
+        }
+
+        public void llOwnerSay(string msg)
+        {
+            m_LSL_Functions.llOwnerSay(msg);
+        }
+
+        public string llRequestSimulatorData(string simulator, int data)
+        {
+            return m_LSL_Functions.llRequestSimulatorData(simulator, data);
+        }
+
+        public void llForceMouselook(int mouselook)
+        {
+            m_LSL_Functions.llForceMouselook(mouselook);
+        }
+
+        public double llGetObjectMass(string id)
+        {
+            return m_LSL_Functions.llGetObjectMass(id);
+        }
+
+        public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end)
+        {
+            return m_LSL_Functions.llListReplaceList(dest, src, start, end);
+        }
+
+        public void llLoadURL(string avatar_id, string message, string url)
+        {
+            m_LSL_Functions.llLoadURL(avatar_id, message, url);
+        }
+
+        public void llParcelMediaCommandList(LSL_Types.list commandList)
+        {
+            m_LSL_Functions.llParcelMediaCommandList(commandList);
+        }
+
+        public void llParcelMediaQuery()
+        {
+            m_LSL_Functions.llParcelMediaQuery();
+        }
+
+        public LSL_Types.LSLInteger llModPow(int a, int b, int c)
+        {
+            return m_LSL_Functions.llModPow(a, b, c);
+        }
+
+        public LSL_Types.LSLInteger llGetInventoryType(string name)
+        {
+            return m_LSL_Functions.llGetInventoryType(name);
+        }
+
+        public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons)
+        {
+            m_LSL_Functions.llSetPayPrice(price, quick_pay_buttons);
+        }
+
+        public vector llGetCameraPos()
+        {
+            return m_LSL_Functions.llGetCameraPos();
+        }
+
+        public rotation llGetCameraRot()
+        {
+            return m_LSL_Functions.llGetCameraRot();
+        }
+
+        public void llSetPrimURL()
+        {
+            m_LSL_Functions.llSetPrimURL();
+        }
+
+        public void llRefreshPrimURL()
+        {
+            m_LSL_Functions.llRefreshPrimURL();
+        }
+
+        public string llEscapeURL(string url)
+        {
+            return m_LSL_Functions.llEscapeURL(url);
+        }
+
+        public string llUnescapeURL(string url)
+        {
+            return m_LSL_Functions.llUnescapeURL(url);
+        }
+
+        public void llMapDestination(string simname, vector pos, vector look_at)
+        {
+            m_LSL_Functions.llMapDestination(simname, pos, look_at);
+        }
+
+        public void llAddToLandBanList(string avatar, double hours)
+        {
+            m_LSL_Functions.llAddToLandBanList(avatar, hours);
+        }
+
+        public void llRemoveFromLandPassList(string avatar)
+        {
+            m_LSL_Functions.llRemoveFromLandPassList(avatar);
+        }
+
+        public void llRemoveFromLandBanList(string avatar)
+        {
+            m_LSL_Functions.llRemoveFromLandBanList(avatar);
+        }
+
+        public void llSetCameraParams(LSL_Types.list rules)
+        {
+            m_LSL_Functions.llSetCameraParams(rules);
+        }
+
+        public void llClearCameraParams()
+        {
+            m_LSL_Functions.llClearCameraParams();
+        }
+
+        public double llListStatistics(int operation, LSL_Types.list src)
+        {
+            return m_LSL_Functions.llListStatistics(operation, src);
+        }
+
+        public LSL_Types.LSLInteger llGetUnixTime()
+        {
+            return m_LSL_Functions.llGetUnixTime();
+        }
+
+        public LSL_Types.LSLInteger llGetParcelFlags(vector pos)
+        {
+            return m_LSL_Functions.llGetParcelFlags(pos);
+        }
+
+        public LSL_Types.LSLInteger llGetRegionFlags()
+        {
+            return m_LSL_Functions.llGetRegionFlags();
+        }
+
+        public string llXorBase64StringsCorrect(string str1, string str2)
+        {
+            return m_LSL_Functions.llXorBase64StringsCorrect(str1, str2);
+        }
+
+        public string llHTTPRequest(string url, LSL_Types.list parameters, string body)
+        {
+            return m_LSL_Functions.llHTTPRequest(url, parameters, body);
+        }
+
+        public void llResetLandBanList()
+        {
+            m_LSL_Functions.llResetLandBanList();
+        }
+
+        public void llResetLandPassList()
+        {
+            m_LSL_Functions.llResetLandPassList();
+        }
+
+        public LSL_Types.LSLInteger llGetParcelPrimCount(vector pos, int category, int sim_wide)
+        {
+            return m_LSL_Functions.llGetParcelPrimCount(pos, category, sim_wide);
+        }
+
+        public LSL_Types.list llGetParcelPrimOwners(vector pos)
+        {
+            return m_LSL_Functions.llGetParcelPrimOwners(pos);
+        }
+
+        public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id)
+        {
+            return m_LSL_Functions.llGetObjectPrimCount(object_id);
+        }
+
+        public LSL_Types.LSLInteger llGetParcelMaxPrims(vector pos, int sim_wide)
+        {
+            return m_LSL_Functions.llGetParcelMaxPrims(pos, sim_wide);
+        }
+
+        public LSL_Types.list llGetParcelDetails(vector pos, LSL_Types.list param)
+        {
+            return m_LSL_Functions.llGetParcelDetails(pos, param);
+        }
+
+        public void llSetLinkTexture(int linknumber, string texture, int face)
+        {
+            m_LSL_Functions.llSetLinkTexture(linknumber, texture, face);
+        }
+
+        public string llStringTrim(string src, int type)
+        {
+            return m_LSL_Functions.llStringTrim(src, type);
+        }
+
+        public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args)
+        {
+            return m_LSL_Functions.llGetObjectDetails(id, args);
+        }
+
+        public double llList2Float(LSL_Types.list src, int index)
+        {
+            return m_LSL_Functions.llList2Float(src, index);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
new file mode 100644
index 0000000..168804d
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared.Api.Interfaces;
+using integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
+using key = System.String;
+using vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
+using rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
+
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
+{
+    public partial class ScriptBaseClass : MarshalByRefObject
+    {
+        public IOSSL_Api m_OSSL_Functions;
+
+        public void ApiTypeOSSL(IScriptApi api)
+        {
+            if(!(api is IOSSL_Api))
+                return;
+
+            m_OSSL_Functions = (IOSSL_Api)api;
+        }
+
+        public void osSetRegionWaterHeight(double height)
+        {
+            m_OSSL_Functions.osSetRegionWaterHeight(height);
+        }
+
+        public double osList2Double(LSL_Types.list src, int index)
+        {
+            return m_OSSL_Functions.osList2Double(src, index);
+        }
+
+        public string osSetDynamicTextureURL(string dynamicID, string contentType, string url, string extraParams,
+                                             int timer)
+        {
+            return m_OSSL_Functions.osSetDynamicTextureURL(dynamicID, contentType, url, extraParams, timer);
+        }
+
+        public string osSetDynamicTextureData(string dynamicID, string contentType, string data, string extraParams,
+                                             int timer)
+        {
+            return m_OSSL_Functions.osSetDynamicTextureData(dynamicID, contentType, data, extraParams, timer);
+        }
+
+        public string osSetDynamicTextureURLBlend(string dynamicID, string contentType, string url, string extraParams,
+                                           int timer, int alpha)
+        {
+            return m_OSSL_Functions.osSetDynamicTextureURLBlend(dynamicID, contentType, url, extraParams, timer, alpha);
+        }
+
+        public string osSetDynamicTextureDataBlend(string dynamicID, string contentType, string data, string extraParams,
+                                             int timer, int alpha)
+        {
+            return m_OSSL_Functions.osSetDynamicTextureDataBlend(dynamicID, contentType, data, extraParams, timer, alpha);
+        }
+
+        public double osTerrainGetHeight(int x, int y)
+        {
+            return m_OSSL_Functions.osTerrainGetHeight(x, y);
+        }
+
+        public int osTerrainSetHeight(int x, int y, double val)
+        {
+            return m_OSSL_Functions.osTerrainSetHeight(x, y, val);
+        }
+
+        public int osRegionRestart(double seconds)
+        {
+            return m_OSSL_Functions.osRegionRestart(seconds);
+        }
+
+        public void osRegionNotice(string msg)
+        {
+            m_OSSL_Functions.osRegionNotice(msg);
+        }
+
+        public bool osConsoleCommand(string Command)
+        {
+            return m_OSSL_Functions.osConsoleCommand(Command);
+        }
+
+        public void osSetParcelMediaURL(string url)
+        {
+            m_OSSL_Functions.osSetParcelMediaURL(url);
+        }
+
+        public void osSetPrimFloatOnWater(int floatYN)
+        {
+            m_OSSL_Functions.osSetPrimFloatOnWater(floatYN);
+        }
+
+        // Animation Functions
+
+        public void osAvatarPlayAnimation(string avatar, string animation)
+        {
+            m_OSSL_Functions.osAvatarPlayAnimation(avatar, animation);
+        }
+
+        public void osAvatarStopAnimation(string avatar, string animation)
+        {
+            m_OSSL_Functions.osAvatarStopAnimation(avatar, animation);
+        }
+
+
+        //Texture Draw functions
+
+        public string osMovePen(string drawList, int x, int y)
+        {
+            return m_OSSL_Functions.osMovePen(drawList, x, y);
+        }
+
+        public string osDrawLine(string drawList, int startX, int startY, int endX, int endY)
+        {
+            return m_OSSL_Functions.osDrawLine(drawList, startX, startY, endX, endY);
+        }
+
+        public string osDrawLine(string drawList, int endX, int endY)
+        {
+            return m_OSSL_Functions.osDrawLine(drawList, endX, endY);
+        }
+
+        public string osDrawText(string drawList, string text)
+        {
+            return m_OSSL_Functions.osDrawText(drawList, text);
+        }
+
+        public string osDrawEllipse(string drawList, int width, int height)
+        {
+            return m_OSSL_Functions.osDrawEllipse(drawList, width, height);
+        }
+
+        public string osDrawRectangle(string drawList, int width, int height)
+        {
+            return m_OSSL_Functions.osDrawRectangle(drawList, width, height);
+        }
+
+        public string osDrawFilledRectangle(string drawList, int width, int height)
+        {
+            return m_OSSL_Functions.osDrawFilledRectangle(drawList, width, height);
+        }
+
+        public string osSetFontSize(string drawList, int fontSize)
+        {
+            return m_OSSL_Functions.osSetFontSize(drawList, fontSize);
+        }
+
+        public string osSetPenSize(string drawList, int penSize)
+        {
+            return m_OSSL_Functions.osSetPenSize(drawList, penSize);
+        }
+
+        public string osSetPenColour(string drawList, string colour)
+        {
+            return m_OSSL_Functions.osSetPenColour(drawList, colour);
+        }
+
+        public string osDrawImage(string drawList, int width, int height, string imageUrl)
+        {
+            return m_OSSL_Functions.osDrawImage(drawList, width, height, imageUrl);
+        }
+        public void osSetStateEvents(int events)
+        {
+            m_OSSL_Functions.osSetStateEvents(events);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj
new file mode 100644
index 0000000..870da9f
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj
@@ -0,0 +1,161 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">

+  <PropertyGroup>

+    <ProjectType>Local</ProjectType>

+    <ProductVersion>9.0.21022</ProductVersion>

+    <SchemaVersion>2.0</SchemaVersion>

+    <ProjectGuid>{21BC44EA-0000-0000-0000-000000000000}</ProjectGuid>

+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

+    <ApplicationIcon></ApplicationIcon>

+    <AssemblyKeyContainerName>

+    </AssemblyKeyContainerName>

+    <AssemblyName>OpenSim.Region.ScriptEngine.Shared.Api.Runtime</AssemblyName>

+    <DefaultClientScript>JScript</DefaultClientScript>

+    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>

+    <DefaultTargetSchema>IE50</DefaultTargetSchema>

+    <DelaySign>false</DelaySign>

+    <OutputType>Library</OutputType>

+    <AppDesignerFolder></AppDesignerFolder>

+    <RootNamespace>OpenSim.Region.ScriptEngine.Shared.Api.Runtime</RootNamespace>

+    <StartupObject></StartupObject>

+    <FileUpgradeFlags>

+    </FileUpgradeFlags>

+  </PropertyGroup>

+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

+    <AllowUnsafeBlocks>False</AllowUnsafeBlocks>

+    <BaseAddress>285212672</BaseAddress>

+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>

+    <ConfigurationOverrideFile>

+    </ConfigurationOverrideFile>

+    <DefineConstants>TRACE;DEBUG</DefineConstants>

+    <DocumentationFile></DocumentationFile>

+    <DebugSymbols>True</DebugSymbols>

+    <FileAlignment>4096</FileAlignment>

+    <Optimize>False</Optimize>

+    <OutputPath>..\..\..\..\..\..\bin\</OutputPath>

+    <RegisterForComInterop>False</RegisterForComInterop>

+    <RemoveIntegerChecks>False</RemoveIntegerChecks>

+    <TreatWarningsAsErrors>False</TreatWarningsAsErrors>

+    <WarningLevel>4</WarningLevel>

+    <NoWarn></NoWarn>

+  </PropertyGroup>

+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

+    <AllowUnsafeBlocks>False</AllowUnsafeBlocks>

+    <BaseAddress>285212672</BaseAddress>

+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>

+    <ConfigurationOverrideFile>

+    </ConfigurationOverrideFile>

+    <DefineConstants>TRACE</DefineConstants>

+    <DocumentationFile></DocumentationFile>

+    <DebugSymbols>False</DebugSymbols>

+    <FileAlignment>4096</FileAlignment>

+    <Optimize>True</Optimize>

+    <OutputPath>..\..\..\..\..\..\bin\</OutputPath>

+    <RegisterForComInterop>False</RegisterForComInterop>

+    <RemoveIntegerChecks>False</RemoveIntegerChecks>

+    <TreatWarningsAsErrors>False</TreatWarningsAsErrors>

+    <WarningLevel>4</WarningLevel>

+    <NoWarn></NoWarn>

+  </PropertyGroup>

+  <ItemGroup>

+    <Reference Include="Axiom.MathLib.dll" >

+      <HintPath>..\..\..\..\..\..\bin\Axiom.MathLib.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="libsecondlife.dll" >

+      <HintPath>..\..\..\..\..\..\bin\libsecondlife.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="log4net.dll" >

+      <HintPath>..\..\..\..\..\..\bin\log4net.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="Nini.dll" >

+      <HintPath>..\..\..\..\..\..\bin\Nini.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="Nini.dll" >

+      <HintPath>..\..\..\..\..\..\bin\Nini.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="RAIL.dll" >

+      <HintPath>..\..\..\..\..\..\bin\RAIL.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="System" >

+      <HintPath>System.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="System.Data" >

+      <HintPath>System.Data.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="System.Web" >

+      <HintPath>System.Web.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+    <Reference Include="System.Xml" >

+      <HintPath>System.Xml.dll</HintPath>

+      <Private>False</Private>

+    </Reference>

+  </ItemGroup>

+  <ItemGroup>

+    <ProjectReference Include="..\..\..\..\Application\OpenSim.csproj">

+      <Name>OpenSim</Name>

+      <Project>{438A9556-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+    <ProjectReference Include="..\..\..\..\..\Framework\OpenSim.Framework.csproj">

+      <Name>OpenSim.Framework</Name>

+      <Project>{8ACA2445-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+    <ProjectReference Include="..\..\..\..\..\Framework\Communications\OpenSim.Framework.Communications.csproj">

+      <Name>OpenSim.Framework.Communications</Name>

+      <Project>{CB52B7E7-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+    <ProjectReference Include="..\..\..\..\..\Framework\Console\OpenSim.Framework.Console.csproj">

+      <Name>OpenSim.Framework.Console</Name>

+      <Project>{A7CD0630-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+    <ProjectReference Include="..\..\..\..\Environment\OpenSim.Region.Environment.csproj">

+      <Name>OpenSim.Region.Environment</Name>

+      <Project>{DCBA491C-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+    <ProjectReference Include="..\..\OpenSim.Region.ScriptEngine.Shared.csproj">

+      <Name>OpenSim.Region.ScriptEngine.Shared</Name>

+      <Project>{D9F1B557-0000-0000-0000-000000000000}</Project>

+      <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>

+                        <Private>False</Private>

+    </ProjectReference>

+  </ItemGroup>

+  <ItemGroup>

+    <Compile Include="LSL_Constants.cs">

+      <SubType>Code</SubType>

+    </Compile>

+    <Compile Include="LSL_Stub.cs">

+      <SubType>Code</SubType>

+    </Compile>

+    <Compile Include="OSSL_Stub.cs">

+      <SubType>Code</SubType>

+    </Compile>

+    <Compile Include="ScriptBase.cs">

+      <SubType>Code</SubType>

+    </Compile>

+  </ItemGroup>

+  <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />

+  <PropertyGroup>

+    <PreBuildEvent>

+    </PreBuildEvent>

+    <PostBuildEvent>

+    </PostBuildEvent>

+  </PropertyGroup>

+</Project>

diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user
new file mode 100644
index 0000000..c28f556
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.csproj.user
@@ -0,0 +1,12 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <PropertyGroup>

+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

+    <ReferencePath>C:\Data\OpenSim\bin\</ReferencePath>

+    <LastOpenVersion>9.0.21022</LastOpenVersion>

+    <ProjectView>ProjectFiles</ProjectView>

+    <ProjectTrust>0</ProjectTrust>

+  </PropertyGroup>

+  <PropertyGroup Condition = " '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' " />

+  <PropertyGroup Condition = " '$(Configuration)|$(Platform)' == 'Release|AnyCPU' " />

+</Project>

diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build
new file mode 100644
index 0000000..c3af05c
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.dll.build
@@ -0,0 +1,62 @@
+<?xml version="1.0" ?>

+<project name="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" default="build">

+    <target name="build">

+        <echo message="Build Directory is ${project::get-base-directory()}/${build.dir}" />

+        <mkdir dir="${project::get-base-directory()}/${build.dir}" />

+        <copy todir="${project::get-base-directory()}/${build.dir}" flatten="true">

+            <fileset basedir="${project::get-base-directory()}">

+            </fileset>

+        </copy>

+        <copy todir="${project::get-base-directory()}/${build.dir}">

+            <fileset basedir=".">

+            </fileset>

+        </copy>

+        <csc target="library" debug="${build.debug}" unsafe="False" warnaserror="False" define="TRACE;DEBUG" main="" output="${project::get-base-directory()}/${build.dir}/${project::get-name()}.dll">

+            <resources prefix="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" dynamicprefix="true" >

+            </resources>

+            <sources failonempty="true">

+                <include name="LSL_Constants.cs" />

+                <include name="LSL_Stub.cs" />

+                <include name="OSSL_Stub.cs" />

+                <include name="ScriptBase.cs" />

+            </sources>

+            <references basedir="${project::get-base-directory()}">

+                <lib>

+                    <include name="${project::get-base-directory()}" />

+                    <include name="${project::get-base-directory()}/${build.dir}" />

+                </lib>

+                <include name="../../../../../../bin/Axiom.MathLib.dll" />

+                <include name="../../../../../../bin/libsecondlife.dll" />

+                <include name="../../../../../../bin/log4net.dll" />

+                <include name="../../../../../../bin/Nini.dll" />

+                <include name="../../../../../../bin/Nini.dll" />

+                <include name="../../../../../../bin/OpenSim.exe" />

+                <include name="../../../../../../bin/OpenSim.Framework.dll" />

+                <include name="../../../../../../bin/OpenSim.Framework.Communications.dll" />

+                <include name="../../../../../../bin/OpenSim.Framework.Console.dll" />

+                <include name="../../../../../../bin/OpenSim.Region.Environment.dll" />

+                <include name="../../../../../../bin/OpenSim.Region.ScriptEngine.Shared.dll" />

+                <include name="../../../../../../bin/RAIL.dll" />

+                <include name="System.dll" />

+                <include name="System.Data.dll" />

+                <include name="System.Web.dll" />

+                <include name="System.Xml.dll" />

+            </references>

+        </csc>

+        <echo message="Copying from [${project::get-base-directory()}/${build.dir}/] to [${project::get-base-directory()}/../../../../../../bin/" />

+        <mkdir dir="${project::get-base-directory()}/../../../../../../bin/"/>

+        <copy todir="${project::get-base-directory()}/../../../../../../bin/">

+            <fileset basedir="${project::get-base-directory()}/${build.dir}/" >

+                <include name="*.dll"/>

+                <include name="*.exe"/>

+                <include name="*.mdb"/>

+            </fileset>

+        </copy>

+    </target>

+    <target name="clean">

+        <delete dir="${obj.dir}" failonerror="false" />

+        <delete dir="${bin.dir}" failonerror="false" />

+    </target>

+    <target name="doc" description="Creates documentation.">

+    </target>

+</project>

diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp
new file mode 100644
index 0000000..37bedfc
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OpenSim.Region.ScriptEngine.Shared.Api.Runtime.mdp
@@ -0,0 +1,43 @@
+<Project name="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" description="" standardNamespace="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" newfilesearch="None" enableviewstate="True" fileversion="2.0" language="C#" clr-version="Net_2_0" ctype="DotNetProject">
+  <Configurations active="Debug">
+    <Configuration name="Debug" ctype="DotNetProjectConfiguration">
+      <Output directory="./../../../../../../bin/" assembly="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" executeScript="" executeBeforeBuild="" executeAfterBuild="" executeBeforeBuildArguments="" executeAfterBuildArguments="" />
+      <Build debugmode="True" target="Library" />
+      <Execution runwithwarnings="True" consolepause="True" runtime="MsNet" clr-version="Net_2_0" />
+      <CodeGeneration compiler="Csc" warninglevel="4" nowarn="" includedebuginformation="True" optimize="False" unsafecodeallowed="False" generateoverflowchecks="False" mainclass="" target="Library" definesymbols="TRACE;DEBUG" generatexmldocumentation="False" win32Icon="" ctype="CSharpCompilerParameters" />
+    </Configuration>
+    <Configuration name="Release" ctype="DotNetProjectConfiguration">
+      <Output directory="./../../../../../../bin/" assembly="OpenSim.Region.ScriptEngine.Shared.Api.Runtime" executeScript="" executeBeforeBuild="" executeAfterBuild="" executeBeforeBuildArguments="" executeAfterBuildArguments="" />
+      <Build debugmode="True" target="Library" />
+      <Execution runwithwarnings="True" consolepause="True" runtime="MsNet" clr-version="Net_2_0" />
+      <CodeGeneration compiler="Csc" warninglevel="4" nowarn="" includedebuginformation="False" optimize="True" unsafecodeallowed="False" generateoverflowchecks="False" mainclass="" target="Library" definesymbols="TRACE" generatexmldocumentation="False" win32Icon="" ctype="CSharpCompilerParameters" />
+    </Configuration>
+  </Configurations>
+  <DeploymentInformation target="" script="" strategy="File">
+    <excludeFiles />
+  </DeploymentInformation>
+  <Contents>
+    <File name="./LSL_Constants.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./LSL_Stub.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./OSSL_Stub.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./ScriptBase.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+  </Contents>
+  <References>
+    <ProjectReference type="Assembly" refto="../../../../../../bin/Axiom.MathLib.dll" localcopy="False" />
+    <ProjectReference type="Assembly" refto="../../../../../../bin/libsecondlife.dll" localcopy="False" />
+    <ProjectReference type="Assembly" refto="../../../../../../bin/log4net.dll" localcopy="False" />
+    <ProjectReference type="Assembly" refto="../../../../../../bin/Nini.dll" localcopy="False" />
+    <ProjectReference type="Assembly" refto="../../../../../../bin/Nini.dll" localcopy="False" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim.Framework" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim.Framework.Communications" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim.Framework.Console" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim.Region.Environment" />
+    <ProjectReference type="Project" localcopy="False" refto="OpenSim.Region.ScriptEngine.Shared" />
+    <ProjectReference type="Assembly" refto="../../../../../../bin/RAIL.dll" localcopy="False" />
+    <ProjectReference type="Gac" localcopy="False" refto="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+    <ProjectReference type="Gac" localcopy="False" refto="System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+    <ProjectReference type="Gac" localcopy="False" refto="System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <ProjectReference type="Gac" localcopy="False" refto="System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  </References>
+</Project>
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
new file mode 100644
index 0000000..aa2c9c2
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/ScriptBase.cs
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenSim.Region.ScriptEngine.Shared;
+
+namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
+{
+    public partial class ScriptBaseClass : MarshalByRefObject, IScript
+    {
+        private Dictionary<string,MethodInfo> inits = new Dictionary<string,MethodInfo>();
+
+        public ScriptBaseClass()
+        {
+            MethodInfo[] myArrayMethodInfo = GetType().GetMethods(BindingFlags.Public|BindingFlags.Instance);
+
+            foreach(MethodInfo mi in myArrayMethodInfo)
+            {
+                if(mi.Name.Length > 7 && mi.Name.Substring(0, 7) == "ApiType")
+                {
+                    string type=mi.Name.Substring(7);
+                    inits[type]=mi;
+                }
+            }
+        }
+
+        public string[] GetApis()
+        {
+            string[] apis = new string[inits.Count];
+            inits.Keys.CopyTo(apis, 0);
+            return apis;
+        }
+
+        public void InitApi(string api, IScriptApi data)
+        {
+            if(!inits.ContainsKey(api))
+                return;
+
+            MethodInfo mi = inits[api];
+            
+            Object[] args = new Object[1];
+            args[0] = data;
+
+            mi.Invoke(this, args);
+        }
+
+        private Dictionary<string, object> m_InitialValues =
+                new Dictionary<string, object>();
+        private Dictionary<string, FieldInfo> m_Fields =
+                new Dictionary<string, FieldInfo>();
+
+        public Dictionary<string, object> GetVars()
+        {
+            Dictionary<string, object> vars = new Dictionary<string, object>();
+
+            if (m_Fields == null)
+                return vars;
+
+            m_Fields.Clear();
+
+            Type t = GetType();
+
+            FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic |
+                                             BindingFlags.Public |
+                                             BindingFlags.Instance |
+                                             BindingFlags.DeclaredOnly);
+
+            foreach (FieldInfo field in fields)
+            {
+                m_Fields[field.Name]=field;
+
+                vars[field.Name]=field.GetValue(this);
+            }
+
+            return vars;
+        }
+
+        public void SetVars(Dictionary<string, object> vars)
+        {
+            foreach (KeyValuePair<string, object> var in vars)
+            {
+                if (m_Fields.ContainsKey(var.Key))
+                {
+                    m_Fields[var.Key].SetValue(this, var.Value);
+                }
+            }
+        }
+
+        public void ResetVars()
+        {
+            SetVars(m_InitialValues);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs
new file mode 100644
index 0000000..27ab04e
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Atom : IUnifiable
+    {
+        private static Dictionary<string, Atom> _atomStore = new Dictionary<string, Atom>();
+        public readonly string _name;
+        public readonly Atom _module;
+
+        /// <summary>
+        /// You should not call this constructor, but use Atom.a instead.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="module"></param>
+        private Atom(string name, Atom module)
+        {
+            _name = name;
+            _module = module;
+        }
+
+        /// <summary>
+        /// Return the unique Atom object for name where module is null. You should use this to create
+        /// an Atom instead of calling the Atom constructor.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static Atom a(string name)
+        {
+            Atom atom;
+            if (!_atomStore.TryGetValue(name, out atom))
+            {
+                atom = new Atom(name, null);
+                _atomStore[name] = atom;
+            }
+            return atom;
+        }
+
+        /// <summary>
+        /// Return an Atom object with the name and module.  If module is null or Atom.NIL,
+        /// this behaves like Atom.a(name) and returns the unique object where the module is null.
+        /// If module is not null or Atom.NIL, this may or may not be the same object as another Atom
+        /// with the same name and module.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="module"></param>
+        /// <returns></returns>
+        public static Atom a(string name, Atom module)
+        {
+            if (module == null || module == Atom.NIL)
+                return a(name);
+            return new Atom(name, module);
+        }
+
+        /// <summary>
+        /// If Obj is an Atom unify its _module with Module.  If the Atom's _module is null, use Atom.NIL.
+        /// </summary>
+        /// <param name="Atom"></param>
+        /// <param name="Module"></param>
+        /// <returns></returns>
+        public static IEnumerable<bool> module(object Obj, object Module)
+        {
+            Obj = YP.getValue(Obj);
+            if (Obj is Atom)
+            {
+                if (((Atom)Obj)._module == null)
+                    return YP.unify(Module, Atom.NIL);
+                else
+                    return YP.unify(Module, ((Atom)Obj)._module);
+            }
+            return YP.fail();
+        }
+
+        public static readonly Atom NIL = Atom.a("[]");
+        public static readonly Atom DOT = Atom.a(".");
+        public static readonly Atom F = Atom.a("f");
+        public static readonly Atom SLASH = Atom.a("/");
+        public static readonly Atom HAT = Atom.a("^");
+        public static readonly Atom RULE = Atom.a(":-");
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            arg = YP.getValue(arg);
+            if (arg is Atom)
+                return Equals(arg) ? YP.succeed() : YP.fail();
+            else if (arg is Variable)
+                return ((Variable)arg).unify(this);
+            else
+                return YP.fail();
+        }
+
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            // Atom does not contain variables.
+        }
+
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            // Atom does not contain variables that need to be copied.
+            return this;
+        }
+
+        public bool termEqual(object term)
+        {
+            return Equals(YP.getValue(term));
+        }
+
+        public bool ground()
+        {
+            // Atom is always ground.
+            return true;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is Atom)
+            {
+                if (_module == null && ((Atom)obj)._module == null)
+                    // When _declaringClass is null, we always use an identical object from _atomStore.
+                    return this == obj;
+                // Otherwise, ignore _declaringClass and do a normal string compare on the _name.
+                return _name == ((Atom)obj)._name;
+            }
+            return false;
+        }
+
+        public override string ToString()
+        {
+            return _name;
+        }
+
+        public override int GetHashCode()
+        {
+            // Debug: need to check _declaringClass.
+            return _name.GetHashCode();
+        }
+
+        public string toQuotedString()
+        {
+            if (_name.Length == 0)
+                return "''";
+            else if (this == Atom.NIL)
+                return "[]";
+
+            StringBuilder result = new StringBuilder(_name.Length);
+            bool useQuotes = false;
+            foreach (char c in _name)
+            {
+                int cInt = (int)c;
+                if (c == '\'')
+                {
+                    result.Append("''");
+                    useQuotes = true;
+                }
+                else if (c == '_' || cInt >= (int)'a' && cInt <= (int)'z' ||
+                         cInt >= (int)'A' && cInt <= (int)'Z' || cInt >= (int)'0' && cInt <= (int)'9')
+                    result.Append(c);
+                else
+                {
+                    // Debug: Need to handle non-printable chars.
+                    result.Append(c);
+                    useQuotes = true;
+                }
+            }
+
+            if (!useQuotes && (int)_name[0] >= (int)'a' && (int)_name[0] <= (int)'z')
+                return result.ToString();
+            else
+            {
+                // Surround in single quotes.
+                result.Append('\'');
+                return "'" + result;
+            }
+        }
+
+        /// <summary>
+        /// Return true if _name is lexicographically less than atom._name.
+        /// </summary>
+        /// <param name="atom"></param>
+        /// <returns></returns>
+        public bool lessThan(Atom atom)
+        {
+            return _name.CompareTo(atom._name) < 0;
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs
new file mode 100644
index 0000000..70c1b5a
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// A BagofAnswers holds answers for bagof and setof.
+    /// </summary>
+    public class BagofAnswers
+    {
+        private object _template;
+        private Variable[] _freeVariables;
+        private Dictionary<object[], List<object>> _bagForFreeVariables;
+        private List<object> _findallBagArray;
+        private static TermArrayEqualityComparer _termArrayEqualityComparer =
+            new TermArrayEqualityComparer();
+
+        /// <summary>
+        /// To get the free variables, split off any existential qualifiers from Goal such as the X in
+        /// "X ^ f(Y)", get the set of unbound variables in Goal that are not qualifiers, then remove
+        /// the unbound variables that are qualifiers as well as the unbound variables in Template.
+        /// </summary>
+        /// <param name="Template"></param>
+        /// <param name="Goal"></param>
+        public BagofAnswers(object Template, object Goal)
+        {
+            _template = Template;
+
+            // First get the set of variables that are not free variables.
+            List<Variable> variableSet = new List<Variable>();
+            YP.addUniqueVariables(Template, variableSet);
+            object UnqualifiedGoal = YP.getValue(Goal);
+            while (UnqualifiedGoal is Functor2 && ((Functor2)UnqualifiedGoal)._name == Atom.HAT)
+            {
+                YP.addUniqueVariables(((Functor2)UnqualifiedGoal)._arg1, variableSet);
+                UnqualifiedGoal = YP.getValue(((Functor2)UnqualifiedGoal)._arg2);
+            }
+
+            // Remember how many non-free variables there are so we can find the unique free variables
+            //   that are added.
+            int nNonFreeVariables = variableSet.Count;
+            YP.addUniqueVariables(UnqualifiedGoal, variableSet);
+            int nFreeVariables = variableSet.Count - nNonFreeVariables;
+            if (nFreeVariables == 0)
+            {
+                // There were no free variables added, so we won't waste time with _bagForFreeVariables.
+                _freeVariables = null;
+                _findallBagArray = new List<object>();
+            }
+            else
+            {
+                // Copy the free variables.
+                _freeVariables = new Variable[nFreeVariables];
+                for (int i = 0; i < nFreeVariables; ++i)
+                    _freeVariables[i] = variableSet[i + nNonFreeVariables];
+
+                _bagForFreeVariables = new Dictionary<object[], List<object>>(_termArrayEqualityComparer);
+            }
+        }
+
+        public void add()
+        {
+            if (_freeVariables == null)
+                // The goal has bound the values in _template but we don't bother with _freeVariables.
+                _findallBagArray.Add(YP.makeCopy(_template, new Variable.CopyStore()));
+            else
+            {
+                // The goal has bound the values in _template and _freeVariables.
+                // Find the entry for this set of _freeVariables values.
+                object[] freeVariableValues = new object[_freeVariables.Length];
+                for (int i = 0; i < _freeVariables.Length; ++i)
+                    freeVariableValues[i] = YP.getValue(_freeVariables[i]);
+                List<object> bagArray;
+                if (!_bagForFreeVariables.TryGetValue(freeVariableValues, out bagArray))
+                {
+                    bagArray = new List<object>();
+                    _bagForFreeVariables[freeVariableValues] = bagArray;
+                }
+
+                // Now copy the template and add to the bag for the freeVariables values.
+                bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore()));
+            }
+        }
+
+        /// <summary>
+        /// For each result, unify the _freeVariables and unify bagArrayVariable with the associated bag.
+        /// </summary>
+        /// <param name="bagArrayVariable">this is unified with the List<object> of matches for template that
+        /// corresponds to the bindings for freeVariables.  Be very careful: this does not unify with a Prolog
+        /// list.</param>
+        /// <returns></returns>
+        public IEnumerable<bool> resultArray(Variable bagArrayVariable)
+        {
+            if (_freeVariables == null)
+            {
+                // No unbound free variables, so we only filled one bag.  If empty, bagof fails.
+                if (_findallBagArray.Count > 0)
+                {
+                    foreach (bool l1 in bagArrayVariable.unify(_findallBagArray))
+                        yield return false;
+                }
+            }
+            else
+            {
+                foreach (KeyValuePair<object[], List<object>> valuesAndBag in _bagForFreeVariables)
+                {
+                    foreach (bool l1 in YP.unifyArrays(_freeVariables, valuesAndBag.Key))
+                    {
+                        foreach (bool l2 in bagArrayVariable.unify(valuesAndBag.Value))
+                            yield return false;
+                    }
+                    // Debug: Should we free memory of the answers already returned?
+                }
+            }
+        }
+
+        /// <summary>
+        /// For each result, unify the _freeVariables and unify Bag with the associated bag.
+        /// </summary>
+        /// <param name="Bag"></param>
+        /// <returns></returns>
+        public IEnumerable<bool> result(object Bag)
+        {
+            Variable bagArrayVariable = new Variable();
+            foreach (bool l1 in resultArray(bagArrayVariable))
+            {
+                foreach (bool l2 in YP.unify(Bag, ListPair.make((List<object>)bagArrayVariable.getValue())))
+                    yield return false;
+            }
+        }
+
+        /// <summary>
+        /// For each result, unify the _freeVariables and unify Bag with the associated bag which is sorted
+        /// with duplicates removed, as in setof.
+        /// </summary>
+        /// <param name="Bag"></param>
+        /// <returns></returns>
+        public IEnumerable<bool> resultSet(object Bag)
+        {
+            Variable bagArrayVariable = new Variable();
+            foreach (bool l1 in resultArray(bagArrayVariable))
+            {
+                List<object> bagArray = (List<object>)bagArrayVariable.getValue();
+                YP.sortArray(bagArray);
+                foreach (bool l2 in YP.unify(Bag, ListPair.makeWithoutRepeatedTerms(bagArray)))
+                    yield return false;
+            }
+        }
+
+        public static IEnumerable<bool> bagofArray
+            (object Template, object Goal, IEnumerable<bool> goalIterator, Variable bagArrayVariable)
+        {
+            BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal);
+            foreach (bool l1 in goalIterator)
+                bagOfAnswers.add();
+            return bagOfAnswers.resultArray(bagArrayVariable);
+        }
+
+        public static IEnumerable<bool> bagof
+            (object Template, object Goal, IEnumerable<bool> goalIterator, object Bag)
+        {
+            BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal);
+            foreach (bool l1 in goalIterator)
+                bagOfAnswers.add();
+            return bagOfAnswers.result(Bag);
+        }
+
+        public static IEnumerable<bool> setof
+            (object Template, object Goal, IEnumerable<bool> goalIterator, object Bag)
+        {
+            BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal);
+            foreach (bool l1 in goalIterator)
+                bagOfAnswers.add();
+            return bagOfAnswers.resultSet(Bag);
+        }
+
+        /// <summary>
+        /// A TermArrayEqualityComparer implements IEqualityComparer to compare two object arrays using YP.termEqual.
+        /// </summary>
+        private class TermArrayEqualityComparer : IEqualityComparer<object[]>
+        {
+            public bool Equals(object[] array1, object[] array2)
+            {
+                if (array1.Length != array2.Length)
+                    return false;
+                for (int i = 0; i < array1.Length; ++i)
+                {
+                    if (!YP.termEqual(array1[i], array2[i]))
+                        return false;
+                }
+                return true;
+            }
+
+            public int GetHashCode(object[] array)
+            {
+                int hashCode = 0;
+                for (int i = 0; i < array.Length; ++i)
+                    hashCode ^= array[i].GetHashCode();
+                return hashCode;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs
new file mode 100644
index 0000000..28709e1
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// A FindallAnswers holds answers for findall.
+    /// </summary>
+    public class FindallAnswers
+    {
+        private object _template;
+        private List<object> _bagArray;
+
+        public FindallAnswers(object Template)
+        {
+            _template = Template;
+            _bagArray = new List<object>();
+        }
+
+        public void add()
+        {
+            _bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore()));
+        }
+
+        public List<object> resultArray()
+        {
+            return _bagArray;
+        }
+
+        /// <summary>
+        /// Unify Bag with the result. This frees the internal answers, so you can only call this once.
+        /// </summary>
+        /// <param name="Bag"></param>
+        /// <returns></returns>
+        public IEnumerable<bool> result(object Bag)
+        {
+            object result = ListPair.make(_bagArray);
+            // Try to free the memory.
+            _bagArray = null;
+            return YP.unify(Bag, result);
+        }
+
+        /// <summary>
+        /// This is a simplified findall when the goal is a single call.
+        /// </summary>
+        /// <param name="Template"></param>
+        /// <param name="goal"></param>
+        /// <param name="Bag"></param>
+        /// <returns></returns>
+        public static IEnumerable<bool> findall(object Template, IEnumerable<bool> goal, object Bag)
+        {
+            FindallAnswers findallAnswers = new FindallAnswers(Template);
+            foreach (bool l1 in goal)
+                findallAnswers.add();
+            return findallAnswers.result(Bag);
+        }
+
+        /// <summary>
+        /// Like findall, except return an array of the results.
+        /// </summary>
+        /// <param name="template"></param>
+        /// <param name="goal"></param>
+        /// <returns></returns>
+        public static List<object> findallArray(object Template, IEnumerable<bool> goal)
+        {
+            FindallAnswers findallAnswers = new FindallAnswers(Template);
+            foreach (bool l1 in goal)
+                findallAnswers.add();
+            return findallAnswers.resultArray();
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs
new file mode 100644
index 0000000..8ef8de0
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Functor : IUnifiable
+    {
+        public readonly Atom _name;
+        public readonly object[] _args;
+
+        public Functor(Atom name, object[] args)
+        {
+            if (args.Length <= 3)
+            {
+                if (args.Length == 0)
+                    throw new Exception("For arity 0 functor, just use name as an Atom");
+                else if (args.Length == 1)
+                    throw new Exception("For arity 1 functor, use Functor1");
+                else if (args.Length == 2)
+                    throw new Exception("For arity 2 functor, use Functor2");
+                else if (args.Length == 3)
+                    throw new Exception("For arity 3 functor, use Functor3");
+                else
+                    // (This shouldn't happen, but include it for completeness.
+                    throw new Exception("Cannot create a Functor of arity " + args.Length);
+            }
+
+            _name = name;
+            _args = args;
+        }
+
+        public Functor(string name, object[] args)
+            : this(Atom.a(name), args)
+        {
+        }
+
+        /// <summary>
+        /// Return an Atom, Functor1, Functor2, Functor3 or Functor depending on the
+        /// length of args.
+        /// Note that this is different than the Functor constructor which requires
+        /// the length of args to be greater than 3.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        public static object make(Atom name, object[] args)
+        {
+            if (args.Length <= 0)
+                return name;
+            else if (args.Length == 1)
+                return new Functor1(name, args[0]);
+            else if (args.Length == 2)
+                return new Functor2(name, args[0], args[1]);
+            else if (args.Length == 3)
+                return new Functor3(name, args[0], args[1], args[2]);
+            else
+                return new Functor(name, args);
+        }
+
+        /// <summary>
+        /// Call the main make, first converting name to an Atom.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        public static object make(string name, object[] args)
+        {
+            return make(Atom.a(name), args);
+        }
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            arg = YP.getValue(arg);
+            if (arg is Functor)
+            {
+                Functor argFunctor = (Functor)arg;
+                if (_name.Equals(argFunctor._name))
+                    return YP.unifyArrays(_args, argFunctor._args);
+                else
+                    return YP.fail();
+            }
+            else if (arg is Variable)
+                return ((Variable)arg).unify(this);
+            else
+                return YP.fail();
+        }
+
+        public override string ToString()
+        {
+            string result = _name + "(" + YP.getValue(_args[0]);
+            for (int i = 1; i < _args.Length; ++i)
+                result += ", " + YP.getValue(_args[i]);
+            result += ")";
+            return result;
+        }
+
+        public bool termEqual(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor)
+            {
+                Functor termFunctor = (Functor)term;
+                if (_name.Equals(termFunctor._name) && _args.Length == termFunctor._args.Length)
+                {
+                    for (int i = 0; i < _args.Length; ++i)
+                    {
+                        if (!YP.termEqual(_args[i], termFunctor._args[i]))
+                            return false;
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public bool lessThan(Functor functor)
+        {
+            // Do the equal check first since it is faster.
+            if (!_name.Equals(functor._name))
+                return _name.lessThan(functor._name);
+
+            if (_args.Length != functor._args.Length)
+                return _args.Length < functor._args.Length;
+
+            for (int i = 0; i < _args.Length; ++i)
+            {
+                if (!YP.termEqual(_args[i], functor._args[i]))
+                    return YP.termLessThan(_args[i], functor._args[i]);
+            }
+
+            return false;
+        }
+
+        public bool ground()
+        {
+            for (int i = 0; i < _args.Length; ++i)
+            {
+                if (!YP.ground(_args[i]))
+                    return false;
+            }
+            return true;
+        }
+
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            for (int i = 0; i < _args.Length; ++i)
+                YP.addUniqueVariables(_args[i], variableSet);
+        }
+
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            object[] argsCopy = new object[_args.Length];
+            for (int i = 0; i < _args.Length; ++i)
+                argsCopy[i] = YP.makeCopy(_args[i], copyStore);
+            return new Functor(_name, argsCopy);
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs
new file mode 100644
index 0000000..3c0c1c4
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Functor1 : IUnifiable
+    {
+        public readonly Atom _name;
+        public readonly object _arg1;
+
+        public Functor1(Atom name, object arg1)
+        {
+            _name = name;
+            _arg1 = arg1;
+        }
+
+        public Functor1(string name, object arg1)
+            : this(Atom.a(name), arg1)
+        {
+        }
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            arg = YP.getValue(arg);
+            if (arg is Functor1)
+            {
+                Functor1 argFunctor = (Functor1)arg;
+                if (_name.Equals(argFunctor._name))
+                {
+                    foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1))
+                        yield return false;
+                }
+            }
+            else if (arg is Variable)
+            {
+                foreach (bool l1 in ((Variable)arg).unify(this))
+                    yield return false;
+            }
+        }
+
+        public override string ToString()
+        {
+            return _name + "(" + YP.getValue(_arg1) + ")";
+        }
+
+        public bool termEqual(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor1)
+            {
+                Functor1 termFunctor = (Functor1)term;
+                return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1);
+            }
+            return false;
+        }
+
+        public bool lessThan(Functor1 functor)
+        {
+            // Do the equal check first since it is faster.
+            if (!_name.Equals(functor._name))
+                return _name.lessThan(functor._name);
+
+            return YP.termLessThan(_arg1, functor._arg1);
+        }
+
+        public bool ground()
+        {
+            return YP.ground(_arg1);
+        }
+
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            YP.addUniqueVariables(_arg1, variableSet);
+        }
+
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            return new Functor1(_name, YP.makeCopy(_arg1, copyStore));
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs
new file mode 100644
index 0000000..596b763
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Functor2 : IUnifiable
+    {
+        public readonly Atom _name;
+        public readonly object _arg1;
+        public readonly object _arg2;
+
+        public Functor2(Atom name, object arg1, object arg2)
+        {
+            _name = name;
+            _arg1 = arg1;
+            _arg2 = arg2;
+        }
+
+        public Functor2(string name, object arg1, object arg2)
+            : this(Atom.a(name), arg1, arg2)
+        {
+        }
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            arg = YP.getValue(arg);
+            if (arg is Functor2)
+            {
+                Functor2 argFunctor = (Functor2)arg;
+                if (_name.Equals(argFunctor._name))
+                {
+                    foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1))
+                    {
+                        foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2))
+                            yield return false;
+                    }
+                }
+            }
+            else if (arg is Variable)
+            {
+                foreach (bool l1 in ((Variable)arg).unify(this))
+                    yield return false;
+            }
+        }
+
+        public override string ToString()
+        {
+            if (_name == Atom.DOT)
+                return listPairToString(this);
+            else
+                return _name + "(" + YP.getValue(_arg1) + ", " +  YP.getValue(_arg2) + ")";
+        }
+
+        public bool termEqual(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor2)
+            {
+                Functor2 termFunctor = (Functor2)term;
+                return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1)
+                     && YP.termEqual(_arg2, termFunctor._arg2);
+            }
+            return false;
+        }
+
+        public bool lessThan(Functor2 functor)
+        {
+            // Do the equal check first since it is faster.
+            if (!_name.Equals(functor._name))
+                return _name.lessThan(functor._name);
+
+            if (!YP.termEqual(_arg1, functor._arg1))
+                return YP.termLessThan(_arg1, functor._arg1);
+
+            return YP.termLessThan(_arg2, functor._arg2);
+        }
+
+        public bool ground()
+        {
+            return YP.ground(_arg1) && YP.ground(_arg2);
+        }
+
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            YP.addUniqueVariables(_arg1, variableSet);
+            YP.addUniqueVariables(_arg2, variableSet);
+        }
+
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            return new Functor2(_name, YP.makeCopy(_arg1, copyStore),
+                YP.makeCopy(_arg2, copyStore));
+        }
+
+        private static string listPairToString(Functor2 listPair)
+        {
+            string result = "[";
+            while (true)
+            {
+                object head = YP.getValue(listPair._arg1);
+                object tail = YP.getValue(listPair._arg2);
+                if (tail == (object)Atom.NIL)
+                {
+                    result += head;
+                    break;
+                }
+                else if (tail is Functor2 && ((Functor2)tail)._name == Atom.DOT)
+                {
+                    result += head + ", ";
+                    listPair = (Functor2)tail;
+                    // Loop again.
+                }
+                else
+                {
+                    // The list is not terminated with NIL.
+                    result += head + "|" + tail;
+                    break;
+                }
+            }
+            result += "]";
+            return result;
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs
new file mode 100644
index 0000000..041cceb
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Functor3 : IUnifiable
+    {
+        public readonly Atom _name;
+        public readonly object _arg1;
+        public readonly object _arg2;
+        public readonly object _arg3;
+
+        public Functor3(Atom name, object arg1, object arg2, object arg3)
+        {
+            _name = name;
+            _arg1 = arg1;
+            _arg2 = arg2;
+            _arg3 = arg3;
+        }
+
+        public Functor3(string name, object arg1, object arg2, object arg3)
+            : this(Atom.a(name), arg1, arg2, arg3)
+        {
+        }
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            arg = YP.getValue(arg);
+            if (arg is Functor3)
+            {
+                Functor3 argFunctor = (Functor3)arg;
+                if (_name.Equals(argFunctor._name))
+                {
+                    foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1))
+                    {
+                        foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2))
+                        {
+                            foreach (bool l3 in YP.unify(_arg3, argFunctor._arg3))
+                                yield return false;
+                        }
+                    }
+                }
+            }
+            else if (arg is Variable)
+            {
+                foreach (bool l1 in ((Variable)arg).unify(this))
+                    yield return false;
+            }
+        }
+
+        public override string ToString()
+        {
+            return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ", " +
+                YP.getValue(_arg3) + ")";
+        }
+
+        public bool termEqual(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor3)
+            {
+                Functor3 termFunctor = (Functor3)term;
+                return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1)
+                     && YP.termEqual(_arg2, termFunctor._arg2)
+                     && YP.termEqual(_arg3, termFunctor._arg3);
+            }
+            return false;
+        }
+
+        public bool lessThan(Functor3 functor)
+        {
+            // Do the equal check first since it is faster.
+            if (!_name.Equals(functor._name))
+                return _name.lessThan(functor._name);
+
+            if (!YP.termEqual(_arg1, functor._arg1))
+                return YP.termLessThan(_arg1, functor._arg1);
+
+            if (!YP.termEqual(_arg2, functor._arg2))
+                return YP.termLessThan(_arg2, functor._arg2);
+
+            return YP.termLessThan(_arg3, functor._arg3);
+        }
+
+        public bool ground()
+        {
+            return YP.ground(_arg1) && YP.ground(_arg2) && YP.ground(_arg3);
+        }
+
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            YP.addUniqueVariables(_arg1, variableSet);
+            YP.addUniqueVariables(_arg2, variableSet);
+            YP.addUniqueVariables(_arg3, variableSet);
+        }
+
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            return new Functor3(_name, YP.makeCopy(_arg1, copyStore),
+                YP.makeCopy(_arg2, copyStore), YP.makeCopy(_arg3, copyStore));
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs
new file mode 100644
index 0000000..1be73f7
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// An IndexedAnswers holds answers to a query based on the values of index arguments.
+    /// </summary>
+    public class IndexedAnswers : YP.IClause
+    {
+        // addAnswer adds the answer here and indexes it later.
+        private List<object[]> _allAnswers = new List<object[]>();
+        // The key has the arity of answers with non-null values for each indexed arg.  The value
+        //   is a list of the matching answers.  The signature is implicit in the pattern on non-null index args.
+        private Dictionary<HashedList, List<object[]>> _indexedAnswers =
+            new Dictionary<HashedList, List<object[]>>();
+        // Keeps track of whether we have started adding entries to _indexedAnswers for the signature.
+        private Dictionary<int, object> _gotAnswersForSignature = new Dictionary<int, object>();
+        private const int MAX_INDEX_ARGS = 31;
+
+        public IndexedAnswers()
+        {
+        }
+
+        /// <summary>
+        /// Elements of answer must be ground, since arguments with unbound variables make this
+        /// into a dynamic rule which we don't index.
+        /// </summary>
+        /// <param name="answer"></param>
+        public void addAnswer(object[] answer)
+        {
+            // Store a copy of the answer array.
+            object[] answerCopy = new object[answer.Length];
+            Variable.CopyStore copyStore = new Variable.CopyStore();
+            for (int i = 0; i < answer.Length; ++i)
+                answerCopy[i] = YP.makeCopy(answer[i], copyStore);
+            if (copyStore.getNUniqueVariables() > 0)
+                throw new InvalidOperationException
+                    ("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() +
+                     " unbound variables");
+            _allAnswers.Add(answerCopy);
+
+            // If match has already indexed answers for a signature, we need to add
+            //   this to the existing indexed answers.
+            foreach (int signature in _gotAnswersForSignature.Keys)
+                indexAnswerForSignature(answerCopy, signature);
+        }
+
+        private void indexAnswerForSignature(object[] answer, int signature)
+        {
+            // First find out which of the answer values can be used as an index.
+            object[] indexValues = new object[answer.Length];
+            for (int i = 0; i < answer.Length; ++i)
+            {
+                // We limit the number of indexed args in a 32-bit signature.
+                if (i >= MAX_INDEX_ARGS)
+                    indexValues[i] = null;
+                else
+                    indexValues[i] = getIndexValue(YP.getValue(answer[i]));
+            }
+
+            // We need an entry in indexArgs from indexValues for each 1 bit in signature.
+            HashedList indexArgs = new HashedList(indexValues.Length);
+            for (int i = 0; i < indexValues.Length; ++i)
+            {
+                if ((signature & (1 << i)) == 0)
+                    indexArgs.Add(null);
+                else
+                {
+                    if (indexValues[i] == null)
+                        // The signature wants an index value here, but we don't have one so
+                        //   we can't add it as an answer for this signature.
+                        return;
+                    else
+                        indexArgs.Add(indexValues[i]);
+                }
+            }
+
+            // Add the answer to the answers list for indexArgs, creating the entry if needed.
+            List<object[]> answers;
+            if (!_indexedAnswers.TryGetValue(indexArgs, out answers))
+            {
+                answers = new List<object[]>();
+                _indexedAnswers[indexArgs] = answers;
+            }
+            answers.Add(answer);
+        }
+
+        public IEnumerable<bool> match(object[] arguments)
+        {
+            // Set up indexArgs, up to arg position MAX_INDEX_ARGS.  The signature has a 1 bit for
+            //   each non-null index arg.
+            HashedList indexArgs = new HashedList(arguments.Length);
+            bool gotAllIndexArgs = true;
+            int signature = 0;
+            for (int i = 0; i < arguments.Length; ++i)
+            {
+                object indexValue = null;
+                if (i < MAX_INDEX_ARGS)
+                {
+                    // We limit the number of args in a 32-bit signature.
+                    indexValue = getIndexValue(YP.getValue(arguments[i]));
+                    if (indexValue != null)
+                        signature += (1 << i);
+                }
+                if (indexValue == null)
+                    gotAllIndexArgs = false;
+                indexArgs.Add(indexValue);
+            }
+
+            List<object[]> answers;
+            if (signature == 0)
+                // No index args, so we have to match from _allAnswers.
+                answers = _allAnswers;
+            else
+            {
+                if (!_gotAnswersForSignature.ContainsKey(signature))
+                {
+                    // We need to create the entry in _indexedAnswers.
+                    foreach (object[] answer in _allAnswers)
+                        indexAnswerForSignature(answer, signature);
+                    // Mark that we did this signature.
+                    _gotAnswersForSignature[signature] = null;
+                }
+                if (!_indexedAnswers.TryGetValue(indexArgs, out answers))
+                    yield break;
+            }
+
+            if (gotAllIndexArgs)
+            {
+                // All the arguments were already bound, so we don't need to do bindings.
+                yield return false;
+                yield break;
+            }
+
+            // Find matches in answers.
+            IEnumerator<bool>[] iterators = new IEnumerator<bool>[arguments.Length];
+            foreach (object[] answer in answers)
+            {
+                bool gotMatch = true;
+                int nIterators = 0;
+                // Try to bind all the arguments.
+                for (int i = 0; i < arguments.Length; ++i)
+                {
+                    if (indexArgs[i] != null)
+                        // We already matched this argument by looking up _indexedAnswers.
+                        continue;
+
+                    IEnumerator<bool> iterator = YP.unify(arguments[i], answer[i]).GetEnumerator();
+                    iterators[nIterators++] = iterator;
+                    // MoveNext() is true if YP.unify succeeds.
+                    if (!iterator.MoveNext())
+                    {
+                        gotMatch = false;
+                        break;
+                    }
+                }
+
+                try
+                {
+                    if (gotMatch)
+                        yield return false;
+                }
+                finally
+                {
+                    // Manually finalize all the iterators.
+                    for (int i = 0; i < nIterators; ++i)
+                        iterators[i].Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// A HashedList extends an ArrayList with methods to get a hash and to check equality
+        /// based on the elements of the list.
+        /// </summary>
+        public class HashedList : ArrayList
+        {
+            private bool _gotHashCode = false;
+            private int _hashCode;
+
+            public HashedList()
+                : base()
+            {
+            }
+
+            public HashedList(int capacity)
+                : base(capacity)
+            {
+            }
+
+            public HashedList(ICollection c)
+                : base(c)
+            {
+            }
+
+            // Debug: Should override all the other methods that change this.
+            public override int Add(object value)
+            {
+                _gotHashCode = false;
+                return base.Add(value);
+            }
+
+            public override int GetHashCode()
+            {
+                if (!_gotHashCode)
+                {
+                    int hashCode = 1;
+                    foreach (object obj in this)
+                        hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode());
+                    _hashCode = hashCode;
+                    _gotHashCode = true;
+                }
+                return _hashCode;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is ArrayList))
+                    return false;
+
+                ArrayList objList = (ArrayList)obj;
+                if (objList.Count != Count)
+                    return false;
+
+                for (int i = 0; i < Count; ++i)
+                {
+                    object value = objList[i];
+                    if (value == null)
+                    {
+                        if (this[i] != null)
+                            return false;
+                    }
+                    else
+                    {
+                        if (!value.Equals(this[i]))
+                            return false;
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// If we keep an index on value, return the value, or null if we don't index it.
+        /// </summary>
+        /// <param name="value">the term to examine.  Assume you already called YP.getValue(value)</param>
+        /// <returns></returns>
+        public static object getIndexValue(object value)
+        {
+            if (value is Atom || value is string || value is Int32 || value is DateTime)
+                return value;
+            else
+                return null;
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs
new file mode 100644
index 0000000..83ace2d
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class ListPair : Functor2
+    {
+        public ListPair(object head, object tail) : base(Atom.DOT, head, tail)
+        {
+        }
+
+        public static object make(List<object> list)
+        {
+            if (list.Count <= 0)
+                return Atom.NIL;
+
+            object result = Atom.NIL;
+            // Start from the end.
+            for (int i = list.Count - 1; i >= 0; --i)
+                result = new ListPair(list[i], result);
+            return result;
+        }
+
+        public static object make(object[] array)
+        {
+            if (array.Length <= 0)
+                return Atom.NIL;
+
+            object result = Atom.NIL;
+            // Start from the end.
+            for (int i = array.Length - 1; i >= 0; --i)
+                result = new ListPair(array[i], result);
+            return result;
+        }
+
+        /// <summary>
+        /// Return a ListPair version of array, where repeated elements
+        /// (according to YP.termEqual) are removed.
+        /// </summary>
+        /// <param name="array"></param>
+        /// <returns></returns>
+        public static object makeWithoutRepeatedTerms(object[] array)
+        {
+            if (array.Length <= 0)
+                return Atom.NIL;
+
+            // Start from the end.
+            object previousTerm = array[array.Length - 1];
+            object result = new ListPair(previousTerm, Atom.NIL);
+            for (int i = array.Length - 2; i >= 0; --i)
+            {
+                object term = array[i];
+                if (YP.termEqual(term, previousTerm))
+                    continue;
+                result = new ListPair(term, result);
+                previousTerm = term;
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Return a ListPair version of array, where repeated elements
+        /// (according to YP.termEqual) are removed.
+        /// </summary>
+        /// <param name="array"></param>
+        /// <returns></returns>
+        public static object makeWithoutRepeatedTerms(List<object> array)
+        {
+            if (array.Count <= 0)
+                return Atom.NIL;
+
+            // Start from the end.
+            object previousTerm = array[array.Count - 1];
+            object result = new ListPair(previousTerm, Atom.NIL);
+            for (int i = array.Count - 2; i >= 0; --i)
+            {
+                object term = array[i];
+                if (YP.termEqual(term, previousTerm))
+                    continue;
+                result = new ListPair(term, result);
+                previousTerm = term;
+            }
+            return result;
+        }
+
+        public static object make(object element1)
+        {
+            return new ListPair(element1, Atom.NIL);
+        }
+
+        public static object make(object element1, object element2)
+        {
+            return new ListPair(element1, new ListPair(element2, Atom.NIL));
+        }
+
+        public static object make(object element1, object element2, object element3)
+        {
+            return new ListPair(element1,
+                new ListPair(element2, new ListPair(element3, Atom.NIL)));
+        }
+
+        /// <summary>
+        /// Return an array of the elements in list or null if it is not
+        /// a proper list.  If list is Atom.NIL, return an array of zero elements.
+        /// This does not call YP.getValue on each element.
+        /// </summary>
+        /// <param name="list"></param>
+        /// <returns></returns>
+        public static object[] toArray(object list)
+        {
+            list = YP.getValue(list);
+            if (list.Equals(Atom.NIL))
+                return new object[0];
+
+            List<object> result = new List<object>();
+            for (object element = list;
+                 element is Functor2 && ((Functor2)element)._name == Atom.DOT;
+                 element = YP.getValue(((Functor2)element)._arg2))
+                result.Add(((Functor2)element)._arg1);
+
+            if (result.Count <= 0)
+                return null;
+            return result.ToArray();
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs
new file mode 100644
index 0000000..105b556
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs
@@ -0,0 +1,4457 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class Parser
+    {
+        public static IEnumerable<bool> formatError(object Output, object Format, object Arguments)
+        {
+            // Debug: Simple implementation for now.
+            YP.write(Format);
+            YP.write(Arguments);
+            YP.nl();
+            yield return false;
+        }
+
+        // Debug: Hand-modify this central predicate to do tail recursion.
+        public static IEnumerable<bool> read_tokens(object arg1, object arg2, object arg3)
+        {
+            bool repeat = true;
+            while (repeat)
+            {
+                repeat = false;
+                {
+                    object C1 = arg1;
+                    object Dict = arg2;
+                    object Tokens = arg3;
+                    Variable C2 = new Variable();
+                    if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL)))
+                    {
+                        if (YP.greaterThanOrEqual(C1, 0))
+                        {
+                            foreach (bool l4 in YP.get_code(C2))
+                            {
+#if false
+                                foreach (bool l5 in read_tokens(C2, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+#endif
+                                arg1 = YP.getValue(C2);
+                                arg2 = YP.getValue(Dict);
+                                arg3 = YP.getValue(Tokens);
+                                repeat = true;
+                            }
+                        }
+                        goto cutIf1;
+                    }
+                    if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL)))
+                        {
+                            foreach (bool l4 in read_identifier(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf2;
+                        }
+                    }
+                    if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL)))
+                        {
+                            foreach (bool l4 in read_variable(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf3;
+                        }
+                    }
+                    if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL)))
+                        {
+                            foreach (bool l4 in read_number(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf4;
+                        }
+                    }
+                    if (YP.lessThan(C1, 127))
+                    {
+                        foreach (bool l3 in read_special(C1, Dict, Tokens))
+                        {
+                            yield return false;
+                        }
+                        goto cutIf5;
+                    }
+                    if (YP.lessThanOrEqual(C1, 160))
+                    {
+                        foreach (bool l3 in YP.get_code(C2))
+                        {
+#if false
+                            foreach (bool l4 in read_tokens(C2, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+#endif
+                            arg1 = YP.getValue(C2);
+                            arg2 = YP.getValue(Dict);
+                            arg3 = YP.getValue(Tokens);
+                            repeat = true;
+                        }
+                        goto cutIf6;
+                    }
+                    if (YP.greaterThanOrEqual(C1, 223))
+                    {
+                        if (YP.notEqual(C1, 247))
+                        {
+                            foreach (bool l4 in read_identifier(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf7;
+                        }
+                    }
+                    if (YP.greaterThanOrEqual(C1, 192))
+                    {
+                        if (YP.notEqual(C1, 215))
+                        {
+                            foreach (bool l4 in read_variable(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf8;
+                        }
+                    }
+                    if (YP.notEqual(C1, 170))
+                    {
+                        if (YP.notEqual(C1, 186))
+                        {
+                            foreach (bool l4 in read_symbol(C1, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf9;
+                        }
+                    }
+                    foreach (bool l2 in read_identifier(C1, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                cutIf9:
+                cutIf8:
+                cutIf7:
+                cutIf6:
+                cutIf5:
+                cutIf4:
+                cutIf3:
+                cutIf2:
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        // Compiler output follows.
+
+        class YPInnerClass { }
+        static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }
+
+        public static IEnumerable<bool> parseInput(object TermList)
+        {
+            {
+                Variable TermAndVariables = new Variable();
+                FindallAnswers findallAnswers1 = new FindallAnswers(TermAndVariables);
+                foreach (bool l2 in parseInputHelper(TermAndVariables))
+                {
+                    findallAnswers1.add();
+                }
+                foreach (bool l2 in findallAnswers1.result(TermList))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> parseInputHelper(object arg1)
+        {
+            {
+                Variable Term = new Variable();
+                Variable Variables = new Variable();
+                Variable Answer = new Variable();
+                Variable x4 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"f", Term, Variables)))
+                {
+                    foreach (bool l3 in YP.repeat())
+                    {
+                        foreach (bool l4 in portable_read3(Answer, Variables, x4))
+                        {
+                            foreach (bool l5 in remove_pos(Answer, Term))
+                            {
+                                if (YP.termEqual(Term, Atom.a(@"end_of_file")))
+                                {
+                                    yield break;
+                                    goto cutIf1;
+                                }
+                                yield return false;
+                            cutIf1:
+                                { }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> clear_errors()
+        {
+            {
+                yield return false;
+            }
+        }
+
+        public static IEnumerable<bool> remove_pos(object arg1, object arg2)
+        {
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, X))
+                {
+                    foreach (bool l3 in YP.unify(arg2, X))
+                    {
+                        if (YP.var(X))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object X = arg2;
+                Variable _Pos = new Variable();
+                Variable _Name = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"$VAR", _Pos, _Name, X)))
+                {
+                    if (YP.var(X))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable H = new Variable();
+                Variable T = new Variable();
+                Variable NH = new Variable();
+                Variable NT = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(H, T)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(NH, NT)))
+                    {
+                        foreach (bool l4 in remove_pos(H, NH))
+                        {
+                            foreach (bool l5 in remove_pos(T, NT))
+                            {
+                                yield return false;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable NA = new Variable();
+                Variable NB = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new Functor2(@",", NA, NB)))
+                    {
+                        foreach (bool l4 in remove_pos(A, NA))
+                        {
+                            foreach (bool l5 in remove_pos(B, NB))
+                            {
+                                yield return false;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable Atom_1 = new Variable();
+                Variable _F = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom_1))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom_1))
+                    {
+                        foreach (bool l4 in YP.functor(Atom_1, _F, 0))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                object Term = arg1;
+                object NewTerm = arg2;
+                Variable Func = new Variable();
+                Variable _Pos = new Variable();
+                Variable Args = new Variable();
+                Variable NArgs = new Variable();
+                if (YP.nonvar(Term))
+                {
+                    foreach (bool l3 in YP.univ(Term, new ListPair(Func, new ListPair(_Pos, Args))))
+                    {
+                        foreach (bool l4 in remove_pos(Args, NArgs))
+                        {
+                            foreach (bool l5 in YP.univ(NewTerm, new ListPair(Func, NArgs)))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> portable_read_position(object Term, object PosTerm, object Syntax)
+        {
+            {
+                foreach (bool l2 in portable_read(PosTerm, Syntax))
+                {
+                    foreach (bool l3 in remove_pos(PosTerm, Term))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> portable_read(object Answer, object Syntax)
+        {
+            {
+                Variable Tokens = new Variable();
+                Variable ParseTokens = new Variable();
+                foreach (bool l2 in read_tokens1(Tokens))
+                {
+                    foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax))
+                    {
+                        foreach (bool l4 in parse2(ParseTokens, Answer))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> portable_read3(object Answer, object Variables, object Syntax)
+        {
+            {
+                Variable Tokens = new Variable();
+                Variable ParseTokens = new Variable();
+                foreach (bool l2 in read_tokens2(Tokens, Variables))
+                {
+                    foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax))
+                    {
+                        foreach (bool l4 in parse2(ParseTokens, Answer))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> remove_comments(object arg1, object arg2, object arg3)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.NIL))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                object Ys = arg2;
+                Variable S = new Variable();
+                Variable E = new Variable();
+                Variable Xs = new Variable();
+                Variable Zs = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"comment", S, E), Xs)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", S, E), Zs)))
+                    {
+                        foreach (bool l4 in remove_comments(Xs, Ys, Zs))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Xs = new Variable();
+                Variable Ys = new Variable();
+                Variable Pos2 = new Variable();
+                Variable Zs = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Xs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"["), Ys)))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs)))
+                        {
+                            foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1)))
+                            {
+                                foreach (bool l6 in remove_comments(Xs, Ys, Zs))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Xs = new Variable();
+                Variable Ys = new Variable();
+                Variable Pos2 = new Variable();
+                Variable Zs = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Xs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), Ys)))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs)))
+                        {
+                            foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1)))
+                            {
+                                foreach (bool l6 in remove_comments(Xs, Ys, Zs))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Zs = arg3;
+                Variable Token = new Variable();
+                Variable Xs = new Variable();
+                Variable Ys = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Xs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Token, Ys)))
+                    {
+                        foreach (bool l4 in remove_comments(Xs, Ys, Zs))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> expect(object Token, object arg2, object arg3)
+        {
+            {
+                object Rest = arg3;
+                foreach (bool l2 in YP.unify(arg2, new ListPair(Token, Rest)))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+            {
+                object S0 = arg2;
+                object x3 = arg3;
+                foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"or"), new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), Atom.NIL)))), S0))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> parse2(object Tokens, object Answer)
+        {
+            {
+                Variable Term = new Variable();
+                Variable LeftOver = new Variable();
+                foreach (bool l2 in clear_errors())
+                {
+                    foreach (bool l3 in parse(Tokens, 1200, Term, LeftOver))
+                    {
+                        foreach (bool l4 in all_read(LeftOver))
+                        {
+                            foreach (bool l5 in YP.unify(Answer, Term))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                    }
+                    foreach (bool l3 in syntax_error(Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> all_read(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    yield return false;
+                }
+            }
+            {
+                Variable Token = new Variable();
+                Variable S = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S)))
+                {
+                    foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"after"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(Token, S)))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> parse(object arg1, object arg2, object arg3, object arg4)
+        {
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"expression"), new ListPair(Atom.a(@"expected"), Atom.NIL)), Atom.NIL))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Precedence = arg2;
+                object Term = arg3;
+                object LeftOver = arg4;
+                Variable Token = new Variable();
+                Variable RestTokens = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, RestTokens)))
+                {
+                    foreach (bool l3 in parse5(Token, RestTokens, Precedence, Term, LeftOver))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> parse5(object arg1, object arg2, object arg3, object arg4, object arg5)
+        {
+            {
+                object S0 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"}")))
+                {
+                    foreach (bool l3 in cannot_start(Atom.a(@"}"), S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"]")))
+                {
+                    foreach (bool l3 in cannot_start(Atom.a(@"]"), S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@")")))
+                {
+                    foreach (bool l3 in cannot_start(Atom.a(@")"), S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    foreach (bool l3 in cannot_start(Atom.a(@","), S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    foreach (bool l3 in cannot_start(Atom.a(@"|"), S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Chars = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", Chars)))
+                {
+                    foreach (bool l3 in exprtl0(S0, Chars, Precedence, Answer, S))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Number = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", Number)))
+                {
+                    foreach (bool l3 in exprtl0(S0, Number, Precedence, Answer, S))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), S1)))
+                    {
+                        foreach (bool l4 in read_atom(new Functor2(@"/", Atom.NIL, 0), S1, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S1 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Arg1 = new Variable();
+                Variable S2 = new Variable();
+                Variable RestArgs = new Variable();
+                Variable S3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in parse(S1, 999, Arg1, S2))
+                    {
+                        foreach (bool l4 in read_list(S2, RestArgs, S3))
+                        {
+                            foreach (bool l5 in exprtl0(S3, new ListPair(Arg1, RestArgs), Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object S1 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Term = new Variable();
+                Variable S2 = new Variable();
+                Variable S3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"(")))
+                {
+                    foreach (bool l3 in parse(S1, 1200, Term, S2))
+                    {
+                        foreach (bool l4 in expect(Atom.a(@")"), S2, S3))
+                        {
+                            foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object S1 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Term = new Variable();
+                Variable S2 = new Variable();
+                Variable S3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@" (")))
+                {
+                    foreach (bool l3 in parse(S1, 1200, Term, S2))
+                    {
+                        foreach (bool l4 in expect(Atom.a(@")"), S2, S3))
+                        {
+                            foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable _Pos = new Variable();
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), _Pos)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"}"), S1)))
+                    {
+                        foreach (bool l4 in read_atom(Atom.a(@"{}"), S1, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S1 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Pos = new Variable();
+                Variable Term = new Variable();
+                Variable S2 = new Variable();
+                Variable S3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), Pos)))
+                {
+                    foreach (bool l3 in parse(S1, 1200, Term, S2))
+                    {
+                        foreach (bool l4 in expect(Atom.a(@"}"), S2, S3))
+                        {
+                            foreach (bool l5 in exprtl0(S3, new Functor2(@"{}", Pos, Term), Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Variable_1 = new Variable();
+                Variable Name = new Variable();
+                Variable Pos = new Variable();
+                Variable S1 = new Variable();
+                Variable Arg1 = new Variable();
+                Variable S2 = new Variable();
+                Variable RestArgs = new Variable();
+                Variable S3 = new Variable();
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1)))
+                    {
+                        foreach (bool l4 in parse(S1, 999, Arg1, S2))
+                        {
+                            foreach (bool l5 in read_args(S2, RestArgs, S3))
+                            {
+                                foreach (bool l6 in YP.univ(Term, new ListPair(Atom.a(@"call"), new ListPair(new Functor3(@"$VAR", Pos, Name, Variable_1), new ListPair(Arg1, RestArgs)))))
+                                {
+                                    foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                                yield break;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Variable_1 = new Variable();
+                Variable Name = new Variable();
+                Variable Pos = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos)))
+                {
+                    foreach (bool l3 in exprtl0(S0, new Functor3(@"$VAR", Pos, Name, Variable_1), Precedence, Answer, S))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Atom_1 = new Variable();
+                Variable P = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", Atom_1, P)))
+                {
+                    foreach (bool l3 in read_atom(new Functor2(@"/", Atom_1, P), S0, Precedence, Answer, S))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_atom(object arg1, object arg2, object Precedence, object Answer, object S)
+        {
+            {
+                Variable _Pos = new Variable();
+                Variable Number = new Variable();
+                Variable S1 = new Variable();
+                Variable Negative = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"-"), _Pos)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"number", Number), S1)))
+                    {
+                        foreach (bool l4 in YP.unify(Negative, YP.negate(Number)))
+                        {
+                            foreach (bool l5 in exprtl0(S1, Negative, Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable Functor_1 = new Variable();
+                Variable Pos = new Variable();
+                Variable S1 = new Variable();
+                Variable Arg1 = new Variable();
+                Variable S2 = new Variable();
+                Variable RestArgs = new Variable();
+                Variable S3 = new Variable();
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Functor_1, Pos)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1)))
+                    {
+                        foreach (bool l4 in parse(S1, 999, Arg1, S2))
+                        {
+                            foreach (bool l5 in read_args(S2, RestArgs, S3))
+                            {
+                                foreach (bool l6 in YP.univ(Term, new ListPair(Functor_1, new ListPair(Pos, new ListPair(Arg1, RestArgs)))))
+                                {
+                                    foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                                yield break;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                Variable Op = new Variable();
+                Variable Pos = new Variable();
+                Variable Oprec = new Variable();
+                Variable Aprec = new Variable();
+                Variable Flag = new Variable();
+                Variable Term = new Variable();
+                Variable Arg = new Variable();
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Op, Pos)))
+                {
+                    foreach (bool l3 in prefixop(Op, Oprec, Aprec))
+                    {
+                        foreach (bool l4 in possible_right_operand(S0, Flag))
+                        {
+                            if (YP.lessThan(Flag, 0))
+                            {
+                                foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, Atom.NIL))))
+                                {
+                                    foreach (bool l7 in exprtl0(S0, Term, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                                goto cutIf1;
+                            }
+                            if (YP.greaterThan(Oprec, Precedence))
+                            {
+                                foreach (bool l6 in syntax_error(new ListPair(Atom.a(@"prefix"), new ListPair(Atom.a(@"operator"), new ListPair(Op, new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"context"), new ListPair(Atom.a(@"with"), new ListPair(Atom.a(@"precedence"), new ListPair(Precedence, Atom.NIL)))))))), S0))
+                                {
+                                    yield return false;
+                                }
+                                goto cutIf2;
+                            }
+                            if (YP.greaterThan(Flag, 0))
+                            {
+                                foreach (bool l6 in parse(S0, Aprec, Arg, S1))
+                                {
+                                    foreach (bool l7 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL)))))
+                                    {
+                                        foreach (bool l8 in exprtl(S1, Oprec, Term, Precedence, Answer, S))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    yield break;
+                                }
+                                goto cutIf3;
+                            }
+                            foreach (bool l5 in peepop(S0, S1))
+                            {
+                                foreach (bool l6 in prefix_is_atom(S1, Oprec))
+                                {
+                                    foreach (bool l7 in exprtl(S1, Oprec, new Functor2(@"/", Op, Pos), Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            }
+                            foreach (bool l5 in parse(S0, Aprec, Arg, S1))
+                            {
+                                foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL)))))
+                                {
+                                    foreach (bool l7 in exprtl(S1, Oprec, Term, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                                yield break;
+                            }
+                        cutIf3:
+                        cutIf2:
+                        cutIf1:
+                            { }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S0 = arg2;
+                Variable Atom_1 = new Variable();
+                Variable Pos = new Variable();
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom_1, Pos)))
+                {
+                    foreach (bool l3 in YP.univ(Term, new ListPair(Atom_1, new ListPair(Pos, Atom.NIL))))
+                    {
+                        foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> cannot_start(object Token, object S0)
+        {
+            {
+                foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"cannot"), new ListPair(Atom.a(@"start"), new ListPair(Atom.a(@"an"), new ListPair(Atom.a(@"expression"), Atom.NIL))))), S0))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_args(object arg1, object arg2, object arg3)
+        {
+            {
+                object S = arg3;
+                Variable S1 = new Variable();
+                Variable Term = new Variable();
+                Variable Rest = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@","), S1)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(Term, Rest)))
+                    {
+                        foreach (bool l4 in parse(S1, 999, Term, S2))
+                        {
+                            foreach (bool l5 in read_args(S2, Rest, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S = arg3;
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@")"), S)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S = arg1;
+                object x2 = arg2;
+                object x3 = arg3;
+                foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", or )"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"arguments"), Atom.NIL)))), S))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_list(object arg1, object arg2, object arg3)
+        {
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), Atom.NIL))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Rest = arg2;
+                object S = arg3;
+                Variable Token = new Variable();
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1)))
+                {
+                    foreach (bool l3 in read_list4(Token, S1, Rest, S))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_list4(object arg1, object arg2, object arg3, object arg4)
+        {
+            {
+                object S1 = arg2;
+                object S = arg4;
+                Variable Term = new Variable();
+                Variable Rest = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Term, Rest)))
+                    {
+                        foreach (bool l4 in parse(S1, 999, Term, S2))
+                        {
+                            foreach (bool l5 in read_list(S2, Rest, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object S1 = arg2;
+                object Rest = arg3;
+                object S = arg4;
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    foreach (bool l3 in parse(S1, 999, Rest, S2))
+                    {
+                        foreach (bool l4 in expect(Atom.a(@"]"), S2, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                    yield break;
+                }
+            }
+            {
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"]")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, S1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.NIL))
+                        {
+                            foreach (bool l5 in YP.unify(arg4, S1))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Token = arg1;
+                object S1 = arg2;
+                object x3 = arg3;
+                object x4 = arg4;
+                foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), new ListPair(Token, S1)))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> possible_right_operand(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Flag = arg2;
+                Variable H = new Variable();
+                Variable T = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(H, T)))
+                {
+                    foreach (bool l3 in possible_right_operand3(H, Flag, T))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> possible_right_operand3(object arg1, object arg2, object arg3)
+        {
+            {
+                object x4 = arg3;
+                Variable x1 = new Variable();
+                Variable x2 = new Variable();
+                Variable x3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", x1, x2, x3)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x2 = arg3;
+                Variable x1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", x1)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x2 = arg3;
+                Variable x1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", x1)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@" (")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"(")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@")")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"]"), x1)))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"]")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"{")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"}"), x1)))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"{")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"}")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x3 = arg3;
+                Variable x1 = new Variable();
+                Variable x2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", x1, x2)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> peepop(object arg1, object arg2)
+        {
+            {
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1))))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1))))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable S1 = new Variable();
+                Variable L = new Variable();
+                Variable P = new Variable();
+                Variable R = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, P, R }), S1)))
+                    {
+                        foreach (bool l4 in infixop(F, L, P, R))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable S1 = new Variable();
+                Variable L = new Variable();
+                Variable P = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, P), S1)))
+                    {
+                        foreach (bool l4 in postfixop(F, L, P))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                Variable S0 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, S0))
+                {
+                    foreach (bool l3 in YP.unify(arg2, S0))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> prefix_is_atom(object arg1, object arg2)
+        {
+            {
+                object Precedence = arg2;
+                Variable Token = new Variable();
+                Variable x2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, x2)))
+                {
+                    foreach (bool l3 in prefix_is_atom(Token, Precedence))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object P = arg2;
+                Variable x1 = new Variable();
+                Variable L = new Variable();
+                Variable x3 = new Variable();
+                Variable x4 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { x1, L, x3, x4 })))
+                {
+                    if (YP.greaterThanOrEqual(L, P))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object P = arg2;
+                Variable x1 = new Variable();
+                Variable L = new Variable();
+                Variable x3 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), x1, L, x3)))
+                {
+                    if (YP.greaterThanOrEqual(L, P))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@")")))
+                {
+                    yield return false;
+                }
+            }
+            {
+                object x1 = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"]")))
+                {
+                    yield return false;
+                }
+            }
+            {
+                object x1 = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"}")))
+                {
+                    yield return false;
+                }
+            }
+            {
+                object P = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    if (YP.greaterThanOrEqual(1100, P))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object P = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    if (YP.greaterThanOrEqual(1000, P))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> exprtl0(object arg1, object arg2, object arg3, object arg4, object arg5)
+        {
+            {
+                object x2 = arg3;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, Term))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, Atom.NIL))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable Token = new Variable();
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1)))
+                {
+                    foreach (bool l3 in exprtl0_6(Token, Term, Precedence, Answer, S, S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> exprtl0_6(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6)
+        {
+            {
+                object x2 = arg3;
+                object S1 = arg6;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"}")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, Term))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"}"), S1)))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object x2 = arg3;
+                object S1 = arg6;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"]")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, Term))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"]"), S1)))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object x2 = arg3;
+                object S1 = arg6;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@")")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, Term))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@")"), S1)))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                object S1 = arg6;
+                Variable Next = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, 1000))
+                    {
+                        foreach (bool l4 in parse(S1, 1000, Next, S2))
+                        {
+                            foreach (bool l5 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in YP.unify(Answer, Term))
+                    {
+                        foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@","), S1)))
+                        {
+                            yield return false;
+                        }
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                object S1 = arg6;
+                Variable Next = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, 1100))
+                    {
+                        foreach (bool l4 in parse(S1, 1100, Next, S2))
+                        {
+                            foreach (bool l5 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                        goto cutIf2;
+                    }
+                    foreach (bool l3 in YP.unify(Answer, Term))
+                    {
+                        foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@"|"), S1)))
+                        {
+                            yield return false;
+                        }
+                    }
+                cutIf2:
+                    { }
+                }
+            }
+            {
+                object x2 = arg2;
+                object x3 = arg3;
+                object x4 = arg4;
+                object x5 = arg5;
+                object S1 = arg6;
+                Variable S = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", S)))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"chars"), new Functor1(@"string", S), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x2 = arg2;
+                object x3 = arg3;
+                object x4 = arg4;
+                object x5 = arg5;
+                object S1 = arg6;
+                Variable N = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", N)))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"number"), new Functor1(@"number", N), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"{")))
+                {
+                    foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"}"), S1)))
+                    {
+                        foreach (bool l4 in exprtl0_atom(Atom.a(@"{}"), Term, Precedence, Answer, S, S1))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                object S1 = arg6;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"{")))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"brace"), Atom.a(@"{"), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable S1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"]"), S1)))
+                    {
+                        foreach (bool l4 in exprtl0_atom(Atom.NIL, Term, Precedence, Answer, S, S1))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                object S1 = arg6;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"[")))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"bracket"), Atom.a(@"["), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                object S1 = arg6;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"(")))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                object x4 = arg5;
+                object S1 = arg6;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@" (")))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object x4 = arg2;
+                object x5 = arg3;
+                object x6 = arg4;
+                object x7 = arg5;
+                object S1 = arg6;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable P = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", A, B, P)))
+                {
+                    foreach (bool l3 in cannot_follow(Atom.a(@"variable"), new Functor3(@"var", A, B, P), S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                object S1 = arg6;
+                Variable F = new Variable();
+                Variable P = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", F, P)))
+                {
+                    foreach (bool l3 in exprtl0_atom(new Functor2(@"/", F, P), Term, Precedence, Answer, S, S1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> exprtl0_atom(object arg1, object arg2, object arg3, object arg4, object arg5, object S1)
+        {
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable L1 = new Variable();
+                Variable O1 = new Variable();
+                Variable R1 = new Variable();
+                Variable L2 = new Variable();
+                Variable O2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos)))
+                {
+                    foreach (bool l3 in ambigop(F, Precedence, L1, O1, R1, L2, O2))
+                    {
+                        foreach (bool l4 in prefix_is_atom(S1, Precedence))
+                        {
+                            foreach (bool l5 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S))
+                            {
+                                yield return false;
+                            }
+                            yield break;
+                        }
+                        foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable L1 = new Variable();
+                Variable O1 = new Variable();
+                Variable R1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos)))
+                {
+                    foreach (bool l3 in infixop(F, L1, O1, R1))
+                    {
+                        foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Term = arg2;
+                object Precedence = arg3;
+                object Answer = arg4;
+                object S = arg5;
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable L2 = new Variable();
+                Variable O2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos)))
+                {
+                    foreach (bool l3 in postfixop(F, L2, O2))
+                    {
+                        foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object X = arg1;
+                object x2 = arg2;
+                object x3 = arg3;
+                object x4 = arg4;
+                object x5 = arg5;
+                Variable x7 = new Variable();
+                foreach (bool l2 in syntax_error(new ListPair(new Functor2(@"-", Atom.a(@"non"), Atom.a(@"operator")), new ListPair(X, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(new Functor2(@"atom", X, x7), S1)))
+                {
+                    yield return false;
+                }
+                yield break;
+            }
+        }
+
+        public static IEnumerable<bool> cannot_follow(object Type, object Token, object Tokens)
+        {
+            {
+                foreach (bool l2 in syntax_error(new ListPair(Type, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL))), new ListPair(Token, Tokens)))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> exprtl(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6)
+        {
+            {
+                object x1 = arg2;
+                object x3 = arg4;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg5, Term))
+                        {
+                            foreach (bool l5 in YP.unify(arg6, Atom.NIL))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object C = arg2;
+                object Term = arg3;
+                object Precedence = arg4;
+                object Answer = arg5;
+                object S = arg6;
+                Variable Token = new Variable();
+                Variable Tokens = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Tokens)))
+                {
+                    foreach (bool l3 in exprtl_7(Token, C, Term, Precedence, Answer, S, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> exprtl_7(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7)
+        {
+            {
+                object C = arg2;
+                object Term = arg3;
+                object Precedence = arg4;
+                object Answer = arg5;
+                object S = arg6;
+                object S1 = arg7;
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable L = new Variable();
+                Variable O = new Variable();
+                Variable R = new Variable();
+                Variable Other = new Variable();
+                Variable S2 = new Variable();
+                Variable Expr = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, O, R })))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, O))
+                    {
+                        if (YP.lessThanOrEqual(C, L))
+                        {
+                            foreach (bool l5 in parse(S1, R, Other, S2))
+                            {
+                                foreach (bool l6 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, new ListPair(Other, Atom.NIL))))))
+                                {
+                                    foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object C = arg2;
+                object Term = arg3;
+                object Precedence = arg4;
+                object Answer = arg5;
+                object S = arg6;
+                object S1 = arg7;
+                Variable F = new Variable();
+                Variable Pos = new Variable();
+                Variable L = new Variable();
+                Variable O = new Variable();
+                Variable Expr = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, O)))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, O))
+                    {
+                        if (YP.lessThanOrEqual(C, L))
+                        {
+                            foreach (bool l5 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, Atom.NIL)))))
+                            {
+                                foreach (bool l6 in peepop(S1, S2))
+                                {
+                                    foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object C = arg2;
+                object Term = arg3;
+                object Precedence = arg4;
+                object Answer = arg5;
+                object S = arg6;
+                object S1 = arg7;
+                Variable Next = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@",")))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, 1000))
+                    {
+                        if (YP.lessThan(C, 1000))
+                        {
+                            foreach (bool l5 in parse(S1, 1000, Next, S2))
+                            {
+                                foreach (bool l6 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object C = arg2;
+                object Term = arg3;
+                object Precedence = arg4;
+                object Answer = arg5;
+                object S = arg6;
+                object S1 = arg7;
+                Variable Next = new Variable();
+                Variable S2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"|")))
+                {
+                    if (YP.greaterThanOrEqual(Precedence, 1100))
+                    {
+                        if (YP.lessThan(C, 1100))
+                        {
+                            foreach (bool l5 in parse(S1, 1100, Next, S2))
+                            {
+                                foreach (bool l6 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Token = arg1;
+                object x2 = arg2;
+                object x4 = arg4;
+                object Tokens = arg7;
+                Variable Term = new Variable();
+                foreach (bool l2 in YP.unify(arg3, Term))
+                {
+                    foreach (bool l3 in YP.unify(arg5, Term))
+                    {
+                        foreach (bool l4 in YP.unify(arg6, new ListPair(Token, Tokens)))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> syntax_error(object _Message, object _List)
+        {
+            {
+                yield break;
+            }
+        }
+
+        public static IEnumerable<bool> syntax_error(object _List)
+        {
+            {
+                yield break;
+            }
+        }
+
+        public static IEnumerable<bool> prefixop(object F, object O, object Q)
+        {
+            {
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"fx"), F))
+                {
+                    foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1)))
+                    {
+                        yield return false;
+                    }
+                    goto cutIf1;
+                }
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"fy"), F))
+                {
+                    foreach (bool l3 in YP.unify(Q, O))
+                    {
+                        yield return false;
+                    }
+                    goto cutIf2;
+                }
+            cutIf2:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> postfixop(object F, object P, object O)
+        {
+            {
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"xf"), F))
+                {
+                    foreach (bool l3 in YP.unify(P, YP.subtract(O, 1)))
+                    {
+                        yield return false;
+                    }
+                    goto cutIf1;
+                }
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"yf"), F))
+                {
+                    foreach (bool l3 in YP.unify(P, O))
+                    {
+                        yield return false;
+                    }
+                    goto cutIf2;
+                }
+            cutIf2:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> infixop(object F, object P, object O, object Q)
+        {
+            {
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"xfy"), F))
+                {
+                    foreach (bool l3 in YP.unify(P, YP.subtract(O, 1)))
+                    {
+                        foreach (bool l4 in YP.unify(Q, O))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf1;
+                }
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"xfx"), F))
+                {
+                    foreach (bool l3 in YP.unify(P, YP.subtract(O, 1)))
+                    {
+                        foreach (bool l4 in YP.unify(Q, P))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf2;
+                }
+                foreach (bool l2 in YP.current_op(O, Atom.a(@"yfx"), F))
+                {
+                    foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1)))
+                    {
+                        foreach (bool l4 in YP.unify(P, O))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf3;
+                }
+            cutIf3:
+            cutIf2:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> ambigop(object F, object Precedence, object L1, object O1, object R1, object L2, object O2)
+        {
+            {
+                foreach (bool l2 in postfixop(F, L2, O2))
+                {
+                    if (YP.lessThanOrEqual(O2, Precedence))
+                    {
+                        foreach (bool l4 in infixop(F, L1, O1, R1))
+                        {
+                            if (YP.lessThanOrEqual(O1, Precedence))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_tokens1(object arg1)
+        {
+            {
+                object TokenList = arg1;
+                Variable C1 = new Variable();
+                Variable _X = new Variable();
+                Variable ListOfTokens = new Variable();
+                foreach (bool l2 in YP.get_code(C1))
+                {
+                    foreach (bool l3 in read_tokens(C1, _X, ListOfTokens))
+                    {
+                        foreach (bool l4 in YP.unify(TokenList, ListOfTokens))
+                        {
+                            yield return false;
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL)))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_tokens2(object arg1, object arg2)
+        {
+            {
+                object TokenList = arg1;
+                object Dictionary = arg2;
+                Variable C1 = new Variable();
+                Variable Dict = new Variable();
+                Variable ListOfTokens = new Variable();
+                foreach (bool l2 in YP.get_code(C1))
+                {
+                    foreach (bool l3 in read_tokens(C1, Dict, ListOfTokens))
+                    {
+                        foreach (bool l4 in terminate_list(Dict))
+                        {
+                            foreach (bool l5 in YP.unify(Dictionary, Dict))
+                            {
+                                foreach (bool l6 in YP.unify(TokenList, ListOfTokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> terminate_list(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    yield return false;
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                Variable Tail = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Tail)))
+                {
+                    foreach (bool l3 in terminate_list(Tail))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_special(object arg1, object Dict, object arg3)
+        {
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 95))
+                {
+                    foreach (bool l3 in read_variable(95, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 247))
+                {
+                    foreach (bool l3 in read_symbol(247, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 215))
+                {
+                    foreach (bool l3 in read_symbol(215, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                Variable StartPos = new Variable();
+                Variable EndPos = new Variable();
+                Variable Tokens = new Variable();
+                Variable Ch = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 37))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(StartPos))
+                        {
+                            foreach (bool l5 in YP.repeat())
+                            {
+                                foreach (bool l6 in YP.get_code(Ch))
+                                {
+                                    if (YP.lessThan(Ch, new ListPair(32, Atom.NIL)))
+                                    {
+                                        if (YP.notEqual(Ch, 9))
+                                        {
+                                            if (YP.termNotEqual(Ch, -1))
+                                            {
+                                                foreach (bool l10 in get_current_position(EndPos))
+                                                {
+                                                    foreach (bool l11 in YP.get_code(NextCh))
+                                                    {
+                                                        foreach (bool l12 in read_tokens(NextCh, Dict, Tokens))
+                                                        {
+                                                            yield return false;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object T = arg3;
+                Variable C2 = new Variable();
+                Variable StartPos = new Variable();
+                Variable EndPos = new Variable();
+                Variable Tokens = new Variable();
+                Variable StartPos1 = new Variable();
+                Variable NextCh = new Variable();
+                Variable Chars = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 47))
+                {
+                    foreach (bool l3 in YP.get_code(C2))
+                    {
+                        if (YP.equal(C2, new ListPair(42, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.unify(T, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens)))
+                            {
+                                foreach (bool l6 in get_current_position(StartPos1))
+                                {
+                                    foreach (bool l7 in YP.unify(StartPos, YP.subtract(StartPos1, 1)))
+                                    {
+                                        foreach (bool l8 in read_solidus(32, NextCh))
+                                        {
+                                            foreach (bool l9 in get_current_position(EndPos))
+                                            {
+                                                foreach (bool l10 in read_tokens(NextCh, Dict, Tokens))
+                                                {
+                                                    yield return false;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            goto cutIf1;
+                        }
+                        foreach (bool l4 in YP.unify(T, Tokens))
+                        {
+                            foreach (bool l5 in rest_symbol(C2, Chars, NextCh))
+                            {
+                                foreach (bool l6 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(47, Chars)))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 33))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@"!"), Pos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(Pos))
+                        {
+                            foreach (bool l5 in YP.get_code(NextCh))
+                            {
+                                foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 40))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@" ("), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 41))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@")"), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 44))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@","), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 59))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@";"), Pos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(Pos))
+                        {
+                            foreach (bool l5 in YP.get_code(NextCh))
+                            {
+                                foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 91))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(Pos))
+                        {
+                            foreach (bool l5 in YP.get_code(NextCh))
+                            {
+                                foreach (bool l6 in read_tokens(NextCh, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 93))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(Pos))
+                        {
+                            foreach (bool l5 in YP.get_code(NextCh))
+                            {
+                                foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 123))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"{"), Pos), Tokens)))
+                    {
+                        foreach (bool l4 in get_current_position(Pos))
+                        {
+                            foreach (bool l5 in YP.get_code(NextCh))
+                            {
+                                foreach (bool l6 in read_tokens(NextCh, Dict, Tokens))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 124))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"|"), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 125))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"}"), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_after_atom(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 46))
+                {
+                    foreach (bool l3 in YP.get_code(NextCh))
+                    {
+                        foreach (bool l4 in read_fullstop(NextCh, Dict, Tokens))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                Variable Chars = new Variable();
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 34))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"string", Chars), Tokens)))
+                    {
+                        foreach (bool l4 in read_string(Chars, 34, NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 39))
+                {
+                    foreach (bool l3 in read_string(Chars, 39, NextCh))
+                    {
+                        foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, Chars))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 35))
+                {
+                    foreach (bool l3 in read_symbol(35, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 36))
+                {
+                    foreach (bool l3 in read_symbol(36, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 38))
+                {
+                    foreach (bool l3 in read_symbol(38, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 42))
+                {
+                    foreach (bool l3 in read_symbol(42, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 43))
+                {
+                    foreach (bool l3 in read_symbol(43, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 45))
+                {
+                    foreach (bool l3 in read_symbol(45, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 58))
+                {
+                    foreach (bool l3 in read_symbol(58, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 60))
+                {
+                    foreach (bool l3 in read_symbol(60, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 61))
+                {
+                    foreach (bool l3 in read_symbol(61, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 62))
+                {
+                    foreach (bool l3 in read_symbol(62, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 63))
+                {
+                    foreach (bool l3 in read_symbol(63, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 64))
+                {
+                    foreach (bool l3 in read_symbol(64, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 92))
+                {
+                    foreach (bool l3 in read_symbol(92, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 94))
+                {
+                    foreach (bool l3 in read_symbol(94, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 96))
+                {
+                    foreach (bool l3 in read_symbol(96, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Tokens = arg3;
+                foreach (bool l2 in YP.unify(arg1, 126))
+                {
+                    foreach (bool l3 in read_symbol(126, Dict, Tokens))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_symbol(object C1, object Dict, object Tokens)
+        {
+            {
+                Variable C2 = new Variable();
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.get_code(C2))
+                {
+                    foreach (bool l3 in rest_symbol(C2, Chars, NextCh))
+                    {
+                        foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(C1, Chars)))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> rest_symbol(object arg1, object arg2, object arg3)
+        {
+            {
+                object C2 = arg1;
+                object LastCh = arg3;
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(C2, Chars)))
+                {
+                    if (YP.greaterThan(C2, 160))
+                    {
+                        if (YP.lessThan(C2, 192))
+                        {
+                            if (YP.notEqual(C2, 186))
+                            {
+                                if (YP.notEqual(C2, 170))
+                                {
+                                    foreach (bool l7 in YP.get_code(NextCh))
+                                    {
+                                        foreach (bool l8 in rest_symbol(NextCh, Chars, LastCh))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    yield break;
+                                }
+                            }
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in symbol_char(C2))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in rest_symbol(NextCh, Chars, LastCh))
+                            {
+                                yield return false;
+                            }
+                        }
+                        yield break;
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+            {
+                Variable C2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, C2))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, C2))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> symbol_char(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, 35))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 36))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 38))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 42))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 43))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 45))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 46))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 47))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 58))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 60))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 61))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 62))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 63))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 64))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 92))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 94))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 96))
+                {
+                    yield return false;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 126))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> get_current_position(object Pos)
+        {
+            {
+                foreach (bool l2 in YP.unify(Pos, 0))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_after_atom4(object Ch, object Dict, object arg3, object Chars)
+        {
+            {
+                Variable Atom_1 = new Variable();
+                Variable Pos = new Variable();
+                Variable Tokens = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom_1, Pos), Tokens)))
+                {
+                    foreach (bool l3 in YP.unify(Pos, 0))
+                    {
+                        foreach (bool l4 in YP.atom_codes(Atom_1, Chars))
+                        {
+                            foreach (bool l5 in read_after_atom(Ch, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_after_atom(object arg1, object Dict, object arg3)
+        {
+            {
+                Variable Tokens = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, 40))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"("), Tokens)))
+                    {
+                        foreach (bool l4 in YP.get_code(NextCh))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Ch = arg1;
+                object Tokens = arg3;
+                foreach (bool l2 in read_tokens(Ch, Dict, Tokens))
+                {
+                    yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_string(object Chars, object Quote, object NextCh)
+        {
+            {
+                Variable Ch = new Variable();
+                Variable Char = new Variable();
+                Variable Next = new Variable();
+                foreach (bool l2 in YP.get_code(Ch))
+                {
+                    foreach (bool l3 in read_char(Ch, Quote, Char, Next))
+                    {
+                        foreach (bool l4 in rest_string5(Char, Next, Chars, Quote, NextCh))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> rest_string5(object arg1, object arg2, object arg3, object arg4, object arg5)
+        {
+            {
+                object _X = arg4;
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg1, -1))
+                {
+                    foreach (bool l3 in YP.unify(arg2, NextCh))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.NIL))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, NextCh))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Char = arg1;
+                object Next = arg2;
+                object Quote = arg4;
+                object NextCh = arg5;
+                Variable Chars = new Variable();
+                Variable Char2 = new Variable();
+                Variable Next2 = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(Char, Chars)))
+                {
+                    foreach (bool l3 in read_char(Next, Quote, Char2, Next2))
+                    {
+                        foreach (bool l4 in rest_string5(Char2, Next2, Chars, Quote, NextCh))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> escape_char(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, 110))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 10))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 78))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 10))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 116))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 9))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 84))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 9))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 114))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 13))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 82))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 13))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 118))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 11))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 86))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 11))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 98))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 8))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 66))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 8))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 102))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 12))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 70))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 12))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 101))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 27))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 69))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 27))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 100))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 127))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 68))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 127))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 115))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 32))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 83))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 32))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 122))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, 90))
+                {
+                    foreach (bool l3 in YP.unify(arg2, -1))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_variable(object C1, object Dict, object arg3)
+        {
+            {
+                Variable Var = new Variable();
+                Variable Name = new Variable();
+                Variable StartPos = new Variable();
+                Variable Tokens = new Variable();
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor3(@"var", Var, Name, StartPos), Tokens)))
+                {
+                    foreach (bool l3 in get_current_position(StartPos))
+                    {
+                        foreach (bool l4 in read_name(C1, Chars, NextCh))
+                        {
+                            foreach (bool l5 in YP.atom_codes(Name, Chars))
+                            {
+                                if (YP.termEqual(Name, Atom.a(@"_")))
+                                {
+                                    foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens))
+                                    {
+                                        yield return false;
+                                    }
+                                    goto cutIf1;
+                                }
+                                foreach (bool l6 in read_lookup(Dict, Name, Var))
+                                {
+                                    foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf1:
+                                { }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_lookup(object arg1, object Name, object Var)
+        {
+            {
+                Variable N = new Variable();
+                Variable V = new Variable();
+                Variable L = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", N, V), L)))
+                {
+                    foreach (bool l3 in YP.unify(N, Name))
+                    {
+                        foreach (bool l4 in YP.unify(V, Var))
+                        {
+                            yield return false;
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in read_lookup(L, Name, Var))
+                    {
+                        yield return false;
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_solidus(object Ch, object LastCh)
+        {
+            {
+                Variable NextCh = new Variable();
+                if (YP.equal(Ch, 42))
+                {
+                    foreach (bool l3 in YP.get_code(NextCh))
+                    {
+                        if (YP.equal(NextCh, 47))
+                        {
+                            foreach (bool l5 in YP.get_code(LastCh))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf2;
+                        }
+                        foreach (bool l4 in read_solidus(NextCh, LastCh))
+                        {
+                            yield return false;
+                        }
+                    cutIf2:
+                        { }
+                    }
+                    goto cutIf1;
+                }
+                if (YP.notEqual(Ch, -1))
+                {
+                    foreach (bool l3 in YP.get_code(NextCh))
+                    {
+                        foreach (bool l4 in read_solidus(NextCh, LastCh))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf3;
+                }
+                foreach (bool l2 in YP.unify(LastCh, Ch))
+                {
+                    foreach (bool l3 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in /*comment~n"), Atom.NIL))
+                    {
+                        yield return false;
+                    }
+                }
+            cutIf3:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> read_identifier(object C1, object Dict, object Tokens)
+        {
+            {
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in read_name(C1, Chars, NextCh))
+                {
+                    foreach (bool l3 in read_after_atom4(NextCh, Dict, Tokens, Chars))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_name(object C1, object arg2, object LastCh)
+        {
+            {
+                Variable Chars = new Variable();
+                Variable C2 = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars)))
+                {
+                    foreach (bool l3 in YP.get_code(C2))
+                    {
+                        if (YP.greaterThanOrEqual(C2, new ListPair(97, Atom.NIL)))
+                        {
+                            if (YP.lessThanOrEqual(C2, new ListPair(122, Atom.NIL)))
+                            {
+                                foreach (bool l6 in read_name(C2, Chars, LastCh))
+                                {
+                                    yield return false;
+                                }
+                                goto cutIf2;
+                            }
+                            if (YP.lessThan(C2, 192))
+                            {
+                                if (YP.notEqual(YP.bitwiseOr(C2, 16), 186))
+                                {
+                                    foreach (bool l7 in YP.unify(Chars, Atom.NIL))
+                                    {
+                                        foreach (bool l8 in YP.unify(LastCh, C2))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf3;
+                                }
+                            }
+                            if (YP.equal(YP.bitwiseOr(C2, 32), 247))
+                            {
+                                foreach (bool l6 in YP.unify(Chars, Atom.NIL))
+                                {
+                                    foreach (bool l7 in YP.unify(LastCh, C2))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                                goto cutIf4;
+                            }
+                            foreach (bool l5 in read_name(C2, Chars, LastCh))
+                            {
+                                yield return false;
+                            }
+                        cutIf4:
+                        cutIf3:
+                        cutIf2:
+                            goto cutIf1;
+                        }
+                        if (YP.greaterThanOrEqual(C2, new ListPair(65, Atom.NIL)))
+                        {
+                            if (YP.greaterThan(C2, new ListPair(90, Atom.NIL)))
+                            {
+                                if (YP.notEqual(C2, new ListPair(95, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in YP.unify(Chars, Atom.NIL))
+                                    {
+                                        foreach (bool l8 in YP.unify(LastCh, C2))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf6;
+                                }
+                            }
+                            foreach (bool l5 in read_name(C2, Chars, LastCh))
+                            {
+                                yield return false;
+                            }
+                        cutIf6:
+                            goto cutIf5;
+                        }
+                        if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL)))
+                        {
+                            if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL)))
+                            {
+                                foreach (bool l6 in read_name(C2, Chars, LastCh))
+                                {
+                                    yield return false;
+                                }
+                                goto cutIf7;
+                            }
+                        }
+                        foreach (bool l4 in YP.unify(Chars, Atom.NIL))
+                        {
+                            foreach (bool l5 in YP.unify(LastCh, C2))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf7:
+                    cutIf5:
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_fullstop(object Ch, object Dict, object Tokens)
+        {
+            {
+                Variable Number = new Variable();
+                Variable Tokens1 = new Variable();
+                Variable Chars = new Variable();
+                Variable NextCh = new Variable();
+                if (YP.lessThanOrEqual(Ch, new ListPair(57, Atom.NIL)))
+                {
+                    if (YP.greaterThanOrEqual(Ch, new ListPair(48, Atom.NIL)))
+                    {
+                        foreach (bool l4 in YP.unify(Tokens, new ListPair(new Functor1(@"number", Number), Tokens1)))
+                        {
+                            foreach (bool l5 in read_float(Number, Dict, Tokens1, new ListPair(48, Atom.NIL), Ch))
+                            {
+                                yield return false;
+                            }
+                        }
+                        goto cutIf1;
+                    }
+                }
+                if (YP.greaterThan(Ch, new ListPair(32, Atom.NIL)))
+                {
+                    foreach (bool l3 in rest_symbol(Ch, Chars, NextCh))
+                    {
+                        foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(46, Chars)))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf2;
+                }
+                if (YP.greaterThanOrEqual(Ch, 0))
+                {
+                    foreach (bool l3 in YP.unify(Tokens, Atom.NIL))
+                    {
+                        yield return false;
+                    }
+                    goto cutIf3;
+                }
+                foreach (bool l2 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file just after full stop~n"), Atom.NIL))
+                {
+                }
+            cutIf3:
+            cutIf2:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> read_float(object Number, object Dict, object Tokens, object Digits, object Digit)
+        {
+            {
+                Variable Chars = new Variable();
+                Variable Rest = new Variable();
+                Variable NextCh = new Variable();
+                foreach (bool l2 in prepend(Digits, Chars, Rest))
+                {
+                    foreach (bool l3 in read_float(Digit, Rest, NextCh, Chars))
+                    {
+                        foreach (bool l4 in YP.number_codes(Number, Chars))
+                        {
+                            foreach (bool l5 in read_tokens(NextCh, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> prepend(object arg1, object arg2, object arg3)
+        {
+            {
+                object X = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(46, X)))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+            {
+                object Y = arg3;
+                Variable C = new Variable();
+                Variable Cs = new Variable();
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(C, Cs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(C, X)))
+                    {
+                        foreach (bool l4 in prepend(Cs, X, Y))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_float(object C1, object arg2, object NextCh, object Total)
+        {
+            {
+                Variable Chars = new Variable();
+                Variable C2 = new Variable();
+                Variable C3 = new Variable();
+                Variable C4 = new Variable();
+                Variable More = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars)))
+                {
+                    foreach (bool l3 in YP.get_code(C2))
+                    {
+                        if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL)))
+                        {
+                            if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL)))
+                            {
+                                foreach (bool l6 in read_float(C2, Chars, NextCh, Total))
+                                {
+                                    yield return false;
+                                }
+                                goto cutIf1;
+                            }
+                        }
+                        if (YP.equal(YP.bitwiseOr(C2, 32), new ListPair(101, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.get_code(C3))
+                            {
+                                if (YP.equal(C3, new ListPair(45, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in YP.get_code(C4))
+                                    {
+                                        foreach (bool l8 in YP.unify(Chars, new ListPair(C2, new ListPair(45, More))))
+                                        {
+                                            if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL)))
+                                            {
+                                                if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL)))
+                                                {
+                                                    foreach (bool l11 in read_exponent(C4, More, NextCh))
+                                                    {
+                                                        yield return false;
+                                                    }
+                                                    goto cutIf4;
+                                                }
+                                            }
+                                            foreach (bool l9 in YP.unify(More, Atom.NIL))
+                                            {
+                                                foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL)))
+                                                {
+                                                }
+                                            }
+                                            foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL)))
+                                            {
+                                                foreach (bool l10 in YP.unify(NextCh, C4))
+                                                {
+                                                    yield return false;
+                                                }
+                                            }
+                                        cutIf4:
+                                            { }
+                                        }
+                                    }
+                                    goto cutIf3;
+                                }
+                                if (YP.equal(C3, new ListPair(43, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in YP.get_code(C4))
+                                    {
+                                        foreach (bool l8 in YP.unify(Chars, new ListPair(C2, More)))
+                                        {
+                                            if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL)))
+                                            {
+                                                if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL)))
+                                                {
+                                                    foreach (bool l11 in read_exponent(C4, More, NextCh))
+                                                    {
+                                                        yield return false;
+                                                    }
+                                                    goto cutIf6;
+                                                }
+                                            }
+                                            foreach (bool l9 in YP.unify(More, Atom.NIL))
+                                            {
+                                                foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL)))
+                                                {
+                                                }
+                                            }
+                                            foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL)))
+                                            {
+                                                foreach (bool l10 in YP.unify(NextCh, C4))
+                                                {
+                                                    yield return false;
+                                                }
+                                            }
+                                        cutIf6:
+                                            { }
+                                        }
+                                    }
+                                    goto cutIf5;
+                                }
+                                foreach (bool l6 in YP.unify(C4, C3))
+                                {
+                                    foreach (bool l7 in YP.unify(Chars, new ListPair(C2, More)))
+                                    {
+                                        if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL)))
+                                        {
+                                            if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL)))
+                                            {
+                                                foreach (bool l10 in read_exponent(C4, More, NextCh))
+                                                {
+                                                    yield return false;
+                                                }
+                                                goto cutIf7;
+                                            }
+                                        }
+                                        foreach (bool l8 in YP.unify(More, Atom.NIL))
+                                        {
+                                            foreach (bool l9 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL)))
+                                            {
+                                            }
+                                        }
+                                        foreach (bool l8 in YP.unify(More, new ListPair(48, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.unify(NextCh, C4))
+                                            {
+                                                yield return false;
+                                            }
+                                        }
+                                    cutIf7:
+                                        { }
+                                    }
+                                }
+                            cutIf5:
+                            cutIf3:
+                                { }
+                            }
+                            goto cutIf2;
+                        }
+                        foreach (bool l4 in YP.unify(Chars, Atom.NIL))
+                        {
+                            foreach (bool l5 in YP.unify(NextCh, C2))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf2:
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_exponent(object C1, object arg2, object NextCh)
+        {
+            {
+                Variable Chars = new Variable();
+                Variable C2 = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars)))
+                {
+                    foreach (bool l3 in YP.get_code(C2))
+                    {
+                        if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL)))
+                        {
+                            if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL)))
+                            {
+                                foreach (bool l6 in read_exponent(C2, Chars, NextCh))
+                                {
+                                    yield return false;
+                                }
+                                goto cutIf1;
+                            }
+                        }
+                        foreach (bool l4 in YP.unify(Chars, Atom.NIL))
+                        {
+                            foreach (bool l5 in YP.unify(NextCh, C2))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_number(object C1, object Dict, object arg3)
+        {
+            {
+                Variable Number = new Variable();
+                Variable Tokens = new Variable();
+                Variable C2 = new Variable();
+                Variable N = new Variable();
+                Variable C = new Variable();
+                Variable C3 = new Variable();
+                Variable Digits = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor1(@"number", Number), Tokens)))
+                {
+                    foreach (bool l3 in read_number4(C1, C2, 0, N))
+                    {
+                        if (YP.equal(C2, 39))
+                        {
+                            if (YP.greaterThanOrEqual(N, 2))
+                            {
+                                if (YP.lessThanOrEqual(N, 36))
+                                {
+                                    foreach (bool l7 in read_based(N, 0, Number, C))
+                                    {
+                                        foreach (bool l8 in read_tokens(C, Dict, Tokens))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf2;
+                                }
+                            }
+                            if (YP.equal(N, 0))
+                            {
+                                foreach (bool l6 in YP.get_code(C3))
+                                {
+                                    foreach (bool l7 in read_char(C3, -1, Number, C))
+                                    {
+                                        foreach (bool l8 in read_tokens(C, Dict, Tokens))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                }
+                                goto cutIf3;
+                            }
+                            foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** ~d' read as ~d '~n"), new ListPair(N, new ListPair(N, Atom.NIL))))
+                            {
+                                foreach (bool l6 in YP.unify(Number, N))
+                                {
+                                    foreach (bool l7 in YP.unify(C, C2))
+                                    {
+                                        foreach (bool l8 in read_tokens(C, Dict, Tokens))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                }
+                            }
+                        cutIf3:
+                        cutIf2:
+                            goto cutIf1;
+                        }
+                        if (YP.equal(C2, 46))
+                        {
+                            foreach (bool l5 in YP.get_code(C3))
+                            {
+                                if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL)))
+                                {
+                                    if (YP.lessThanOrEqual(C3, new ListPair(57, Atom.NIL)))
+                                    {
+                                        foreach (bool l8 in YP.number_codes(N, Digits))
+                                        {
+                                            foreach (bool l9 in read_float(Number, Dict, Tokens, Digits, C3))
+                                            {
+                                                yield return false;
+                                            }
+                                        }
+                                        goto cutIf5;
+                                    }
+                                }
+                                foreach (bool l6 in YP.unify(Number, N))
+                                {
+                                    foreach (bool l7 in read_fullstop(C3, Dict, Tokens))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf5:
+                                { }
+                            }
+                            goto cutIf4;
+                        }
+                        foreach (bool l4 in YP.unify(Number, N))
+                        {
+                            foreach (bool l5 in read_tokens(C2, Dict, Tokens))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf4:
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_number4(object C0, object C, object N0, object N)
+        {
+            {
+                Variable N1 = new Variable();
+                Variable C1 = new Variable();
+                if (YP.greaterThanOrEqual(C0, new ListPair(48, Atom.NIL)))
+                {
+                    if (YP.lessThanOrEqual(C0, new ListPair(57, Atom.NIL)))
+                    {
+                        foreach (bool l4 in YP.unify(N1, YP.add(YP.subtract(YP.multiply(N0, 10), new ListPair(48, Atom.NIL)), C0)))
+                        {
+                            foreach (bool l5 in YP.get_code(C1))
+                            {
+                                foreach (bool l6 in read_number4(C1, C, N1, N))
+                                {
+                                    yield return false;
+                                }
+                            }
+                        }
+                        goto cutIf1;
+                    }
+                }
+                if (YP.equal(C0, 95))
+                {
+                    foreach (bool l3 in YP.get_code(C1))
+                    {
+                        foreach (bool l4 in read_number4(C1, C, N0, N))
+                        {
+                            yield return false;
+                        }
+                    }
+                    goto cutIf2;
+                }
+                foreach (bool l2 in YP.unify(C, C0))
+                {
+                    foreach (bool l3 in YP.unify(N, N0))
+                    {
+                        yield return false;
+                    }
+                }
+            cutIf2:
+            cutIf1:
+                { }
+            }
+        }
+
+        public static IEnumerable<bool> read_based(object Base, object N0, object N, object C)
+        {
+            {
+                Variable C1 = new Variable();
+                Variable Digit = new Variable();
+                Variable N1 = new Variable();
+                foreach (bool l2 in YP.get_code(C1))
+                {
+                    if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, new ListPair(48, Atom.NIL))))
+                            {
+                                if (YP.lessThan(Digit, Base))
+                                {
+                                    foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit)))
+                                    {
+                                        foreach (bool l8 in read_based(Base, N1, N, C))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf2;
+                                }
+                                if (YP.equal(C1, new ListPair(95, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in read_based(Base, N0, N, C))
+                                    {
+                                        yield return false;
+                                    }
+                                    goto cutIf3;
+                                }
+                                foreach (bool l6 in YP.unify(N, N0))
+                                {
+                                    foreach (bool l7 in YP.unify(C, C1))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf3:
+                            cutIf2:
+                                { }
+                            }
+                            goto cutIf1;
+                        }
+                    }
+                    if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(65, Atom.NIL), 10))))
+                            {
+                                if (YP.lessThan(Digit, Base))
+                                {
+                                    foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit)))
+                                    {
+                                        foreach (bool l8 in read_based(Base, N1, N, C))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf5;
+                                }
+                                if (YP.equal(C1, new ListPair(95, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in read_based(Base, N0, N, C))
+                                    {
+                                        yield return false;
+                                    }
+                                    goto cutIf6;
+                                }
+                                foreach (bool l6 in YP.unify(N, N0))
+                                {
+                                    foreach (bool l7 in YP.unify(C, C1))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf6:
+                            cutIf5:
+                                { }
+                            }
+                            goto cutIf4;
+                        }
+                    }
+                    if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL)))
+                    {
+                        if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(97, Atom.NIL), 10))))
+                            {
+                                if (YP.lessThan(Digit, Base))
+                                {
+                                    foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit)))
+                                    {
+                                        foreach (bool l8 in read_based(Base, N1, N, C))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf8;
+                                }
+                                if (YP.equal(C1, new ListPair(95, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in read_based(Base, N0, N, C))
+                                    {
+                                        yield return false;
+                                    }
+                                    goto cutIf9;
+                                }
+                                foreach (bool l6 in YP.unify(N, N0))
+                                {
+                                    foreach (bool l7 in YP.unify(C, C1))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf9:
+                            cutIf8:
+                                { }
+                            }
+                            goto cutIf7;
+                        }
+                    }
+                    foreach (bool l3 in YP.unify(Digit, 99))
+                    {
+                        if (YP.lessThan(Digit, Base))
+                        {
+                            foreach (bool l5 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit)))
+                            {
+                                foreach (bool l6 in read_based(Base, N1, N, C))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            goto cutIf10;
+                        }
+                        if (YP.equal(C1, new ListPair(95, Atom.NIL)))
+                        {
+                            foreach (bool l5 in read_based(Base, N0, N, C))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf11;
+                        }
+                        foreach (bool l4 in YP.unify(N, N0))
+                        {
+                            foreach (bool l5 in YP.unify(C, C1))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf11:
+                    cutIf10:
+                        { }
+                    }
+                cutIf7:
+                cutIf4:
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> read_char(object Char, object Quote, object Result, object Next)
+        {
+            {
+                Variable C1 = new Variable();
+                Variable C2 = new Variable();
+                Variable C3 = new Variable();
+                Variable Ch = new Variable();
+                if (YP.equal(Char, 92))
+                {
+                    foreach (bool l3 in YP.get_code(C1))
+                    {
+                        if (YP.lessThan(C1, 0))
+                        {
+                            foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~cquoted~c~n"), new ListPair(Quote, new ListPair(Quote, Atom.NIL))))
+                            {
+                                foreach (bool l6 in YP.unify(Result, -1))
+                                {
+                                    foreach (bool l7 in YP.unify(Next, C1))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            }
+                            goto cutIf2;
+                        }
+                        if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.get_code(C2))
+                            {
+                                foreach (bool l6 in read_char(C2, Quote, Result, Next))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            goto cutIf3;
+                        }
+                        if (YP.equal(YP.bitwiseOr(C1, 32), new ListPair(99, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.get_code(C2))
+                            {
+                                foreach (bool l6 in read_char(C2, Quote, Result, Next))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            goto cutIf4;
+                        }
+                        if (YP.lessThanOrEqual(C1, new ListPair(55, Atom.NIL)))
+                        {
+                            if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL)))
+                            {
+                                foreach (bool l6 in YP.get_code(C2))
+                                {
+                                    if (YP.lessThanOrEqual(C2, new ListPair(55, Atom.NIL)))
+                                    {
+                                        if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.get_code(C3))
+                                            {
+                                                if (YP.lessThanOrEqual(C3, new ListPair(55, Atom.NIL)))
+                                                {
+                                                    if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL)))
+                                                    {
+                                                        foreach (bool l12 in YP.get_code(Next))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(YP.add(YP.multiply(C1, 8), C2), 8), C3), YP.multiply(73, new ListPair(48, Atom.NIL)))))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf7;
+                                                    }
+                                                }
+                                                foreach (bool l10 in YP.unify(Next, C3))
+                                                {
+                                                    foreach (bool l11 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(C1, 8), C2), YP.multiply(9, new ListPair(48, Atom.NIL)))))
+                                                    {
+                                                        yield return false;
+                                                    }
+                                                }
+                                            cutIf7:
+                                                { }
+                                            }
+                                            goto cutIf6;
+                                        }
+                                    }
+                                    foreach (bool l7 in YP.unify(Next, C2))
+                                    {
+                                        foreach (bool l8 in YP.unify(Result, YP.subtract(C1, new ListPair(48, Atom.NIL))))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                cutIf6:
+                                    { }
+                                }
+                                goto cutIf5;
+                            }
+                        }
+                        if (YP.equal(C1, new ListPair(94, Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.get_code(C2))
+                            {
+                                if (YP.lessThan(C2, 0))
+                                {
+                                    foreach (bool l7 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~c..~c^..~c~n"), new ListPair(Quote, new ListPair(92, new ListPair(Quote, Atom.NIL)))))
+                                    {
+                                        foreach (bool l8 in YP.unify(Result, -1))
+                                        {
+                                            foreach (bool l9 in YP.unify(Next, C2))
+                                            {
+                                                yield return false;
+                                            }
+                                        }
+                                    }
+                                    goto cutIf9;
+                                }
+                                if (YP.equal(C2, new ListPair(63, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in YP.unify(Result, 127))
+                                    {
+                                        foreach (bool l8 in YP.get_code(Next))
+                                        {
+                                            yield return false;
+                                        }
+                                    }
+                                    goto cutIf10;
+                                }
+                                foreach (bool l6 in YP.unify(Result, YP.bitwiseAnd(C2, 31)))
+                                {
+                                    foreach (bool l7 in YP.get_code(Next))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            cutIf10:
+                            cutIf9:
+                                { }
+                            }
+                            goto cutIf8;
+                        }
+                        foreach (bool l4 in escape_char(C1, Result))
+                        {
+                            foreach (bool l5 in YP.get_code(Next))
+                            {
+                                yield return false;
+                            }
+                            goto cutIf11;
+                        }
+                        foreach (bool l4 in YP.unify(Result, C1))
+                        {
+                            foreach (bool l5 in YP.get_code(Next))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf11:
+                    cutIf8:
+                    cutIf5:
+                    cutIf4:
+                    cutIf3:
+                    cutIf2:
+                        { }
+                    }
+                    goto cutIf1;
+                }
+                if (YP.equal(Char, Quote))
+                {
+                    foreach (bool l3 in YP.get_code(Ch))
+                    {
+                        if (YP.equal(Ch, Quote))
+                        {
+                            foreach (bool l5 in YP.unify(Result, Quote))
+                            {
+                                foreach (bool l6 in YP.get_code(Next))
+                                {
+                                    yield return false;
+                                }
+                            }
+                            goto cutIf13;
+                        }
+                        foreach (bool l4 in YP.unify(Result, -1))
+                        {
+                            foreach (bool l5 in YP.unify(Next, Ch))
+                            {
+                                yield return false;
+                            }
+                        }
+                    cutIf13:
+                        { }
+                    }
+                    goto cutIf12;
+                }
+                if (YP.lessThan(Char, new ListPair(32, Atom.NIL)))
+                {
+                    if (YP.notEqual(Char, 9))
+                    {
+                        if (YP.notEqual(Char, 10))
+                        {
+                            if (YP.notEqual(Char, 13))
+                            {
+                                foreach (bool l6 in YP.unify(Result, -1))
+                            {
+                                    foreach (bool l7 in YP.unify(Next, Char))
+                                {
+                                        foreach (bool l8 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Strange character ~d ends ~ctoken~c~n"), new ListPair(Char, new ListPair(Quote, new ListPair(Quote, Atom.NIL)))))
+                                    {
+                                        yield return false;
+                                    }
+                                }
+                            }
+                            goto cutIf14;
+                            }
+                        }
+                    }
+                }
+                foreach (bool l2 in YP.unify(Result, Char))
+                {
+                    foreach (bool l3 in YP.get_code(Next))
+                    {
+                        yield return false;
+                    }
+                }
+            cutIf14:
+            cutIf12:
+            cutIf1:
+                { }
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs
new file mode 100644
index 0000000..f29c751
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// A PrologException is used as the exception thrown by YP.throw(Term).
+    /// </summary>
+    public class PrologException : Exception
+    {
+        public readonly object _term;
+
+        /// <summary>
+        /// Create a PrologException with the given Term.  The printable exception message is the full Term.
+        /// </summary>
+        /// <param name="Term">the term of the exception</param>
+        /// </param>
+        public PrologException(object Term)
+            : base(YP.getValue(Term).ToString())
+        {
+            _term = YP.makeCopy(Term, new Variable.CopyStore());
+        }
+
+        /// <summary>
+        /// Create a PrologException where the Term is error(ErrorTerm, Message).
+        /// This uses YP.makeCopy to copy the ErrorTerm and Message so that they are valid after unbinding.
+        /// </summary>
+        /// <param name="ErrorTerm">the term of the exception</param>
+        /// <param name="Messsage">the message, converted to a string, to use as the printable exception message
+        /// </param>
+        public PrologException(object ErrorTerm, object Message)
+            : base(YP.getValue(Message).ToString())
+        {
+            _term = YP.makeCopy(new Functor2(Atom.a("error"), ErrorTerm, Message), new Variable.CopyStore());
+        }
+
+        public object Term
+        {
+            get { return _term; }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs
new file mode 100644
index 0000000..4b6112f
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// An UndefinedPredicateException extends PrologException to create an existence_error exception.
+    /// </summary>
+    public class UndefinedPredicateException : PrologException
+    {
+        private Atom _predicateName;
+        private int _arity;
+
+        public UndefinedPredicateException(object message, Atom predicateName, int arity)
+            : base(new Functor2
+                   (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.a("/"), predicateName, arity)),
+                   message)
+        {
+            _predicateName = predicateName;
+            _arity = arity;
+        }
+
+        public Atom PredicateName
+        {
+            get { return _predicateName; }
+        }
+
+        public int Arity
+        {
+            get { return _arity; }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs
new file mode 100644
index 0000000..2b5b0f1
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public interface IUnifiable
+    {
+        IEnumerable<bool> unify(object arg);
+        void addUniqueVariables(List<Variable> variableSet);
+        object makeCopy(Variable.CopyStore copyStore);
+        bool termEqual(object term);
+        bool ground();
+    }
+
+    public class Variable : IUnifiable
+    {
+        // Use _isBound separate from _value so that it can be bound to any value,
+        //   including null.
+        private bool _isBound = false;
+        private object _value;
+
+        public object getValue()
+        {
+            if (!_isBound)
+                return this;
+
+            object result = _value;
+            while (result is Variable)
+            {
+                if (!((Variable)result)._isBound)
+                    return result;
+
+                // Keep following the Variable chain.
+                result = ((Variable)result)._value;
+            }
+
+            return result;
+        }
+
+        public IEnumerable<bool> unify(object arg)
+        {
+            if (!_isBound)
+            {
+                _value = YP.getValue(arg);
+                if (_value == this)
+                    // We are unifying this unbound variable with itself, so leave it unbound.
+                    yield return false;
+                else
+                {
+                    _isBound = true;
+                    try
+                    {
+                        yield return false;
+                    }
+                    finally
+                    {
+                        // Remove the binding.
+                        _isBound = false;
+                    }
+                }
+            }
+            else
+            {
+                foreach (bool l1 in YP.unify(this, arg))
+                    yield return false;
+            }
+        }
+
+        public override string ToString()
+        {
+            object value = getValue();
+            if (value == this)
+                return "Variable";
+            else
+                return getValue().ToString();
+        }
+
+        /// <summary>
+        /// If bound, call YP.addUniqueVariables on the value.  Otherwise, if this unbound
+        /// variable is not already in variableSet, add it.
+        /// </summary>
+        /// <param name="variableSet"></param>
+        public void addUniqueVariables(List<Variable> variableSet)
+        {
+            if (_isBound)
+                YP.addUniqueVariables(getValue(), variableSet);
+            else
+            {
+                if (variableSet.IndexOf(this) < 0)
+                    variableSet.Add(this);
+            }
+        }
+
+        /// <summary>
+        /// If bound, return YP.makeCopy for the value, else return copyStore.getCopy(this).
+        /// However, if copyStore is null, just return this.
+        /// </summary>
+        /// <param name="copyStore"></param>
+        /// <returns></returns>
+        public object makeCopy(Variable.CopyStore copyStore)
+        {
+            if (_isBound)
+                return YP.makeCopy(getValue(), copyStore);
+            else
+                return copyStore == null ? this : copyStore.getCopy(this);
+        }
+
+        public bool termEqual(object term)
+        {
+            if (_isBound)
+                return YP.termEqual(getValue(), term);
+            else
+                return this == YP.getValue(term);
+        }
+
+        public bool ground()
+        {
+            if (_isBound)
+                // This is usually called by YP.ground which already did getValue, so this
+                //   should never be reached, but check anyway.
+                return YP.ground(getValue());
+            else
+                return false;
+        }
+
+        /// <summary>
+        /// A CopyStore is used by makeCopy to track which Variable objects have
+        /// been copied.
+        /// </summary>
+        public class CopyStore
+        {
+            private List<Variable> _inVariableSet = new List<Variable>();
+            private List<Variable> _outVariableSet = new List<Variable>();
+
+            /// <summary>
+            /// If inVariable has already been copied, return its copy. Otherwise,
+            /// return a fresh Variable associated with inVariable.
+            /// </summary>
+            /// <param name="inVariable"></param>
+            /// <returns></returns>
+            public Variable getCopy(Variable inVariable)
+            {
+                int index = _inVariableSet.IndexOf(inVariable);
+                if (index >= 0)
+                    return _outVariableSet[index];
+                else
+                {
+                    Variable outVariable = new Variable();
+                    _inVariableSet.Add(inVariable);
+                    _outVariableSet.Add(outVariable);
+                    return outVariable;
+                }
+            }
+
+            /// <summary>
+            /// Return the number of unique variables that have been copied.
+            /// </summary>
+            /// <returns></returns>
+            public int getNUniqueVariables()
+            {
+                return _inVariableSet.Count;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs
new file mode 100644
index 0000000..74704aa
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs
@@ -0,0 +1,1644 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    /// <summary>
+    /// YP has static methods for general functions in Yield Prolog such as <see cref="getValue"/>
+    /// and <see cref="unify"/>.
+    /// </summary>
+    public class YP
+    {
+        private static Fail _fail = new Fail();
+        private static Repeat _repeat = new Repeat();
+        private static Dictionary<NameArity, List<IClause>> _predicatesStore =
+            new Dictionary<NameArity, List<IClause>>();
+        private static TextWriter _outputStream = System.Console.Out;
+        private static TextReader _inputStream = System.Console.In;
+        private static List<object[]> _operatorTable = null;
+
+        /// <summary>
+        /// An IClause is used so that dynamic predicates can call match.
+        /// </summary>
+        public interface IClause
+        {
+            IEnumerable<bool> match(object[] args);
+        }
+
+        public static object getValue(object value)
+        {
+            if (value is Variable)
+                return ((Variable)value).getValue();
+            else
+                return value;
+        }
+
+        public static IEnumerable<bool> unify(object arg1, object arg2)
+        {
+            arg1 = getValue(arg1);
+            arg2 = getValue(arg2);
+            if (arg1 is IUnifiable)
+                return ((IUnifiable)arg1).unify(arg2);
+            else if (arg2 is IUnifiable)
+                return ((IUnifiable)arg2).unify(arg1);
+            else
+            {
+                // Arguments are "normal" types.
+                if (arg1.Equals(arg2))
+                    return new Succeed();
+                else
+                    return _fail;
+            }
+        }
+
+        /// <summary>
+        /// This is used for the lookup key in _factStore.
+        /// </summary>
+        public struct NameArity
+        {
+            public readonly Atom _name;
+            public readonly int _arity;
+
+            public NameArity(Atom name, int arity)
+            {
+                _name = name;
+                _arity = arity;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (obj is NameArity)
+                {
+                    NameArity nameArity = (NameArity)obj;
+                    return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            public override int GetHashCode()
+            {
+                return _name.GetHashCode() ^ _arity.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Convert term to an int.
+        /// If term is a single-element List, use its first element
+        /// (to handle the char types like "a").  If can't convert, throw an exception.
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        public static int convertInt(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                // Assume it is a char type like "a".
+                term = YP.getValue(((Functor2)term)._arg1);
+
+            return (int)term;
+        }
+
+        /// <summary>
+        /// Convert term to a double.  This may convert an int to a double, etc.
+        /// If term is a single-element List, use its first element
+        /// (to handle the char types like "a").  If can't convert, throw an exception.
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        public static double convertDouble(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                // Assume it is a char type like "a".
+                term = YP.getValue(((Functor2)term)._arg1);
+            if (term is Variable)
+                throw new PrologException(Atom.a("instantiation_error"), 
+                    "Expected a number but the argument is an unbound variable");
+
+            return Convert.ToDouble(term);
+        }
+
+        /// <summary>
+        /// If term is an integer, set intTerm.
+        /// If term is a single-element List, use its first element
+        /// (to handle the char types like "a").  Return true for success, false if can't convert.
+        /// We use a success return value because throwing an exception is inefficient.
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        public static bool getInt(object term, out int intTerm)
+        {
+            term = YP.getValue(term);
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                // Assume it is a char type like "a".
+                term = YP.getValue(((Functor2)term)._arg1);
+
+            if (term is int)
+            {
+                intTerm = (int)term;
+                return true;
+            }
+
+            intTerm = 0;
+            return false;
+        }
+
+        public static bool equal(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x == (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) == YP.convertDouble(y);
+        }
+
+        public static bool notEqual(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x != (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) != YP.convertDouble(y);
+        }
+
+        public static bool greaterThan(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x > (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) > YP.convertDouble(y);
+        }
+
+        public static bool lessThan(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x < (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) < YP.convertDouble(y);
+        }
+
+        public static bool greaterThanOrEqual(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x >= (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) >= YP.convertDouble(y);
+        }
+
+        public static bool lessThanOrEqual(object x, object y)
+        {
+            x = YP.getValue(x);
+            if (x is DateTime)
+                return (DateTime)x <= (DateTime)YP.getValue(y);
+            // Assume convertDouble converts an int to a double perfectly.
+            return YP.convertDouble(x) <= YP.convertDouble(y);
+        }
+
+        public static object negate(object x)
+        {
+            int intX;
+            if (getInt(x, out intX))
+                return -intX;
+            return -convertDouble(x);
+        }
+
+        public static object abs(object x)
+        {
+            int intX;
+            if (getInt(x, out intX))
+                return Math.Abs(intX);
+            return Math.Abs(convertDouble(x));
+        }
+
+        public static object sign(object x)
+        {
+            int intX;
+            if (getInt(x, out intX))
+                return Math.Sign(intX);
+            return Math.Sign(convertDouble(x));
+        }
+
+        /// <summary>
+        /// The ISO standard returns an int.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        public static object floor(object x)
+        {
+            return (int)Math.Floor(convertDouble(x));
+        }
+
+        /// <summary>
+        /// The ISO standard returns an int.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        public static object truncate(object x)
+        {
+            return (int)Math.Truncate(convertDouble(x));
+        }
+
+        /// <summary>
+        /// The ISO standard returns an int.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        public static object round(object x)
+        {
+            return (int)Math.Round(convertDouble(x));
+        }
+
+        /// <summary>
+        /// The ISO standard returns an int.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        public static object ceiling(object x)
+        {
+            return (int)Math.Ceiling(convertDouble(x));
+        }
+
+        public static object sin(object x)
+        {
+            return Math.Sin(YP.convertDouble(x));
+        }
+
+        public static object cos(object x)
+        {
+            return Math.Cos(YP.convertDouble(x));
+        }
+
+        public static object atan(object x)
+        {
+            return Math.Atan(YP.convertDouble(x));
+        }
+
+        public static object exp(object x)
+        {
+            return Math.Exp(YP.convertDouble(x));
+        }
+
+        public static object log(object x)
+        {
+            return Math.Log(YP.convertDouble(x));
+        }
+
+        public static object sqrt(object x)
+        {
+            return Math.Sqrt(convertDouble(x));
+        }
+
+        public static object bitwiseComplement(object x)
+        {
+            return ~YP.convertInt(x);
+        }
+
+        public static object add(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return intX + intY;
+            return convertDouble(x) + convertDouble(y);
+        }
+
+        public static object subtract(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return intX - intY;
+            return convertDouble(x) - convertDouble(y);
+        }
+
+        public static object multiply(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return intX * intY;
+            return convertDouble(x) * convertDouble(y);
+        }
+
+        /// <summary>
+        /// Return floating point, even if both arguments are integer.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <returns></returns>
+        public static object divide(object x, object y)
+        {
+            return convertDouble(x) / convertDouble(y);
+        }
+
+        public static object intDivide(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return intX / intY;
+            // Still allow passing a double, but treat as an int.
+            return (int)convertDouble(x) / (int)convertDouble(y);
+        }
+
+        public static object mod(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return intX % intY;
+            // Still allow passing a double, but treat as an int.
+            return (int)convertDouble(x) % (int)convertDouble(y);
+        }
+
+        public static object pow(object x, object y)
+        {
+            return Math.Pow(YP.convertDouble(x), YP.convertDouble(y));
+        }
+
+        public static object bitwiseShiftRight(object x, object y)
+        {
+            return YP.convertInt(x) >> YP.convertInt(y);
+        }
+
+        public static object bitwiseShiftLeft(object x, object y)
+        {
+            return YP.convertInt(x) << YP.convertInt(y);
+        }
+
+        public static object bitwiseAnd(object x, object y)
+        {
+            return YP.convertInt(x) & YP.convertInt(y);
+        }
+
+        public static object bitwiseOr(object x, object y)
+        {
+            return YP.convertInt(x) | YP.convertInt(y);
+        }
+
+        public static object min(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return Math.Min(intX, intY);
+            return Math.Min(convertDouble(x), convertDouble(y));
+        }
+
+        public static object max(object x, object y)
+        {
+            int intX, intY;
+            if (getInt(x, out intX) && getInt(y, out intY))
+                return Math.Max(intX, intY);
+            return Math.Max(convertDouble(x), convertDouble(y));
+        }
+
+        public static IEnumerable<bool> copy_term(object inTerm, object outTerm)
+        {
+            return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore()));
+        }
+
+        public static void addUniqueVariables(object term, List<Variable> variableSet)
+        {
+            term = YP.getValue(term);
+            if (term is IUnifiable)
+                ((IUnifiable)term).addUniqueVariables(variableSet);
+        }
+
+        public static object makeCopy(object term, Variable.CopyStore copyStore)
+        {
+            term = YP.getValue(term);
+            if (term is IUnifiable)
+                return ((IUnifiable)term).makeCopy(copyStore);
+            else
+                // term is a "normal" type. Assume it is ground.
+                return term;
+        }
+
+        /// <summary>
+        /// Sort the array in place according to termLessThan.  This does not remove duplicates
+        /// </summary>
+        /// <param name="array"></param>
+        public static void sortArray(object[] array)
+        {
+            Array.Sort(array, YP.compareTerms);
+        }
+
+        /// <summary>
+        /// Sort the array in place according to termLessThan.  This does not remove duplicates
+        /// </summary>
+        /// <param name="array"></param>
+        public static void sortArray(List<object> array)
+        {
+            array.Sort(YP.compareTerms);
+        }
+
+        /// <summary>
+        /// Sort List according to termLessThan, remove duplicates and unify with Sorted.
+        /// </summary>
+        /// <param name="List"></param>
+        /// <param name="Sorted"></param>
+        /// <returns></returns>
+        public static IEnumerable<bool> sort(object List, object Sorted)
+        {
+            object[] array = ListPair.toArray(List);
+            if (array == null)
+                return YP.fail();
+            if (array.Length > 1)
+                sortArray(array);
+            return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
+        }
+
+
+
+        /// <summary>
+        /// Use YP.unify to unify each of the elements of the two arrays, and yield
+        /// once if they all unify.
+        /// </summary>
+        /// <param name="array1"></param>
+        /// <param name="array2"></param>
+        /// <returns></returns>
+        public static IEnumerable<bool> unifyArrays(object[] array1, object[] array2)
+        {
+            if (array1.Length != array2.Length)
+                yield break;
+
+            IEnumerator<bool>[] iterators = new IEnumerator<bool>[array1.Length];
+            bool gotMatch = true;
+            int nIterators = 0;
+            // Try to bind all the arguments.
+            for (int i = 0; i < array1.Length; ++i)
+            {
+                IEnumerator<bool> iterator = YP.unify(array1[i], array2[i]).GetEnumerator();
+                iterators[nIterators++] = iterator;
+                // MoveNext() is true if YP.unify succeeds.
+                if (!iterator.MoveNext())
+                {
+                    gotMatch = false;
+                    break;
+                }
+            }
+
+            try
+            {
+                if (gotMatch)
+                    yield return false;
+            }
+            finally
+            {
+                // Manually finalize all the iterators.
+                for (int i = 0; i < nIterators; ++i)
+                    iterators[i].Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Return an iterator (which you can use in a for-in loop) which does
+        /// zero iterations.  This returns a pre-existing iterator which is
+        /// more efficient than letting the compiler generate a new one.
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<bool> fail()
+        {
+            return _fail;
+        }
+
+        /// <summary>
+        /// Return an iterator (which you can use in a for-in loop) which does
+        /// one iteration.  This returns a pre-existing iterator which is
+        /// more efficient than letting the compiler generate a new one.
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<bool> succeed()
+        {
+            return new Succeed();
+        }
+
+        /// <summary>
+        /// Return an iterator (which you can use in a for-in loop) which repeats
+        /// indefinitely.  This returns a pre-existing iterator which is
+        /// more efficient than letting the compiler generate a new one.
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<bool> repeat()
+        {
+            return _repeat;
+        }
+
+        public static IEnumerable<bool> univ(object Term, object List)
+        {
+            Term = YP.getValue(Term);
+            List = YP.getValue(List);
+
+            if (nonvar(Term))
+                return YP.unify(new ListPair
+                    (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List);
+
+            Variable Name = new Variable();
+            Variable ArgList = new Variable();
+            foreach (bool l1 in new ListPair(Name, ArgList).unify(List))
+            {
+                object[] args = ListPair.toArray(ArgList);
+                if (args == null)
+                    throw new Exception("Expected a list. Got: " + ArgList.getValue());
+                if (args.Length == 0)
+                    // Return the Name, even if it is not an Atom.
+                    return YP.unify(Term, Name);
+                if (!atom(Name))
+                    throw new Exception("Expected an atom. Got: " + Name.getValue());
+
+                return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args));
+            }
+
+            return YP.fail();
+        }
+
+        public static IEnumerable<bool> functor(object Term, object FunctorName, object Arity)
+        {
+            Term = YP.getValue(Term);
+            FunctorName = YP.getValue(FunctorName);
+            Arity = YP.getValue(Arity);
+
+            if (!(Term is Variable))
+            {
+                foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term)))
+                {
+                    foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length))
+                        yield return false;
+                }
+            }
+            else
+                throw new NotImplementedException("Debug: must finish functor/3");
+        }
+
+        public static IEnumerable<bool> arg(object ArgNumber, object Term, object Value)
+        {
+            if (YP.var(ArgNumber))
+                throw new NotImplementedException("Debug: must finish arg/3");
+            else
+            {
+                int argNumberInt = convertInt(ArgNumber);
+                if (argNumberInt < 0)
+                    throw new Exception("ArgNumber must be non-negative");
+                object[] termArgs = YP.getFunctorArgs(Term);
+                // Silently fail if argNumberInt is out of range.
+                if (argNumberInt >= 1 && argNumberInt <= termArgs.Length)
+                {
+                    // The first ArgNumber is at 1, not 0.
+                    foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1]))
+                        yield return false;
+                }
+            }
+        }
+
+        public static bool termEqual(object Term1, object Term2)
+        {
+            Term1 = YP.getValue(Term1);
+            if (Term1 is IUnifiable)
+                return ((IUnifiable)Term1).termEqual(Term2);
+            return Term1.Equals(YP.getValue(Term2));
+        }
+
+        public static bool termNotEqual(object Term1, object Term2)
+        {
+            return !termEqual(Term1, Term2);
+        }
+
+        public static bool termLessThan(object Term1, object Term2)
+        {
+            Term1 = YP.getValue(Term1);
+            Term2 = YP.getValue(Term2);
+            int term1TypeCode = getTypeCode(Term1);
+            int term2TypeCode = getTypeCode(Term2);
+            if (term1TypeCode != term2TypeCode)
+                return term1TypeCode < term2TypeCode;
+
+            // The terms are the same type code.
+            if (term1TypeCode == -2)
+            {
+                // Variable.
+                // We always check for equality first because we want to be sure
+                //   that less than returns false if the terms are equal, in
+                //   case that the less than check really behaves like less than or equal.
+                if ((Variable)Term1 != (Variable)Term2)
+                    // The hash code should be unique to a Variable object.
+                    return Term1.GetHashCode() < Term2.GetHashCode();
+                return false;
+            }
+            if (term1TypeCode == 0)
+                return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0;
+            if (term1TypeCode == 1)
+                return ((Functor1)Term1).lessThan((Functor1)Term2);
+            if (term1TypeCode == 2)
+                return ((Functor2)Term1).lessThan((Functor2)Term2);
+            if (term1TypeCode == 3)
+                return ((Functor3)Term1).lessThan((Functor3)Term2);
+            if (term1TypeCode == 4)
+                return ((Functor)Term1).lessThan((Functor)Term2);
+
+            // Type code is -1 for general objects.  First compare their type names.
+            // Note that this puts Double before Int32 as required by ISO Prolog.
+            string term1TypeName = Term1.GetType().ToString();
+            string term2TypeName = Term2.GetType().ToString();
+            if (term1TypeName != term2TypeName)
+                return term1TypeName.CompareTo(term2TypeName) < 0;
+
+            // The terms are the same type name.
+            if (Term1 is int)
+                return (int)Term1 < (int)Term2;
+            else if (Term1 is double)
+                return (double)Term1 < (double)Term2;
+            else if (Term1 is DateTime)
+                return (DateTime)Term1 < (DateTime)Term2;
+            else if (Term1 is String)
+                return ((String)Term1).CompareTo((String)Term2) < 0;
+            // Debug: Should we try arrays, etc.?
+
+            if (!Term1.Equals(Term2))
+                // Could be equal or greater than.
+                return Term1.GetHashCode() < Term2.GetHashCode();
+            return false;
+        }
+
+        /// <summary>
+        /// Type code is -2 if term is a Variable, 0 if it is an Atom,
+        /// 1 if it is a Functor1, 2 if it is a Functor2, 3 if it is a Functor3,
+        /// 4 if it is Functor.
+        /// Otherwise, type code is -1.
+        /// This does not call YP.getValue(term).
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        private static int getTypeCode(object term)
+        {
+            if (term is Variable)
+                return -2;
+            else if (term is Atom)
+                return 0;
+            else if (term is Functor1)
+                return 1;
+            else if (term is Functor2)
+                return 2;
+            else if (term is Functor3)
+                return 3;
+            else if (term is Functor)
+                return 4;
+            else
+                return -1;
+        }
+
+        public static bool termLessThanOrEqual(object Term1, object Term2)
+        {
+            if (YP.termEqual(Term1, Term2))
+                return true;
+            return YP.termLessThan(Term1, Term2);
+        }
+
+        public static bool termGreaterThan(object Term1, object Term2)
+        {
+            return !YP.termLessThanOrEqual(Term1, Term2);
+        }
+
+        public static bool termGreaterThanOrEqual(object Term1, object Term2)
+        {
+            // termLessThan should ensure that it returns false if terms are equal,
+            //   so that this would return true.
+            return !YP.termLessThan(Term1, Term2);
+        }
+
+        public static int compareTerms(object Term1, object Term2)
+        {
+            if (YP.termEqual(Term1, Term2))
+                return 0;
+            else if (YP.termLessThan(Term1, Term2))
+                return -1;
+            else
+                return 1;
+        }
+
+        public static bool ground(object Term)
+        {
+            Term = YP.getValue(Term);
+            if (Term is IUnifiable)
+                return ((IUnifiable)Term).ground();
+            return true;
+        }
+
+        public static IEnumerable<bool> current_op
+            (object Priority, object Specifier, object Operator)
+        {
+            if (_operatorTable == null)
+            {
+                // Initialize.
+                _operatorTable = new List<object[]>();
+                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a(":-") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a("?-") });
+                _operatorTable.Add(new object[] { 1100, Atom.a("xfy"), Atom.a(";") });
+                _operatorTable.Add(new object[] { 1050, Atom.a("xfy"), Atom.a("->") });
+                _operatorTable.Add(new object[] { 1000, Atom.a("xfy"), Atom.a(",") });
+                _operatorTable.Add(new object[] { 900, Atom.a("fy"), Atom.a("\\+") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("==") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=..") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("is") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">=") });
+                _operatorTable.Add(new object[] { 600, Atom.a("xfy"), Atom.a(":") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("+") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("-") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("*") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("/") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("//") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("rem") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("mod") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("<<") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a(">>") });
+                _operatorTable.Add(new object[] { 200, Atom.a("xfx"), Atom.a("**") });
+                _operatorTable.Add(new object[] { 200, Atom.a("xfy"), Atom.a("^") });
+                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("-") });
+                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("\\") });
+                // Debug: This is hacked in to run the Prolog test suite until we implement op/3.
+                _operatorTable.Add(new object[] { 20, Atom.a("xfx"), Atom.a("<--") });
+            }
+
+            object[] args = new object[] { Priority, Specifier, Operator };
+            foreach (object[] answer in _operatorTable)
+            {
+                foreach (bool l1 in YP.unifyArrays(args, answer))
+                    yield return false;
+            }
+        }
+
+        public static IEnumerable<bool> atom_length(object atom, object Length)
+        {
+            return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length);
+        }
+
+        public static IEnumerable<bool> atom_concat(object Start, object End, object Whole)
+        {
+            // Debug: Should implement for var(Start) which is a kind of search.
+            // Debug: Should we try to preserve the _declaringClass?
+            return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name +
+                ((Atom)YP.getValue(End))._name));
+        }
+
+        public static IEnumerable<bool> sub_atom
+            (object atom, object Before, object Length, object After, object Sub_atom)
+        {
+            // Debug: Should implement for var(atom) which is a kind of search.
+            // Debug: Should we try to preserve the _declaringClass?
+            Atom atomAtom = (Atom)YP.getValue(atom);
+            int beforeInt = YP.convertInt(Before);
+            int lengthInt = YP.convertInt(Length);
+            if (beforeInt < 0)
+                throw new Exception("Before must be non-negative");
+            if (lengthInt < 0)
+                throw new Exception("Length must be non-negative");
+            int afterInt = atomAtom._name.Length - (beforeInt + lengthInt);
+            if (afterInt >= 0)
+            {
+                foreach (bool l1 in YP.unify(After, afterInt))
+                {
+                    foreach (bool l2 in YP.unify
+                        (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt))))
+                        yield return false;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> atom_codes(object atom, object List)
+        {
+            atom = YP.getValue(atom);
+            List = YP.getValue(List);
+
+            if (nonvar(atom))
+            {
+                string name = ((Atom)atom)._name;
+                object codeList = Atom.NIL;
+                // Start from the back to make the list.
+                for (int i = name.Length - 1; i >= 0; --i)
+                    codeList = new ListPair((int)name[i], codeList);
+                return YP.unify(List, codeList);
+            }
+            {
+                object[] codeArray = ListPair.toArray(List);
+                char[] charArray = new char[codeArray.Length];
+                for (int i = 0; i < codeArray.Length; ++i)
+                    charArray[i] = (char)YP.convertInt(codeArray[i]);
+                return YP.unify(atom, Atom.a(new String(charArray)));
+            }
+        }
+
+        public static IEnumerable<bool> number_codes(object number, object List)
+        {
+            number = YP.getValue(number);
+            List = YP.getValue(List);
+
+            if (nonvar(number))
+            {
+                string numberString = null;
+                // Try converting to an int first.
+                int intNumber;
+                if (YP.getInt(number, out intNumber))
+                    numberString = intNumber.ToString();
+                else
+                    numberString = YP.doubleToString(YP.convertDouble(number));
+
+                object codeList = Atom.NIL;
+                // Start from the back to make the list.
+                for (int i = numberString.Length - 1; i >= 0; --i)
+                    codeList = new ListPair((int)numberString[i], codeList);
+                return YP.unify(List, codeList);
+            }
+            {
+                object[] codeArray = ListPair.toArray(List);
+                char[] charArray = new char[codeArray.Length];
+                for (int i = 0; i < codeArray.Length; ++i)
+                    charArray[i] = (char)YP.convertInt(codeArray[i]);
+                String numberString = new String(charArray);
+                // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
+                try
+                {
+                    // Try an int first.
+                    return YP.unify(number, Convert.ToInt32(numberString));
+                }
+                catch (FormatException) { }
+                return YP.unify(number, Convert.ToDouble(numberString));
+            }
+        }
+
+        /// <summary>
+        /// If term is an Atom or functor type, return its name.
+        /// Otherwise, return term.
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        public static object getFunctorName(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor1)
+                return ((Functor1)term)._name;
+            else if (term is Functor2)
+                return ((Functor2)term)._name;
+            else if (term is Functor3)
+                return ((Functor3)term)._name;
+            else if (term is Functor)
+                return ((Functor)term)._name;
+            else
+                return term;
+        }
+
+        /// <summary>
+        /// If term is an Atom or functor type, return an array of its args.
+        /// Otherwise, return an empty array.
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        public static object[] getFunctorArgs(object term)
+        {
+            term = YP.getValue(term);
+            if (term is Functor1)
+            {
+                Functor1 functor = (Functor1)term;
+                return new object[] { functor._arg1 };
+            }
+            else if (term is Functor2)
+            {
+                Functor2 functor = (Functor2)term;
+                return new object[] { functor._arg1, functor._arg2 };
+            }
+            else if (term is Functor3)
+            {
+                Functor3 functor = (Functor3)term;
+                return new object[] { functor._arg1, functor._arg2, functor._arg3 };
+            }
+            else if (term is Functor) {
+                Functor functor = (Functor)term;
+                return functor._args;
+            }
+            else
+                return new object[0];
+        }
+
+        public static bool var(object Term)
+        {
+            return YP.getValue(Term) is Variable;
+        }
+
+        public static bool nonvar(object Term)
+        {
+            return !YP.var(Term);
+        }
+
+        public static bool atom(object Term)
+        {
+            return YP.getValue(Term) is Atom;
+        }
+
+        public static bool integer(object Term)
+        {
+            // Debug: Should exhaustively check for all integer types.
+            return getValue(Term) is int;
+        }
+
+        // Use isFloat instead of float because it is a reserved keyword.
+        public static bool isFloat(object Term)
+        {
+            // Debug: Should exhaustively check for all float types.
+            return getValue(Term) is double;
+        }
+
+        public static bool number(object Term)
+        {
+            return YP.integer(Term) || YP.isFloat(Term);
+        }
+
+        public static bool atomic(object Term)
+        {
+            return YP.atom(Term) || YP.number(Term);
+        }
+
+        public static bool compound(object Term)
+        {
+            Term = getValue(Term);
+            return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor;
+        }
+
+        public static void see(object input)
+        {
+            input = YP.getValue(input);
+            if (input is TextReader)
+            {
+                _inputStream = (TextReader)input;
+                return;
+            }
+            else if (input is Atom)
+            {
+                _inputStream = new StreamReader(((Atom)input)._name);
+                return;
+            }
+            else if (input is String)
+            {
+                _inputStream = new StreamReader((String)input);
+                return;
+            }
+            else
+                throw new InvalidOperationException("Can't open stream for " + input);
+        }
+
+        public static void seen()
+        {
+            if (_inputStream == Console.In)
+                return;
+            _inputStream.Close();
+            _inputStream = Console.In;
+        }
+
+        public static void tell(object output)
+        {
+            output = YP.getValue(output);
+            if (output is TextWriter)
+            {
+                _outputStream = (TextWriter)output;
+                return;
+            }
+            else if (output is Atom)
+            {
+                _outputStream = new StreamWriter(((Atom)output)._name);
+                return;
+            }
+            else if (output is String)
+            {
+                _outputStream = new StreamWriter((String)output);
+                return;
+            }
+            else
+                throw new InvalidOperationException("Can't open stream for " + output);
+        }
+
+        public static void told()
+        {
+            if (_outputStream == Console.Out)
+                return;
+            _outputStream.Close();
+            _outputStream = Console.Out;
+        }
+
+        public static IEnumerable<bool> current_output(object Stream)
+        {
+            return YP.unify(Stream, _outputStream);
+        }
+
+        public static void write(object x)
+        {
+            x = YP.getValue(x);
+            if (x is double)
+                _outputStream.Write(doubleToString((double)x));
+            else
+                _outputStream.Write(x.ToString());
+        }
+
+        /// <summary>
+        /// Format x as a string, making sure that it will parse as an int later.  I.e., for 1.0, don't just
+        /// use "1" which will parse as an int.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        private static string doubleToString(double x)
+        {
+            string xString = x.ToString();
+            // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
+            try
+            {
+                Convert.ToInt32(xString);
+                // The string will parse as an int, not a double, so re-format so that it does.
+                // Use float if possible, else exponential if it would be too big.
+                return x.ToString(x >= 100000.0 ? "E1" : "f1");
+            }
+            catch (FormatException)
+            {
+                // Assume it will parse as a double.
+            }
+            return xString;
+        }
+
+        public static void put_code(object x)
+        {
+            _outputStream.Write((char)YP.convertInt(x));
+        }
+
+        public static void nl()
+        {
+            _outputStream.WriteLine();
+        }
+
+        public static IEnumerable<bool> get_code(object code)
+        {
+            return YP.unify(code, _inputStream.Read());
+        }
+
+        public static void asserta(object Term, Type declaringClass)
+        {
+            assertDynamic(Term, declaringClass, true);
+        }
+
+        public static void assertz(object Term, Type declaringClass)
+        {
+            assertDynamic(Term, declaringClass, false);
+        }
+
+        public static void assertDynamic(object Term, Type declaringClass, bool prepend)
+        {
+            Term = getValue(Term);
+            if (Term is Variable)
+                throw new PrologException("instantiation_error", "Term to assert is an unbound variable");
+
+            Variable.CopyStore copyStore = new Variable.CopyStore();
+            object TermCopy = makeCopy(Term, copyStore);
+            object Head, Body;
+            if (TermCopy is Functor2 && ((Functor2)TermCopy)._name == Atom.RULE)
+            {
+                Head = YP.getValue(((Functor2)TermCopy)._arg1);
+                Body = YP.getValue(((Functor2)TermCopy)._arg2);
+            }
+            else
+            {
+                Head = TermCopy;
+                Body = Atom.a("true");
+            }
+
+            Atom name = getFunctorName(Head) as Atom;
+            if (name == null)
+                // name is a non-Atom, such as a number.
+                throw new PrologException
+                    (new Functor2("type_error", Atom.a("callable"), Head), "Term to assert is not callable");
+            object[] args = getFunctorArgs(Head);
+            if (!isDynamic(name, args.Length))
+                throw new PrologException
+                    (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"),
+                                  new Functor2(Atom.SLASH, name, args.Length)),
+                     "Assert cannot modify static predicate " + name + "/" + args.Length);
+
+            if (copyStore.getNUniqueVariables() == 0 && Body == Atom.a("true"))
+            {
+                // Debug: Until IndexedAnswers supports prepend, compile the fact so we can prepend it below.
+                if (!prepend)
+                {
+                    // This is a fact with no unbound variables
+                    // assertFact uses IndexedAnswers, so don't we don't need to compile.
+                    assertFact(name, args);
+                    return;
+                }
+            }
+
+            IClause clause = YPCompiler.compileAnonymousClause(Head, Body, declaringClass);
+
+            // Add the clause to the entry in _predicatesStore.
+            NameArity nameArity = new NameArity(name, args.Length);
+            List<IClause> clauses;
+            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
+                // Create an entry for the nameArity.
+                _predicatesStore[nameArity] = (clauses = new List<IClause>());
+
+            if (prepend)
+                clauses.Insert(0, clause);
+            else
+                clauses.Add(clause);
+        }
+
+        private static bool isDynamic(Atom name, int arity)
+        {
+            if (arity == 2 && (name == Atom.a(",") || name == Atom.a(";") || name == Atom.DOT))
+                return false;
+            // Use the same mapping to static predicates in YP as the compiler.
+            foreach (bool l1 in YPCompiler.functorCallYPFunctionName(name, arity, new Variable()))
+                return false;
+            // Debug: Do we need to check if name._module is null?
+            return true;
+        }
+
+        /// <summary>
+        /// Assert values at the end of the set of facts for the predicate with the
+        /// name and with arity values.Length.
+        /// </summary>
+        /// <param name="name">must be an Atom</param>
+        /// <param name="values">the array of arguments to the fact predicate.
+        /// It is an error if an value has an unbound variable.</param>
+        public static void assertFact(Atom name, object[] values)
+        {
+            NameArity nameArity = new NameArity(name, values.Length);
+            List<IClause> clauses;
+            IndexedAnswers indexedAnswers;
+            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
+            {
+                // Create an IndexedAnswers as the first clause of the predicate.
+                _predicatesStore[nameArity] = (clauses = new List<IClause>());
+                clauses.Add(indexedAnswers = new IndexedAnswers());
+            }
+            else
+            {
+                indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers;
+                if (indexedAnswers == null)
+                    // The latest clause is not an IndexedAnswers, so add one.
+                    clauses.Add(indexedAnswers = new IndexedAnswers());
+            }
+
+            indexedAnswers.addAnswer(values);
+        }
+
+        /// <summary>
+        /// Match all clauses of the dynamic predicate with the name and with arity
+        /// arguments.Length.
+        /// It is an error if the predicate is not defined.
+        /// </summary>
+        /// <param name="name">must be an Atom</param>
+        /// <param name="arguments">an array of arity number of arguments</param>
+        /// <returns>an iterator which you can use in foreach</returns>
+        public static IEnumerable<bool> matchDynamic(Atom name, object[] arguments)
+        {
+            List<IClause> clauses;
+            if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses))
+                throw new UndefinedPredicateException
+                    ("Undefined fact: " + name + "/" + arguments.Length, name,
+                    arguments.Length);
+
+            if (clauses.Count == 1)
+                // Usually there is only one clause, so return it without needing to wrap it in an iterator.
+                return clauses[0].match(arguments);
+            else
+                return matchAllClauses(clauses, arguments);
+        }
+
+        /// <summary>
+        /// Call match(arguments) for each IClause in clauses.  We make this a separate
+        /// function so that matchDynamic itself does not need to be an iterator object.
+        /// </summary>
+        /// <param name="clauses"></param>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        private static IEnumerable<bool> matchAllClauses(List<IClause> clauses, object[] arguments)
+        {
+            // Debug: If the clause asserts another clause into this same predicate, the iterator
+            //   over clauses will be corrupted.  Should we take the time to copy clauses?
+            foreach (IClause clause in clauses)
+            {
+                foreach (bool lastCall in clause.match(arguments))
+                {
+                    yield return false;
+                    if (lastCall)
+                        // This happens after a cut in a clause.
+                        yield break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is deprecated and just calls matchDynamic. This matches all clauses, 
+        /// not just the ones defined with assertFact.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        public static IEnumerable<bool> matchFact(Atom name, object[] arguments)
+        {
+            return matchDynamic(name, arguments);
+        }
+
+        /// <summary>
+        /// This actually searches all clauses, not just
+        /// the ones defined with assertFact, but we keep the name for 
+        /// backwards compatibility.
+        /// </summary>
+        /// <param name="name">must be an Atom</param>
+        /// <param name="arguments">an array of arity number of arguments</param>
+        public static void retractFact(Atom name, object[] arguments)
+        {
+            NameArity nameArity = new NameArity(name, arguments.Length);
+            List<IClause> clauses;
+            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
+                // Can't find, so ignore.
+                return;
+
+            foreach (object arg in arguments)
+            {
+                if (!YP.var(arg))
+                    throw new InvalidOperationException("All arguments must be unbound");
+            }
+            // Set to a fresh empty IndexedAnswers.
+            _predicatesStore[nameArity] = (clauses = new List<IClause>());
+            clauses.Add(new IndexedAnswers());
+        }
+
+        public static IEnumerable<bool> current_predicate(object NameSlashArity)
+        {
+            NameSlashArity = YP.getValue(NameSlashArity);
+            // First check if Name and Arity are nonvar so we can do a direct lookup.
+            if (YP.ground(NameSlashArity))
+            {
+                if (NameSlashArity is Functor2)
+                {
+                    Functor2 NameArityFunctor = (Functor2)NameSlashArity;
+                    if (NameArityFunctor._name == Atom.SLASH)
+                    {
+                        if (_predicatesStore.ContainsKey(new NameArity
+                             ((Atom)YP.getValue(NameArityFunctor._arg1),
+                              (int)YP.getValue(NameArityFunctor._arg2))))
+                            // The predicate is defined.
+                            yield return false;
+                    }
+                }
+                yield break;
+            }
+
+            foreach (NameArity key in _predicatesStore.Keys)
+            {
+                foreach (bool l1 in YP.unify
+                    (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity))
+                    yield return false;
+            }
+        }
+
+        /// <summary>
+        /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the
+        /// declaringClass, using arguments from YP.getFunctorArgs(Goal).
+        /// Note that Goal must be a simple functor, not a complex expression.
+        /// If not found, this throws UndefinedPredicateException.
+        /// </summary>
+        /// <param name="Goal"></param>
+        /// <param name="contextClass">the class for looking up default function references</param>
+        /// <returns></returns>
+        public static IEnumerable<bool> getIterator(object Goal, Type declaringClass)
+        {
+            Goal = YP.getValue(Goal);
+            if (Goal is Variable)
+                throw new PrologException("instantiation_error", "Goal to call is an unbound variable");
+#if true
+            List<Variable> variableSetList = new List<Variable>();
+            addUniqueVariables(Goal, variableSetList);
+            Variable[] variableSet = variableSetList.ToArray();
+
+            // Use Atom.F since it is ignored.
+            return YPCompiler.compileAnonymousClause
+                (Functor.make(Atom.F, variableSet), Goal, declaringClass).match(variableSet);
+#else
+            Atom name;
+            object[] args;
+            while (true)
+            {
+                name = (Atom)YP.getFunctorName(Goal);
+                args = YP.getFunctorArgs(Goal);
+                if (name == Atom.HAT && args.Length == 2)
+                    // Assume this is called from a bagof operation.  Skip the leading qualifiers.
+                    Goal = YP.getValue(((Functor2)Goal)._arg2);
+                else
+                    break;
+            }
+            try
+            {
+                return (IEnumerable<bool>)declaringClass.InvokeMember
+                  (name._name, BindingFlags.InvokeMethod, null, null, args);
+            }
+            catch (TargetInvocationException exception)
+            {
+                throw exception.InnerException;
+            }
+            catch (MissingMethodException)
+            {
+                throw new UndefinedPredicateException
+                    ("Cannot find predicate function: " + name + "/" + args.Length + " in " +
+                     declaringClass.FullName, name, args.Length);
+            }
+#endif
+        }
+
+        public static void throwException(object Term)
+        {
+            throw new PrologException(Term);
+        }
+
+        /// <summary>
+        /// script_event calls hosting script with events as a callback method.
+        /// </summary>
+        /// <param name="script_event"></param>
+        /// <param name="script_params"></param>
+        /// <returns></returns>
+        public static void script_event(object script_event, object script_params)
+        {
+            string function = ((Atom)YP.getValue(script_event))._name;
+            object[] array = ListPair.toArray(script_params);
+            if (array == null)
+                return; // YP.fail();
+            if (array.Length > 1)
+            {
+                //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue
+                //(localID, itemID, function, array);
+                // sortArray(array);
+            }
+            //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
+        }
+
+        /// <summary>
+        /// An enumerator that does zero loops.
+        /// </summary>
+        private class Fail : IEnumerator<bool>, IEnumerable<bool>
+        {
+            public bool MoveNext()
+            {
+                return false;
+            }
+
+            public IEnumerator<bool> GetEnumerator()
+            {
+                return (IEnumerator<bool>)this;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public bool Current
+            {
+                get { return true; }
+            }
+
+            object IEnumerator.Current
+            {
+                get { return true; }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            public void Reset()
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// An enumerator that does one iteration.
+        /// </summary>
+        private class Succeed : IEnumerator<bool>, IEnumerable<bool>
+        {
+            private bool _didIteration = false;
+
+            public bool MoveNext()
+            {
+                if (!_didIteration)
+                {
+                    _didIteration = true;
+                    return true;
+                }
+                else
+                    return false;
+            }
+
+            public IEnumerator<bool> GetEnumerator()
+            {
+                return (IEnumerator<bool>)this;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public bool Current
+            {
+                get { return false; }
+            }
+
+            object IEnumerator.Current
+            {
+                get { return false; }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            public void Reset()
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// An enumerator that repeats forever.
+        /// </summary>
+        private class Repeat : IEnumerator<bool>, IEnumerable<bool>
+        {
+            public bool MoveNext()
+            {
+                return true;
+            }
+
+            public IEnumerator<bool> GetEnumerator()
+            {
+                return (IEnumerator<bool>)this;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public bool Current
+            {
+                get { return false; }
+            }
+
+            object IEnumerator.Current
+            {
+                get { return false; }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            public void Reset()
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// An enumerator that wraps another enumerator in order to catch a PrologException.
+        /// </summary>
+        public class Catch : IEnumerator<bool>, IEnumerable<bool>
+        {
+            private IEnumerator<bool> _enumerator;
+            private PrologException _exception = null;
+
+            public Catch(IEnumerable<bool> iterator)
+            {
+                _enumerator = iterator.GetEnumerator();
+            }
+
+            /// <summary>
+            /// Call _enumerator.MoveNext().  If it throws a PrologException, set _exception
+            /// and return false.  After this returns false, call unifyExceptionOrThrow.
+            /// Assume that, after this returns false, it will not be called again.
+            /// </summary>
+            /// <returns></returns>
+            public bool MoveNext()
+            {
+                try
+                {
+                    return _enumerator.MoveNext();
+                }
+                catch (PrologException exception)
+                {
+                    _exception = exception;
+                    return false;
+                }
+            }
+
+            /// <summary>
+            /// Call this after MoveNext() returns false to check for an exception.  If
+            /// MoveNext did not get a PrologException, don't yield.
+            /// Otherwise, unify the exception with Catcher and yield so the caller can
+            /// do the handler code.  However, if can't unify with Catcher then throw the exception.
+            /// </summary>
+            /// <param name="Catcher"></param>
+            /// <returns></returns>
+            public IEnumerable<bool> unifyExceptionOrThrow(object Catcher)
+            {
+                if (_exception != null)
+                {
+                    bool didUnify = false;
+                    foreach (bool l1 in YP.unify(_exception._term, Catcher))
+                    {
+                        didUnify = true;
+                        yield return false;
+                    }
+                    if (!didUnify)
+                        throw _exception;
+                }
+            }
+
+            public IEnumerator<bool> GetEnumerator()
+            {
+                return (IEnumerator<bool>)this;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            public bool Current
+            {
+                get { return _enumerator.Current; }
+            }
+
+            object IEnumerator.Current
+            {
+                get { return _enumerator.Current; }
+            }
+
+            public void Dispose()
+            {
+                _enumerator.Dispose();
+            }
+
+            public void Reset()
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs
new file mode 100644
index 0000000..f2f8145
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs
@@ -0,0 +1,5651 @@
+/*
+ * Copyright (C) 2007-2008, Jeff Thompson
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the copyright holder nor the names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.CodeDom.Compiler;
+
+namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog
+{
+    public class YPCompiler
+    {
+        private class CompilerState
+        {
+            public IndexedAnswers _pred = new IndexedAnswers();
+            public Dictionary<YP.NameArity, Atom> _moduleForNameArity = new Dictionary<YP.NameArity, Atom>();
+            public int _gensymCounter;
+            public bool _useFinalCutCode;
+            public Variable _finalCutCode;
+            public bool _codeUsesYield;
+            public Atom _determinism;
+            // a list of '='(Name, Variable)
+            public List<object> _variableNames;
+
+            // Make these static functions that explicitly take the State so Prolog can call it.
+
+            /// <summary>
+            /// Make a new CompilerState and bind it to State.
+            /// </summary>
+            /// <param name="State"></param>
+            /// <returns></returns>
+            public static IEnumerable<bool> make(object State)
+            {
+                return YP.unify(State, new CompilerState());
+            }
+
+            public static void assertPred(object State, object Pred, object Determinism)
+            {
+                State = YP.getValue(State);
+                object functorName = YP.getFunctorName(Pred);
+                object[] functorArgs = YP.getFunctorArgs(Pred);
+                // Debug: Should check if it's already asserted and is the same.
+                ((CompilerState)State)._pred.addAnswer
+                    (new object[] { functorName, functorArgs.Length, Pred, YP.getValue(Determinism) });
+            }
+
+            public static void assertModuleForNameArity(object State, object Name, object Arity, object Module)
+            {
+                State = YP.getValue(State);
+                Name = YP.getValue(Name);
+                Arity = YP.getValue(Arity);
+                Module = YP.getValue(Module);
+                // If the Module Atom comes from the parser, it always has null _declaringClass.
+                if (Module is Atom && ((Atom)Module)._module == null && Name is Atom && Arity is int)
+                {
+                    // Replace a previous entry if it exists.
+                    ((CompilerState)State)._moduleForNameArity[new YP.NameArity((Atom)Name, (int)Arity)] =
+                        (Atom)Module;
+                }
+            }
+
+            public static void startFunction(object State, object Head)
+            {
+                State = YP.getValue(State);
+                ((CompilerState)State)._gensymCounter = 0;
+                ((CompilerState)State)._useFinalCutCode = false;
+                ((CompilerState)State)._finalCutCode = new Variable();
+                ((CompilerState)State)._codeUsesYield = false;
+                if (CompilerState.isDetNoneOut(State, Head))
+                    ((CompilerState)State)._determinism = Atom.a("detNoneOut");
+                else if (CompilerState.isSemidetNoneOut(State, Head))
+                    ((CompilerState)State)._determinism = Atom.a("semidetNoneOut");
+                else
+                    ((CompilerState)State)._determinism = Atom.a("nondet");
+            }
+
+            public static void setCodeUsesYield(object State)
+            {
+                State = YP.getValue(State);
+                ((CompilerState)State)._codeUsesYield = true;
+            }
+
+            public static bool codeUsesYield(object State)
+            {
+                State = YP.getValue(State);
+                return ((CompilerState)State)._codeUsesYield;
+            }
+
+            public static bool determinismEquals(object State, object Term)
+            {
+                State = YP.getValue(State);
+                return YP.termEqual(((CompilerState)State)._determinism, Term);
+            }
+
+            /// <summary>
+            /// Set _variableNames to a new list of (Name = Variable) for each unique variable in rule.
+            /// If the variable is in variableNameSuggestions, use it, otherwise use x1, x2, etc.
+            /// </summary>
+            /// <param name="State"></param>
+            /// <param name="rule"></param>
+            /// <param name="variableNameSuggestions"></param>
+            public static void newVariableNames(object State, object Rule, object VariableNameSuggestions)
+            {
+                State = YP.getValue(State);
+                List<Variable> variablesSet = new List<Variable>();
+                YP.addUniqueVariables(Rule, variablesSet);
+
+                ((CompilerState)State)._variableNames = new List<object>();
+                int xCounter = 0;
+                foreach (Variable variable in variablesSet)
+                    ((CompilerState)State)._variableNames.Add
+                        (new Functor2(Atom.a("="), makeVariableName(variable, VariableNameSuggestions, ++xCounter),
+                                      variable));
+            }
+
+            private static object makeVariableName(object variable, object variableNameSuggestions, int xCounter)
+            {
+                // Debug: should require named variables to start with _ or capital. Should
+                //   check for duplicates and clashes with keywords.
+                for (object element = YP.getValue(variableNameSuggestions);
+                     element is Functor2 && ((Functor2)element)._name == Atom.DOT;
+                     element = YP.getValue(((Functor2)element)._arg2))
+                {
+                    object suggestionPair = YP.getValue(((Functor2)element)._arg1);
+                    if (sameVariable(variable, ((Functor2)suggestionPair)._arg2))
+                    {
+                        Atom suggestion = (Atom)YP.getValue(((Functor2)suggestionPair)._arg1);
+                        if (suggestion.Equals(Atom.a("Atom")))
+                            suggestion = Atom.a("Atom_1");
+                        if (suggestion.Equals(Atom.a("Variable")))
+                            suggestion = Atom.a("Variable_1");
+                        if (suggestion.Equals(Atom.a("Functor")))
+                            suggestion = Atom.a("Functor_1");
+                        return suggestion;
+                    }
+                }
+
+                return Atom.a("x" + xCounter);
+            }
+
+            /// <summary>
+            /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames
+            ///   for variable.
+            /// </summary>
+            /// <param name="variable">a Variable</param>
+            /// <param name="State"></param>
+            /// <param name="Result">the assigned Name</param>
+            public static IEnumerable<bool> getVariableName(object State, object variable, object Result)
+            {
+                State = YP.getValue(State);
+                foreach (object variableInfo in ((CompilerState)State)._variableNames)
+                {
+                    if (variableInfo is Functor2 && ((Functor2)variableInfo)._name.Equals(Atom.a("=")))
+                    {
+                        if (sameVariable(variable, ((Functor2)variableInfo)._arg2))
+                            return YP.unify(Result, ((Functor2)variableInfo)._arg1);
+                    }
+                }
+
+                // We set up names for all unique variables, so this should never happen.
+                throw new PrologException(Atom.a("Can't find entry in _variableNames"));
+            }
+
+            public static IEnumerable<bool> variableNamesList(object State, object VariableNamesList)
+            {
+                State = YP.getValue(State);
+                return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames));
+            }
+
+            public static IEnumerable<bool> gensym(object State, object Base, object Symbol)
+            {
+                State = YP.getValue(State);
+                return YP.unify(Symbol, Atom.a(Base.ToString() + ++((CompilerState)State)._gensymCounter));
+            }
+
+            public static bool isDetNoneOut(object State, object Term)
+            {
+                State = YP.getValue(State);
+                object functorName = YP.getFunctorName(Term);
+                object[] functorArgs = YP.getFunctorArgs(Term);
+
+                Variable pred = new Variable();
+                foreach (bool l1 in ((CompilerState)State)._pred.match
+                    (new object[] { functorName, functorArgs.Length, pred, Atom.a("det") }))
+                {
+                    if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue())))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            public static bool isSemidetNoneOut(object State, object Term)
+            {
+                State = YP.getValue(State);
+                object functorName = YP.getFunctorName(Term);
+                object[] functorArgs = YP.getFunctorArgs(Term);
+
+                Variable pred = new Variable();
+                foreach (bool l1 in ((CompilerState)State)._pred.match
+                    (new object[] { functorName, functorArgs.Length, pred, Atom.a("semidet") }))
+                {
+                    if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue())))
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            /// Return false if any of args is out, otherwise true.
+            /// args is an array of ::(Type,Mode) where Mode is in or out.
+            /// </summary>
+            /// <param name="args"></param>
+            /// <returns></returns>
+            private static bool isNoneOut(object[] args)
+            {
+                foreach (object arg in args)
+                {
+                    if (arg is Functor2 && ((Functor2)arg)._name == Atom.a("::") &&
+                        ((Functor2)arg)._arg2 == Atom.a("out"))
+                        return false;
+                }
+                return true;
+            }
+
+            public static bool nameArityHasModule(object State, object Name, object Arity, object Module)
+            {
+                State = YP.getValue(State);
+                Name = YP.getValue(Name);
+                Arity = YP.getValue(Arity);
+                Module = YP.getValue(Module);
+                if (Name is Atom && Arity is int)
+                {
+                    Atom FoundModule;
+                    if (!((CompilerState)State)._moduleForNameArity.TryGetValue
+                         (new YP.NameArity((Atom)Name, (int)Arity), out FoundModule))
+                        return false;
+                    return FoundModule == Module;
+                }
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Use makeFunctionPseudoCode, convertFunctionCSharp and compileAnonymousFunction
+        /// to return an anonymous YP.IClause for the Head and Body of a rule clause.
+        /// </summary>
+        /// <param name="Head">a prolog term such as new Functor2("test1", X, Y).
+        /// Note that the name of the head is ignored.
+        /// </param>
+        /// <param name="Body">a prolog term such as 
+        /// new Functor2(",", new Functor1(Atom.a("test2", Atom.a("")), X), 
+        ///              new Functor2("=", Y, X)).
+        /// This may not be null.  (For a head-only clause, set the Body to Atom.a("true").
+        /// </param>
+        /// <param name="declaringClass">if not null, the code is compiled as a subclass of this class
+        /// to resolve references to the default module Atom.a("")</param>
+        /// <returns>a new YP.IClause object on which you can call match(object[] args) where
+        /// args length is the arity of the Head</returns>
+        public static YP.IClause compileAnonymousClause(object Head, object Body, Type declaringClass)
+        {
+            object[] args = YP.getFunctorArgs(Head);
+            // compileAnonymousFunction wants "function".
+            object Rule = new Functor2(Atom.RULE, Functor.make("function", args), Body);
+            object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL));
+
+            StringWriter functionCode = new StringWriter();
+            Variable SaveOutputStream = new Variable();
+            foreach (bool l1 in YP.current_output(SaveOutputStream))
+            {
+                try
+                {
+                    YP.tell(functionCode);
+                    Variable FunctionCode = new Variable();
+                    foreach (bool l2 in makeFunctionPseudoCode(RuleList, FunctionCode))
+                    {
+                        if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass")))
+                            // Ignore getDeclaringClass since we have access to the one passed in.
+                            continue;
+
+                        // Debug: should check if FunctionCode is a single call.
+                        convertFunctionCSharp(FunctionCode);
+                    }
+                    YP.told();
+                }
+                finally
+                {
+                    // Restore after calling tell.
+                    YP.tell(SaveOutputStream.getValue());
+                }
+            }
+            return YPCompiler.compileAnonymousFunction
+                (functionCode.ToString(), args.Length, declaringClass);
+        }
+
+        /// <summary>
+        /// Use CodeDomProvider to compile the functionCode and return a YP.IClause.
+        /// The function name must be "function" and have nArgs arguments.
+        /// </summary>
+        /// <param name="functionCode">the code for the iterator, such as
+        /// "public static IEnumerable<bool> function() { yield return false; }"
+        /// </param>
+        /// <param name="nArgs">the number of args in the function</param>
+        /// <param name="declaringClass">if not null, then use the functionCode inside a class which
+        /// inherits from contextClass, so that references in functionCode to methods in declaringClass don't
+        /// have to be qualified</param>
+        /// <returns>a new YP.IClause object on which you can call match(object[] args) where
+        /// args length is nArgs</returns>
+        public static YP.IClause compileAnonymousFunction(string functionCode, int nArgs, Type declaringClass)
+        {
+            CompilerParameters parameters = new CompilerParameters();
+            // This gets the location of the System assembly.
+            parameters.ReferencedAssemblies.Add(typeof(System.Int32).Assembly.Location);
+            // This gets the location of this assembly which also has YieldProlog.YP, etc.
+            parameters.ReferencedAssemblies.Add(typeof(YPCompiler).Assembly.Location);
+            if (declaringClass != null)
+                parameters.ReferencedAssemblies.Add(declaringClass.Assembly.Location);
+            parameters.GenerateInMemory = true;
+
+            StringBuilder sourceCode = new StringBuilder();
+            sourceCode.Append(@"
+using System;
+using System.Collections.Generic;
+using YieldProlog;
+
+namespace Temporary {
+  public class Temporary : YP.IClause {
+    public class Inner" + (declaringClass == null ? "" : " : " + declaringClass.FullName) + @" {
+");
+            sourceCode.Append(functionCode);
+            // Basically, match applies the args to function.
+            sourceCode.Append(@"
+    }
+    public IEnumerable<bool> match(object[] args) {
+      return Inner.function(");
+            if (nArgs >= 1)
+                sourceCode.Append("args[0]");
+            for (int i = 1; i < nArgs; ++i)
+                sourceCode.Append(", args[" + i + "]");
+            sourceCode.Append(@");
+    }
+  }
+}
+");
+
+            CompilerResults results = CodeDomProvider.CreateProvider
+                ("CSharp").CompileAssemblyFromSource(parameters, sourceCode.ToString());
+            if (results.Errors.Count > 0)
+                throw new Exception("Error evaluating code: " + results.Errors[0]);
+
+            // Return a new Temporary.Temporary object.
+            return (YP.IClause)results.CompiledAssembly.GetType
+                ("Temporary.Temporary").GetConstructor(Type.EmptyTypes).Invoke(null);
+        }
+
+        // Compiler output follows.
+
+        public class YPInnerClass { }
+        public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }
+
+        public static void repeatWrite(object arg1, object N)
+        {
+            {
+                object _Value = arg1;
+                if (YP.termEqual(N, 0))
+                {
+                    return;
+                }
+            }
+            {
+                object Value = arg1;
+                Variable NextN = new Variable();
+                YP.write(Value);
+                foreach (bool l2 in YP.unify(NextN, YP.subtract(N, 1)))
+                {
+                    repeatWrite(Value, NextN);
+                    return;
+                }
+            }
+        }
+
+        public static bool sameVariable(object Variable1, object Variable2)
+        {
+            {
+                if (YP.var(Variable1))
+                {
+                    if (YP.var(Variable2))
+                    {
+                        if (YP.termEqual(Variable1, Variable2))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        public static IEnumerable<bool> makeFunctionPseudoCode(object RuleList, object FunctionCode)
+        {
+            {
+                Variable State = new Variable();
+                foreach (bool l2 in CompilerState.make(State))
+                {
+                    CompilerState.assertPred(State, Atom.a(@"nl"), Atom.a(@"det"));
+                    CompilerState.assertPred(State, new Functor1(@"write", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det"));
+                    CompilerState.assertPred(State, new Functor1(@"put_code", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det"));
+                    CompilerState.assertPred(State, new Functor1(@"throw", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det"));
+                    CompilerState.assertPred(State, new Functor1(@"var", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"nonvar", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"atom", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"integer", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"float", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"number", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"atomic", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor1(@"compound", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"\==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"@<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"@=<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"@>", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    CompilerState.assertPred(State, new Functor2(@"@>=", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
+                    processCompilerDirectives(RuleList, State);
+                    foreach (bool l3 in YP.unify(FunctionCode, Atom.a(@"getDeclaringClass")))
+                    {
+                        yield return false;
+                    }
+                    foreach (bool l3 in makeFunctionPseudoCode3(RuleList, State, FunctionCode))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static void processCompilerDirectives(object arg1, object arg2)
+        {
+            {
+                object _State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                object State = arg2;
+                Variable Pred = new Variable();
+                Variable Determinism = new Variable();
+                Variable x3 = new Variable();
+                Variable RestRules = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor1(@"pred", new Functor2(@"is", Pred, Determinism))), x3), RestRules)))
+                {
+                    CompilerState.assertPred(State, Pred, Determinism);
+                    processCompilerDirectives(RestRules, State);
+                    return;
+                }
+            }
+            {
+                object State = arg2;
+                Variable Module = new Variable();
+                Variable PredicateList = new Variable();
+                Variable x3 = new Variable();
+                Variable RestRules = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor2(@"import", Module, PredicateList)), x3), RestRules)))
+                {
+                    foreach (bool l3 in importPredicateList(State, Module, PredicateList))
+                    {
+                        processCompilerDirectives(RestRules, State);
+                        return;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable x1 = new Variable();
+                Variable x2 = new Variable();
+                Variable RestRules = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", x1), x2), RestRules)))
+                {
+                    processCompilerDirectives(RestRules, State);
+                    return;
+                }
+            }
+            {
+                object State = arg2;
+                Variable Head = new Variable();
+                Variable _Body = new Variable();
+                Variable x3 = new Variable();
+                Variable RestRules = new Variable();
+                Variable Name = new Variable();
+                Variable Arity = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor2(@":-", Head, _Body), x3), RestRules)))
+                {
+                    foreach (bool l3 in YP.functor(Head, Name, Arity))
+                    {
+                        CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@""));
+                        processCompilerDirectives(RestRules, State);
+                        return;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable Fact = new Variable();
+                Variable x2 = new Variable();
+                Variable RestRules = new Variable();
+                Variable Name = new Variable();
+                Variable Arity = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", Fact, x2), RestRules)))
+                {
+                    foreach (bool l3 in YP.functor(Fact, Name, Arity))
+                    {
+                        CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@""));
+                        processCompilerDirectives(RestRules, State);
+                        return;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable x1 = new Variable();
+                Variable RestRules = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestRules)))
+                {
+                    processCompilerDirectives(RestRules, State);
+                    return;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> importPredicateList(object arg1, object arg2, object arg3)
+        {
+            {
+                object _State = arg1;
+                object _Module = arg2;
+                foreach (bool l2 in YP.unify(arg3, Atom.NIL))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+            {
+                object State = arg1;
+                object Module = arg2;
+                Variable Name = new Variable();
+                Variable Arity = new Variable();
+                Variable Rest = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"/", Name, Arity), Rest)))
+                {
+                    CompilerState.assertModuleForNameArity(State, Name, Arity, Module);
+                    foreach (bool l3 in importPredicateList(State, Module, Rest))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg1;
+                object Module = arg2;
+                Variable x3 = new Variable();
+                Variable Rest = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new ListPair(x3, Rest)))
+                {
+                    foreach (bool l3 in importPredicateList(State, Module, Rest))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> makeFunctionPseudoCode3(object RuleList, object State, object FunctionCode)
+        {
+            {
+                Variable SamePredicateRuleList = new Variable();
+                Variable RestRules = new Variable();
+                foreach (bool l2 in samePredicateRuleList(RuleList, SamePredicateRuleList, RestRules))
+                {
+                    if (YP.termNotEqual(SamePredicateRuleList, Atom.NIL))
+                    {
+                        foreach (bool l4 in compileSamePredicateFunction(SamePredicateRuleList, State, FunctionCode))
+                        {
+                            yield return false;
+                        }
+                        foreach (bool l4 in makeFunctionPseudoCode3(RestRules, State, FunctionCode))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileSamePredicateFunction(object SamePredicateRuleList, object State, object FunctionCode)
+        {
+            {
+                Variable FirstRule = new Variable();
+                Variable x5 = new Variable();
+                Variable x6 = new Variable();
+                Variable x7 = new Variable();
+                Variable Head = new Variable();
+                Variable x9 = new Variable();
+                Variable ArgAssignments = new Variable();
+                Variable Calls = new Variable();
+                Variable Rule = new Variable();
+                Variable VariableNameSuggestions = new Variable();
+                Variable ClauseBag = new Variable();
+                Variable Name = new Variable();
+                Variable ArgsList = new Variable();
+                Variable FunctionArgNames = new Variable();
+                Variable MergedArgName = new Variable();
+                Variable ArgName = new Variable();
+                Variable MergedArgNames = new Variable();
+                Variable FunctionArgs = new Variable();
+                Variable BodyCode = new Variable();
+                Variable ReturnType = new Variable();
+                Variable BodyWithReturn = new Variable();
+                foreach (bool l2 in YP.unify(new ListPair(new Functor2(@"f", FirstRule, x5), x6), SamePredicateRuleList))
+                {
+                    foreach (bool l3 in YP.unify(FirstRule, new Functor1(@":-", x7)))
+                    {
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in YP.unify(new Functor2(@":-", Head, x9), FirstRule))
+                    {
+                        CompilerState.startFunction(State, Head);
+                        FindallAnswers findallAnswers3 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls));
+                        foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList))
+                        {
+                            foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls))
+                            {
+                                findallAnswers3.add();
+                            }
+                        }
+                        foreach (bool l4 in findallAnswers3.result(ClauseBag))
+                        {
+                            foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList)))
+                            {
+                                foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames))
+                                {
+                                    FindallAnswers findallAnswers4 = new FindallAnswers(MergedArgName);
+                                    foreach (bool l7 in member(ArgName, FunctionArgNames))
+                                    {
+                                        foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName))
+                                        {
+                                            findallAnswers4.add();
+                                            goto cutIf5;
+                                        }
+                                        foreach (bool l8 in YP.unify(MergedArgName, ArgName))
+                                        {
+                                            findallAnswers4.add();
+                                        }
+                                    cutIf5:
+                                        { }
+                                    }
+                                    foreach (bool l7 in findallAnswers4.result(MergedArgNames))
+                                    {
+                                        foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs))
+                                        {
+                                            foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode))
+                                            {
+                                                if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                {
+                                                    foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void")))
+                                                    {
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf7;
+                                                        }
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf8;
+                                                        }
+                                                        if (CompilerState.codeUsesYield(State))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf9;
+                                                        }
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                    cutIf9:
+                                                    cutIf8:
+                                                    cutIf7:
+                                                        { }
+                                                    }
+                                                    goto cutIf6;
+                                                }
+                                                if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                {
+                                                    foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool")))
+                                                    {
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf11;
+                                                        }
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf12;
+                                                        }
+                                                        if (CompilerState.codeUsesYield(State))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf13;
+                                                        }
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                    cutIf13:
+                                                    cutIf12:
+                                                    cutIf11:
+                                                        { }
+                                                    }
+                                                    goto cutIf10;
+                                                }
+                                                foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable<bool>")))
+                                                {
+                                                    if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                    {
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf14;
+                                                    }
+                                                    if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                    {
+                                                        foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf15;
+                                                    }
+                                                    if (CompilerState.codeUsesYield(State))
+                                                    {
+                                                        foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf16;
+                                                    }
+                                                    foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                            {
+                                                        foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                        {
+                                                            yield return false;
+                                                        }
+                                                    }
+                                                cutIf16:
+                                                cutIf15:
+                                                cutIf14:
+                                                    { }
+                                                }
+                                            cutIf10:
+                                            cutIf6:
+                                                { }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        goto cutIf2;
+                    }
+                    foreach (bool l3 in YP.unify(Head, FirstRule))
+                    {
+                        CompilerState.startFunction(State, Head);
+                        FindallAnswers findallAnswers17 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls));
+                        foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList))
+                        {
+                            foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls))
+                            {
+                                findallAnswers17.add();
+                            }
+                        }
+                        foreach (bool l4 in findallAnswers17.result(ClauseBag))
+                        {
+                            foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList)))
+                            {
+                                foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames))
+                                {
+                                    FindallAnswers findallAnswers18 = new FindallAnswers(MergedArgName);
+                                    foreach (bool l7 in member(ArgName, FunctionArgNames))
+                                    {
+                                        foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName))
+                                        {
+                                            findallAnswers18.add();
+                                            goto cutIf19;
+                                        }
+                                        foreach (bool l8 in YP.unify(MergedArgName, ArgName))
+                                        {
+                                            findallAnswers18.add();
+                                        }
+                                    cutIf19:
+                                        { }
+                                    }
+                                    foreach (bool l7 in findallAnswers18.result(MergedArgNames))
+                                    {
+                                        foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs))
+                                        {
+                                            foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode))
+                                            {
+                                                if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                {
+                                                    foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void")))
+                                                    {
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf21;
+                                                        }
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf22;
+                                                        }
+                                                        if (CompilerState.codeUsesYield(State))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf23;
+                                                        }
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                    cutIf23:
+                                                    cutIf22:
+                                                    cutIf21:
+                                                        { }
+                                                    }
+                                                    goto cutIf20;
+                                                }
+                                                if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                {
+                                                    foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool")))
+                                                    {
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf25;
+                                                        }
+                                                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf26;
+                                                        }
+                                                        if (CompilerState.codeUsesYield(State))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
+                                                            {
+                                                                foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                                {
+                                                                    yield return false;
+                                                                }
+                                                            }
+                                                            goto cutIf27;
+                                                        }
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                    cutIf27:
+                                                    cutIf26:
+                                                    cutIf25:
+                                                        { }
+                                                    }
+                                                    goto cutIf24;
+                                                }
+                                                foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable<bool>")))
+                                                {
+                                                    if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                                                    {
+                                                        foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf28;
+                                                    }
+                                                    if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                                                    {
+                                                        foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf29;
+                                                    }
+                                                    if (CompilerState.codeUsesYield(State))
+                                                    {
+                                                        foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode))
+                                                        {
+                                                            foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                            {
+                                                                yield return false;
+                                                            }
+                                                        }
+                                                        goto cutIf30;
+                                                    }
+                                                    foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
+                                                    {
+                                                        foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
+                                                        {
+                                                            yield return false;
+                                                        }
+                                                    }
+                                                cutIf30:
+                                                cutIf29:
+                                                cutIf28:
+                                                    { }
+                                                }
+                                            cutIf24:
+                                            cutIf20:
+                                                { }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                cutIf2:
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> samePredicateRuleList(object arg1, object arg2, object arg3)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.NIL))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                Variable First = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(First, Atom.NIL)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(First, Atom.NIL)))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.NIL))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object SamePredicateRuleList = arg2;
+                object RestRules = arg3;
+                Variable First = new Variable();
+                Variable Rest = new Variable();
+                Variable FirstRule = new Variable();
+                Variable x6 = new Variable();
+                Variable SecondRule = new Variable();
+                Variable x8 = new Variable();
+                Variable x9 = new Variable();
+                Variable FirstHead = new Variable();
+                Variable x11 = new Variable();
+                Variable SecondHead = new Variable();
+                Variable x13 = new Variable();
+                Variable Name = new Variable();
+                Variable Arity = new Variable();
+                Variable RestSamePredicates = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest)))
+                {
+                    foreach (bool l3 in YP.unify(new Functor2(@"f", FirstRule, x6), First))
+                    {
+                        foreach (bool l4 in YP.unify(new ListPair(new Functor2(@"f", SecondRule, x8), x9), Rest))
+                        {
+                            foreach (bool l5 in YP.unify(new Functor2(@":-", FirstHead, x11), FirstRule))
+                            {
+                                foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule))
+                                {
+                                    foreach (bool l7 in YP.functor(FirstHead, Name, Arity))
+                                    {
+                                        foreach (bool l8 in YP.functor(SecondHead, Name, Arity))
+                                        {
+                                            foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules))
+                                            {
+                                                foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates)))
+                                                {
+                                                    yield return true;
+                                                    yield break;
+                                                }
+                                            }
+                                            goto cutIf3;
+                                        }
+                                        foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.unify(RestRules, Rest))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    cutIf3:
+                                        { }
+                                    }
+                                    goto cutIf2;
+                                }
+                                foreach (bool l6 in YP.unify(SecondHead, SecondRule))
+                                {
+                                    foreach (bool l7 in YP.functor(FirstHead, Name, Arity))
+                                    {
+                                        foreach (bool l8 in YP.functor(SecondHead, Name, Arity))
+                                        {
+                                            foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules))
+                                            {
+                                                foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates)))
+                                                {
+                                                    yield return true;
+                                                    yield break;
+                                                }
+                                            }
+                                            goto cutIf4;
+                                        }
+                                        foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.unify(RestRules, Rest))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    cutIf4:
+                                        { }
+                                    }
+                                }
+                            cutIf2:
+                                goto cutIf1;
+                            }
+                            foreach (bool l5 in YP.unify(FirstHead, FirstRule))
+                            {
+                                foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule))
+                                {
+                                    foreach (bool l7 in YP.functor(FirstHead, Name, Arity))
+                                    {
+                                        foreach (bool l8 in YP.functor(SecondHead, Name, Arity))
+                                        {
+                                            foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules))
+                                            {
+                                                foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates)))
+                                                {
+                                                    yield return true;
+                                                    yield break;
+                                                }
+                                            }
+                                            goto cutIf6;
+                                        }
+                                        foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.unify(RestRules, Rest))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    cutIf6:
+                                        { }
+                                    }
+                                    goto cutIf5;
+                                }
+                                foreach (bool l6 in YP.unify(SecondHead, SecondRule))
+                                {
+                                    foreach (bool l7 in YP.functor(FirstHead, Name, Arity))
+                                    {
+                                        foreach (bool l8 in YP.functor(SecondHead, Name, Arity))
+                                        {
+                                            foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules))
+                                            {
+                                                foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates)))
+                                                {
+                                                    yield return true;
+                                                    yield break;
+                                                }
+                                            }
+                                            goto cutIf7;
+                                        }
+                                        foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL)))
+                                        {
+                                            foreach (bool l9 in YP.unify(RestRules, Rest))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    cutIf7:
+                                        { }
+                                    }
+                                }
+                            cutIf5:
+                                { }
+                            }
+                        cutIf1:
+                            { }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> maplist_compileClause(object arg1, object arg2, object arg3)
+        {
+            {
+                object _MergedArgNames = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object MergedArgNames = arg2;
+                Variable ArgAssignments = new Variable();
+                Variable Calls = new Variable();
+                Variable Rest = new Variable();
+                Variable ClauseCode = new Variable();
+                Variable RestResults = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", ArgAssignments, Calls), Rest)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"blockScope", ClauseCode), RestResults)))
+                    {
+                        foreach (bool l4 in prependArgAssignments(ArgAssignments, Calls, MergedArgNames, ClauseCode))
+                        {
+                            foreach (bool l5 in maplist_compileClause(Rest, MergedArgNames, RestResults))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> prependArgAssignments(object arg1, object arg2, object arg3, object arg4)
+        {
+            {
+                object _MergedArgNames = arg3;
+                Variable In = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, In))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, In))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object In = arg2;
+                object MergedArgNames = arg3;
+                object ClauseCode = arg4;
+                Variable VariableName = new Variable();
+                Variable ArgName = new Variable();
+                Variable RestArgAssignments = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", VariableName, ArgName), RestArgAssignments)))
+                {
+                    foreach (bool l3 in member(VariableName, MergedArgNames))
+                    {
+                        foreach (bool l4 in prependArgAssignments(RestArgAssignments, In, MergedArgNames, ClauseCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in prependArgAssignments(RestArgAssignments, new ListPair(new Functor3(@"declare", Atom.a(@"object"), VariableName, new Functor1(@"var", ArgName)), In), MergedArgNames, ClauseCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> argAssignedAll(object arg1, object arg2, object VariableName)
+        {
+            {
+                object _ArgName = arg1;
+                foreach (bool l2 in YP.unify(arg2, Atom.NIL))
+                {
+                    if (YP.nonvar(VariableName))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object ArgName = arg1;
+                Variable ArgAssignments = new Variable();
+                Variable _Calls = new Variable();
+                Variable RestClauseBag = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(new Functor2(@"f", ArgAssignments, _Calls), RestClauseBag)))
+                {
+                    foreach (bool l3 in member(new Functor2(@"f", VariableName, ArgName), ArgAssignments))
+                    {
+                        foreach (bool l4 in argAssignedAll(ArgName, RestClauseBag, VariableName))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> maplist_arg(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable First = new Variable();
+                Variable Rest = new Variable();
+                Variable RestResults = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"arg", First), RestResults)))
+                    {
+                        foreach (bool l4 in maplist_arg(Rest, RestResults))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> getFunctionArgNames(object arg1, object arg2, object arg3)
+        {
+            {
+                object _StartArgNumber = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object StartArgNumber = arg2;
+                Variable x1 = new Variable();
+                Variable Rest = new Variable();
+                Variable ArgName = new Variable();
+                Variable RestFunctionArgs = new Variable();
+                Variable NumberCodes = new Variable();
+                Variable NumberAtom = new Variable();
+                Variable NextArgNumber = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Rest)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(ArgName, RestFunctionArgs)))
+                    {
+                        foreach (bool l4 in YP.number_codes(StartArgNumber, NumberCodes))
+                        {
+                            foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes))
+                            {
+                                foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName))
+                                {
+                                    foreach (bool l7 in YP.unify(NextArgNumber, YP.add(StartArgNumber, 1)))
+                                    {
+                                        foreach (bool l8 in getFunctionArgNames(Rest, NextArgNumber, RestFunctionArgs))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileBodyWithHeadBindings(object Rule, object VariableNameSuggestions, object State, object ArgAssignments, object Calls)
+        {
+            {
+                Variable Head = new Variable();
+                Variable Body = new Variable();
+                Variable x8 = new Variable();
+                Variable HeadArgs = new Variable();
+                Variable CompiledHeadArgs = new Variable();
+                Variable BodyCode = new Variable();
+                Variable VariableNamesList = new Variable();
+                Variable ArgUnifications = new Variable();
+                foreach (bool l2 in YP.unify(new Functor2(@":-", Head, Body), Rule))
+                {
+                    CompilerState.newVariableNames(State, Rule, VariableNameSuggestions);
+                    foreach (bool l3 in YP.univ(Head, new ListPair(x8, HeadArgs)))
+                    {
+                        foreach (bool l4 in maplist_compileTerm(HeadArgs, State, CompiledHeadArgs))
+                        {
+                            foreach (bool l5 in compileRuleBody(Body, State, BodyCode))
+                            {
+                                foreach (bool l6 in CompilerState.variableNamesList(State, VariableNamesList))
+                                {
+                                    foreach (bool l7 in compileArgUnifications(HeadArgs, CompiledHeadArgs, 1, HeadArgs, BodyCode, ArgUnifications))
+                                    {
+                                        foreach (bool l8 in compileDeclarations(VariableNamesList, HeadArgs, Atom.NIL, ArgAssignments, ArgUnifications, Calls))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in compileBodyWithHeadBindings(new Functor2(@":-", Rule, Atom.a(@"true")), VariableNameSuggestions, State, ArgAssignments, Calls))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileArgUnifications(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6)
+        {
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                object x3 = arg4;
+                Variable BodyCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg5, BodyCode))
+                    {
+                        foreach (bool l4 in YP.unify(arg6, BodyCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Index = arg3;
+                object AllHeadArgs = arg4;
+                object BodyCode = arg5;
+                object ArgUnifications = arg6;
+                Variable HeadArg = new Variable();
+                Variable RestHeadArgs = new Variable();
+                Variable x3 = new Variable();
+                Variable RestCompiledHeadArgs = new Variable();
+                Variable _ArgIndex1 = new Variable();
+                Variable NextIndex = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(HeadArg, RestHeadArgs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(x3, RestCompiledHeadArgs)))
+                    {
+                        foreach (bool l4 in getVariableArgIndex1(HeadArg, AllHeadArgs, _ArgIndex1))
+                        {
+                            foreach (bool l5 in YP.unify(NextIndex, YP.add(Index, 1)))
+                            {
+                                foreach (bool l6 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, ArgUnifications))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Index = arg3;
+                object AllHeadArgs = arg4;
+                object BodyCode = arg5;
+                Variable _HeadArg = new Variable();
+                Variable RestHeadArgs = new Variable();
+                Variable CompiledHeadArg = new Variable();
+                Variable RestCompiledHeadArgs = new Variable();
+                Variable ArgName = new Variable();
+                Variable RestArgUnifications = new Variable();
+                Variable NumberCodes = new Variable();
+                Variable NumberAtom = new Variable();
+                Variable NextIndex = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(_HeadArg, RestHeadArgs)))
+                {
+                    foreach (bool l3 in YP.unify(arg2, new ListPair(CompiledHeadArg, RestCompiledHeadArgs)))
+                    {
+                        foreach (bool l4 in YP.unify(arg6, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(new Functor1(@"var", ArgName), new ListPair(CompiledHeadArg, Atom.NIL))), RestArgUnifications), Atom.NIL)))
+                        {
+                            foreach (bool l5 in YP.number_codes(Index, NumberCodes))
+                            {
+                                foreach (bool l6 in YP.atom_codes(NumberAtom, NumberCodes))
+                                {
+                                    foreach (bool l7 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName))
+                                    {
+                                        foreach (bool l8 in YP.unify(NextIndex, YP.add(Index, 1)))
+                                        {
+                                            foreach (bool l9 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, RestArgUnifications))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileDeclarations(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6)
+        {
+            {
+                object _HeadArgs = arg2;
+                Variable ArgAssignmentsIn = new Variable();
+                Variable DeclarationsIn = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, ArgAssignmentsIn))
+                    {
+                        foreach (bool l4 in YP.unify(arg4, ArgAssignmentsIn))
+                        {
+                            foreach (bool l5 in YP.unify(arg5, DeclarationsIn))
+                            {
+                                foreach (bool l6 in YP.unify(arg6, DeclarationsIn))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object HeadArgs = arg2;
+                object ArgAssignmentsIn = arg3;
+                object ArgAssignmentsOut = arg4;
+                object DeclarationsIn = arg5;
+                object DeclarationsOut = arg6;
+                Variable VariableName = new Variable();
+                Variable Var = new Variable();
+                Variable RestVariableNames = new Variable();
+                Variable ArgIndex1 = new Variable();
+                Variable NumberCodes = new Variable();
+                Variable NumberAtom = new Variable();
+                Variable ArgName = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, Var), RestVariableNames)))
+                {
+                    foreach (bool l3 in getVariableArgIndex1(Var, HeadArgs, ArgIndex1))
+                    {
+                        foreach (bool l4 in YP.number_codes(ArgIndex1, NumberCodes))
+                        {
+                            foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes))
+                            {
+                                foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName))
+                                {
+                                    foreach (bool l7 in compileDeclarations(RestVariableNames, HeadArgs, new ListPair(new Functor2(@"f", VariableName, ArgName), ArgAssignmentsIn), ArgAssignmentsOut, DeclarationsIn, DeclarationsOut))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object HeadArgs = arg2;
+                object ArgAssignmentsIn = arg3;
+                object ArgAssignmentsOut = arg4;
+                object DeclarationsIn = arg5;
+                Variable VariableName = new Variable();
+                Variable _Var = new Variable();
+                Variable RestVariableNames = new Variable();
+                Variable DeclarationsOut = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, _Var), RestVariableNames)))
+                {
+                    foreach (bool l3 in YP.unify(arg6, new ListPair(new Functor3(@"declare", Atom.a(@"Variable"), VariableName, new Functor2(@"new", Atom.a(@"Variable"), Atom.NIL)), DeclarationsOut)))
+                    {
+                        foreach (bool l4 in compileDeclarations(RestVariableNames, HeadArgs, ArgAssignmentsIn, ArgAssignmentsOut, DeclarationsIn, DeclarationsOut))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> getVariableArgIndex1(object Var, object arg2, object arg3)
+        {
+            {
+                Variable FirstHeadArgs = new Variable();
+                Variable RestHeadArgs = new Variable();
+                Variable x4 = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(FirstHeadArgs, RestHeadArgs)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, 1))
+                    {
+                        if (sameVariable(Var, FirstHeadArgs))
+                        {
+                            foreach (bool l5 in getVariableArgIndex1(Var, RestHeadArgs, x4))
+                            {
+                                goto cutIf1;
+                            }
+                            yield return false;
+                        cutIf1:
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object Index = arg3;
+                Variable x2 = new Variable();
+                Variable RestHeadArgs = new Variable();
+                Variable RestIndex = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(x2, RestHeadArgs)))
+                {
+                    foreach (bool l3 in getVariableArgIndex1(Var, RestHeadArgs, RestIndex))
+                    {
+                        foreach (bool l4 in YP.unify(Index, YP.add(1, RestIndex)))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileRuleBody(object arg1, object arg2, object arg3)
+        {
+            {
+                object A = arg1;
+                object State = arg2;
+                object PseudoCode = arg3;
+                if (YP.var(A))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), Atom.a(@"true")), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"!")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL)))
+                    {
+                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"!")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL)))
+                    {
+                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"!")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldtrue"), new ListPair(Atom.a(@"yieldbreak"), Atom.NIL))))
+                    {
+                        CompilerState.setCodeUsesYield(State);
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object _State = arg2;
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"$CUTIF", Name)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL)))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"true")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL)))
+                    {
+                        if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"true")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL)))
+                    {
+                        if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"true")))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)))
+                    {
+                        CompilerState.setCodeUsesYield(State);
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    if (YP.var(A))
+                    {
+                        foreach (bool l4 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), B), State, PseudoCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable T = new Variable();
+                Variable B = new Variable();
+                Variable C = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), B), C)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@"->", A, new Functor2(@",", T, C)), new Functor2(@",", B, C)), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable C = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", A, B), C)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, C), new Functor2(@",", B, C)), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor1(@"not", ACode), BCode), Atom.NIL)))
+                    {
+                        if (CompilerState.isSemidetNoneOut(State, A))
+                        {
+                            foreach (bool l5 in compileFunctorCall(A, State, ACode))
+                            {
+                                foreach (bool l6 in compileRuleBody(B, State, BCode))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"fail")), Atom.a(@"true")), B), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"once", A), B)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"true")), Atom.a(@"fail")), B), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable T = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"->", A, T), B)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), Atom.a(@"fail")), B), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable C = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"\=", A, B), C)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"\+", new Functor2(@"=", A, B)), C), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable ACode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"!"), A)))
+                {
+                    foreach (bool l3 in compileRuleBody(A, State, ACode))
+                    {
+                        foreach (bool l4 in append(ACode, new ListPair(Atom.a(@"yieldbreak"), Atom.NIL), PseudoCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable Name = new Variable();
+                Variable A = new Variable();
+                Variable ACode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$CUTIF", Name), A)))
+                {
+                    foreach (bool l3 in compileRuleBody(A, State, ACode))
+                    {
+                        foreach (bool l4 in append(ACode, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL), PseudoCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object _State = arg2;
+                Variable x1 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"fail"), x1)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"true"), A)))
+                {
+                    foreach (bool l3 in compileRuleBody(A, State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable Term = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable TermCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"is", A, Term), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(ACode, new ListPair(TermCode, Atom.NIL))), BCode), Atom.NIL)))
+                    {
+                        foreach (bool l4 in compileTerm(A, State, ACode))
+                        {
+                            foreach (bool l5 in compileExpression(Term, State, TermCode))
+                            {
+                                foreach (bool l6 in compileRuleBody(B, State, BCode))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode)))
+                    {
+                        if (CompilerState.isDetNoneOut(State, A))
+                        {
+                            foreach (bool l5 in compileFunctorCall(A, State, ACode))
+                            {
+                                foreach (bool l6 in compileRuleBody(B, State, BCode))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", ACode, BCode), Atom.NIL)))
+                    {
+                        if (CompilerState.isSemidetNoneOut(State, A))
+                        {
+                            foreach (bool l5 in compileFunctorCall(A, State, ACode))
+                            {
+                                foreach (bool l6 in compileRuleBody(B, State, BCode))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable ACode = new Variable();
+                Variable B = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", ACode), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode)))
+                    {
+                        foreach (bool l4 in compileRuleBody(B, State, BCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable FunctionName = new Variable();
+                Variable X1Code = new Variable();
+                Variable X2Code = new Variable();
+                Variable BCode = new Variable();
+                Variable Name = new Variable();
+                Variable X1 = new Variable();
+                Variable X2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor2(@"call", FunctionName, new ListPair(X1Code, new ListPair(X2Code, Atom.NIL))), BCode), Atom.NIL)))
+                    {
+                        foreach (bool l4 in YP.univ(A, new ListPair(Name, new ListPair(X1, new ListPair(X2, Atom.NIL)))))
+                        {
+                            foreach (bool l5 in binaryExpressionConditional(Name, FunctionName))
+                            {
+                                foreach (bool l6 in compileExpression(X1, State, X1Code))
+                                {
+                                    foreach (bool l7 in compileExpression(X2, State, X2Code))
+                                    {
+                                        foreach (bool l8 in compileRuleBody(B, State, BCode))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable C = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@",", A, B), C)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", A, new Functor2(@",", B, C)), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable Template = new Variable();
+                Variable Goal = new Variable();
+                Variable Bag = new Variable();
+                Variable B = new Variable();
+                Variable TemplateCode = new Variable();
+                Variable FindallAnswers = new Variable();
+                Variable GoalAndAddCode = new Variable();
+                Variable BagCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"findall", Template, Goal, Bag), B)))
+                {
+                    foreach (bool l3 in compileTerm(Template, State, TemplateCode))
+                    {
+                        foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"findallAnswers"), FindallAnswers))
+                        {
+                            foreach (bool l5 in compileRuleBody(new Functor2(@",", Goal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode))
+                            {
+                                foreach (bool l6 in compileTerm(Bag, State, BagCode))
+                                {
+                                    foreach (bool l7 in compileRuleBody(B, State, BCode))
+                                    {
+                                        foreach (bool l8 in append(new ListPair(new Functor3(@"declare", Atom.a(@"FindallAnswers"), FindallAnswers, new Functor2(@"new", Atom.a(@"FindallAnswers"), new ListPair(TemplateCode, Atom.NIL))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"result"), new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable Template = new Variable();
+                Variable Goal = new Variable();
+                Variable Bag = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"bagof", Template, Goal, Bag), B)))
+                {
+                    foreach (bool l3 in compileBagof(Atom.a(@"result"), Template, Goal, Bag, B, State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable Template = new Variable();
+                Variable Goal = new Variable();
+                Variable Bag = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"setof", Template, Goal, Bag), B)))
+                {
+                    foreach (bool l3 in compileBagof(Atom.a(@"resultSet"), Template, Goal, Bag, B, State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ATermCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"call", A), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL)))
+                    {
+                        foreach (bool l4 in compileTerm(A, State, ATermCode))
+                        {
+                            foreach (bool l5 in compileRuleBody(B, State, BCode))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ATermCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"asserta", A), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.asserta"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode)))
+                    {
+                        foreach (bool l4 in compileTerm(A, State, ATermCode))
+                        {
+                            foreach (bool l5 in compileRuleBody(B, State, BCode))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ATermCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"assertz", A), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.assertz"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode)))
+                    {
+                        foreach (bool l4 in compileTerm(A, State, ATermCode))
+                        {
+                            foreach (bool l5 in compileRuleBody(B, State, BCode))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"assert", A), B)))
+                {
+                    foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"assertz", A), B), State, PseudoCode))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable Goal = new Variable();
+                Variable Catcher = new Variable();
+                Variable Handler = new Variable();
+                Variable B = new Variable();
+                Variable CatchGoal = new Variable();
+                Variable GoalTermCode = new Variable();
+                Variable BCode = new Variable();
+                Variable CatcherTermCode = new Variable();
+                Variable HandlerAndBCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"catch", Goal, Catcher, Handler), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor3(@"declare", Atom.a(@"YP.Catch"), CatchGoal, new Functor2(@"new", Atom.a(@"YP.Catch"), new ListPair(new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(GoalTermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), Atom.NIL))), new ListPair(new Functor2(@"foreach", new Functor1(@"var", CatchGoal), BCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", CatchGoal), Atom.a(@"unifyExceptionOrThrow"), new ListPair(CatcherTermCode, Atom.NIL)), HandlerAndBCode), Atom.NIL)))))
+                    {
+                        foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"catchGoal"), CatchGoal))
+                        {
+                            foreach (bool l5 in compileTerm(Goal, State, GoalTermCode))
+                            {
+                                foreach (bool l6 in compileTerm(Catcher, State, CatcherTermCode))
+                                {
+                                    foreach (bool l7 in compileRuleBody(B, State, BCode))
+                                    {
+                                        foreach (bool l8 in compileRuleBody(new Functor2(@",", Handler, B), State, HandlerAndBCode))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", ACode, BCode), Atom.NIL)))
+                    {
+                        foreach (bool l4 in compileFunctorCall(A, State, ACode))
+                        {
+                            foreach (bool l5 in compileRuleBody(B, State, BCode))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B)))
+                {
+                    if (YP.var(A))
+                    {
+                        foreach (bool l4 in compileRuleBody(new Functor2(@";", new Functor1(@"call", A), B), State, PseudoCode))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable A = new Variable();
+                Variable T = new Variable();
+                Variable B = new Variable();
+                Variable CutIfLabel = new Variable();
+                Variable Code = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@";", new Functor2(@"->", A, T), B)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"breakableBlock", CutIfLabel, Code), Atom.NIL)))
+                    {
+                        foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"cutIf"), CutIfLabel))
+                        {
+                            foreach (bool l5 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, new Functor2(@",", new Functor1(@"$CUTIF", CutIfLabel), T)), B), State, Code))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                object PseudoCode = arg3;
+                Variable A = new Variable();
+                Variable B = new Variable();
+                Variable ACode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B)))
+                {
+                    foreach (bool l3 in compileRuleBody(A, State, ACode))
+                    {
+                        foreach (bool l4 in compileRuleBody(B, State, BCode))
+                        {
+                            foreach (bool l5 in append(ACode, BCode, PseudoCode))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object A = arg1;
+                object State = arg2;
+                object PseudoCode = arg3;
+                foreach (bool l2 in compileRuleBody(new Functor2(@",", A, Atom.a(@"true")), State, PseudoCode))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileBagof(object ResultMethod, object Template, object Goal, object Bag, object B, object State, object PseudoCode)
+        {
+            {
+                Variable TemplateCode = new Variable();
+                Variable GoalTermCode = new Variable();
+                Variable UnqualifiedGoal = new Variable();
+                Variable BagofAnswers = new Variable();
+                Variable GoalAndAddCode = new Variable();
+                Variable BagCode = new Variable();
+                Variable BCode = new Variable();
+                foreach (bool l2 in compileTerm(Template, State, TemplateCode))
+                {
+                    foreach (bool l3 in compileTerm(Goal, State, GoalTermCode))
+                    {
+                        foreach (bool l4 in unqualifiedGoal(Goal, UnqualifiedGoal))
+                        {
+                            foreach (bool l5 in CompilerState.gensym(State, Atom.a(@"bagofAnswers"), BagofAnswers))
+                            {
+                                foreach (bool l6 in compileRuleBody(new Functor2(@",", UnqualifiedGoal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode))
+                                {
+                                    foreach (bool l7 in compileTerm(Bag, State, BagCode))
+                                    {
+                                        foreach (bool l8 in compileRuleBody(B, State, BCode))
+                                        {
+                                            foreach (bool l9 in append(new ListPair(new Functor3(@"declare", Atom.a(@"BagofAnswers"), BagofAnswers, new Functor2(@"new", Atom.a(@"BagofAnswers"), new ListPair(TemplateCode, new ListPair(GoalTermCode, Atom.NIL)))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), ResultMethod, new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> unqualifiedGoal(object arg1, object arg2)
+        {
+            {
+                object Goal = arg1;
+                foreach (bool l2 in YP.unify(arg2, new Functor1(@"call", Goal)))
+                {
+                    if (YP.var(Goal))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object UnqualifiedGoal = arg2;
+                Variable x1 = new Variable();
+                Variable Goal = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"^", x1, Goal)))
+                {
+                    foreach (bool l3 in unqualifiedGoal(Goal, UnqualifiedGoal))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                Variable UnqualifiedGoal = new Variable();
+                foreach (bool l2 in YP.unify(arg1, UnqualifiedGoal))
+                {
+                    foreach (bool l3 in YP.unify(arg2, UnqualifiedGoal))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> binaryExpressionConditional(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"=:=")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.equal")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"=\=")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.notEqual")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@">")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThan")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"<")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThan")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@">=")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThanOrEqual")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"=<")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThanOrEqual")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileFunctorCall(object Functor_1, object State, object PseudoCode)
+        {
+            {
+                Variable FunctorName = new Variable();
+                Variable FunctorArgs = new Variable();
+                Variable x6 = new Variable();
+                Variable Arity = new Variable();
+                Variable CompiledArgs = new Variable();
+                Variable FunctionName = new Variable();
+                foreach (bool l2 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs)))
+                {
+                    foreach (bool l3 in YP.functor(Functor_1, x6, Arity))
+                    {
+                        foreach (bool l4 in maplist_compileTerm(FunctorArgs, State, CompiledArgs))
+                        {
+                            foreach (bool l5 in functorCallFunctionName(State, FunctorName, Arity, FunctionName))
+                            {
+                                if (YP.termEqual(FunctionName, Atom.NIL))
+                                {
+                                    foreach (bool l7 in YP.unify(PseudoCode, new Functor2(@"call", Atom.a(@"YP.matchDynamic"), new ListPair(new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", FunctorName), Atom.NIL)), new ListPair(new Functor1(@"objectArray", CompiledArgs), Atom.NIL)))))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                                    goto cutIf1;
+                                }
+                                foreach (bool l6 in YP.unify(PseudoCode, new Functor2(@"call", FunctionName, CompiledArgs)))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            cutIf1:
+                                { }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> functorCallFunctionName(object arg1, object arg2, object arg3, object arg4)
+        {
+            {
+                object x1 = arg1;
+                object Name = arg2;
+                object Arity = arg3;
+                object FunctionName = arg4;
+                foreach (bool l2 in functorCallYPFunctionName(Name, Arity, FunctionName))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+            {
+                object State = arg1;
+                object Arity = arg3;
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg2, Name))
+                {
+                    foreach (bool l3 in YP.unify(arg4, Name))
+                    {
+                        if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@"")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object _State = arg1;
+                object _Arity = arg3;
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg2, Name))
+                {
+                    foreach (bool l3 in YP.unify(arg4, Name))
+                    {
+                        foreach (bool l4 in Atom.module(Name, Atom.a(@"")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object _State = arg1;
+                object Name = arg2;
+                object Arity = arg3;
+                foreach (bool l2 in YP.unify(arg4, Atom.NIL))
+                {
+                    foreach (bool l3 in Atom.module(Name, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object _State = arg1;
+                object Name = arg2;
+                object Arity = arg3;
+                object x4 = arg4;
+                Variable Module = new Variable();
+                Variable Message = new Variable();
+                foreach (bool l2 in Atom.module(Name, Module))
+                {
+                    foreach (bool l3 in YP.atom_concat(Atom.a(@"Not supporting calls to external module: "), Module, Message))
+                    {
+                        YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Message));
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+                {
+                object _State = arg1;
+                object Name = arg2;
+                object _Arity = arg3;
+                object x4 = arg4;
+                YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), Name), Atom.a(@"Term is not callable")));
+                yield return true;
+                yield break;
+            }
+        }
+
+        public static IEnumerable<bool> functorCallYPFunctionName(object arg1, object arg2, object arg3)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"=")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.unify")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"=..")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.univ")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"var")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.var")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"nonvar")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nonvar")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"arg")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 3))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.arg")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"functor")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 3))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.functor")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"repeat")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.repeat")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"get_code")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.get_code")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"current_op")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 3))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.current_op")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_length")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_length")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_concat")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 3))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_concat")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"sub_atom")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 5))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sub_atom")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_codes")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_codes")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"number_codes")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number_codes")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"copy_term")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.copy_term")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"sort")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sort")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+            // Manually included : script_event for callback to LSL/C#
+
+                //object x1 = arg1;
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"script_event")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.script_event")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"nl")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 0))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nl")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"write")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.write")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"put_code")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.put_code")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"integer")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.integer")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"float")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.isFloat")))
+                {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"number")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atomic")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atomic")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"compound")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.compound")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"==")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termEqual")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"\==")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termNotEqual")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"@<")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThan")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"@=<")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThanOrEqual")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThan")))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>=")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 2))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThanOrEqual")))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"throw")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, 1))
+                {
+                        foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.throwException")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+        }
+
+        public static IEnumerable<bool> compileTerm(object arg1, object arg2, object arg3)
+        {
+            {
+                object Term = arg1;
+                object State = arg2;
+                Variable VariableName = new Variable();
+                foreach (bool l2 in YP.unify(arg3, new Functor1(@"var", VariableName)))
+                {
+                    if (YP.var(Term))
+                    {
+                        foreach (bool l4 in CompilerState.getVariableName(State, Term, VariableName))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                }
+            }
+            {
+                object _State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new Functor1(@"var", Atom.a(@"Atom.NIL"))))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Term = arg1;
+                object State = arg2;
+                object Code = arg3;
+                Variable ModuleCode = new Variable();
+                if (YP.atom(Term))
+                {
+                    foreach (bool l3 in compileAtomModule(Term, 0, State, ModuleCode))
+                    {
+                        foreach (bool l4 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), new ListPair(ModuleCode, Atom.NIL)))))
+                {
+                            yield return true;
+                            yield break;
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), Atom.NIL))))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+            {
+                object State = arg2;
+                Variable First = new Variable();
+                Variable Rest = new Variable();
+                Variable Arg1 = new Variable();
+                Variable Arg2 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new Functor2(@"new", Atom.a(@"ListPair"), new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))
+                    {
+                        foreach (bool l4 in compileTerm(First, State, Arg1))
+                        {
+                            foreach (bool l5 in compileTerm(Rest, State, Arg2))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Term = arg1;
+                object State = arg2;
+                object Result = arg3;
+                Variable Name = new Variable();
+                Variable TermArgs = new Variable();
+                Variable x6 = new Variable();
+                Variable Arity = new Variable();
+                Variable ModuleCode = new Variable();
+                Variable NameCode = new Variable();
+                Variable X1 = new Variable();
+                Variable Arg1 = new Variable();
+                Variable X2 = new Variable();
+                Variable Arg2 = new Variable();
+                Variable X3 = new Variable();
+                Variable Arg3 = new Variable();
+                Variable Args = new Variable();
+                foreach (bool l2 in YP.univ(Term, new ListPair(Name, TermArgs)))
+                {
+                    if (YP.termEqual(TermArgs, Atom.NIL))
+                    {
+                        foreach (bool l4 in YP.unify(Result, new Functor1(@"object", Name)))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                        goto cutIf2;
+                    }
+                    foreach (bool l3 in YP.functor(Term, x6, Arity))
+                    {
+                        foreach (bool l4 in compileAtomModule(Name, Arity, State, ModuleCode))
+                        {
+                            foreach (bool l5 in YP.unify(NameCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Name), new ListPair(ModuleCode, Atom.NIL)))))
+                            {
+                                foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL)))
+                                {
+                                    foreach (bool l7 in compileTerm(X1, State, Arg1))
+                                    {
+                                        foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL)))))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                    goto cutIf4;
+                    }
+                                foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL))))
+                    {
+                                    foreach (bool l7 in compileTerm(X1, State, Arg1))
+                                    {
+                                        foreach (bool l8 in compileTerm(X2, State, Arg2))
+                        {
+                                            foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                                    goto cutIf5;
+                                }
+                                foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL)))))
+                                {
+                                    foreach (bool l7 in compileTerm(X1, State, Arg1))
+                    {
+                                        foreach (bool l8 in compileTerm(X2, State, Arg2))
+                        {
+                                            foreach (bool l9 in compileTerm(X3, State, Arg3))
+                            {
+                                                foreach (bool l10 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL)))))))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            }
+                        }
+                                    }
+                                }
+                                foreach (bool l6 in maplist_compileTerm(TermArgs, State, Args))
+                                {
+                                    foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL)))))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                }
+                            cutIf5:
+                            cutIf4:
+                                { }
+                            }
+                        goto cutIf3;
+                    }
+                        foreach (bool l4 in YP.unify(NameCode, new Functor1(@"object", Name)))
+                        {
+                            foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL)))
+                    {
+                                foreach (bool l6 in compileTerm(X1, State, Arg1))
+                                {
+                                    foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL)))))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                }
+                                goto cutIf6;
+                            }
+                            foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL))))
+                            {
+                                foreach (bool l6 in compileTerm(X1, State, Arg1))
+                                {
+                                    foreach (bool l7 in compileTerm(X2, State, Arg2))
+                                    {
+                                        foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                }
+                                goto cutIf7;
+                            }
+                            foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL)))))
+                            {
+                                foreach (bool l6 in compileTerm(X1, State, Arg1))
+                        {
+                                    foreach (bool l7 in compileTerm(X2, State, Arg2))
+                            {
+                                        foreach (bool l8 in compileTerm(X3, State, Arg3))
+                                {
+                                            foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL)))))))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                            foreach (bool l5 in maplist_compileTerm(TermArgs, State, Args))
+                    {
+                                foreach (bool l6 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL)))))
+                        {
+                            yield return true;
+                            yield break;
+                        }
+                    }
+                        cutIf7:
+                        cutIf6:
+                            { }
+                        }
+                cutIf3:
+                        { }
+                    }
+                cutIf2:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileAtomModule(object Name, object Arity, object State, object ModuleCode)
+        {
+            {
+                if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@"")))
+                {
+                    foreach (bool l3 in YP.unify(ModuleCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Atom.a(@"")), Atom.NIL))))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> maplist_compileTerm(object arg1, object arg2, object arg3)
+        {
+            {
+                object _State = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg3, Atom.NIL))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object State = arg2;
+                Variable First = new Variable();
+                Variable Rest = new Variable();
+                Variable FirstResult = new Variable();
+                Variable RestResults = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(FirstResult, RestResults)))
+                    {
+                        foreach (bool l4 in compileTerm(First, State, FirstResult))
+                        {
+                            foreach (bool l5 in maplist_compileTerm(Rest, State, RestResults))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> compileExpression(object Term, object State, object Result)
+        {
+            {
+                Variable Name = new Variable();
+                Variable TermArgs = new Variable();
+                Variable X1 = new Variable();
+                Variable FunctionName = new Variable();
+                Variable Arg1 = new Variable();
+                Variable x9 = new Variable();
+                Variable X2 = new Variable();
+                Variable Arg2 = new Variable();
+                Variable x12 = new Variable();
+                Variable Arity = new Variable();
+                if (YP.nonvar(Term))
+                {
+                    foreach (bool l3 in YP.univ(Term, new ListPair(Name, TermArgs)))
+                    {
+                        if (YP.atom(Name))
+                        {
+                            foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL)))
+                            {
+                                foreach (bool l6 in unaryFunction(Name, FunctionName))
+                                {
+                                    foreach (bool l7 in compileExpression(X1, State, Arg1))
+                                    {
+                                        foreach (bool l8 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, Atom.NIL))))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                    }
+                                    goto cutIf1;
+                                }
+                            }
+                            foreach (bool l5 in YP.unify(Term, new ListPair(x9, Atom.NIL)))
+                            {
+                                foreach (bool l6 in compileTerm(Term, State, Result))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                                goto cutIf2;
+                            }
+                            foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL))))
+                            {
+                                foreach (bool l6 in binaryFunction(Name, FunctionName))
+                                {
+                                    foreach (bool l7 in compileExpression(X1, State, Arg1))
+                                    {
+                                        foreach (bool l8 in compileExpression(X2, State, Arg2))
+                                        {
+                                            foreach (bool l9 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))
+                                            {
+                                                yield return true;
+                                                yield break;
+                                            }
+                                        }
+                                    }
+                                    goto cutIf3;
+                                }
+                            }
+                            foreach (bool l5 in YP.functor(Term, x12, Arity))
+                            {
+                                YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"evaluable"), new Functor2(@"/", Name, Arity)), Atom.a(@"Not an expression function")));
+                            yield return false;
+                            }
+                        cutIf3:
+                        cutIf2:
+                        cutIf1:
+                            { }
+                        }
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in compileTerm(Term, State, Result))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+        }
+
+        public static IEnumerable<bool> unaryFunction(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"-")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.negate")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"abs")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.abs")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"sign")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sign")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.floor")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"truncate")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.truncate")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"round")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.round")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.ceiling")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"sin")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sin")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"cos")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.cos")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"atan")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.atan")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"exp")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.exp")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"log")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.log")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"sqrt")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sqrt")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"\")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseComplement")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> binaryFunction(object arg1, object arg2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"+")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.add")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"-")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.subtract")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"*")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.multiply")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"/")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.divide")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"//")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.intDivide")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"mod")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.mod")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"**")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.pow")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@">>")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftRight")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"<<")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftLeft")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"/\")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseAnd")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"\/")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseOr")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"min")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.min")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"max")))
+                {
+                    foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.max")))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static void convertFunctionCSharp(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass")))
+                {
+                    YP.write(Atom.a(@"public class YPInnerClass {}"));
+                    YP.nl();
+                    YP.write(Atom.a(@"public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }"));
+                    YP.nl();
+                    YP.nl();
+                    return;
+                }
+            }
+            {
+                Variable ReturnType = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable Body = new Variable();
+                Variable Level = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { ReturnType, Name, ArgList, Body })))
+                {
+                    YP.write(Atom.a(@"public static "));
+                    YP.write(ReturnType);
+                    YP.write(Atom.a(@" "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(Level, 1))
+                    {
+                        convertStatementListCSharp(Body, Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        YP.nl();
+                        return;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> convertStatementListCSharp(object arg1, object x1, object x2)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+        }
+
+        public static void convertStatementListCSharp(object arg1, object Level)
+        {
+            {
+                Variable Name = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NewStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements)))
+                {
+                    foreach (bool l3 in append(Body, new ListPair(new Functor1(@"label", Name), RestStatements), NewStatements))
+                    {
+                        convertStatementListCSharp(NewStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                Variable Type = new Variable();
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", Type, Name, Expression), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Type);
+                    YP.write(Atom.a(@" "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionCSharp(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionCSharp(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"yield return true;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"yield return false;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"yield break;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"return;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"return true;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"return false;"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"label", Name), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@":"));
+                    YP.nl();
+                    if (YP.termEqual(RestStatements, Atom.NIL))
+                    {
+                        convertIndentationCSharp(Level);
+                        YP.write(Atom.a(@"{}"));
+                        YP.nl();
+                        convertStatementListCSharp(RestStatements, Level);
+                        return;
+                        goto cutIf1;
+                    }
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"goto "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@");"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@");"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"{"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListCSharp(Body, NextLevel);
+                        convertIndentationCSharp(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListCSharp(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"if ("));
+                    convertExpressionCSharp(Expression);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListCSharp(Body, NextLevel);
+                        convertIndentationCSharp(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListCSharp(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"foreach (bool l"));
+                    YP.write(Level);
+                    YP.write(Atom.a(@" in "));
+                    convertExpressionCSharp(Expression);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListCSharp(Body, NextLevel);
+                        convertIndentationCSharp(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListCSharp(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
+                {
+                    convertIndentationCSharp(Level);
+                    YP.write(Atom.a(@"throw "));
+                    convertExpressionCSharp(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListCSharp(RestStatements, Level);
+                    return;
+                }
+            }
+        }
+
+        public static void convertIndentationCSharp(object Level)
+        {
+            {
+                Variable N = new Variable();
+                foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2)))
+                {
+                    repeatWrite(Atom.a(@" "), N);
+                    return;
+                }
+            }
+        }
+
+        public static void convertArgListCSharp(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Head = new Variable();
+                Variable Tail = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail)))
+                {
+                    convertExpressionCSharp(Head);
+                    if (YP.termNotEqual(Tail, Atom.NIL))
+                    {
+                        YP.write(Atom.a(@", "));
+                        convertArgListCSharp(Tail);
+                        return;
+                        goto cutIf1;
+                    }
+                    convertArgListCSharp(Tail);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static void convertExpressionCSharp(object arg1)
+        {
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X)))
+                {
+                    YP.write(Atom.a(@"object "));
+                    YP.write(X);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList)))
+                {
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList)))
+                {
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList)))
+                {
+                    YP.write(Atom.a(@"new "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name)))
+                {
+                    YP.write(Name);
+                    return;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"null")))
+                {
+                    YP.write(Atom.a(@"null"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X)))
+                {
+                    YP.write(Atom.a(@"!("));
+                    convertExpressionCSharp(X);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Y = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y)))
+                {
+                    YP.write(Atom.a(@"("));
+                    convertExpressionCSharp(X);
+                    YP.write(Atom.a(@") && ("));
+                    convertExpressionCSharp(Y);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList)))
+                {
+                    YP.write(Atom.a(@"new object[] {"));
+                    convertArgListCSharp(ArgList);
+                    YP.write(Atom.a(@"}"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Codes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    if (YP.atom(X))
+                    {
+                        YP.write(Atom.a(@"@"""));
+                        foreach (bool l4 in YP.atom_codes(X, Codes))
+                        {
+                            convertStringCodesCSharp(Codes);
+                            YP.write(Atom.a(@""""));
+                            return;
+                        }
+                    }
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    YP.write(X);
+                    return;
+                }
+            }
+        }
+
+        public static void convertStringCodesCSharp(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Code = new Variable();
+                Variable RestCodes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes)))
+                {
+                    if (YP.termEqual(Code, 34))
+                    {
+                        YP.put_code(34);
+                        YP.put_code(Code);
+                        convertStringCodesCSharp(RestCodes);
+                        return;
+                        goto cutIf1;
+                    }
+                    YP.put_code(Code);
+                    convertStringCodesCSharp(RestCodes);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static void convertFunctionJavascript(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass")))
+                {
+                    YP.write(Atom.a(@"function getDeclaringClass() { return null; }"));
+                    YP.nl();
+                    return;
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable Body = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body })))
+                {
+                    YP.write(Atom.a(@"function "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    convertStatementListJavascript(Body, 1);
+                    YP.write(Atom.a(@"}"));
+                    YP.nl();
+                    YP.nl();
+                    return;
+                }
+            }
+        }
+
+        public static void convertStatementListJavascript(object arg1, object arg2)
+        {
+            {
+                object x1 = arg2;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Name = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@":"));
+                    YP.nl();
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"{"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListJavascript(Body, NextLevel);
+                        convertIndentationJavascript(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListJavascript(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                Variable _Type = new Variable();
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"var "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionJavascript(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionJavascript(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"yield true;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"yield false;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"return;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"return;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"return true;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"return false;"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Name = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"break "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@");"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@");"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"{"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListJavascript(Body, NextLevel);
+                        convertIndentationJavascript(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListJavascript(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"if ("));
+                    convertExpressionJavascript(Expression);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListJavascript(Body, NextLevel);
+                        convertIndentationJavascript(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListJavascript(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"for each (var l"));
+                    YP.write(Level);
+                    YP.write(Atom.a(@" in "));
+                    convertExpressionJavascript(Expression);
+                    YP.write(Atom.a(@") {"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        convertStatementListJavascript(Body, NextLevel);
+                        convertIndentationJavascript(Level);
+                        YP.write(Atom.a(@"}"));
+                        YP.nl();
+                        convertStatementListJavascript(RestStatements, Level);
+                        return;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
+                {
+                    convertIndentationJavascript(Level);
+                    YP.write(Atom.a(@"throw "));
+                    convertExpressionJavascript(Expression);
+                    YP.write(Atom.a(@";"));
+                    YP.nl();
+                    convertStatementListJavascript(RestStatements, Level);
+                    return;
+                }
+            }
+        }
+
+        public static void convertIndentationJavascript(object Level)
+        {
+            {
+                Variable N = new Variable();
+                foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2)))
+                {
+                    repeatWrite(Atom.a(@" "), N);
+                    return;
+                }
+            }
+        }
+
+        public static void convertArgListJavascript(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Head = new Variable();
+                Variable Tail = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail)))
+                {
+                    convertExpressionJavascript(Head);
+                    if (YP.termNotEqual(Tail, Atom.NIL))
+                    {
+                        YP.write(Atom.a(@", "));
+                        convertArgListJavascript(Tail);
+                        return;
+                        goto cutIf1;
+                    }
+                    convertArgListJavascript(Tail);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static void convertExpressionJavascript(object arg1)
+        {
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X)))
+                {
+                    YP.write(X);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList)))
+                {
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList)))
+                {
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList)))
+                {
+                    YP.write(Atom.a(@"new "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name)))
+                {
+                    YP.write(Name);
+                    return;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"null")))
+                {
+                    YP.write(Atom.a(@"null"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X)))
+                {
+                    YP.write(Atom.a(@"!("));
+                    convertExpressionJavascript(X);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Y = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y)))
+                {
+                    YP.write(Atom.a(@"("));
+                    convertExpressionJavascript(X);
+                    YP.write(Atom.a(@") && ("));
+                    convertExpressionJavascript(Y);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList)))
+                {
+                    YP.write(Atom.a(@"["));
+                    convertArgListJavascript(ArgList);
+                    YP.write(Atom.a(@"]"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Codes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    if (YP.atom(X))
+                    {
+                        YP.write(Atom.a(@""""));
+                        foreach (bool l4 in YP.atom_codes(X, Codes))
+                        {
+                            convertStringCodesJavascript(Codes);
+                            YP.write(Atom.a(@""""));
+                            return;
+                        }
+                    }
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    YP.write(X);
+                    return;
+                }
+            }
+        }
+
+        public static void convertStringCodesJavascript(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Code = new Variable();
+                Variable RestCodes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes)))
+                {
+                    if (YP.termEqual(Code, 34))
+                    {
+                        YP.put_code(92);
+                        YP.put_code(Code);
+                        convertStringCodesJavascript(RestCodes);
+                        return;
+                        goto cutIf1;
+                    }
+                    if (YP.termEqual(Code, 92))
+                    {
+                        YP.put_code(92);
+                        YP.put_code(Code);
+                        convertStringCodesJavascript(RestCodes);
+                        return;
+                        goto cutIf1;
+                    }
+                    YP.put_code(Code);
+                    convertStringCodesJavascript(RestCodes);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static void convertFunctionPython(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass")))
+                {
+                    YP.write(Atom.a(@"def getDeclaringClass():"));
+                    YP.nl();
+                    YP.write(Atom.a(@"  return None"));
+                    YP.nl();
+                    YP.nl();
+                    return;
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable Body = new Variable();
+                Variable Level = new Variable();
+                Variable HasBreakableBlock = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body })))
+                {
+                    YP.write(Atom.a(@"def "));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@"):"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(Level, 1))
+                    {
+                        if (hasBreakableBlockPython(Body))
+                        {
+                            foreach (bool l5 in YP.unify(HasBreakableBlock, 1))
+                            {
+                                if (YP.termEqual(HasBreakableBlock, 1))
+                                {
+                                    convertIndentationPython(Level);
+                                    YP.write(Atom.a(@"doBreak = False"));
+                                    YP.nl();
+                                    foreach (bool l7 in convertStatementListPython(Body, Level, HasBreakableBlock))
+                                    {
+                                        YP.nl();
+                                        return;
+                                    }
+                                    goto cutIf2;
+                                }
+                                foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock))
+                                {
+                                    YP.nl();
+                                    return;
+                                }
+                            cutIf2:
+                                { }
+                            }
+                            goto cutIf1;
+                        }
+                        foreach (bool l4 in YP.unify(HasBreakableBlock, 0))
+                        {
+                            if (YP.termEqual(HasBreakableBlock, 1))
+                            {
+                                convertIndentationPython(Level);
+                                YP.write(Atom.a(@"doBreak = False"));
+                                YP.nl();
+                                foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock))
+                                {
+                                    YP.nl();
+                                    return;
+                                }
+                                goto cutIf3;
+                            }
+                            foreach (bool l5 in convertStatementListPython(Body, Level, HasBreakableBlock))
+                            {
+                                YP.nl();
+                                return;
+                            }
+                        cutIf3:
+                            { }
+                        }
+                    cutIf1:
+                        { }
+                    }
+                }
+            }
+        }
+
+        public static bool hasBreakableBlockPython(object arg1)
+        {
+            {
+                Variable _Name = new Variable();
+                Variable _Body = new Variable();
+                Variable _RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", _Name, _Body), _RestStatements)))
+                {
+                    return true;
+                }
+            }
+            {
+                Variable Body = new Variable();
+                Variable _RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), _RestStatements)))
+                {
+                    if (hasBreakableBlockPython(Body))
+                    {
+                        return true;
+                    }
+                }
+            }
+            {
+                Variable _Expression = new Variable();
+                Variable Body = new Variable();
+                Variable _RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", _Expression, Body), _RestStatements)))
+                {
+                    if (hasBreakableBlockPython(Body))
+                    {
+                        return true;
+                    }
+                }
+            }
+            {
+                Variable _Expression = new Variable();
+                Variable Body = new Variable();
+                Variable _RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", _Expression, Body), _RestStatements)))
+                {
+                    if (hasBreakableBlockPython(Body))
+                    {
+                        return true;
+                    }
+                }
+            }
+            {
+                Variable x1 = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestStatements)))
+                {
+                    if (hasBreakableBlockPython(RestStatements))
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        public static IEnumerable<bool> convertStatementListPython(object arg1, object arg2, object arg3)
+        {
+            {
+                object x1 = arg2;
+                object x2 = arg3;
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    yield return true;
+                    yield break;
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Name = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = False"));
+                    YP.nl();
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"for _ in [1]:"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock))
+                        {
+                            convertIndentationPython(Level);
+                            YP.write(Atom.a(@"if "));
+                            YP.write(Name);
+                            YP.write(Atom.a(@":"));
+                            YP.nl();
+                            convertIndentationPython(NextLevel);
+                            YP.write(Atom.a(@"doBreak = False"));
+                            YP.nl();
+                            convertIndentationPython(Level);
+                            YP.write(Atom.a(@"if doBreak:"));
+                            YP.nl();
+                            convertIndentationPython(NextLevel);
+                            YP.write(Atom.a(@"break"));
+                            YP.nl();
+                            foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable _Type = new Variable();
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionPython(Expression);
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Name = new Variable();
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = "));
+                    convertExpressionPython(Expression);
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"yield True"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"yield False"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"return"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"return"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"return True"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"return False"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Name = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@" = True"));
+                    YP.nl();
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"doBreak = True"));
+                    YP.nl();
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"break"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@")"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@")"));
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements)))
+                {
+                    if (YP.termEqual(HasBreakableBlock, 1))
+                    {
+                        convertIndentationPython(Level);
+                        YP.write(Atom.a(@"for _ in [1]:"));
+                        YP.nl();
+                        foreach (bool l4 in YP.unify(NextLevel, YP.add(Level, 1)))
+                        {
+                            foreach (bool l5 in convertStatementListPython(Body, NextLevel, HasBreakableBlock))
+                            {
+                                if (YP.termEqual(HasBreakableBlock, 1))
+                                {
+                                    if (YP.greaterThan(Level, 1))
+                                    {
+                                        convertIndentationPython(Level);
+                                        YP.write(Atom.a(@"if doBreak:"));
+                                        YP.nl();
+                                        convertIndentationPython(NextLevel);
+                                        YP.write(Atom.a(@"break"));
+                                        YP.nl();
+                                        foreach (bool l8 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                        {
+                                            yield return true;
+                                            yield break;
+                                        }
+                                        goto cutIf3;
+                                    }
+                                    foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                cutIf3:
+                                    goto cutIf2;
+                                }
+                                foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            cutIf2:
+                                { }
+                            }
+                        }
+                        goto cutIf1;
+                    }
+                    foreach (bool l3 in YP.unify(NextLevel, Level))
+                    {
+                        foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock))
+                        {
+                            if (YP.termEqual(HasBreakableBlock, 1))
+                            {
+                                if (YP.greaterThan(Level, 1))
+                                {
+                                    convertIndentationPython(Level);
+                                    YP.write(Atom.a(@"if doBreak:"));
+                                    YP.nl();
+                                    convertIndentationPython(NextLevel);
+                                    YP.write(Atom.a(@"break"));
+                                    YP.nl();
+                                    foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                    {
+                                        yield return true;
+                                        yield break;
+                                    }
+                                    goto cutIf5;
+                                }
+                                foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                            cutIf5:
+                                goto cutIf4;
+                            }
+                            foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        cutIf4:
+                            { }
+                        }
+                    }
+                cutIf1:
+                    { }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"if "));
+                    convertExpressionPython(Expression);
+                    YP.write(Atom.a(@":"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock))
+                        {
+                            foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        }
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Expression = new Variable();
+                Variable Body = new Variable();
+                Variable RestStatements = new Variable();
+                Variable NextLevel = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"for l"));
+                    YP.write(Level);
+                    YP.write(Atom.a(@" in "));
+                    convertExpressionPython(Expression);
+                    YP.write(Atom.a(@":"));
+                    YP.nl();
+                    foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1)))
+                    {
+                        foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock))
+                        {
+                            if (YP.termEqual(HasBreakableBlock, 1))
+                            {
+                                convertIndentationPython(Level);
+                                YP.write(Atom.a(@"if doBreak:"));
+                                YP.nl();
+                                convertIndentationPython(NextLevel);
+                                YP.write(Atom.a(@"break"));
+                                YP.nl();
+                                foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                                {
+                                    yield return true;
+                                    yield break;
+                                }
+                                goto cutIf6;
+                            }
+                            foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                            {
+                                yield return true;
+                                yield break;
+                            }
+                        cutIf6:
+                            { }
+                        }
+                    }
+                }
+            }
+            {
+                object Level = arg2;
+                object HasBreakableBlock = arg3;
+                Variable Expression = new Variable();
+                Variable RestStatements = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
+                {
+                    convertIndentationPython(Level);
+                    YP.write(Atom.a(@"raise "));
+                    convertExpressionPython(Expression);
+                    YP.nl();
+                    foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
+                    {
+                        yield return true;
+                        yield break;
+                    }
+                }
+            }
+        }
+
+        public static void convertIndentationPython(object Level)
+        {
+            {
+                Variable N = new Variable();
+                foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2)))
+                {
+                    repeatWrite(Atom.a(@" "), N);
+                    return;
+                }
+            }
+        }
+
+        public static void convertArgListPython(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Head = new Variable();
+                Variable Tail = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail)))
+                {
+                    convertExpressionPython(Head);
+                    if (YP.termNotEqual(Tail, Atom.NIL))
+                    {
+                        YP.write(Atom.a(@", "));
+                        convertArgListPython(Tail);
+                        return;
+                        goto cutIf1;
+                    }
+                    convertArgListPython(Tail);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static void convertExpressionPython(object arg1)
+        {
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X)))
+                {
+                    YP.write(X);
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList)))
+                {
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Obj = new Variable();
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList)))
+                {
+                    YP.write(Obj);
+                    YP.write(Atom.a(@"."));
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList)))
+                {
+                    YP.write(Name);
+                    YP.write(Atom.a(@"("));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable Name = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name)))
+                {
+                    YP.write(Name);
+                    return;
+                }
+            }
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.a(@"null")))
+                {
+                    YP.write(Atom.a(@"None"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X)))
+                {
+                    YP.write(Atom.a(@"not ("));
+                    convertExpressionPython(X);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Y = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y)))
+                {
+                    YP.write(Atom.a(@"("));
+                    convertExpressionPython(X);
+                    YP.write(Atom.a(@") and ("));
+                    convertExpressionPython(Y);
+                    YP.write(Atom.a(@")"));
+                    return;
+                }
+            }
+            {
+                Variable ArgList = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList)))
+                {
+                    YP.write(Atom.a(@"["));
+                    convertArgListPython(ArgList);
+                    YP.write(Atom.a(@"]"));
+                    return;
+                }
+            }
+            {
+                Variable X = new Variable();
+                Variable Codes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    if (YP.atom(X))
+                    {
+                        YP.write(Atom.a(@""""));
+                        foreach (bool l4 in YP.atom_codes(X, Codes))
+                        {
+                            convertStringCodesPython(Codes);
+                            YP.write(Atom.a(@""""));
+                            return;
+                        }
+                    }
+                }
+            }
+            {
+                Variable X = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X)))
+                {
+                    YP.write(X);
+                    return;
+                }
+            }
+        }
+
+        public static void convertStringCodesPython(object arg1)
+        {
+            {
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    return;
+                }
+            }
+            {
+                Variable Code = new Variable();
+                Variable RestCodes = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes)))
+                {
+                    if (YP.termEqual(Code, 34))
+                    {
+                        YP.put_code(92);
+                        YP.put_code(Code);
+                        convertStringCodesPython(RestCodes);
+                        return;
+                        goto cutIf1;
+                    }
+                    if (YP.termEqual(Code, 92))
+                    {
+                        YP.put_code(92);
+                        YP.put_code(Code);
+                        convertStringCodesPython(RestCodes);
+                        return;
+                        goto cutIf1;
+                    }
+                    YP.put_code(Code);
+                    convertStringCodesPython(RestCodes);
+                    return;
+                cutIf1:
+                    { }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> member(object X, object arg2)
+        {
+            {
+                Variable x2 = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(X, x2)))
+                {
+                    yield return false;
+                }
+            }
+            {
+                Variable x2 = new Variable();
+                Variable Rest = new Variable();
+                foreach (bool l2 in YP.unify(arg2, new ListPair(x2, Rest)))
+                {
+                    foreach (bool l3 in member(X, Rest))
+                    {
+                        yield return false;
+                    }
+                }
+            }
+        }
+
+        public static IEnumerable<bool> append(object arg1, object arg2, object arg3)
+        {
+            {
+                Variable List = new Variable();
+                foreach (bool l2 in YP.unify(arg1, Atom.NIL))
+                {
+                    foreach (bool l3 in YP.unify(arg2, List))
+                    {
+                        foreach (bool l4 in YP.unify(arg3, List))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+            {
+                object List2 = arg2;
+                Variable X = new Variable();
+                Variable List1 = new Variable();
+                Variable List12 = new Variable();
+                foreach (bool l2 in YP.unify(arg1, new ListPair(X, List1)))
+                {
+                    foreach (bool l3 in YP.unify(arg3, new ListPair(X, List12)))
+                    {
+                        foreach (bool l4 in append(List1, List2, List12))
+                        {
+                            yield return false;
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}