bindings --> api; and moved nlsat/sat/subpaving tactics

src/api/dotnet/AST.cs

@@ -0,0 +1,260 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    AST.cs
+
+Abstract:
+
+    Z3 Managed API: ASTs
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// The abstract syntax tree (AST) class. 
+    /// </summary>
+    [ContractVerification(true)]
+    public class AST : Z3Object, IComparable
+    {
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <param name="a">An AST</param>
+        /// <param name="b">An AST</param>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context 
+        /// and represent the same sort; false otherwise.</returns>
+        public static bool operator ==(AST a, AST b)
+        {
+            return Object.ReferenceEquals(a, b) ||
+                   (!Object.ReferenceEquals(a, null) &&
+                    !Object.ReferenceEquals(b, null) &&
+                    a.Context.nCtx == b.Context.nCtx &&
+                    Native.Z3_is_eq_ast(a.Context.nCtx, a.NativeObject, b.NativeObject) != 0);
+        }
+
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <param name="a">An AST</param>
+        /// <param name="b">An AST</param>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context 
+        /// or represent different sorts; false otherwise.</returns>
+        public static bool operator !=(AST a, AST b)
+        {
+            return !(a == b);
+        }
+
+        /// <summary>
+        /// Object comparison.
+        /// </summary>
+        public override bool Equals(object o)
+        {
+            AST casted = o as AST;
+            if (casted == null) return false;
+            return this == casted;
+        }
+
+        /// <summary>
+        /// Object Comparison.
+        /// </summary>
+        /// <param name="other">Another AST</param>
+        /// <returns>Negative if the object should be sorted before <paramref name="other"/>, positive if after else zero.</returns>
+        public virtual int CompareTo(object other)
+        {
+            if (other == null) return 1;
+            AST oAST = other as AST;
+            if (oAST == null)
+                return 1;
+            else
+            {
+                if (Id < oAST.Id)
+                    return -1;
+                else if (Id > oAST.Id)
+                    return +1;
+                else
+                    return 0;
+            }
+        }
+
+        /// <summary>
+        /// The AST's hash code.
+        /// </summary>
+        /// <returns>A hash code</returns>
+        public override int GetHashCode()
+        {
+            return (int)Native.Z3_get_ast_hash(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// A unique identifier for the AST (unique among all ASTs).
+        /// </summary>
+        public uint Id
+        {
+            get { return Native.Z3_get_ast_id(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Translates (copies) the AST to the Context <paramref name="ctx"/>.
+        /// </summary>
+        /// <param name="ctx">A context</param>
+        /// <returns>A copy of the AST which is associated with <paramref name="ctx"/></returns>
+        public AST Translate(Context ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Ensures(Contract.Result<AST>() != null);
+
+            if (ReferenceEquals(Context, ctx))
+                return this;
+            else
+                return new AST(ctx, Native.Z3_translate(Context.nCtx, NativeObject, ctx.nCtx));
+        }
+
+        /// <summary>
+        /// The kind of the AST.
+        /// </summary>    
+        public Z3_ast_kind ASTKind
+        {
+            get { return (Z3_ast_kind)Native.Z3_get_ast_kind(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Indicates whether the AST is an Expr
+        /// </summary>
+        public bool IsExpr
+        {
+            get
+            {
+                switch (ASTKind)
+                {
+                    case Z3_ast_kind.Z3_APP_AST:
+                    case Z3_ast_kind.Z3_NUMERAL_AST:
+                    case Z3_ast_kind.Z3_QUANTIFIER_AST:
+                    case Z3_ast_kind.Z3_VAR_AST: return true;
+                    default: return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the AST is a BoundVariable
+        /// </summary>
+        public bool IsVar
+        {
+            get { return this.ASTKind == Z3_ast_kind.Z3_VAR_AST; }
+        }
+
+        /// <summary>
+        /// Indicates whether the AST is a Quantifier
+        /// </summary>
+        public bool IsQuantifier
+        {
+            get { return this.ASTKind == Z3_ast_kind.Z3_QUANTIFIER_AST; }
+        }
+
+        /// <summary>
+        /// Indicates whether the AST is a Sort
+        /// </summary>
+        public bool IsSort
+        {
+            get { return this.ASTKind == Z3_ast_kind.Z3_SORT_AST; }
+        }
+
+        /// <summary>
+        /// Indicates whether the AST is a FunctionDeclaration
+        /// </summary>
+        public bool IsFuncDecl
+        {
+            get { return this.ASTKind == Z3_ast_kind.Z3_FUNC_DECL_AST; }
+        }
+
+        /// <summary>
+        /// A string representation of the AST.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_ast_to_string(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// A string representation of the AST in s-expression notation.
+        /// </summary>
+        public string SExpr()
+        {
+            Contract.Ensures(Contract.Result<string>() != null);
+
+            return Native.Z3_ast_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal AST(Context ctx) : base(ctx) { Contract.Requires(ctx != null); }
+        internal AST(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {            
+            // Console.WriteLine("AST IncRef()");
+            if (Context == null)
+                throw new Z3Exception("inc() called on null context");
+            if (o == IntPtr.Zero)
+                throw new Z3Exception("inc() called on null AST");
+            Context.AST_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            // Console.WriteLine("AST DecRef()");
+            if (Context == null)
+                throw new Z3Exception("dec() called on null context");
+            if (o == IntPtr.Zero)
+                throw new Z3Exception("dec() called on null AST");
+            Context.AST_DRQ.Add(o);
+            base.DecRef(o);
+        }
+
+        internal static AST Create(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Ensures(Contract.Result<AST>() != null);
+
+            switch ((Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj))
+            {
+                case Z3_ast_kind.Z3_FUNC_DECL_AST: return new FuncDecl(ctx, obj);
+                case Z3_ast_kind.Z3_QUANTIFIER_AST: return new Quantifier(ctx, obj);
+                case Z3_ast_kind.Z3_SORT_AST: return Sort.Create(ctx, obj);
+                case Z3_ast_kind.Z3_APP_AST:
+                case Z3_ast_kind.Z3_NUMERAL_AST:
+                case Z3_ast_kind.Z3_VAR_AST: return Expr.Create(ctx, obj);
+                default:
+                    throw new Z3Exception("Unknown AST kind");
+            }
+        }
+        #endregion
+    }
+}

src/api/dotnet/ASTMap.cs

@@ -0,0 +1,155 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    ASTMap.cs
+
+Abstract:
+
+    Z3 Managed API: AST Maps
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Map from AST to AST
+    /// </summary>
+    [ContractVerification(true)]
+    internal class ASTMap : Z3Object
+    {
+        /// <summary>
+        /// Checks whether the map contains the key <paramref name="k"/>.
+        /// </summary>
+        /// <param name="k">An AST</param>
+        /// <returns>True if <paramref name="k"/> is a key in the map, false otherwise.</returns>
+        public bool Contains(AST k)
+        {
+            Contract.Requires(k != null);
+
+            return Native.Z3_ast_map_contains(Context.nCtx, NativeObject, k.NativeObject) != 0;
+        }
+
+        /// <summary>
+        /// Finds the value associated with the key <paramref name="k"/>.
+        /// </summary>
+        /// <remarks>
+        /// This function signs an error when <paramref name="k"/> is not a key in the map.
+        /// </remarks>
+        /// <param name="k">An AST</param>    
+        public AST Find(AST k)
+        {
+            Contract.Requires(k != null);
+            Contract.Ensures(Contract.Result<AST>() != null);
+
+            return new AST(Context, Native.Z3_ast_map_find(Context.nCtx, NativeObject, k.NativeObject));
+        }
+
+        /// <summary>
+        /// Stores or replaces a new key/value pair in the map.
+        /// </summary>
+        /// <param name="k">The key AST</param>
+        /// <param name="v">The value AST</param>
+        public void Insert(AST k, AST v)
+        {
+            Contract.Requires(k != null);
+            Contract.Requires(v != null);
+
+            Native.Z3_ast_map_insert(Context.nCtx, NativeObject, k.NativeObject, v.NativeObject);
+        }
+
+        /// <summary>
+        /// Erases the key <paramref name="k"/> from the map.
+        /// </summary>
+        /// <param name="k">An AST</param>
+        public void Erase(AST k)
+        {
+            Contract.Requires(k != null);
+
+            Native.Z3_ast_map_erase(Context.nCtx, NativeObject, k.NativeObject);
+        }
+
+        /// <summary>
+        /// Removes all keys from the map.
+        /// </summary>
+        public void Reset()
+        {
+            Native.Z3_ast_map_reset(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// The size of the map
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_ast_map_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The keys stored in the map.
+        /// </summary>
+        public ASTVector Keys
+        {
+            get
+            {
+                return new ASTVector(Context, Native.Z3_ast_map_keys(Context.nCtx, NativeObject));
+            }
+        }
+
+        /// <summary>
+        /// Retrieves a string representation of the map. 
+        /// </summary>    
+        public override string ToString()
+        {
+            return Native.Z3_ast_map_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal ASTMap(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal ASTMap(Context ctx)
+            : base(ctx, Native.Z3_mk_ast_map(ctx.nCtx))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_ast_map_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_ast_map_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.ASTMap_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.ASTMap_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/ASTVector.cs

@@ -0,0 +1,132 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    ASTVector.cs
+
+Abstract:
+
+    Z3 Managed API: AST Vectors
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Vectors of ASTs.
+    /// </summary>
+    internal class ASTVector : Z3Object
+    {
+        /// <summary>
+        /// The size of the vector
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_ast_vector_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Retrieves the i-th object in the vector.
+        /// </summary>
+        /// <remarks>May throw an IndexOutOfBoundsException when <paramref name="i"/> is out of range.</remarks>
+        /// <param name="i">Index</param>
+        /// <returns>An AST</returns>
+        public AST this[uint i]
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<AST>() != null);
+
+                return new AST(Context, Native.Z3_ast_vector_get(Context.nCtx, NativeObject, i));
+            }
+            set
+            {
+                Contract.Requires(value!= null);
+
+                Native.Z3_ast_vector_set(Context.nCtx, NativeObject, i, value.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Resize the vector to <paramref name="newSize"/>.
+        /// </summary>
+        /// <param name="newSize">The new size of the vector.</param>
+        public void Resize(uint newSize)
+        {
+            Native.Z3_ast_vector_resize(Context.nCtx, NativeObject, newSize);
+        }
+
+        /// <summary>
+        /// Add the AST <paramref name="a"/> to the back of the vector. The size
+        /// is increased by 1.
+        /// </summary>
+        /// <param name="a">An AST</param>
+        public void Push(AST a)
+        {
+            Contract.Requires(a != null);
+
+            Native.Z3_ast_vector_push(Context.nCtx, NativeObject, a.NativeObject);
+        }
+
+        /// <summary>
+        /// Translates all ASTs in the vector to <paramref name="ctx"/>.
+        /// </summary>
+        /// <param name="ctx">A context</param>
+        /// <returns>A new ASTVector</returns>
+        public ASTVector Translate(Context ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Ensures(Contract.Result<ASTVector>() != null);
+
+            return new ASTVector(Context, Native.Z3_ast_vector_translate(Context.nCtx, NativeObject, ctx.nCtx));
+        }
+
+        /// <summary>
+        /// Retrieves a string representation of the vector. 
+        /// </summary>    
+        public override string ToString()
+        {
+            return Native.Z3_ast_vector_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal ASTVector(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        internal ASTVector(Context ctx) : base(ctx, Native.Z3_mk_ast_vector(ctx.nCtx)) { Contract.Requires(ctx != null); }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_ast_vector_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_ast_vector_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.ASTVector_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.ASTVector_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/ApplyResult.cs

@@ -0,0 +1,111 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    ApplyResult.cs
+
+Abstract:
+
+    Z3 Managed API: Result object for tactic applications
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// ApplyResult objects represent the result of an application of a 
+    /// tactic to a goal. It contains the subgoals that were produced.
+    /// </summary>
+    [ContractVerification(true)]
+    public class ApplyResult : Z3Object
+    {
+        /// <summary>
+        /// The number of Subgoals.
+        /// </summary>
+        public uint NumSubgoals
+        {
+            get { return Native.Z3_apply_result_get_num_subgoals(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Retrieves the subgoals from the ApplyResult.
+        /// </summary>
+        public Goal[] Subgoals
+        {
+            get
+            {
+              Contract.Ensures(Contract.Result<Goal[]>() != null);
+              Contract.Ensures(Contract.Result<Goal[]>().Length == this.NumSubgoals);
+
+                uint n = NumSubgoals;
+                Goal[] res = new Goal[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new Goal(Context, Native.Z3_apply_result_get_subgoal(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Convert a model for the subgoal <paramref name="i"/> into a model for the original 
+        /// goal <c>g</c>, that the ApplyResult was obtained from. 
+        /// </summary>
+        /// <returns>A model for <c>g</c></returns>
+        public Model ConvertModel(uint i, Model m)
+        {
+            Contract.Requires(m != null);
+            Contract.Ensures(Contract.Result<Model>() != null);
+
+            return new Model(Context, Native.Z3_apply_result_convert_model(Context.nCtx, NativeObject, i, m.NativeObject));
+        }
+
+        /// <summary>
+        /// A string representation of the ApplyResult.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_apply_result_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal ApplyResult(Context ctx, IntPtr obj) : base(ctx, obj) 
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_apply_result_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_apply_result_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.ApplyResult_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.ApplyResult_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Constructor.cs

@@ -0,0 +1,170 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Constructor.cs
+
+Abstract:
+
+    Z3 Managed API: Constructors
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-22
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Constructors are used for datatype sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Constructor : Z3Object
+    {
+        /// <summary>
+        /// The number of fields of the constructor.
+        /// </summary>
+        public uint NumFields
+        {
+            get { init();  return n; }
+        }
+
+        /// <summary>
+        /// The function declaration of the constructor.
+        /// </summary>
+        public FuncDecl ConstructorDecl
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                init();  return m_constructorDecl; }
+        }
+
+        /// <summary>
+        /// The function declaration of the tester.
+        /// </summary>
+        public FuncDecl TesterDecl
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                init();  return m_testerDecl; }
+        }
+
+        /// <summary>
+        /// The function declarations of the accessors
+        /// </summary>
+        public FuncDecl[] AccessorDecls
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+                init();  return m_accessorDecls; }
+        }        
+
+        /// <summary>
+        /// Destructor.
+        /// </summary>
+        ~Constructor()
+        {
+            Native.Z3_del_constructor(Context.nCtx, NativeObject);
+        }
+
+        #region Object invariant
+
+        [ContractInvariantMethod]
+        private void ObjectInvariant()
+        {
+            Contract.Invariant(m_testerDecl  == null || m_constructorDecl != null);
+            Contract.Invariant(m_testerDecl == null || m_accessorDecls != null);
+        }
+        
+        #endregion
+
+        #region Internal
+        readonly private uint n = 0;
+        private FuncDecl m_testerDecl = null;
+        private FuncDecl m_constructorDecl = null;
+        private FuncDecl[] m_accessorDecls = null;
+
+        internal Constructor(Context ctx, Symbol name, Symbol recognizer, Symbol[] fieldNames,
+                             Sort[] sorts, uint[] sortRefs)
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+            Contract.Requires(recognizer != null);
+
+            n = AST.ArrayLength(fieldNames);
+
+            if (n != AST.ArrayLength(sorts))
+                throw new Z3Exception("Number of field names does not match number of sorts");
+            if (sortRefs != null && sortRefs.Length != n)
+                throw new Z3Exception("Number of field names does not match number of sort refs");
+            
+            if (sortRefs == null) sortRefs = new uint[n];
+
+            NativeObject = Native.Z3_mk_constructor(ctx.nCtx, name.NativeObject, recognizer.NativeObject,
+                                                    n,
+                                                    Symbol.ArrayToNative(fieldNames),
+                                                    Sort.ArrayToNative(sorts),
+                                                    sortRefs);
+
+        }
+
+        private void init() 
+        {
+            Contract.Ensures(m_constructorDecl != null);
+            Contract.Ensures(m_testerDecl != null);
+            Contract.Ensures(m_accessorDecls != null);
+
+            if (m_testerDecl != null) return;
+            IntPtr constructor = IntPtr.Zero;
+            IntPtr tester = IntPtr.Zero;
+            IntPtr[] accessors = new IntPtr[n];
+            Native.Z3_query_constructor(Context.nCtx, NativeObject, n, ref constructor, ref tester, accessors);
+            m_constructorDecl = new FuncDecl(Context, constructor);
+            m_testerDecl = new FuncDecl(Context, tester);
+            m_accessorDecls = new FuncDecl[n];
+            for (uint i = 0; i < n; i++)
+                m_accessorDecls[i] = new FuncDecl(Context, accessors[i]);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Lists of constructors
+    /// </summary>
+    public class ConstructorList : Z3Object
+    {
+        /// <summary>
+        /// Destructor.
+        /// </summary>
+        ~ConstructorList()
+        {         
+            Native.Z3_del_constructor_list(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal ConstructorList(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal ConstructorList(Context ctx, Constructor[] constructors)
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(constructors != null);
+
+            NativeObject = Native.Z3_mk_constructor_list(Context.nCtx, (uint)constructors.Length, Constructor.ArrayToNative(constructors));
+        }        
+        #endregion
+    }
+}

src/api/dotnet/DecRefQUeue.cs

@@ -0,0 +1,92 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    DecRefQueue.cs
+
+Abstract:
+
+    Z3 Managed API: DecRef Queues
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{    
+    [ContractClass(typeof(DecRefQueueContracts))]
+    internal abstract class DecRefQueue
+    {
+        #region Object invariant
+
+        [ContractInvariantMethod]
+        private void ObjectInvariant()
+        {
+            Contract.Invariant(this.m_queue != null);
+        }
+        
+        #endregion
+
+        readonly internal protected Object m_lock = new Object();
+        readonly internal protected List<IntPtr> m_queue = new List<IntPtr>();
+        internal const uint m_move_limit = 1024;
+
+        public abstract void IncRef(Context ctx, IntPtr obj);
+        public abstract void DecRef(Context ctx, IntPtr obj);
+
+        public void IncAndClear(Context ctx, IntPtr o)
+        {
+            Contract.Requires(ctx != null);
+
+            IncRef(ctx, o);
+            if (m_queue.Count >= m_move_limit) Clear(ctx);
+        }
+
+        public void Add(IntPtr o)
+        {
+            if (o == IntPtr.Zero) return;
+
+            lock (m_lock)
+            {
+                m_queue.Add(o);
+            }
+        }
+
+        public void Clear(Context ctx)
+        {
+            Contract.Requires(ctx != null);
+
+            lock (m_lock)
+            {
+                foreach (IntPtr o in m_queue)
+                    DecRef(ctx, o);
+                m_queue.Clear();
+            }
+        }
+    }
+
+    [ContractClassFor(typeof(DecRefQueue))]
+    abstract class DecRefQueueContracts : DecRefQueue
+    {
+        public override void IncRef(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        public override void DecRef(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+    }
+}

src/api/dotnet/Fixedpoint.cs

@@ -0,0 +1,303 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Fixedpoints.cs
+
+Abstract:
+
+    Z3 Managed API: Fixedpoints
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Object for managing fixedpoints
+    /// </summary>
+    [ContractVerification(true)]
+    public class Fixedpoint : Z3Object
+    {
+
+        /// <summary>
+        /// A string that describes all available fixedpoint solver parameters.
+        /// </summary>
+        public string Help
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+                return Native.Z3_fixedpoint_get_help(Context.nCtx, NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Sets the fixedpoint solver parameters.
+        /// </summary>
+        public Params Parameters
+        {
+            set
+            {
+                Contract.Requires(value != null);
+                Context.CheckContextMatch(value);
+                Native.Z3_fixedpoint_set_params(Context.nCtx, NativeObject, value.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves parameter descriptions for Fixedpoint solver.
+        /// </summary>
+        public ParamDescrs ParameterDescriptions
+        {
+            get { return new ParamDescrs(Context, Native.Z3_fixedpoint_get_param_descrs(Context.nCtx, NativeObject)); }
+        }
+
+
+        /// <summary>
+        /// Assert a constraint (or multiple) into the fixedpoint solver.
+        /// </summary>        
+        public void Assert(params BoolExpr[] constraints)
+        {
+            Contract.Requires(constraints != null);
+            Contract.Requires(Contract.ForAll(constraints, c => c != null));
+
+            Context.CheckContextMatch(constraints);
+            foreach (BoolExpr a in constraints)
+            {
+                Native.Z3_fixedpoint_assert(Context.nCtx, NativeObject, a.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Register predicate as recursive relation.
+        /// </summary>       
+        public void RegisterRelation(FuncDecl f)
+        {
+            Contract.Requires(f != null);
+
+            Context.CheckContextMatch(f);
+            Native.Z3_fixedpoint_register_relation(Context.nCtx, NativeObject, f.NativeObject);
+        }
+
+        /// <summary>
+        /// Add rule into the fixedpoint solver.
+        /// </summary>        
+        public void AddRule(BoolExpr rule, Symbol name = null)
+        {
+            Contract.Requires(rule != null);
+
+            Context.CheckContextMatch(rule);
+            Native.Z3_fixedpoint_add_rule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name));
+        }
+
+        /// <summary>
+        /// Add table fact to the fixedpoint solver.
+        /// </summary>        
+        public void AddFact(FuncDecl pred, params uint[] args)
+        {
+            Contract.Requires(pred != null);
+            Contract.Requires(args != null);
+
+            Context.CheckContextMatch(pred);
+            Native.Z3_fixedpoint_add_fact(Context.nCtx, NativeObject, pred.NativeObject, (uint)args.Length, args);
+        }
+
+        /// <summary>
+        /// Query the fixedpoint solver.
+        /// A query is a conjunction of constraints. The constraints may include the recursively defined relations.
+        /// The query is satisfiable if there is an instance of the query variables and a derivation for it.
+        /// The query is unsatisfiable if there are no derivations satisfying the query variables. 
+        /// </summary>        
+        public Status Query(BoolExpr query)
+        {
+            Contract.Requires(query != null);
+
+            Context.CheckContextMatch(query);
+            Z3_lbool r = (Z3_lbool)Native.Z3_fixedpoint_query(Context.nCtx, NativeObject, query.NativeObject);
+            switch (r)
+            {
+                case Z3_lbool.Z3_L_TRUE: return Status.SATISFIABLE;
+                case Z3_lbool.Z3_L_FALSE: return Status.UNSATISFIABLE;
+                default: return Status.UNKNOWN;
+            }
+        }
+
+        /// <summary>
+        /// Query the fixedpoint solver.
+        /// A query is an array of relations.
+        /// The query is satisfiable if there is an instance of some relation that is non-empty.
+        /// The query is unsatisfiable if there are no derivations satisfying any of the relations.
+        /// </summary>        
+        public Status Query(FuncDecl[] relations)
+        {
+            Contract.Requires(relations != null);
+            Contract.Requires(Contract.ForAll(0, relations.Length, i => relations[i] != null));
+
+            Context.CheckContextMatch(relations);
+            Z3_lbool r = (Z3_lbool)Native.Z3_fixedpoint_query_relations(Context.nCtx, NativeObject,
+                                   AST.ArrayLength(relations), AST.ArrayToNative(relations));
+            switch (r)
+            {
+                case Z3_lbool.Z3_L_TRUE: return Status.SATISFIABLE;
+                case Z3_lbool.Z3_L_FALSE: return Status.UNSATISFIABLE;
+                default: return Status.UNKNOWN;
+            }
+        }
+
+        /// <summary>
+        /// Creates a backtracking point.
+        /// </summary>
+        /// <seealso cref="Pop"/>
+        public void Push()
+        {
+            Native.Z3_fixedpoint_push(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// Backtrack one backtracking point.
+        /// </summary>
+        /// <remarks>Note that an exception is thrown if Pop is called without a corresponding <c>Push</c></remarks>
+        /// <seealso cref="Push"/>
+        public void Pop()
+        {
+            Native.Z3_fixedpoint_pop(Context.nCtx, NativeObject);
+        }
+
+
+        /// <summary>
+        /// Update named rule into in the fixedpoint solver.
+        /// </summary>        
+        public void UpdateRule(BoolExpr rule, Symbol name)
+        {
+            Contract.Requires(rule != null);
+
+            Context.CheckContextMatch(rule);
+            Native.Z3_fixedpoint_update_rule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name));
+        }
+
+        /// <summary>
+        /// Retrieve satisfying instance or instances of solver, 
+        /// or definitions for the recursive predicates that show unsatisfiability.
+        /// </summary>                
+        public Expr GetAnswer()
+        {
+            IntPtr ans = Native.Z3_fixedpoint_get_answer(Context.nCtx, NativeObject);
+            return (ans == IntPtr.Zero) ? null : Expr.Create(Context, ans);
+        }
+
+        /// <summary>
+        /// Retrieve explanation why fixedpoint engine returned status Unknown.
+        /// </summary>                
+        public string GetReasonUnknown()
+        {
+            Contract.Ensures(Contract.Result<string>() != null);
+
+            return Native.Z3_fixedpoint_get_reason_unknown(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// Retrieve the number of levels explored for a given predicate.
+        /// </summary>                
+        public uint GetNumLevels(FuncDecl predicate)
+        {
+            return Native.Z3_fixedpoint_get_num_levels(Context.nCtx, NativeObject, predicate.NativeObject);
+        }
+
+        /// <summary>
+        /// Retrieve the cover of a predicate.
+        /// </summary>                
+        public Expr GetCoverDelta(int level, FuncDecl predicate)
+        {
+            IntPtr res = Native.Z3_fixedpoint_get_cover_delta(Context.nCtx, NativeObject, level, predicate.NativeObject);
+            return (res == IntPtr.Zero) ? null : Expr.Create(Context, res);
+        }
+
+        /// <summary>
+        /// Add <tt>property</tt> about the <tt>predicate</tt>.
+        /// The property is added at <tt>level</tt>.
+        /// </summary>                
+        public void AddCover(int level, FuncDecl predicate, Expr property)
+        {
+            Native.Z3_fixedpoint_add_cover(Context.nCtx, NativeObject, level, predicate.NativeObject, property.NativeObject);
+        }
+
+        /// <summary>
+        /// Retrieve internal string representation of fixedpoint object.
+        /// </summary>                
+        public override string ToString()
+        {
+            return Native.Z3_fixedpoint_to_string(Context.nCtx, NativeObject, 0, null);
+        }
+
+        /// <summary>
+        /// Instrument the Datalog engine on which table representation to use for recursive predicate.
+        /// </summary>                
+        public void SetPredicateRepresentation(FuncDecl f, Symbol[] kinds)
+        {
+            Contract.Requires(f != null);
+
+            Native.Z3_fixedpoint_set_predicate_representation(Context.nCtx, NativeObject,
+                               f.NativeObject, AST.ArrayLength(kinds), Symbol.ArrayToNative(kinds));
+
+        }
+
+        /// <summary>
+        /// Convert benchmark given as set of axioms, rules and queries to a string.
+        /// </summary>                
+        public string ToString(BoolExpr[] queries)
+        {
+
+            return Native.Z3_fixedpoint_to_string(Context.nCtx, NativeObject,
+                             AST.ArrayLength(queries), AST.ArrayToNative(queries));
+        }
+
+
+        #region Internal
+        internal Fixedpoint(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal Fixedpoint(Context ctx)
+            : base(ctx, Native.Z3_mk_fixedpoint(ctx.nCtx))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_fixedpoint_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_fixedpoint_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Fixedpoint_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Fixedpoint_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/FuncDecl.cs

@@ -0,0 +1,344 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    FuncDecl.cs
+
+Abstract:
+
+    Z3 Managed API: Function Declarations
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Function declarations. 
+    /// </summary>
+    [ContractVerification(true)]
+    public class FuncDecl : AST
+    {
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> share the same context and are equal, false otherwise.</returns>
+        public static bool operator ==(FuncDecl a, FuncDecl b)
+        {
+            return Object.ReferenceEquals(a, b) ||
+                   (!Object.ReferenceEquals(a, null) &&
+                    !Object.ReferenceEquals(b, null) &&
+                    a.Context.nCtx == b.Context.nCtx &&
+                    Native.Z3_is_eq_func_decl(a.Context.nCtx, a.NativeObject, b.NativeObject) != 0);
+        }
+
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> do not share the same context or are not equal, false otherwise.</returns>
+        public static bool operator !=(FuncDecl a, FuncDecl b)
+        {
+            return !(a == b);
+        }
+
+        /// <summary>
+        /// Object comparison.
+        /// </summary>
+        public override bool Equals(object o)
+        {
+            FuncDecl casted = o as FuncDecl;
+            if (casted == null) return false;
+            return this == casted;
+        }
+
+        /// <summary>
+        /// A hash code.
+        /// </summary>    
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <summary>
+        /// A string representations of the function declaration.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_func_decl_to_string(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// Returns a unique identifier for the function declaration.
+        /// </summary>
+        new public uint Id
+        {
+            get { return Native.Z3_get_func_decl_id(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The arity of the function declaration
+        /// </summary>
+        public uint Arity
+        {
+            get { return Native.Z3_get_arity(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The size of the domain of the function declaration
+        /// <seealso cref="Arity"/>
+        /// </summary>
+        public uint DomainSize
+        {
+            get { return Native.Z3_get_domain_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The domain of the function declaration
+        /// </summary>
+        public Sort[] Domain
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Sort[]>() != null);
+
+                var n = DomainSize;
+
+                Sort[] res = new Sort[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Sort.Create(Context, Native.Z3_get_domain(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The range of the function declaration
+        /// </summary>
+        public Sort Range
+        {
+            get {
+                Contract.Ensures(Contract.Result<Sort>() != null);
+                return Sort.Create(Context, Native.Z3_get_range(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The kind of the function declaration.
+        /// </summary>
+        public Z3_decl_kind DeclKind
+        {
+            get { return (Z3_decl_kind)Native.Z3_get_decl_kind(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The name of the function declaration
+        /// </summary>
+        public Symbol Name
+        {
+            get {
+                Contract.Ensures(Contract.Result<Symbol>() != null);
+                return Symbol.Create(Context, Native.Z3_get_decl_name(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The number of parameters of the function declaration
+        /// </summary>
+        public uint NumParameters
+        {
+            get { return Native.Z3_get_decl_num_parameters(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The parameters of the function declaration
+        /// </summary>
+        public Parameter[] Parameters
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Parameter[]>() != null);
+
+                uint num = NumParameters;
+                Parameter[] res = new Parameter[num];
+                for (uint i = 0; i < num; i++)
+                {
+                    Z3_parameter_kind k = (Z3_parameter_kind)Native.Z3_get_decl_parameter_kind(Context.nCtx, NativeObject, i);
+                    switch (k)
+                    {
+                        case Z3_parameter_kind.Z3_PARAMETER_INT:
+                            res[i] = new Parameter(k, Native.Z3_get_decl_int_parameter(Context.nCtx, NativeObject, i));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_DOUBLE:
+                            res[i] = new Parameter(k, Native.Z3_get_decl_double_parameter(Context.nCtx, NativeObject, i));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_SYMBOL:
+                            res[i] = new Parameter(k, Symbol.Create(Context, Native.Z3_get_decl_symbol_parameter(Context.nCtx, NativeObject, i)));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_SORT:
+                            res[i] = new Parameter(k, Sort.Create(Context, Native.Z3_get_decl_sort_parameter(Context.nCtx, NativeObject, i)));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_AST:
+                            res[i] = new Parameter(k, new AST(Context, Native.Z3_get_decl_ast_parameter(Context.nCtx, NativeObject, i)));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_FUNC_DECL:
+                            res[i] = new Parameter(k, new FuncDecl(Context, Native.Z3_get_decl_func_decl_parameter(Context.nCtx, NativeObject, i)));
+                            break;
+                        case Z3_parameter_kind.Z3_PARAMETER_RATIONAL:
+                            res[i] = new Parameter(k, Native.Z3_get_decl_rational_parameter(Context.nCtx, NativeObject, i));
+                            break;
+                        default:
+                            throw new Z3Exception("Unknown function declaration parameter kind encountered");
+                    }
+                }
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Function declarations can have Parameters associated with them. 
+        /// </summary>
+        public class Parameter
+        {
+            readonly private Z3_parameter_kind kind;
+            readonly private int i;
+            readonly private double d;
+            readonly private Symbol sym;
+            readonly private Sort srt;
+            readonly private AST ast;
+            readonly private FuncDecl fd;
+            readonly private string r;
+
+            /// <summary>The int value of the parameter.</summary>
+            public int Int { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_INT) throw new Z3Exception("parameter is not an int"); return i; } }
+            /// <summary>The double value of the parameter.</summary>
+            public double Double { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_DOUBLE) throw new Z3Exception("parameter is not a double "); return d; } }
+            /// <summary>The Symbol value of the parameter.</summary>
+            public Symbol Symbol { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_SYMBOL) throw new Z3Exception("parameter is not a Symbol"); return sym; } }
+            /// <summary>The Sort value of the parameter.</summary>
+            public Sort Sort { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_SORT) throw new Z3Exception("parameter is not a Sort"); return srt; } }
+            /// <summary>The AST value of the parameter.</summary>
+            public AST AST { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_AST) throw new Z3Exception("parameter is not an AST"); return ast; } }
+            /// <summary>The FunctionDeclaration value of the parameter.</summary>
+            public FuncDecl FuncDecl { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_FUNC_DECL) throw new Z3Exception("parameter is not a function declaration"); return fd; } }
+            /// <summary>The rational string value of the parameter.</summary>
+            public string Rational { get { if (ParameterKind != Z3_parameter_kind.Z3_PARAMETER_RATIONAL) throw new Z3Exception("parameter is not a rational string"); return r; } }
+
+            /// <summary>
+            /// The kind of the parameter.
+            /// </summary>
+            public Z3_parameter_kind ParameterKind { get { return kind; } }
+
+            #region Internal
+            internal Parameter(Z3_parameter_kind k, int i)
+            {
+                this.kind = k;
+                this.i = i;
+            }
+
+            internal Parameter(Z3_parameter_kind k, double d)
+            {
+                this.kind = k;
+                this.d = d;
+            }
+
+            internal Parameter(Z3_parameter_kind k, Symbol s)
+            {
+                this.kind = k;
+                this.sym = s;
+            }
+
+            internal Parameter(Z3_parameter_kind k, Sort s)
+            {
+                this.kind = k;
+                this.srt = s;
+            }
+
+            internal Parameter(Z3_parameter_kind k, AST a)
+            {
+                this.kind = k;
+                this.ast = a;
+            }
+
+            internal Parameter(Z3_parameter_kind k, FuncDecl fd)
+            {
+                this.kind = k;
+                this.fd = fd;
+            }
+
+            internal Parameter(Z3_parameter_kind k, string r)
+            {
+                this.kind = k;
+                this.r = r;
+            }
+            #endregion
+        }
+
+        #region Internal
+        internal FuncDecl(Context ctx, IntPtr obj) : base(ctx, obj) 
+        { 
+            Contract.Requires(ctx != null); 
+        }
+
+        internal FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range)
+            : base(ctx, Native.Z3_mk_func_decl(ctx.nCtx, name.NativeObject,
+                                             AST.ArrayLength(domain), AST.ArrayToNative(domain),
+                                             range.NativeObject))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+            Contract.Requires(range != null);
+        }        
+
+        internal FuncDecl(Context ctx, string prefix, Sort[] domain, Sort range)
+            : base(ctx, Native.Z3_mk_fresh_func_decl(ctx.nCtx, prefix,
+                                             AST.ArrayLength(domain), AST.ArrayToNative(domain),
+                                             range.NativeObject))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(range != null);
+        }
+
+        #if DEBUG
+        internal override void CheckNativeObject(IntPtr obj)
+        {
+            if (Native.Z3_get_ast_kind(Context.nCtx, obj) != (uint)Z3_ast_kind.Z3_FUNC_DECL_AST)
+                throw new Z3Exception("Underlying object is not a function declaration");
+            base.CheckNativeObject(obj);
+        }
+        #endif
+        #endregion
+
+        /// <summary>
+        /// Create expression that applies function to arguments.
+        /// </summary>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        public Expr this[params Expr[] args] { 
+            get {
+                Contract.Requires(args == null || Contract.ForAll(args, a => a != null));
+
+                return Apply(args); 
+            } 
+        }
+
+        /// <summary>
+        /// Create expression that applies function to arguments.
+        /// </summary>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        public Expr Apply(params Expr[] args)
+        {
+            Contract.Requires(args == null || Contract.ForAll(args, a => a != null));
+
+            Context.CheckContextMatch(args);
+            return Expr.Create(Context, this, args);
+        }
+
+    }
+}

src/api/dotnet/FuncInterp.cs

@@ -0,0 +1,221 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    FuncInterp.cs
+
+Abstract:
+
+    Z3 Managed API: Function Interpretations
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    ///  A function interpretation is represented as a finite map and an 'else' value.
+    ///  Each entry in the finite map represents the value of a function given a set of arguments.  
+    /// </summary>
+    [ContractVerification(true)]
+    public class FuncInterp : Z3Object
+    {
+        /// <summary>
+        /// An Entry object represents an element in the finite map used to encode
+        /// a function interpretation.
+        /// </summary>
+        public class Entry : Z3Object
+        {
+            /// <summary>
+            /// Return the (symbolic) value of this entry.
+            /// </summary>
+            public Expr Value
+            {
+                get {
+                    Contract.Ensures(Contract.Result<Expr>() != null);
+                    return Expr.Create(Context, Native.Z3_func_entry_get_value(Context.nCtx, NativeObject)); }
+            }
+
+            /// <summary>
+            /// The number of arguments of the entry.
+            /// </summary>
+            public uint NumArgs
+            {
+                get { return Native.Z3_func_entry_get_num_args(Context.nCtx, NativeObject); }
+            }
+
+            /// <summary>
+            /// The arguments of the function entry.
+            /// </summary>
+            public Expr[] Args
+            {
+                get
+                {
+                    Contract.Ensures(Contract.Result<Expr[]>() != null);
+                    Contract.Ensures(Contract.Result<Expr[]>().Length == this.NumArgs);
+
+                    uint n = NumArgs;
+                    Expr[] res = new Expr[n];
+                    for (uint i = 0; i < n; i++)
+                        res[i] = Expr.Create(Context, Native.Z3_func_entry_get_arg(Context.nCtx, NativeObject, i));
+                    return res;
+                }
+            }
+
+            /// <summary>
+            /// A string representation of the function entry.
+            /// </summary>
+            public override string ToString()
+            {
+                uint n = NumArgs;
+                string res = "[";
+                Expr[] args = Args;
+                for (uint i = 0; i < n; i++)
+                    res += args[i] + ", ";
+                return res + Value + "]";
+            }
+
+            #region Internal
+            internal Entry(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+            internal class DecRefQueue : Z3.DecRefQueue
+            {
+                public override void IncRef(Context ctx, IntPtr obj)
+                {
+                    Native.Z3_func_entry_inc_ref(ctx.nCtx, obj);
+                }
+
+                public override void DecRef(Context ctx, IntPtr obj)
+                {
+                    Native.Z3_func_entry_dec_ref(ctx.nCtx, obj);
+                }
+            };
+
+            internal override void IncRef(IntPtr o)
+            {
+                Context.FuncEntry_DRQ.IncAndClear(Context, o);
+                base.IncRef(o);
+            }
+
+            internal override void DecRef(IntPtr o)
+            {
+                Context.FuncEntry_DRQ.Add(o);
+                base.DecRef(o);
+            }
+            #endregion
+        };
+
+        /// <summary>
+        /// The number of entries in the function interpretation.
+        /// </summary>
+        public uint NumEntries
+        {
+            get { return Native.Z3_func_interp_get_num_entries(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The entries in the function interpretation
+        /// </summary>
+        public Entry[] Entries
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Entry[]>() != null);
+                Contract.Ensures(Contract.ForAll(0, Contract.Result<Entry[]>().Length, 
+                    j => Contract.Result<Entry[]>()[j] != null));
+
+                uint n = NumEntries;
+                Entry[] res = new Entry[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new Entry(Context, Native.Z3_func_interp_get_entry(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The (symbolic) `else' value of the function interpretation.
+        /// </summary>
+        public Expr Else
+        {
+            get {
+                Contract.Ensures(Contract.Result<Expr>() != null);
+
+                return Expr.Create(Context, Native.Z3_func_interp_get_else(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The arity of the function interpretation
+        /// </summary>
+        public uint Arity
+        {
+            get { return Native.Z3_func_interp_get_arity(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// A string representation of the function interpretation.
+        /// </summary>    
+        public override string ToString()
+        {
+            string res = "";
+            res += "[";
+            foreach (Entry e in Entries)
+            {
+                uint n = e.NumArgs;                
+                if (n > 1) res += "[";
+                Expr[] args = e.Args;
+                for (uint i = 0; i < n; i++)
+                {
+                    if (i != 0) res += ", ";
+                    res += args[i];
+                }
+                if (n > 1) res += "]";
+                res += " -> " + e.Value + ", ";
+            }
+            res += "else -> " + Else;
+            res += "]";
+            return res;
+        }
+
+        #region Internal
+        internal FuncInterp(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_func_interp_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_func_interp_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.FuncInterp_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.FuncInterp_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Goal.cs

@@ -0,0 +1,239 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Goal.cs
+
+Abstract:
+
+    Z3 Managed API: Goal
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// A goal (aka problem). A goal is essentially a set
+    /// of formulas, that can be solved and/or transformed using
+    /// tactics and solvers.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Goal : Z3Object
+    {
+        /// <summary>
+        /// The precision of the goal. 
+        /// </summary>
+        /// <remarks>
+        /// Goals can be transformed using over and under approximations.
+        /// An under approximation is applied when the objective is to find a model for a given goal.
+        /// An over approximation is applied when the objective is to find a proof for a given goal.
+        /// </remarks>
+        public Z3_goal_prec Precision
+        {
+            get { return (Z3_goal_prec)Native.Z3_goal_precision(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal is precise.
+        /// </summary>
+        public bool IsPrecise
+        {
+            get { return Precision == Z3_goal_prec.Z3_GOAL_PRECISE; }
+        }
+        /// <summary>
+        /// Indicates whether the goal is an under-approximation.
+        /// </summary>
+        public bool IsUnderApproximation
+        {
+            get { return Precision == Z3_goal_prec.Z3_GOAL_UNDER; }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal is an over-approximation.
+        /// </summary>
+        public bool IsOverApproximation
+        {
+            get { return Precision == Z3_goal_prec.Z3_GOAL_OVER; }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal is garbage (i.e., the product of over- and under-approximations).
+        /// </summary>
+        public bool IsGarbage
+        {
+            get { return Precision == Z3_goal_prec.Z3_GOAL_UNDER_OVER; }
+        }
+
+        /// <summary>
+        /// Adds the <paramref name="constraints"/> to the given goal. 
+        /// </summary>   
+        public void Assert(params BoolExpr[] constraints)
+        {
+            Contract.Requires(constraints != null);
+            Contract.Requires(Contract.ForAll(constraints, c => c != null));
+
+            Context.CheckContextMatch(constraints);
+            foreach (BoolExpr c in constraints)
+            {
+                Contract.Assert(c != null); // It was an assume, now made an assert just to be sure we do not regress
+                Native.Z3_goal_assert(Context.nCtx, NativeObject, c.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal contains `false'.
+        /// </summary>
+        public bool Inconsistent
+        {
+            get { return Native.Z3_goal_inconsistent(Context.nCtx, NativeObject) != 0; }
+        }
+
+        /// <summary>
+        /// The depth of the goal.
+        /// </summary>
+        /// <remarks>
+        /// This tracks how many transformations were applied to it.
+        /// </remarks>
+        public uint Depth
+        {
+            get { return Native.Z3_goal_depth(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Erases all formulas from the given goal.
+        /// </summary>
+        public void Reset()
+        {
+            Native.Z3_goal_reset(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// The number of formulas in the goal.
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_goal_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The formulas in the goal.
+        /// </summary>
+        public BoolExpr[] Formulas
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<BoolExpr[]>() != null);
+
+                uint n = Size;
+                BoolExpr[] res = new BoolExpr[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new BoolExpr(Context, Native.Z3_goal_formula(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The number of formulas, subformulas and terms in the goal.
+        /// </summary>
+        public uint NumExprs
+        {
+            get { return Native.Z3_goal_num_exprs(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal is empty, and it is precise or the product of an under approximation.
+        /// </summary>
+        public bool IsDecidedSat
+        {
+            get { return Native.Z3_goal_is_decided_sat(Context.nCtx, NativeObject) != 0; }
+        }
+
+        /// <summary>
+        /// Indicates whether the goal contains `false', and it is precise or the product of an over approximation.
+        /// </summary>
+        public bool IsDecidedUnsat
+        {
+            get { return Native.Z3_goal_is_decided_unsat(Context.nCtx, NativeObject) != 0; }
+        }
+
+        /// <summary>
+        /// Translates (copies) the Goal to the target Context <paramref name="ctx"/>.
+        /// </summary>
+        public Goal Translate(Context ctx)
+        {
+            Contract.Requires(ctx != null);
+
+            return new Goal(ctx, Native.Z3_goal_translate(Context.nCtx, NativeObject, ctx.nCtx));
+        }
+
+        /// <summary>
+        /// Simplifies the goal.
+        /// </summary>
+        /// <remarks>Essentially invokes the `simplify' tactic on the goal.</remarks>
+        public Goal Simplify(Params p = null)
+        {
+            Tactic t = Context.MkTactic("simplify");
+            ApplyResult res = t.Apply(this, p);
+            
+            if (res.NumSubgoals == 0)
+                return Context.MkGoal();
+            else        
+                return res.Subgoals[0];
+        }
+
+        /// <summary>
+        /// Goal to string conversion.
+        /// </summary>
+        /// <returns>A string representation of the Goal.</returns>
+        public override string ToString()
+        {
+            return Native.Z3_goal_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal Goal(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+        internal Goal(Context ctx, bool models, bool unsatCores, bool proofs)
+            : base(ctx, Native.Z3_mk_goal(ctx.nCtx, (models) ? 1 : 0, (unsatCores) ? 1 : 0, (proofs) ? 1 : 0))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_goal_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_goal_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Goal_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Goal_DRQ.Add(o);
+            base.DecRef(o);
+        }
+
+        #endregion
+    }
+}

src/api/dotnet/Log.cs

@@ -0,0 +1,79 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Log.cs
+
+Abstract:
+
+    Z3 Managed API: Log
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-15
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Interaction logging for Z3.
+    /// </summary>
+    /// <remarks>
+    /// Note that this is a global, static log and if multiple Context 
+    /// objects are created, it logs the interaction with all of them.
+    /// </remarks>
+    [ContractVerification(true)]
+    public static class Log
+    {
+        private static bool m_is_open = false;
+
+        /// <summary>
+        /// Open an interaction log file.
+        /// </summary>
+        /// <param name="filename">the name of the file to open</param>
+        /// <returns>True if opening the log file succeeds, false otherwise.</returns>
+        public static bool Open(string filename)
+        {
+            m_is_open = true;
+            return Native.Z3_open_log(filename) == 1;
+        }
+
+        /// <summary>
+        /// Closes the interaction log.
+        /// </summary>
+        public static void Close()
+        {
+            m_is_open = false;
+            Native.Z3_close_log();
+        }
+
+        /// <summary>
+        /// Appends the user-provided string <paramref name="s"/> to the interaction log.
+        /// </summary>    
+        public static void Append(string s)
+        {
+            Contract.Requires(isOpen());
+
+            if (!m_is_open)
+                throw new Z3Exception("Log cannot be closed.");
+            Native.Z3_append_log(s);
+        }
+
+        /// <summary>
+        /// Checks whether the interaction log is opened.
+        /// </summary>
+        /// <returns>True if the interaction log is open, false otherwise.</returns>
+        [Pure]
+        public static bool isOpen()
+        {
+            return m_is_open;
+        }
+    }
+}

src/api/dotnet/Microsoft.Z3.csproj

@@ -0,0 +1,309 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EC3DB697-B734-42F7-9468-5B62821EEB5A}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Microsoft.Z3</RootNamespace>
+    <AssemblyName>Microsoft.Z3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>
+    </DocumentationFile>
+    <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>True</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsDisjunctiveRequires>True</CodeContractsDisjunctiveRequires>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>2</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\external\</OutputPath>
+    <DefineConstants>
+    </DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'external|AnyCPU' ">
+    <OutputPath>..\external\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\Debug\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>False</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\x64\external_64\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>True</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions>-repro</CodeContractsExtraAnalysisOptions>
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>2</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external|x64'">
+    <OutputPath>..\x64\external\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>
+    </AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|AnyCPU'">
+    <OutputPath>..\Release_delaysign\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\Release_delaysign\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <DefineConstants>DELAYSIGN</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|x64'">
+    <OutputPath>bin\x64\Release_delaysign\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Numerics" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ApplyResult.cs" />
+    <Compile Include="AST.cs" />
+    <Compile Include="ASTMap.cs" />
+    <Compile Include="ASTVector.cs" />
+    <Compile Include="Constructor.cs" />
+    <Compile Include="DecRefQueue.cs" />
+    <Compile Include="Enumerations.cs" />
+    <Compile Include="Expr.cs" />
+    <Compile Include="Fixedpoint.cs" />
+    <Compile Include="FuncDecl.cs" />
+    <Compile Include="FuncInterp.cs" />
+    <Compile Include="Goal.cs" />
+    <Compile Include="Model.cs" />
+    <Compile Include="Numeral.cs" />
+    <Compile Include="Params.cs" />
+    <Compile Include="ParamDescrs.cs" />
+    <Compile Include="Pattern.cs" />
+    <Compile Include="Statistics.cs" />
+    <Compile Include="Status.cs" />
+    <Compile Include="Context.cs" />
+    <Compile Include="Probe.cs" />
+    <Compile Include="Solver.cs" />
+    <Compile Include="Tactic.cs" />
+    <Compile Include="Z3Exception.cs" />
+    <Compile Include="Log.cs" />
+    <Compile Include="Native.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Quantifier.cs" />
+    <Compile Include="Sort.cs" />
+    <Compile Include="Symbol.cs" />
+    <Compile Include="Version.cs" />
+    <Compile Include="Z3Object.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

src/api/dotnet/Microsoft.Z3_35.csproj

@@ -0,0 +1,403 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EC3DB697-B734-42F7-9468-5B62821EEB5A}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Microsoft.Z3</RootNamespace>
+    <AssemblyName>Microsoft.Z3</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin35\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>
+    </DocumentationFile>
+    <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>True</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>True</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsDisjunctiveRequires>True</CodeContractsDisjunctiveRequires>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>2</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin35\external\bin\</OutputPath>
+    <DefineConstants>FRAMEWORK_LT_4</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'external|AnyCPU' ">
+    <OutputPath>bin35\external\bin\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <DefineConstants>FRAMEWORK_LT_4</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'external|Win32' ">
+    <OutputPath>bin35\external\bin\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <DefineConstants>FRAMEWORK_LT_4</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin35\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\Debug\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>False</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin35\external\x64\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>True</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>True</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>True</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>True</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>True</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>True</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions>-repro</CodeContractsExtraAnalysisOptions>
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>True</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>2</CodeContractsAnalysisWarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external|x64'">
+    <OutputPath>bin35\external\x64</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external_64|AnyCPU'">
+    <OutputPath>bin35\external_64\x64</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <DefineConstants>FRAMEWORK_LT_4</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external_64|x64'">
+    <OutputPath>bin35\external_64\x64</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsInferRequires>False</CodeContractsInferRequires>
+    <CodeContractsInferEnsures>False</CodeContractsInferEnsures>
+    <CodeContractsInferObjectInvariants>False</CodeContractsInferObjectInvariants>
+    <CodeContractsSuggestAssumptions>False</CodeContractsSuggestAssumptions>
+    <CodeContractsSuggestRequires>True</CodeContractsSuggestRequires>
+    <CodeContractsSuggestEnsures>False</CodeContractsSuggestEnsures>
+    <CodeContractsSuggestObjectInvariants>False</CodeContractsSuggestObjectInvariants>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
+    <DefineConstants>FRAMEWORK_LT_4</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>z3.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|AnyCPU'">
+    <OutputPath>bin35\Release_delaysign\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\Release_delaysign\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <DefineConstants>DELAYSIGN</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|x64'">
+    <OutputPath>bin\x64\Release_delaysign\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\release\Microsoft.Z3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=736440c9b414ea16, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\Program Files\Microsoft\Contracts\Contracts\v3.5\Microsoft.Contracts.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ApplyResult.cs" />
+    <Compile Include="AST.cs" />
+    <Compile Include="ASTMap.cs" />
+    <Compile Include="ASTVector.cs" />
+    <Compile Include="Constructor.cs" />
+    <Compile Include="DecRefQueue.cs" />
+    <Compile Include="Enumerations.cs" />
+    <Compile Include="Expr.cs" />
+    <Compile Include="Fixedpoint.cs" />
+    <Compile Include="FuncDecl.cs" />
+    <Compile Include="FuncInterp.cs" />
+    <Compile Include="Goal.cs" />
+    <Compile Include="Model.cs" />
+    <Compile Include="Numeral.cs" />
+    <Compile Include="Params.cs" />
+    <Compile Include="Pattern.cs" />
+    <Compile Include="Statistics.cs" />
+    <Compile Include="Status.cs" />
+    <Compile Include="Context.cs" />
+    <Compile Include="Probe.cs" />
+    <Compile Include="Solver.cs" />
+    <Compile Include="Tactic.cs" />
+    <Compile Include="Z3Exception.cs" />
+    <Compile Include="Log.cs" />
+    <Compile Include="Native.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Quantifier.cs" />
+    <Compile Include="Sort.cs" />
+    <Compile Include="Symbol.cs" />
+    <Compile Include="Util.cs" />
+    <Compile Include="Version.cs" />
+    <Compile Include="Z3Object.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="z3.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

src/api/dotnet/Model.cs

@@ -0,0 +1,318 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Model.cs
+
+Abstract:
+
+    Z3 Managed API: Models
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// A Model contains interpretations (assignments) of constants and functions. 
+    /// </summary>
+    [ContractVerification(true)]
+    public class Model : Z3Object
+    {
+        /// <summary>
+        /// Retrieves the interpretation (the assignment) of <paramref name="a"/> in the model. 
+        /// </summary>
+        /// <param name="a">A Constant</param>
+        /// <returns>An expression if the constant has an interpretation in the model, null otherwise.</returns>
+        public Expr ConstInterp(Expr a)
+        {
+            Contract.Requires(a != null);
+
+            Context.CheckContextMatch(a);
+            return ConstInterp(a.FuncDecl);
+        }
+
+        /// <summary>
+        /// Retrieves the interpretation (the assignment) of <paramref name="f"/> in the model. 
+        /// </summary>
+        /// <param name="f">A function declaration of zero arity</param>
+        /// <returns>An expression if the function has an interpretation in the model, null otherwise.</returns>    
+        public Expr ConstInterp(FuncDecl f)
+        {
+            Contract.Requires(f != null);
+
+            Context.CheckContextMatch(f);
+            if (f.Arity != 0 ||
+                Native.Z3_get_sort_kind(Context.nCtx, Native.Z3_get_range(Context.nCtx, f.NativeObject)) == (uint)Z3_sort_kind.Z3_ARRAY_SORT)
+                throw new Z3Exception("Non-zero arity functions and arrays have FunctionInterpretations as a model. Use FuncInterp.");
+
+            IntPtr n = Native.Z3_model_get_const_interp(Context.nCtx, NativeObject, f.NativeObject);
+            if (n == IntPtr.Zero)
+                return null;
+            else
+                return Expr.Create(Context, n);
+        }
+
+        /// <summary>
+        /// Retrieves the interpretation (the assignment) of a non-constant <paramref name="f"/> in the model. 
+        /// </summary>
+        /// <param name="f">A function declaration of non-zero arity</param>
+        /// <returns>A FunctionInterpretation if the function has an interpretation in the model, null otherwise.</returns> 
+        public FuncInterp FuncInterp(FuncDecl f)
+        {
+            Contract.Requires(f != null);
+
+            Context.CheckContextMatch(f);
+
+            Z3_sort_kind sk = (Z3_sort_kind)Native.Z3_get_sort_kind(Context.nCtx, Native.Z3_get_range(Context.nCtx, f.NativeObject));
+
+            if (f.Arity == 0)
+            {
+                IntPtr n = Native.Z3_model_get_const_interp(Context.nCtx, NativeObject, f.NativeObject);
+
+                if (sk == Z3_sort_kind.Z3_ARRAY_SORT)
+                {
+                    if (n == IntPtr.Zero)
+                        return null;
+                    else
+                    {
+                        if (Native.Z3_is_as_array(Context.nCtx, n) == 0)
+                            throw new Z3Exception("Argument was not an array constant");
+                        IntPtr fd = Native.Z3_get_as_array_func_decl(Context.nCtx, n);
+                        return FuncInterp(new FuncDecl(Context, fd));
+                    }
+                }
+                else
+                {
+                    throw new Z3Exception("Constant functions do not have a function interpretation; use ConstInterp");
+                }
+            }
+            else
+            {
+                IntPtr n = Native.Z3_model_get_func_interp(Context.nCtx, NativeObject, f.NativeObject);
+                if (n == IntPtr.Zero)
+                    return null;
+                else
+                    return new FuncInterp(Context, n);
+            }
+        }
+
+        /// <summary>
+        /// The number of constants that have an interpretation in the model.
+        /// </summary>
+        public uint NumConsts
+        {
+            get { return Native.Z3_model_get_num_consts(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The function declarations of the constants in the model.
+        /// </summary>
+        public FuncDecl[] ConstDecls
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                uint n = NumConsts;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_model_get_const_decl(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The number of function interpretations in the model.
+        /// </summary>
+        public uint NumFuncs
+        {
+            get { return Native.Z3_model_get_num_funcs(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The function declarations of the function interpretations in the model.
+        /// </summary>
+        public FuncDecl[] FuncDecls
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                uint n = NumFuncs;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_model_get_func_decl(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// All symbols that have an interpretation in the model.
+        /// </summary>
+        public FuncDecl[] Decls
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                var nFuncs = NumFuncs;
+                var nConsts = NumConsts;
+                uint n = nFuncs + nConsts;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < nConsts; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_model_get_const_decl(Context.nCtx, NativeObject, i));
+                for (uint i = 0; i < nFuncs; i++)
+                    res[nConsts + i] = new FuncDecl(Context, Native.Z3_model_get_func_decl(Context.nCtx, NativeObject, i));                
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// A ModelEvaluationFailedException is thrown when an expression cannot be evaluated by the model.
+        /// </summary>
+        public class ModelEvaluationFailedException : Z3Exception
+        {
+            /// <summary>
+            /// An exception that is thrown when model evaluation fails.
+            /// </summary>
+            public ModelEvaluationFailedException() : base() { }
+        }
+
+        /// <summary>
+        /// Evaluates the expression <paramref name="t"/> in the current model.
+        /// </summary>
+        /// <remarks>
+        /// This function may fail if <paramref name="t"/> contains quantifiers, 
+        /// is partial (MODEL_PARTIAL enabled), or if <paramref name="t"/> is not well-sorted.
+        /// In this case a <c>ModelEvaluationFailedException</c> is thrown.
+        /// </remarks>
+        /// <param name="t">An expression</param>
+        /// <param name="completion">
+        /// When this flag is enabled, a model value will be assigned to any constant 
+        /// or function that does not have an interpretation in the model.
+        /// </param>
+        /// <returns>The evaluation of <paramref name="t"/> in the model.</returns>        
+        public Expr Eval(Expr t, bool completion = false)
+        {
+            Contract.Requires(t != null);
+            Contract.Ensures(Contract.Result<Expr>() != null);
+
+            IntPtr v = IntPtr.Zero;
+            if (Native.Z3_model_eval(Context.nCtx, NativeObject, t.NativeObject, (completion) ? 1 : 0, ref v) == 0)
+                throw new ModelEvaluationFailedException();
+            else
+                return Expr.Create(Context, v);
+        }
+
+        /// <summary>
+        /// Alias for <c>Eval</c>.
+        /// </summary>        
+        public Expr Evaluate(Expr t, bool completion = false)
+        {
+            Contract.Requires(t != null);
+            Contract.Ensures(Contract.Result<Expr>() != null);
+
+            return Eval(t, completion);
+        }
+
+        /// <summary>
+        /// The number of uninterpreted sorts that the model has an interpretation for.
+        /// </summary>    
+        public uint NumSorts { get { return Native.Z3_model_get_num_sorts(Context.nCtx, NativeObject); } }
+
+        /// <summary>
+        /// The uninterpreted sorts that the model has an interpretation for. 
+        /// </summary>
+        /// <remarks>
+        /// Z3 also provides an intepretation for uninterpreted sorts used in a formula.
+        /// The interpretation for a sort is a finite set of distinct values. We say this finite set is
+        /// the "universe" of the sort.
+        /// </remarks>
+        /// <seealso cref="NumSorts"/>
+        /// <seealso cref="SortUniverse"/>
+        public Sort[] Sorts
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Sort[]>() != null);
+
+                uint n = NumSorts;
+                Sort[] res = new Sort[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Sort.Create(Context, Native.Z3_model_get_sort(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The finite set of distinct values that represent the interpretation for sort <paramref name="s"/>.
+        /// </summary>
+        /// <seealso cref="Sorts"/>
+        /// <param name="s">An uninterpreted sort</param>
+        /// <returns>An array of expressions, where each is an element of the universe of <paramref name="s"/></returns>
+        public Expr[] SortUniverse(Sort s)
+        {
+            Contract.Requires(s != null);
+            Contract.Ensures(Contract.Result<Expr[]>() != null);
+
+            ASTVector nUniv = new ASTVector(Context, Native.Z3_model_get_sort_universe(Context.nCtx, NativeObject, s.NativeObject));
+            uint n = nUniv.Size;
+            Expr[] res = new Expr[n];
+            for (uint i = 0; i < n; i++)
+                res[i] = Expr.Create(Context, nUniv[i].NativeObject);
+            return res;
+        }
+
+        /// <summary>
+        /// Conversion of models to strings. 
+        /// </summary>
+        /// <returns>A string representation of the model.</returns>
+        public override string ToString()
+        {
+            return Native.Z3_model_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal Model(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_model_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_model_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Model_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Model_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Numeral.cs

@@ -0,0 +1,344 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Numeral.cs
+
+Abstract:
+
+    Z3 Managed API: Numerals
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-20
+
+Notes:
+    
+--*/
+using System;
+using System.Diagnostics.Contracts;
+
+#if !FRAMEWORK_LT_4
+using System.Numerics;
+#endif
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Integer Numerals
+    /// </summary>
+    [ContractVerification(true)]
+    public class IntNum : IntExpr
+    {
+
+        #region Internal
+        internal IntNum(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+
+
+        /// <summary>
+        /// Retrieve the 64-bit unsigned integer value.
+        /// </summary>
+        public UInt64 UInt64
+        {
+            get
+            {
+                UInt64 res = 0;
+                if (Native.Z3_get_numeral_uint64(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not a 64 bit unsigned");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the int value.
+        /// </summary>
+        public int Int
+        {
+            get
+            {
+                int res = 0;
+                if (Native.Z3_get_numeral_int(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not an int");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the 64-bit int value.
+        /// </summary>
+        public Int64 Int64
+        {
+            get
+            {
+                Int64 res = 0;
+                if (Native.Z3_get_numeral_int64(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not an int64");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the int value.
+        /// </summary>
+        public uint UInt
+        {
+            get
+            {
+                uint res = 0;
+                if (Native.Z3_get_numeral_uint(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not a uint");
+                return res;
+            }
+        }
+
+#if !FRAMEWORK_LT_4
+        /// <summary>
+        /// Retrieve the BigInteger value.
+        /// </summary>
+        public BigInteger BigInteger
+        {
+            get
+            {  
+                return BigInteger.Parse(this.ToString());
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Returns a string representation of the numeral.
+        /// </summary>        
+        public override string ToString()
+        {
+            return Native.Z3_get_numeral_string(Context.nCtx, NativeObject);
+        }
+    }
+
+    /// <summary>
+    /// Rational Numerals
+    /// </summary>
+    [ContractVerification(true)]
+    public class RatNum : RealExpr
+    {
+        /// <summary>
+        /// The numerator of a rational numeral.
+        /// </summary>
+        public IntNum Numerator
+        {
+            get {
+                Contract.Ensures(Contract.Result<IntNum>() != null);
+
+                return new IntNum(Context, Native.Z3_get_numerator(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The denominator of a rational numeral.
+        /// </summary>
+        public IntNum Denominator
+        {
+            get {
+                Contract.Ensures(Contract.Result<IntNum>() != null);
+
+                return new IntNum(Context, Native.Z3_get_denominator(Context.nCtx, NativeObject)); }
+        }
+
+#if !FRAMEWORK_LT_4
+        /// <summary>
+        /// Converts the numerator of the rational to a BigInteger
+        /// </summary>
+        public BigInteger BigIntNumerator
+        {
+            get
+            {                
+                IntNum n = Numerator;
+                return BigInteger.Parse(n.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Converts the denominator of the rational to a BigInteger
+        /// </summary>
+        public BigInteger BigIntDenominator
+        {
+            get
+            {
+                IntNum n = Denominator;
+                return BigInteger.Parse(n.ToString());
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Returns a string representation in decimal notation.
+        /// </summary>
+        /// <remarks>The result has at most <paramref name="precision"/> decimal places.</remarks>    
+        public string ToDecimalString(uint precision)
+        {
+            return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision);
+        }
+
+        /// <summary>
+        /// Returns a string representation of the numeral.
+        /// </summary>        
+        public override string ToString()
+        {
+            return Native.Z3_get_numeral_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal RatNum(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+    }
+
+
+    /// <summary>
+    /// Bit-vector numerals
+    /// </summary>
+    [ContractVerification(true)]
+    public class BitVecNum : BitVecExpr
+    {
+        /// <summary>
+        /// Retrieve the 64-bit unsigned integer value.
+        /// </summary>
+        public UInt64 UInt64
+        {
+            get
+            {
+                UInt64 res = 0;
+                if (Native.Z3_get_numeral_uint64(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not a 64 bit unsigned");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the int value.
+        /// </summary>
+        public int Int
+        {
+            get
+            {
+                int res = 0;
+                if (Native.Z3_get_numeral_int(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not an int");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the 64-bit int value.
+        /// </summary>
+        public Int64 Int64
+        {
+            get
+            {
+                Int64 res = 0;
+                if (Native.Z3_get_numeral_int64(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not an int64");
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the int value.
+        /// </summary>
+        public uint UInt
+        {
+            get
+            {
+                uint res = 0;
+                if (Native.Z3_get_numeral_uint(Context.nCtx, NativeObject, ref res) == 0)
+                    throw new Z3Exception("Numeral is not a uint");
+                return res;
+            }
+        }
+
+#if !FRAMEWORK_LT_4
+        /// <summary>
+        /// Retrieve the BigInteger value.
+        /// </summary>
+        public BigInteger BigInteger
+        {
+            get
+            {
+                return BigInteger.Parse(this.ToString());
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Returns a string representation of the numeral.
+        /// </summary>        
+        public override string ToString()
+        {
+            return Native.Z3_get_numeral_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal BitVecNum(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        #endregion
+    }
+
+    /// <summary>
+    /// Algebraic numbers
+    /// </summary>
+    [ContractVerification(true)]
+    public class AlgebraicNum : ArithExpr
+    {
+        /// <summary>
+        /// Return a upper bound for a given real algebraic number. 
+        /// The interval isolating the number is smaller than 1/10^<paramref name="precision"/>.    
+        /// <seealso cref="Expr.IsAlgebraicNumber"/>   
+        /// </summary>
+        /// <param name="precision">the precision of the result</param>
+        /// <returns>A numeral Expr of sort Real</returns>
+        public RatNum ToUpper(uint precision)
+        {
+            Contract.Ensures(Contract.Result<RatNum>() != null);
+
+            return new RatNum(Context, Native.Z3_get_algebraic_number_upper(Context.nCtx, NativeObject, precision));
+        }
+
+        /// <summary>
+        /// Return a lower bound for the given real algebraic number. 
+        /// The interval isolating the number is smaller than 1/10^<paramref name="precision"/>.    
+        /// <seealso cref="Expr.IsAlgebraicNumber"/>
+        /// </summary>
+        /// <param name="precision"></param>
+        /// <returns>A numeral Expr of sort Real</returns>
+        public RatNum ToLower(uint precision)
+        {
+            Contract.Ensures(Contract.Result<RatNum>() != null);
+
+            return new RatNum(Context, Native.Z3_get_algebraic_number_lower(Context.nCtx, NativeObject, precision));
+        }
+
+        /// <summary>
+        /// Returns a string representation in decimal notation.
+        /// </summary>
+        /// <remarks>The result has at most <paramref name="precision"/> decimal places.</remarks>    
+        public string ToDecimal(uint precision)
+        {
+            Contract.Ensures(Contract.Result<string>() != null);
+
+            return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision);
+        }
+
+        #region Internal
+        internal AlgebraicNum(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+    }
+}

src/api/dotnet/ParamDescrs.cs

@@ -0,0 +1,114 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Parameter.cs
+
+Abstract:
+
+    Z3 Managed API: Parameter Descriptions
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-20
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// A ParamDescrs describes a set of parameters.
+    /// </summary>
+    [ContractVerification(true)]
+    public class ParamDescrs : Z3Object
+    {
+        /// <summary>
+        /// validate a set of parameters.
+        /// </summary>
+        public void Validate(Params p)
+        {
+            Contract.Requires(p != null);
+            Native.Z3_params_validate(Context.nCtx, p.NativeObject, NativeObject);
+        }
+
+        /// <summary>
+        /// Retrieve kind of parameter.
+        /// </summary>
+        public Z3_param_kind GetKind(Symbol name)
+        {
+            Contract.Requires(name != null);
+            return (Z3_param_kind)Native.Z3_param_descrs_get_kind(Context.nCtx, NativeObject, name.NativeObject);
+        }
+
+        /// <summary>
+        /// Retrieve all names of parameters.
+        /// </summary>
+        public Symbol[] Names 
+        {
+            get 
+            {
+                  uint sz = Native.Z3_param_descrs_size(Context.nCtx, NativeObject);
+                  Symbol[] names = new Symbol[sz];
+                  for (uint i = 0; i < sz; ++i) {
+                      names[i] = Symbol.Create(Context, Native.Z3_param_descrs_get_name(Context.nCtx, NativeObject, i));
+                  }
+                  return names;
+            }
+        }
+
+        /// <summary>
+        /// The size of the ParamDescrs.
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_param_descrs_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Retrieves a string representation of the ParamDescrs. 
+        /// </summary>    
+        public override string ToString()
+        {
+            return Native.Z3_param_descrs_to_string(Context.nCtx, NativeObject); 
+        }
+
+        #region Internal
+        internal ParamDescrs(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_param_descrs_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_param_descrs_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.ParamDescrs_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.ParamDescrs_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Params.cs

@@ -0,0 +1,147 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Parameter.cs
+
+Abstract:
+
+    Z3 Managed API: Parameters
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-20
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// A ParameterSet represents a configuration in the form of Symbol/value pairs.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Params : Z3Object
+    {
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(Symbol name, bool value)
+        {
+            Contract.Requires(name != null);
+
+            Native.Z3_params_set_bool(Context.nCtx, NativeObject, name.NativeObject, (value) ? 1 : 0);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(Symbol name, uint value)
+        {
+            Contract.Requires(name != null);
+
+            Native.Z3_params_set_uint(Context.nCtx, NativeObject, name.NativeObject, value);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(Symbol name, double value)
+        {
+            Contract.Requires(name != null);
+            
+            Native.Z3_params_set_double(Context.nCtx, NativeObject, name.NativeObject, value);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(Symbol name, Symbol value)
+        {
+            Contract.Requires(name != null);
+            Contract.Requires(value != null);
+
+            Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, value.NativeObject);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(string name, bool value)
+        {
+            Native.Z3_params_set_bool(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, (value) ? 1 : 0);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(string name, uint value)
+        {
+            Native.Z3_params_set_uint(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(string name, double value)
+        {
+            Native.Z3_params_set_double(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value);
+        }
+
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(string name, Symbol value)
+        {
+            Contract.Requires(value != null);
+
+            Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value.NativeObject);
+        }
+
+        /// <summary>
+        /// A string representation of the parameter set.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_params_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal Params(Context ctx)
+            : base(ctx, Native.Z3_mk_params(ctx.nCtx))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_params_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_params_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Params_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Params_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Pattern.cs

@@ -0,0 +1,75 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Pattern.cs
+
+Abstract:
+
+    Z3 Managed API: Patterns
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Patterns comprise a list of terms. The list should be
+    /// non-empty.  If the list comprises of more than one term, it is
+    /// also called a multi-pattern.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Pattern : AST
+    {
+        /// <summary>
+        /// The number of terms in the pattern.
+        /// </summary>
+        public uint NumTerms
+        {
+            get { return Native.Z3_get_pattern_num_terms(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The terms in the pattern.
+        /// </summary>
+        public Expr[] Terms
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Expr[]>() != null);
+
+                uint n = NumTerms;
+                Expr[] res = new Expr[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Expr.Create(Context, Native.Z3_get_pattern(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// A string representation of the pattern.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_pattern_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal Pattern(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Probe.cs

@@ -0,0 +1,95 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Probe.cs
+
+Abstract:
+
+    Z3 Managed API: Probes
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>  
+    /// Probes are used to inspect a goal (aka problem) and collect information that may be used to decide
+    /// which solver and/or preprocessing step will be used.
+    /// The complete list of probes may be obtained using the procedures <c>Context.NumProbes</c>
+    /// and <c>Context.ProbeNames</c>.
+    /// It may also be obtained using the command <c>(help-tactics)</c> in the SMT 2.0 front-end.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Probe : Z3Object
+    {
+        /// <summary>
+        /// Execute the probe over the goal. 
+        /// </summary>
+        /// <returns>A probe always produce a double value.
+        /// "Boolean" probes return 0.0 for false, and a value different from 0.0 for true.</returns>
+        public double Apply(Goal g)
+        {
+            Contract.Requires(g != null);
+
+            Context.CheckContextMatch(g);
+            return Native.Z3_probe_apply(Context.nCtx, NativeObject, g.NativeObject);
+        }
+
+        /// <summary>
+        /// Apply the probe to a goal.
+        /// </summary>
+        public double this[Goal g] { get {
+            Contract.Requires(g != null);
+
+            return Apply(g); } }
+
+        #region Internal
+        internal Probe(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal Probe(Context ctx, string name)
+            : base(ctx, Native.Z3_mk_probe(ctx.nCtx, name))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_probe_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_probe_dec_ref(ctx.nCtx, obj);
+            }
+        };        
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Probe_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Probe_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Properties/AssemblyInfo.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Z3 .NET Interface")]
+[assembly: AssemblyDescription(".NET Interface to the Z3 Theorem Prover")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft Corporation")]
+[assembly: AssemblyProduct("Z3")]
+[assembly: AssemblyCopyright("Copyright © Microsoft Corporation 2006")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4853ed71-2078-40f4-8117-bc46646bce0e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("4.2.0.0")]
+[assembly: AssemblyVersion("4.3.0.0")]
+[assembly: AssemblyFileVersion("4.3.0.0")]
+

src/api/dotnet/Quantifier.cs

@@ -0,0 +1,257 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Quantifier.cs
+
+Abstract:
+
+    Z3 Managed API: Quantifiers
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-19
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Quantifier expressions.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Quantifier : BoolExpr
+    {
+        /// <summary>
+        /// Indicates whether the quantifier is universal.
+        /// </summary>
+        public bool IsUniversal
+        {
+            get { return Native.Z3_is_quantifier_forall(Context.nCtx, NativeObject) != 0; }
+        }
+
+        /// <summary>
+        /// Indicates whether the quantifier is existential.
+        /// </summary>
+        public bool IsExistential
+        {
+            get { return !IsUniversal; }
+        }
+
+        /// <summary>
+        /// The weight of the quantifier.
+        /// </summary>
+        public uint Weight
+        {
+            get { return Native.Z3_get_quantifier_weight(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The number of patterns.
+        /// </summary>
+        public uint NumPatterns
+        {
+            get { return Native.Z3_get_quantifier_num_patterns(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The patterns.
+        /// </summary>
+        public Pattern[] Patterns
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Pattern[]>() != null);
+
+                uint n = NumPatterns;
+                Pattern[] res = new Pattern[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new Pattern(Context, Native.Z3_get_quantifier_pattern_ast(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The number of no-patterns.
+        /// </summary>
+        public uint NumNoPatterns
+        {
+            get { return Native.Z3_get_quantifier_num_no_patterns(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The no-patterns.
+        /// </summary>
+        public Pattern[] NoPatterns
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Pattern[]>() != null);
+
+                uint n = NumNoPatterns;
+                Pattern[] res = new Pattern[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new Pattern(Context, Native.Z3_get_quantifier_no_pattern_ast(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The number of bound variables.
+        /// </summary>
+        public uint NumBound
+        {
+            get { return Native.Z3_get_quantifier_num_bound(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The symbols for the bound variables.
+        /// </summary>
+        public Symbol[] BoundVariableNames
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Symbol[]>() != null);
+
+                uint n = NumBound;
+                Symbol[] res = new Symbol[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Symbol.Create(Context, Native.Z3_get_quantifier_bound_name(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The sorts of the bound variables.
+        /// </summary>
+        public Sort[] BoundVariableSorts
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Sort[]>() != null);
+
+                uint n = NumBound;
+                Sort[] res = new Sort[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Sort.Create(Context, Native.Z3_get_quantifier_bound_sort(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The body of the quantifier.
+        /// </summary>
+        public BoolExpr Body
+        {
+            get {
+                Contract.Ensures(Contract.Result<BoolExpr>() != null);
+                
+                return new BoolExpr(Context, Native.Z3_get_quantifier_body(Context.nCtx, NativeObject)); }
+        }
+
+        #region Internal
+        [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug
+        internal Quantifier(Context ctx, bool isForall, Sort[] sorts, Symbol[] names, Expr body,
+                            uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null,
+                            Symbol quantifierID = null, Symbol skolemID = null
+                            )
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(sorts != null);
+            Contract.Requires(names != null);
+            Contract.Requires(body != null);
+            Contract.Requires(sorts.Length == names.Length);
+            Contract.Requires(Contract.ForAll(sorts, s => s != null));
+            Contract.Requires(Contract.ForAll(names, n => n != null));
+            Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null));
+            Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null));
+
+            Context.CheckContextMatch(patterns);
+            Context.CheckContextMatch(noPatterns);
+            Context.CheckContextMatch(sorts);
+            Context.CheckContextMatch(names);
+            Context.CheckContextMatch(body);
+
+            if (sorts.Length != names.Length)
+                throw new Z3Exception("Number of sorts does not match number of names");
+
+            IntPtr[] _patterns = AST.ArrayToNative(patterns);
+
+            if (noPatterns == null && quantifierID == null && skolemID == null)
+            {
+                NativeObject = Native.Z3_mk_quantifier(ctx.nCtx, (isForall) ? 1 : 0, weight,
+                                           AST.ArrayLength(patterns),  AST.ArrayToNative(patterns),
+                                           AST.ArrayLength(sorts), AST.ArrayToNative(sorts),
+                                           Symbol.ArrayToNative(names),
+                                           body.NativeObject);
+            }
+            else
+            {
+                NativeObject = Native.Z3_mk_quantifier_ex(ctx.nCtx, (isForall) ? 1 : 0, weight,
+                                  AST.GetNativeObject(quantifierID), AST.GetNativeObject(skolemID),
+                                  AST.ArrayLength(patterns), AST.ArrayToNative(patterns),
+                                  AST.ArrayLength(noPatterns), AST.ArrayToNative(noPatterns),
+                                  AST.ArrayLength(sorts), AST.ArrayToNative(sorts),
+                                  Symbol.ArrayToNative(names),
+                                  body.NativeObject);
+            }
+        }
+
+        [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug
+        internal Quantifier(Context ctx, bool isForall, Expr[] bound, Expr body,
+                            uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null,
+                            Symbol quantifierID = null, Symbol skolemID = null
+            )
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(body != null);
+
+            Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null));       
+            Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null));
+            Contract.Requires(bound == null || Contract.ForAll(bound, n => n != null));
+
+            Context.CheckContextMatch(noPatterns);
+            Context.CheckContextMatch(patterns);
+            //Context.CheckContextMatch(bound);
+            Context.CheckContextMatch(body);
+            
+            if (noPatterns == null && quantifierID == null && skolemID == null)
+            {
+                NativeObject = Native.Z3_mk_quantifier_const(ctx.nCtx, (isForall) ? 1 : 0, weight,
+                                                 AST.ArrayLength(bound), AST.ArrayToNative(bound),
+                                                 AST.ArrayLength(patterns), AST.ArrayToNative(patterns),
+                                                 body.NativeObject);
+            }
+            else
+            {
+                NativeObject = Native.Z3_mk_quantifier_const_ex(ctx.nCtx, (isForall) ? 1 : 0, weight,
+                                        AST.GetNativeObject(quantifierID), AST.GetNativeObject(skolemID),
+                                        AST.ArrayLength(bound), AST.ArrayToNative(bound),
+                                        AST.ArrayLength(patterns), AST.ArrayToNative(patterns),
+                                        AST.ArrayLength(noPatterns), AST.ArrayToNative(noPatterns),
+                                        body.NativeObject);
+            }
+        }
+
+
+        internal Quantifier(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+        #if DEBUG
+        internal override void CheckNativeObject(IntPtr obj)
+        {
+            if ((Z3_ast_kind)Native.Z3_get_ast_kind(Context.nCtx, obj) != Z3_ast_kind.Z3_QUANTIFIER_AST)
+                throw new Z3Exception("Underlying object is not a quantifier");
+            base.CheckNativeObject(obj);
+        }
+        #endif
+        #endregion
+    }
+}

src/api/dotnet/Solver.cs

@@ -0,0 +1,301 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Solver.cs
+
+Abstract:
+
+    Z3 Managed API: Solvers
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-22
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Solvers.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Solver : Z3Object
+    {
+        /// <summary>
+        /// A string that describes all available solver parameters.
+        /// </summary>
+        public string Help
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+
+                return Native.Z3_solver_get_help(Context.nCtx, NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Sets the solver parameters.
+        /// </summary>
+        public Params Parameters
+        {
+            set
+            {
+                Contract.Requires(value != null);
+
+                Context.CheckContextMatch(value);
+                Native.Z3_solver_set_params(Context.nCtx, NativeObject, value.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves parameter descriptions for solver.
+        /// </summary>
+        public ParamDescrs ParameterDescriptions
+        {
+            get { return new ParamDescrs(Context, Native.Z3_solver_get_param_descrs(Context.nCtx, NativeObject)); }
+        }
+
+
+        /// <summary>
+        /// The current number of backtracking points (scopes).
+        /// </summary>
+        /// <seealso cref="Pop"/>
+        /// <seealso cref="Push"/>
+        public uint NumScopes
+        {
+            get { return Native.Z3_solver_get_num_scopes(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Creates a backtracking point.
+        /// </summary>
+        /// <seealso cref="Pop"/>
+        public void Push()
+        {
+            Native.Z3_solver_push(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// Backtracks <paramref name="n"/> backtracking points.
+        /// </summary>
+        /// <remarks>Note that an exception is thrown if <paramref name="n"/> is not smaller than <c>NumScopes</c></remarks>
+        /// <seealso cref="Push"/>
+        public void Pop(uint n = 1)
+        {
+            Native.Z3_solver_pop(Context.nCtx, NativeObject, n);
+        }
+
+        /// <summary>
+        /// Resets the Solver.
+        /// </summary>
+        /// <remarks>This removes all assertions from the solver.</remarks>
+        public void Reset()
+        {
+            Native.Z3_solver_reset(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// Assert a constraint (or multiple) into the solver.
+        /// </summary>        
+        public void Assert(params BoolExpr[] constraints)
+        {
+            Contract.Requires(constraints != null);
+            Contract.Requires(Contract.ForAll(constraints, c => c != null));
+
+            Context.CheckContextMatch(constraints);
+            foreach (BoolExpr a in constraints)
+            {
+                Native.Z3_solver_assert(Context.nCtx, NativeObject, a.NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// The number of assertions in the solver.
+        /// </summary>
+        public uint NumAssertions
+        {
+            get
+            {
+                ASTVector ass = new ASTVector(Context, Native.Z3_solver_get_assertions(Context.nCtx, NativeObject));
+                return ass.Size;
+            }
+        }
+
+        /// <summary>
+        /// The set of asserted formulas.
+        /// </summary>
+        public BoolExpr[] Assertions
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<BoolExpr[]>() != null);
+
+                ASTVector ass = new ASTVector(Context, Native.Z3_solver_get_assertions(Context.nCtx, NativeObject));
+                uint n = ass.Size;
+                BoolExpr[] res = new BoolExpr[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new BoolExpr(Context, ass[i].NativeObject);
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// Checks whether the assertions in the solver are consistent or not.
+        /// </summary>
+        /// <remarks>
+        /// <seealso cref="Model"/>
+        /// <seealso cref="UnsatCore"/>
+        /// <seealso cref="Proof"/>    
+        /// </remarks>    
+        public Status Check(params Expr[] assumptions)
+        {
+            Z3_lbool r;
+            if (assumptions == null)
+                r = (Z3_lbool)Native.Z3_solver_check(Context.nCtx, NativeObject);
+            else
+                r = (Z3_lbool)Native.Z3_solver_check_assumptions(Context.nCtx, NativeObject, (uint)assumptions.Length, AST.ArrayToNative(assumptions));
+            switch (r)
+            {
+                case Z3_lbool.Z3_L_TRUE: return Status.SATISFIABLE;
+                case Z3_lbool.Z3_L_FALSE: return Status.UNSATISFIABLE;
+                default: return Status.UNKNOWN;
+            }
+        }
+
+        /// <summary>
+        /// The model of the last <c>Check</c>.
+        /// </summary>
+        /// <remarks>
+        /// The result is <c>null</c> if <c>Check</c> was not invoked before,
+        /// if its results was not <c>SATISFIABLE</c>, or if model production is not enabled.
+        /// </remarks>
+        public Model Model
+        {
+            get
+            {
+                IntPtr x = Native.Z3_solver_get_model(Context.nCtx, NativeObject);
+                if (x == IntPtr.Zero)
+                    return null;
+                else
+                    return new Model(Context, x);
+            }
+        }
+
+        /// <summary>
+        /// The proof of the last <c>Check</c>.
+        /// </summary>
+        /// <remarks>    
+        /// The result is <c>null</c> if <c>Check</c> was not invoked before,
+        /// if its results was not <c>UNSATISFIABLE</c>, or if proof production is disabled.
+        /// </remarks>
+        public Expr Proof
+        {
+            get
+            {
+                IntPtr x = Native.Z3_solver_get_proof(Context.nCtx, NativeObject);
+                if (x == IntPtr.Zero)
+                    return null;
+                else
+                    return Expr.Create(Context, x);
+            }
+        }
+
+        /// <summary>
+        /// The unsat core of the last <c>Check</c>.
+        /// </summary>
+        /// <remarks>
+        /// The unsat core is a subset of <c>Assertions</c>
+        /// The result is empty if <c>Check</c> was not invoked before,
+        /// if its results was not <c>UNSATISFIABLE</c>, or if core production is disabled.
+        /// </remarks>
+        public Expr[] UnsatCore
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Expr[]>() != null);
+
+                ASTVector core = new ASTVector(Context, Native.Z3_solver_get_unsat_core(Context.nCtx, NativeObject));
+                uint n = core.Size;
+                Expr[] res = new Expr[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Expr.Create(Context, core[i].NativeObject);
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// A brief justification of why the last call to <c>Check</c> returned <c>UNKNOWN</c>.
+        /// </summary>
+        public string ReasonUnknown
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+
+                return Native.Z3_solver_get_reason_unknown(Context.nCtx, NativeObject);
+            }
+        }
+
+        /// <summary>
+        /// Solver statistics.
+        /// </summary>
+        public Statistics Statistics
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Statistics>() != null);
+
+                return new Statistics(Context, Native.Z3_solver_get_statistics(Context.nCtx, NativeObject));
+            }
+        }
+
+        /// <summary>
+        /// A string representation of the solver.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_solver_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        internal Solver(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_solver_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_solver_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Solver_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Solver_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Sort.cs

@@ -0,0 +1,745 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Sort.cs
+
+Abstract:
+
+    Z3 Managed API: Sorts
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-15
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// The Sort class implements type information for ASTs.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Sort : AST
+    {
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <param name="a">A Sort</param>
+        /// <param name="b">A Sort</param>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context 
+        /// and represent the same sort; false otherwise.</returns>
+        public static bool operator ==(Sort a, Sort b)
+        {
+            return Object.ReferenceEquals(a, b) ||
+                   (!Object.ReferenceEquals(a, null) &&
+                    !Object.ReferenceEquals(b, null) &&
+                    a.Context == b.Context &&
+                    Native.Z3_is_eq_sort(a.Context.nCtx, a.NativeObject, b.NativeObject) != 0);
+        }
+
+        /// <summary>
+        /// Comparison operator.
+        /// </summary>
+        /// <param name="a">A Sort</param>
+        /// <param name="b">A Sort</param>
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context 
+        /// or represent different sorts; false otherwise.</returns>
+        public static bool operator !=(Sort a, Sort b)
+        {
+            return !(a == b);
+        }
+
+        /// <summary>
+        /// Equality operator for objects of type Sort.
+        /// </summary>
+        /// <param name="o"></param>
+        /// <returns></returns>
+        public override bool Equals(object o)
+        {
+            Sort casted = o as Sort;
+            if (casted == null) return false;
+            return this == casted;
+        }
+
+        /// <summary>
+        /// Hash code generation for Sorts
+        /// </summary>
+        /// <returns>A hash code</returns>
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a unique identifier for the sort.
+        /// </summary>
+        new public uint Id
+        {
+            get { return Native.Z3_get_sort_id(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The kind of the sort.
+        /// </summary>
+        public Z3_sort_kind SortKind
+        {
+            get { return (Z3_sort_kind)Native.Z3_get_sort_kind(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The name of the sort
+        /// </summary>
+        public Symbol Name
+        {
+            get {
+                Contract.Ensures(Contract.Result<Symbol>() != null);
+                return Symbol.Create(Context, Native.Z3_get_sort_name(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// A string representation of the sort.
+        /// </summary>
+        public override string ToString()
+        {
+            return Native.Z3_sort_to_string(Context.nCtx, NativeObject);
+        }
+
+        #region Internal
+        /// <summary>
+        /// Sort constructor
+        /// </summary>
+        internal protected Sort(Context ctx) : base(ctx) { Contract.Requires(ctx != null); }
+        internal Sort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+        #if DEBUG
+        internal override void CheckNativeObject(IntPtr obj)
+        {
+            if (Native.Z3_get_ast_kind(Context.nCtx, obj) != (uint)Z3_ast_kind.Z3_SORT_AST)
+                throw new Z3Exception("Underlying object is not a sort");
+            base.CheckNativeObject(obj);
+        }
+        #endif
+
+        [ContractVerification(true)]
+        new internal static Sort Create(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Ensures(Contract.Result<Sort>() != null);
+
+            switch ((Z3_sort_kind)Native.Z3_get_sort_kind(ctx.nCtx, obj))
+            {
+                case Z3_sort_kind.Z3_ARRAY_SORT: return new ArraySort(ctx, obj);
+                case Z3_sort_kind.Z3_BOOL_SORT: return new BoolSort(ctx, obj);
+                case Z3_sort_kind.Z3_BV_SORT: return new BitVecSort(ctx, obj);
+                case Z3_sort_kind.Z3_DATATYPE_SORT: return new DatatypeSort(ctx, obj);
+                case Z3_sort_kind.Z3_INT_SORT: return new IntSort(ctx, obj);
+                case Z3_sort_kind.Z3_REAL_SORT: return new RealSort(ctx, obj);
+                case Z3_sort_kind.Z3_UNINTERPRETED_SORT: return new UninterpretedSort(ctx, obj);
+                case Z3_sort_kind.Z3_FINITE_DOMAIN_SORT: return new FiniteDomainSort(ctx, obj);
+                case Z3_sort_kind.Z3_RELATION_SORT: return new RelationSort(ctx, obj);
+                default:
+                    throw new Z3Exception("Unknown sort kind");
+            }
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// A Boolean sort.
+    /// </summary>
+    public class BoolSort : Sort
+    {
+        #region Internal
+        internal BoolSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx)) { Contract.Requires(ctx != null); }
+        #endregion
+    };
+
+    /// <summary>
+    /// An arithmetic sort, i.e., Int or Real.
+    /// </summary>
+    public class ArithSort : Sort
+    {
+        #region Internal
+        internal ArithSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        #endregion
+    };
+
+    /// <summary>
+    ///  An Integer sort
+    /// </summary>
+    public class IntSort : ArithSort
+    {
+        #region Internal
+        internal IntSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal IntSort(Context ctx)
+            : base(ctx, Native.Z3_mk_int_sort(ctx.nCtx))
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// A real sort
+    /// </summary>
+    public class RealSort : ArithSort
+    {
+        #region Internal
+        internal RealSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal RealSort(Context ctx)
+            : base(ctx, Native.Z3_mk_real_sort(ctx.nCtx))
+        {
+            Contract.Requires(ctx != null);
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Bit-vector sorts.
+    /// </summary>
+    public class BitVecSort : Sort
+    {
+        /// <summary>
+        /// The size of the bit-vector sort.
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_get_bv_sort_size(Context.nCtx, NativeObject); }
+        }
+
+        #region Internal
+        internal BitVecSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        internal BitVecSort(Context ctx, uint size) : base(ctx, Native.Z3_mk_bv_sort(ctx.nCtx, size)) { Contract.Requires(ctx != null); }
+        #endregion
+    };
+
+    /// <summary>
+    /// Array sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class ArraySort : Sort
+    {
+        /// <summary>
+        /// The domain of the array sort.
+        /// </summary>
+        public Sort Domain
+        {
+            get {
+                Contract.Ensures(Contract.Result<Sort>() != null);
+
+                return Sort.Create(Context, Native.Z3_get_array_sort_domain(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The range of the array sort.
+        /// </summary>
+        public Sort Range
+        {
+            get {
+                Contract.Ensures(Contract.Result<Sort>() != null);
+
+                return Sort.Create(Context, Native.Z3_get_array_sort_range(Context.nCtx, NativeObject)); }
+        }
+
+        #region Internal
+        internal ArraySort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+        internal ArraySort(Context ctx, Sort domain, Sort range)
+            : base(ctx, Native.Z3_mk_array_sort(ctx.nCtx, domain.NativeObject, range.NativeObject))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(domain != null);
+            Contract.Requires(range != null);
+        }
+        #endregion
+    };
+
+    /// <summary>
+    /// Datatype sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class DatatypeSort : Sort
+    {
+        /// <summary>
+        /// The number of constructors of the datatype sort.
+        /// </summary>
+        public uint NumConstructors
+        {
+            get { return Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The constructors.
+        /// </summary>
+        public FuncDecl[] Constructors
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                uint n = NumConstructors;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The recognizers.
+        /// </summary>
+        public FuncDecl[] Recognizers
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                uint n = NumConstructors;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_get_datatype_sort_recognizer(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The constructor accessors.
+        /// </summary>
+        public FuncDecl[][] Accessors
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[][]>() != null);
+
+                uint n = NumConstructors;
+                FuncDecl[][] res = new FuncDecl[n][];
+                for (uint i = 0; i < n; i++)
+                {
+                    FuncDecl fd = new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor(Context.nCtx, NativeObject, i));
+                    uint ds = fd.DomainSize;
+                    FuncDecl[] tmp = new FuncDecl[ds];
+                    for (uint j = 0; j < ds; j++)
+                        tmp[j] = new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor_accessor(Context.nCtx, NativeObject, i, j));
+                    res[i] = tmp;
+                }
+                return res;
+            }
+        }
+
+        #region Internal
+        internal DatatypeSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
+
+        internal DatatypeSort(Context ctx, Symbol name, Constructor[] constructors)
+            : base(ctx, Native.Z3_mk_datatype(ctx.nCtx, name.NativeObject, (uint)constructors.Length, ArrayToNative(constructors)))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+            Contract.Requires(constructors != null);
+        }
+        #endregion
+    };
+
+    /// <summary>
+    /// Uninterpreted Sorts
+    /// </summary>
+    public class UninterpretedSort : Sort
+    {
+        #region Internal
+        internal UninterpretedSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal UninterpretedSort(Context ctx, Symbol s)
+            : base(ctx, Native.Z3_mk_uninterpreted_sort(ctx.nCtx, s.NativeObject))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(s != null);
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Tuple sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class TupleSort : Sort
+    {
+        /// <summary>
+        /// The constructor function of the tuple.
+        /// </summary>
+        public FuncDecl MkDecl
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+
+                return new FuncDecl(Context, Native.Z3_get_tuple_sort_mk_decl(Context.nCtx, NativeObject)); }
+        }
+
+        /// <summary>
+        /// The number of fields in the tuple.
+        /// </summary>
+        public uint NumFields
+        {
+            get { return Native.Z3_get_tuple_sort_num_fields(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The field declarations.
+        /// </summary>
+        public FuncDecl[] FieldDecls
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                uint n = NumFields;
+                FuncDecl[] res = new FuncDecl[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = new FuncDecl(Context, Native.Z3_get_tuple_sort_field_decl(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        #region Internal
+        internal TupleSort(Context ctx, Symbol name, uint numFields, Symbol[] fieldNames, Sort[] fieldSorts)
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+
+            IntPtr t = IntPtr.Zero;
+            NativeObject = Native.Z3_mk_tuple_sort(ctx.nCtx, name.NativeObject, numFields,
+                                                   Symbol.ArrayToNative(fieldNames), AST.ArrayToNative(fieldSorts),
+                                                   ref t, new IntPtr[numFields]);
+        }
+        #endregion
+    };
+
+    /// <summary>
+    /// Enumeration sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class EnumSort : Sort
+    {
+        /// <summary>
+        /// The function declarations of the constants in the enumeration.
+        /// </summary>
+        public FuncDecl[] ConstDecls
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+
+                return _constdecls; }
+        }
+
+        /// <summary>
+        /// The constants in the enumeration.
+        /// </summary>
+        public Expr[] Consts
+        {
+            get {
+                Contract.Ensures(Contract.Result<Expr[]>() != null);
+
+                return _consts; }
+        }
+
+        /// <summary>
+        /// The test predicates for the constants in the enumeration.
+        /// </summary>
+        public FuncDecl[] TesterDecls
+        {
+            get {
+                Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
+                
+                return _testerdecls;
+            }
+        }
+
+        #region Object Invariant
+
+        [ContractInvariantMethod]
+        private void ObjectInvariant()
+        {
+            Contract.Invariant(this._constdecls != null);
+            Contract.Invariant(this._testerdecls != null);
+            Contract.Invariant(this._consts != null);
+        }
+
+        
+        #endregion
+
+        #region Internal
+        readonly private FuncDecl[] _constdecls = null, _testerdecls = null;
+        readonly private Expr[] _consts = null;
+
+        internal EnumSort(Context ctx, Symbol name, Symbol[] enumNames)
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+            Contract.Requires(enumNames != null);
+
+            int n = enumNames.Length;
+            IntPtr[] n_constdecls = new IntPtr[n];
+            IntPtr[] n_testers = new IntPtr[n];
+            NativeObject = Native.Z3_mk_enumeration_sort(ctx.nCtx, name.NativeObject, (uint)n,
+                                                         Symbol.ArrayToNative(enumNames), n_constdecls, n_testers);
+            _constdecls = new FuncDecl[n];            
+            for (uint i = 0; i < n; i++)            
+                _constdecls[i] = new FuncDecl(ctx, n_constdecls[i]);
+            _testerdecls = new FuncDecl[n];
+            for (uint i = 0; i < n; i++)
+                _testerdecls[i] = new FuncDecl(ctx, n_testers[i]);
+            _consts = new Expr[n];
+            for (uint i = 0; i < n; i++)
+                _consts[i] = ctx.MkApp(_constdecls[i]);
+        }
+        #endregion
+    };
+
+    /// <summary>
+    /// List sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class ListSort : Sort
+    {
+        /// <summary>
+        /// The declaration of the nil function of this list sort.
+        /// </summary>
+        public FuncDecl NilDecl { get {
+            Contract.Ensures(Contract.Result<FuncDecl>() != null);
+            return nilDecl; } }
+
+        /// <summary>
+        /// The empty list.
+        /// </summary>
+        public Expr Nil
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Expr>() != null);
+                return nilConst;
+            }
+        }
+
+        /// <summary>
+        /// The declaration of the isNil function of this list sort.
+        /// </summary>
+        public FuncDecl IsNilDecl
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                return isNilDecl;
+            }
+        }
+
+        /// <summary>
+        /// The declaration of the cons function of this list sort.
+        /// </summary>
+        public FuncDecl ConsDecl
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                return consDecl;
+            }
+        }
+
+        /// <summary>
+        /// The declaration of the isCons function of this list sort.
+        /// </summary>
+        /// 
+        public FuncDecl IsConsDecl
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                return isConsDecl;
+            }
+        }
+
+        /// <summary>
+        /// The declaration of the head function of this list sort.
+        /// </summary>
+        public FuncDecl HeadDecl
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                return headDecl;
+            }
+        }
+
+        /// <summary>
+        /// The declaration of the tail function of this list sort.
+        /// </summary>
+        public FuncDecl TailDecl
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<FuncDecl>() != null);
+                return tailDecl;
+            }
+        }
+
+        #region Object Invariant
+
+        [ContractInvariantMethod]
+        private void ObjectInvariant()
+        {
+            Contract.Invariant(nilConst != null);
+            Contract.Invariant(nilDecl != null);
+            Contract.Invariant(isNilDecl != null);
+            Contract.Invariant(consDecl != null);
+            Contract.Invariant(isConsDecl != null);
+            Contract.Invariant(headDecl != null);
+            Contract.Invariant(tailDecl != null);
+        }
+
+        
+        #endregion
+
+        #region Internal
+        readonly private FuncDecl nilDecl, isNilDecl, consDecl, isConsDecl, headDecl, tailDecl;
+        readonly private Expr nilConst;
+
+        internal ListSort(Context ctx, Symbol name, Sort elemSort)
+            : base(ctx)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+            Contract.Requires(elemSort != null);
+
+            IntPtr inil = IntPtr.Zero,
+                   iisnil = IntPtr.Zero,
+                   icons = IntPtr.Zero,
+                   iiscons = IntPtr.Zero,
+                   ihead = IntPtr.Zero,
+                   itail = IntPtr.Zero;
+
+            NativeObject = Native.Z3_mk_list_sort(ctx.nCtx, name.NativeObject, elemSort.NativeObject,
+                                                  ref inil, ref iisnil, ref icons, ref iiscons, ref ihead, ref itail);
+            nilDecl = new FuncDecl(ctx, inil);
+            isNilDecl = new FuncDecl(ctx, iisnil);
+            consDecl = new FuncDecl(ctx, icons);
+            isConsDecl = new FuncDecl(ctx, iiscons);
+            headDecl = new FuncDecl(ctx, ihead);
+            tailDecl = new FuncDecl(ctx, itail);
+            nilConst = ctx.MkConst(nilDecl);
+        }
+        #endregion
+    };
+
+    /// <summary>
+    /// Relation sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class RelationSort : Sort
+    {
+        /// <summary>
+        /// The arity of the relation sort.
+        /// </summary>
+        public uint Arity
+        {
+            get { return Native.Z3_get_relation_arity(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The sorts of the columns of the relation sort.
+        /// </summary>
+        public Sort[] ColumnSorts
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Sort[]>() != null);
+
+                if (m_columnSorts != null)
+                    return m_columnSorts;
+
+                uint n = Arity;
+                Sort[] res = new Sort[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Sort.Create(Context, Native.Z3_get_relation_column(Context.nCtx, NativeObject, i));
+                return res;
+            }
+        }
+
+        #region Internal
+        private Sort[] m_columnSorts = null;
+
+        internal RelationSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }        
+        #endregion
+    }
+
+    /// <summary>
+    /// Finite domain sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class FiniteDomainSort : Sort
+    {
+        /// <summary>
+        /// The size of the finite domain sort.
+        /// </summary>
+        public ulong Size
+        {
+            get { ulong res = 0; Native.Z3_get_finite_domain_sort_size(Context.nCtx, NativeObject, ref res); return res; }
+        }
+
+        #region Internal
+        internal FiniteDomainSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal FiniteDomainSort(Context ctx, Symbol name, ulong size)
+            : base(ctx, Native.Z3_mk_finite_domain_sort(ctx.nCtx, name.NativeObject, size))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(name != null);
+
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Set sorts.
+    /// </summary>
+    [ContractVerification(true)]
+    public class SetSort : Sort
+    {
+        #region Internal
+        internal SetSort(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal SetSort(Context ctx, Sort ty)
+            : base(ctx, Native.Z3_mk_set_sort(ctx.nCtx, ty.NativeObject))
+        {
+            Contract.Requires(ctx != null);
+            Contract.Requires(ty != null);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Statistics.cs

@@ -0,0 +1,206 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Statistics.cs
+
+Abstract:
+
+    Z3 Managed API: Statistics
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-22
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Objects of this class track statistical information about solvers. 
+    /// </summary>
+    [ContractVerification(true)]
+    public class Statistics : Z3Object
+    {
+        /// <summary>
+        /// Statistical data is organized into pairs of [Key, Entry], where every
+        /// Entry is either a <c>DoubleEntry</c> or a <c>UIntEntry</c>
+        /// </summary>
+        public class Entry
+        {
+            /// <summary>
+            /// The key of the entry.
+            /// </summary>
+            readonly public string Key;
+            /// <summary>
+            /// The uint-value of the entry.
+            /// </summary>
+            public uint UIntValue { get { return m_uint; } }
+            /// <summary>
+            /// The double-value of the entry.
+            /// </summary>
+            public double DoubleValue { get { return m_double; } }
+            /// <summary>
+            /// True if the entry is uint-valued.
+            /// </summary>
+            public bool IsUInt { get { return m_is_uint; } }
+            /// <summary>
+            /// True if the entry is double-valued.
+            /// </summary>
+            public bool IsDouble { get { return m_is_double; } }
+
+            /// <summary>
+            /// The string representation of the the entry's value.
+            /// </summary>
+            public string Value
+            {
+                get
+                {
+                    Contract.Ensures(Contract.Result<string>() != null);
+
+                    if (IsUInt)
+                        return m_uint.ToString();
+                    else if (IsDouble)
+                        return m_double.ToString();
+                    else
+                        throw new Z3Exception("Unknown statistical entry type");
+                }
+            }
+
+            /// <summary>
+            /// The string representation of the Entry.
+            /// </summary>
+            public override string ToString()
+            {
+                return Key + ": " + Value;
+            }
+
+            #region Internal
+            readonly private bool m_is_uint = false;
+            readonly private bool m_is_double = false;
+            readonly private uint m_uint = 0;
+            readonly private double m_double = 0.0;
+            internal Entry(string k, uint v) { Key = k; m_is_uint = true; m_uint = v; }
+            internal Entry(string k, double v) { Key = k; m_is_double = true; m_double = v; }
+            #endregion
+        }
+
+        /// <summary>
+        /// A string representation of the statistical data.
+        /// </summary>    
+        public override string ToString()
+        {
+            return Native.Z3_stats_to_string(Context.nCtx, NativeObject);
+        }
+
+        /// <summary>
+        /// The number of statistical data.
+        /// </summary>
+        public uint Size
+        {
+            get { return Native.Z3_stats_size(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// The data entries.
+        /// </summary>
+        public Entry[] Entries
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Entry[]>() != null);
+                Contract.Ensures(Contract.Result<Entry[]>().Length == this.Size);
+                Contract.Ensures(Contract.ForAll(0, Contract.Result<Entry[]>().Length, j => Contract.Result<Entry[]>()[j] != null));
+
+                uint n = Size;
+                Entry[] res = new Entry[n];
+                for (uint i = 0; i < n; i++)
+                {
+                    Entry e;
+                    string k = Native.Z3_stats_get_key(Context.nCtx, NativeObject, i);
+                    if (Native.Z3_stats_is_uint(Context.nCtx, NativeObject, i) != 0)
+                        e = new Entry(k, Native.Z3_stats_get_uint_value(Context.nCtx, NativeObject, i));
+                    else if (Native.Z3_stats_is_double(Context.nCtx, NativeObject, i) != 0)
+                        e = new Entry(k, Native.Z3_stats_get_double_value(Context.nCtx, NativeObject, i));
+                    else
+                        throw new Z3Exception("Unknown data entry value");
+                    res[i] = e;
+                }
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The statistical counters.
+        /// </summary>
+        public string[] Keys
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string[]>() != null);
+
+                uint n = Size;
+                string[] res = new string[n];
+                for (uint i = 0; i < n; i++)
+                    res[i] = Native.Z3_stats_get_key(Context.nCtx, NativeObject, i);
+                return res;
+            }
+        }
+
+        /// <summary>
+        /// The value of a particular statistical counter.
+        /// </summary>        
+        /// <remarks>Returns null if the key is unknown.</remarks>
+        public Entry this[string key]
+        {
+            get
+            {
+                uint n = Size;
+                Entry[] es = Entries;
+                for (uint i = 0; i < n; i++)
+                    if (es[i].Key == key)
+                        return es[i];
+                return null;
+            }
+        }
+
+        #region Internal
+        internal Statistics(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_stats_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_stats_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Statistics_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Statistics_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Status.cs

@@ -0,0 +1,45 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Status.cs
+
+Abstract:
+
+    Z3 Managed API: Status
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-15
+
+Notes:
+    
+--*/
+
+using System;
+
+namespace Microsoft.Z3
+{
+  /// <summary>
+  /// Status values.
+  /// </summary>
+  public enum Status
+  {    
+    /// <summary>
+    /// Used to signify an unsatisfiable status.
+    /// </summary>
+    UNSATISFIABLE = -1,
+
+    /// <summary>
+    /// Used to signify an unknown status.
+    /// </summary>
+    UNKNOWN = 0,
+
+    /// <summary>
+    /// Used to signify a satisfiable status.
+    /// </summary>
+    SATISFIABLE = 1
+  }
+
+}

src/api/dotnet/Symbol.cs

@@ -0,0 +1,181 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Symbol.cs
+
+Abstract:
+
+    Z3 Managed API: Symbols
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Symbols are used to name several term and type constructors.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Symbol : Z3Object
+    {
+        /// <summary>
+        /// The kind of the symbol (int or string)
+        /// </summary>
+        protected Z3_symbol_kind Kind
+        {
+            get { return (Z3_symbol_kind)Native.Z3_get_symbol_kind(Context.nCtx, NativeObject); }
+        }
+
+        /// <summary>
+        /// Indicates whether the symbol is of Int kind
+        /// </summary>    
+        public bool IsIntSymbol()
+        {
+            return Kind == Z3_symbol_kind.Z3_INT_SYMBOL;
+        }
+
+        /// <summary>
+        /// Indicates whether the symbol is of string kind.
+        /// </summary>
+        public bool IsStringSymbol()
+        {
+            return Kind == Z3_symbol_kind.Z3_STRING_SYMBOL;
+        }
+
+        /// <summary>
+        /// A string representation of the symbol.
+        /// </summary>
+        public override string ToString()
+        {
+            if (IsIntSymbol())
+                return ((IntSymbol)this).Int.ToString();
+            else if (IsStringSymbol())
+                return ((StringSymbol)this).String;
+            else
+                throw new Z3Exception("Unknown symbol kind encountered");
+        }
+
+        #region Internal
+        /// <summary>
+        /// Symbol constructor
+        /// </summary>
+        internal protected Symbol(Context ctx, IntPtr obj) : base(ctx, obj) 
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal static Symbol Create(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+            Contract.Ensures(Contract.Result<Symbol>() != null);
+
+            switch ((Z3_symbol_kind)Native.Z3_get_symbol_kind(ctx.nCtx, obj))
+            {
+                case Z3_symbol_kind.Z3_INT_SYMBOL: return new IntSymbol(ctx, obj);
+                case Z3_symbol_kind.Z3_STRING_SYMBOL: return new StringSymbol(ctx, obj);
+                default:
+                    throw new Z3Exception("Unknown symbol kind encountered");
+            }
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Numbered symbols
+    /// </summary>
+    [ContractVerification(true)]
+    public class IntSymbol : Symbol
+    {
+        /// <summary>
+        /// The int value of the symbol.
+        /// </summary>
+        /// <remarks>Throws an exception if the symbol is not of int kind. </remarks>
+        public int Int
+        {
+            get
+            {
+                if (!IsIntSymbol())
+                    throw new Z3Exception("Int requested from non-Int symbol");
+                return Native.Z3_get_symbol_int(Context.nCtx, NativeObject);
+            }
+        }
+
+        #region Internal
+        internal IntSymbol(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal IntSymbol(Context ctx, int i)
+            : base(ctx, Native.Z3_mk_int_symbol(ctx.nCtx, i))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        #if DEBUG
+        internal override void CheckNativeObject(IntPtr obj)
+        {
+            if ((Z3_symbol_kind)Native.Z3_get_symbol_kind(Context.nCtx, obj) != Z3_symbol_kind.Z3_INT_SYMBOL)
+                throw new Z3Exception("Symbol is not of integer kind");
+            base.CheckNativeObject(obj);
+        }
+        #endif
+        #endregion
+    }
+
+    /// <summary>
+    /// Named symbols
+    /// </summary>
+    [ContractVerification(true)]
+    public class StringSymbol : Symbol
+    {
+        /// <summary>
+        /// The string value of the symbol.
+        /// </summary>
+        /// <remarks>Throws an exception if the symbol is not of string kind.</remarks>
+        public string String
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+
+                if (!IsStringSymbol())
+                    throw new Z3Exception("String requested from non-String symbol");
+                return Native.Z3_get_symbol_string(Context.nCtx, NativeObject);                
+            }
+        }
+
+        #region Internal
+        internal StringSymbol(Context ctx, IntPtr obj) : base(ctx, obj) 
+        {            
+            Contract.Requires(ctx != null);
+        }
+
+        internal StringSymbol(Context ctx, string s) : base(ctx, Native.Z3_mk_string_symbol(ctx.nCtx, s)) 
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        #if DEBUG
+        internal override void CheckNativeObject(IntPtr obj)
+        {
+            if ((Z3_symbol_kind)Native.Z3_get_symbol_kind(Context.nCtx, obj) != Z3_symbol_kind.Z3_STRING_SYMBOL)
+                throw new Z3Exception("Symbol is not of string kind");
+
+            base.CheckNativeObject(obj);
+        }
+        #endif
+        #endregion
+    }
+}

src/api/dotnet/Tactic.cs

@@ -0,0 +1,141 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Tactic.cs
+
+Abstract:
+
+    Z3 Managed API: Tactics
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Tactics are the basic building block for creating custom solvers for specific problem domains.
+    /// The complete list of tactics may be obtained using <c>Context.NumTactics</c> 
+    /// and <c>Context.TacticNames</c>.
+    /// It may also be obtained using the command <c>(help-tactics)</c> in the SMT 2.0 front-end.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Tactic : Z3Object
+    {
+        /// <summary>
+        /// A string containing a description of parameters accepted by the tactic.
+        /// </summary>
+        public string Help
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<string>() != null);
+
+                return Native.Z3_tactic_get_help(Context.nCtx, NativeObject);
+            }
+        }
+
+
+        /// <summary>
+        /// Retrieves parameter descriptions for Tactics.
+        /// </summary>
+        public ParamDescrs ParameterDescriptions
+        {
+            get { return new ParamDescrs(Context, Native.Z3_tactic_get_param_descrs(Context.nCtx, NativeObject)); }
+        }
+
+
+        /// <summary>
+        /// Execute the tactic over the goal. 
+        /// </summary>
+        public ApplyResult Apply(Goal g, Params p = null)
+        {
+            Contract.Requires(g != null);
+            Contract.Ensures(Contract.Result<ApplyResult>() != null);
+
+            Context.CheckContextMatch(g);
+            if (p == null)
+                return new ApplyResult(Context, Native.Z3_tactic_apply(Context.nCtx, NativeObject, g.NativeObject));
+            else
+            {
+                Context.CheckContextMatch(p);
+                return new ApplyResult(Context, Native.Z3_tactic_apply_ex(Context.nCtx, NativeObject, g.NativeObject, p.NativeObject));
+            }
+        }
+
+        /// <summary>
+        /// Apply the tactic to a goal.
+        /// </summary>
+        public ApplyResult this[Goal g]
+        {
+            get
+            {
+                Contract.Requires(g != null);
+                Contract.Ensures(Contract.Result<ApplyResult>() != null);
+
+                return Apply(g);
+            }
+        }
+
+        /// <summary>
+        /// Creates a solver that is implemented using the given tactic.
+        /// </summary>
+        /// <seealso cref="Context.MkSolver(Tactic)"/>
+        public Solver Solver
+        {
+            get
+            {
+                Contract.Ensures(Contract.Result<Solver>() != null);
+
+                return Context.MkSolver(this);
+            }
+        }
+
+        #region Internal
+        internal Tactic(Context ctx, IntPtr obj)
+            : base(ctx, obj)
+        {
+            Contract.Requires(ctx != null);
+        }
+        internal Tactic(Context ctx, string name)
+            : base(ctx, Native.Z3_mk_tactic(ctx.nCtx, name))
+        {
+            Contract.Requires(ctx != null);
+        }
+
+        internal class DecRefQueue : Z3.DecRefQueue
+        {
+            public override void IncRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_tactic_inc_ref(ctx.nCtx, obj);
+            }
+
+            public override void DecRef(Context ctx, IntPtr obj)
+            {
+                Native.Z3_tactic_dec_ref(ctx.nCtx, obj);
+            }
+        };
+
+        internal override void IncRef(IntPtr o)
+        {
+            Context.Tactic_DRQ.IncAndClear(Context, o);
+            base.IncRef(o);
+        }
+
+        internal override void DecRef(IntPtr o)
+        {
+            Context.Tactic_DRQ.Add(o);
+            base.DecRef(o);
+        }
+        #endregion
+    }
+}

src/api/dotnet/Version.cs

@@ -0,0 +1,98 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Version.cs
+
+Abstract:
+
+    Z3 Managed API: Version information
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-16
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+  /// <summary>
+  /// Version information.
+  /// </summary>
+  /// <remarks>Note that this class is static.</remarks>
+    [ContractVerification(true)]
+    public static class Version
+  {
+    static Version() { }
+
+    /// <summary>
+    /// The major version
+    /// </summary>
+    public static uint Major
+    {
+      get
+      {
+        uint major = 0, minor = 0, build = 0, revision = 0;
+        Native.Z3_get_version(ref major, ref minor, ref build, ref revision);
+        return major;
+      }
+    }
+
+    /// <summary>
+    /// The minor version
+    /// </summary>
+    public static uint Minor
+    {
+      get
+      {
+        uint major = 0, minor = 0, build = 0, revision = 0;
+        Native.Z3_get_version(ref major, ref minor, ref build, ref revision);
+        return minor;
+      }
+    }
+
+    /// <summary>
+    /// The build version
+    /// </summary>
+    public static uint Build
+    {
+      get
+      {
+        uint major = 0, minor = 0, build = 0, revision = 0;
+        Native.Z3_get_version(ref major, ref minor, ref build, ref revision);
+        return build;
+      }
+    }
+
+    /// <summary>
+    /// The revision
+    /// </summary>
+    public static uint Revision
+    {
+      get
+      {
+        uint major = 0, minor = 0, build = 0, revision = 0;
+        Native.Z3_get_version(ref major, ref minor, ref build, ref revision);
+        return revision;
+      }
+    }
+
+    /// <summary>
+    /// A string representation of the version information.
+    /// </summary>
+    new public static string ToString()
+    {
+        Contract.Ensures(Contract.Result<string>() != null);
+
+      uint major = 0, minor = 0, build = 0, revision = 0;
+      Native.Z3_get_version(ref major, ref minor, ref build, ref revision);
+      return major.ToString() + "." + minor.ToString() + "." + build.ToString() + "." + revision.ToString();
+    }
+  }
+}

src/api/dotnet/Z3Exception.cs

@@ -0,0 +1,44 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Exception.cs
+
+Abstract:
+
+    Z3 Managed API: Exceptions
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-15
+
+Notes:
+    
+--*/
+
+using System;
+
+namespace Microsoft.Z3
+{
+  /// <summary>
+  /// The exception base class for error reporting from Z3
+  /// </summary>
+  public class Z3Exception : Exception
+  {
+    /// <summary>
+    /// Constructor.
+    /// </summary>
+    public Z3Exception() : base() { }
+
+    /// <summary>
+    /// Constructor.
+    /// </summary>
+    public Z3Exception(string message) : base(message) { }
+
+    /// <summary>
+    /// Constructor.
+    /// </summary>
+    public Z3Exception(string message, System.Exception inner) : base(message, inner) { }
+  }
+}

src/api/dotnet/Z3Object.cs

@@ -0,0 +1,145 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    Z3Object.cs
+
+Abstract:
+
+    Z3 Managed API: Internal Z3 Objects
+
+Author:
+
+    Christoph Wintersteiger (cwinter) 2012-03-21
+
+Notes:
+    
+--*/
+
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// Internal base class for interfacing with native Z3 objects.
+    /// Should not be used externally.
+    /// </summary>
+    [ContractVerification(true)]
+    public class Z3Object : IDisposable
+    {
+        /// <summary>
+        /// Finalizer.
+        /// </summary>
+        ~Z3Object()
+        {
+            Dispose();            
+        }
+
+        /// <summary>
+        /// Disposes of the underlying native Z3 object.
+        /// </summary>
+        public void Dispose()
+        {
+            if (m_n_obj != IntPtr.Zero)
+            {
+                DecRef(m_n_obj);
+                m_n_obj = IntPtr.Zero;                
+            }
+
+            if (m_ctx != null)
+            {
+                m_ctx.refCount--;
+                if (m_ctx.refCount == 0)
+                    GC.ReRegisterForFinalize(m_ctx);
+                m_ctx = null;
+            }
+
+            GC.SuppressFinalize(this);
+        }
+
+        #region Object Invariant
+        
+        [ContractInvariantMethod]
+        private void ObjectInvariant()
+        {
+            Contract.Invariant(this.m_ctx != null);
+        }
+
+        #endregion
+
+        #region Internal
+        private Context m_ctx = null;
+        private IntPtr m_n_obj = IntPtr.Zero;
+
+        internal Z3Object(Context ctx)
+        {
+            Contract.Requires(ctx != null);
+
+            ctx.refCount++;
+            m_ctx = ctx;
+        }
+
+        internal Z3Object(Context ctx, IntPtr obj)
+        {
+            Contract.Requires(ctx != null);
+
+            ctx.refCount++;
+            m_ctx = ctx;
+            IncRef(obj);
+            m_n_obj = obj;
+        }
+
+        internal virtual void IncRef(IntPtr o) { }
+        internal virtual void DecRef(IntPtr o) { }
+
+        internal virtual void CheckNativeObject(IntPtr obj) { }
+
+        internal virtual IntPtr NativeObject
+        {
+            get { return m_n_obj; }
+            set
+            {
+                if (value != IntPtr.Zero) { CheckNativeObject(value); IncRef(value); }
+                if (m_n_obj != IntPtr.Zero) { DecRef(m_n_obj); }
+                m_n_obj = value;
+            }
+        }
+
+        internal static IntPtr GetNativeObject(Z3Object s)
+        {
+            if (s == null) return new IntPtr();
+            return s.NativeObject;
+        }
+
+        internal Context Context
+        {
+            get 
+            {
+                Contract.Ensures(Contract.Result<Context>() != null);
+                return m_ctx; 
+            }            
+        }
+
+        [Pure]
+        internal static IntPtr[] ArrayToNative(Z3Object[] a)
+        {
+            Contract.Ensures(a == null || Contract.Result<IntPtr[]>() != null);
+            Contract.Ensures(a == null || Contract.Result<IntPtr[]>().Length == a.Length);
+
+            if (a == null) return null;
+            IntPtr[] an = new IntPtr[a.Length];
+            for (uint i = 0; i < a.Length; i++)
+                if (a[i] != null) an[i] = a[i].NativeObject;
+            return an;
+        }
+
+        [Pure]
+        internal static uint ArrayLength(Z3Object[] a)
+        {
+            return (a == null)?0:(uint)a.Length;
+        }
+        #endregion
+    }
+}

src/api/dotnet/dead/Microsoft.Z3V3/AssemblyInfo.cpp

@@ -0,0 +1,34 @@
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute("Z3 .NET Interface")];
+[assembly:AssemblyDescriptionAttribute(".NET Interface to the Z3 Theorem Prover")];
+[assembly:AssemblyConfigurationAttribute("")];
+[assembly:AssemblyCompanyAttribute("Microsoft Corporation")];
+[assembly:AssemblyProductAttribute("Z3")];
+[assembly:AssemblyCopyrightAttribute("Copyright (c) Microsoft Corporation 2006")];
+[assembly:AssemblyTrademarkAttribute("")];
+[assembly:AssemblyCultureAttribute("")];
+
+[assembly:ComVisible(false)];
+[assembly:CLSCompliantAttribute(true)];
+[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];
+
+[assembly:AssemblyVersionAttribute("4.2.0.0")];
+[assembly:AssemblyFileVersionAttribute("4.2.0.0")];
+
+//#ifdef DELAYSIGN
+//[assembly:AssemblyKeyFile("35MSSharedLib1024.snk")];
+//[assembly:AssemblyDelaySign(true)];
+//#else
+//[assembly:AssemblyKeyFile("z3.snk")];
+//[assembly:AssemblyDelaySign(true)];
+//#endif

src/api/dotnet/dead/Microsoft.Z3V3/Microsoft.Z3V3.vcxproj

@@ -0,0 +1,555 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="commercial|Win32">
+      <Configuration>commercial</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="commercial|x64">
+      <Configuration>commercial</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="external|Win32">
+      <Configuration>external</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="external|x64">
+      <Configuration>external</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="release_mt|Win32">
+      <Configuration>release_mt</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="release_mt|x64">
+      <Configuration>release_mt</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Trace|Win32">
+      <Configuration>Trace</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Trace|x64">
+      <Configuration>Trace</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F008F2C4-D652-4A58-8DEF-DB83E2355454}</ProjectGuid>
+    <RootNamespace>Microsoft.Z3V3</RootNamespace>
+    <Keyword>ManagedCProj</Keyword>
+    <ProjectName>Microsoft.Z3V3</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='external|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='external|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='commercial|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Trace|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <CLRSupport>true</CLRSupport>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='external|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='external|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='commercial|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Trace|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'">$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Trace|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Trace|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Trace|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'">$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='external|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='external|Win32'">$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'">$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='external|Win32'">false</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='external|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='commercial|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='external|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='commercial|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='external|x64'">false</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='commercial|x64'">false</LinkIncremental>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='commercial_64|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='external|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='external|Win32'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='external|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='external|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='commercial|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='external|x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='commercial|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='external|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='commercial|x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Trace|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Trace|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Trace|x64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;Z3DEBUG;_WINDOWS;_TRACE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AssemblyDebug>true</AssemblyDebug>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_TRACE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AssemblyDebug>true</AssemblyDebug>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Trace|Win32'">
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Trace|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|Win32'">
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='external|Win32'">
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_EXTERNAL_RELEASE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+      <Profile>true</Profile>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='commercial|Win32'">
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_Z3_COMMERCIAL;_EXTERNAL_RELEASE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='external|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_EXTERNAL_RELEASE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX64</TargetMachine>
+      <Profile>true</Profile>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='commercial|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_Z3_COMMERCIAL;_AMD64_;_EXTERNAL_RELEASE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OutputFile>$(OutDir)Microsoft.Z3V3.dll</OutputFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'">
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='release_mt|x64'">
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System">
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </Reference>
+    <Reference Include="System.Data">
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </Reference>
+    <Reference Include="System.Numerics" />
+    <Reference Include="System.Xml">
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="AssemblyInfo.cpp" />
+    <ClCompile Include="Microsoft.Z3V3.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Microsoft.Z3V3.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\lib\lib.vcxproj">
+      <Project>{4a7e5a93-19d8-4382-8950-fb2edec7a76e}</Project>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>