OpenSim-Test/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs

/*
 * 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();
// disable warning: don't see how we can code this differently short
// of rewriting the whole thing
#pragma warning disable 0168
                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;
                    }
                }
#pragma warning restore 0168

                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();
// disable warning: don't see how we can code this differently short
// of rewriting the whole thing
#pragma warning disable 0168
                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;
                    }
                }
#pragma warning restore 0168

                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;
            }
        }

        // disable warning unused variables, the following code is
        // infested with it.
#pragma warning disable 0168, 0219

        /// <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 OpenSim.Region.ScriptEngine.Shared.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;
                        }
                    }
                }
            }
        }
       #pragma warning restore 0168

    }
}