From 824d8b5f30239b6520d303b9f5b351b6a631434d Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Wed, 2 Oct 2013 19:31:58 +0300
Subject: [PATCH 1/6] Rewrote the generating of properties to additionaly
 handle property overrides and read-only properties.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 src/AST/Class.cs                              |    2 +-
 src/AST/Property.cs                           |   36 +
 src/Generator/Driver.cs                       |    1 +
 .../Generators/CSharp/CSharpTextTemplate.cs   |   96 +-
 src/Generator/Passes/FindSymbolsPass.cs       |    2 +-
 .../GenerateAbstractImplementationsPass.cs    |    5 +-
 .../Passes/GetterSetterToPropertyPass.cs      |  239 +-
 .../Passes/MultipleInheritancePass.cs         |   12 +-
 src/Generator/Passes/RenamePass.cs            |   12 +-
 src/Generator/Passes/verbs.txt                | 8828 +++++++++++++++++
 tests/Basic/Basic.Tests.cs                    |   10 +-
 tests/VTables/VTables.Tests.cs                |   13 +-
 12 files changed, 9130 insertions(+), 126 deletions(-)
 create mode 100644 src/Generator/Passes/verbs.txt

diff --git a/src/AST/Class.cs b/src/AST/Class.cs
index 04a136ae..30c4adaf 100644
--- a/src/AST/Class.cs
+++ b/src/AST/Class.cs
@@ -231,7 +231,7 @@ namespace CppSharp.AST
         public Property GetRootBaseProperty(Property @override, bool onlyFirstBase = false)
         {
             return (from @base in Bases
-                    where !onlyFirstBase || !@base.Class.IsInterface
+                    where (!onlyFirstBase || !@base.Class.IsInterface) && @base.IsClass
                     let baseProperty = (
                         from property in @base.Class.Properties
                         where
diff --git a/src/AST/Property.cs b/src/AST/Property.cs
index 50a34440..bad67004 100644
--- a/src/AST/Property.cs
+++ b/src/AST/Property.cs
@@ -28,6 +28,42 @@ namespace CppSharp.AST
 
         public QualifiedType QualifiedType { get; set; }
 
+        public bool IsStatic
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsStatic) ||
+                       (SetMethod != null && SetMethod.IsStatic);
+            }
+        }
+
+        public bool IsPure
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsPure) ||
+                       (SetMethod != null && SetMethod.IsPure);
+            }
+        }
+
+        public bool IsVirtual
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsVirtual) ||
+                       (SetMethod != null && SetMethod.IsVirtual);
+            }
+        }
+
+        public bool IsOverride
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsOverride) ||
+                       (SetMethod != null && SetMethod.IsOverride);
+            }
+        }
+
         public Method GetMethod { get; set; }
 
         public Method SetMethod { get; set; }
diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs
index a700b2db..deca3f22 100644
--- a/src/Generator/Driver.cs
+++ b/src/Generator/Driver.cs
@@ -158,6 +158,7 @@ namespace CppSharp
                 TranslationUnitPasses.AddPass(new MultipleInheritancePass());
                 TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass());
             }
+            TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass());
         }
 
         public void ProcessCode()
diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
index 84ca66c6..984c1194 100644
--- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
+++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
@@ -784,7 +784,6 @@ namespace CppSharp.Generators.CSharp
         {
             PushBlock(CSharpBlockKind.Method);
             WriteLine("set");
-            WriteStartBraceIndent();
 
             var param = new Parameter
             {
@@ -801,7 +800,14 @@ namespace CppSharp.Generators.CSharp
             if (decl is Function)
             {
                 var function = decl as Function;
+                if (function.IsPure && Driver.Options.GenerateAbstractImpls)
+                {
+                    Write("; ");
+                    PopBlock(NewLineKind.BeforeNextBlock);
+                    return;
+                }
 
+                WriteStartBraceIndent();
                 if (function.Parameters.Count == 0)
                     throw new NotSupportedException("Expected at least one parameter in setter");
 
@@ -810,16 +816,32 @@ namespace CppSharp.Generators.CSharp
                 var method = function as Method;
                 if (method != null && method.OperatorKind == CXXOperatorKind.Subscript)
                 {
-                    GenerateIndexerSetter(returnType, method);
+                    if (method.IsOverride && method.IsSynthetized)
+                    {
+                        GenerateVirtualTableFunctionCall(function, @class);
+                    }
+                    else
+                    {
+                        if (method.OperatorKind == CXXOperatorKind.Subscript)
+                        {
+                            GenerateIndexerSetter(returnType, method);                            
+                        }
+                        else
+                        {
+                            var parameters = new List<Parameter> { param };
+                            GenerateInternalFunctionCall(function, parameters);
+                        }
+                    }
                 }
                 else
                 {
                     var parameters = new List<Parameter> { param };
-                    GenerateInternalFunctionCall(function, parameters);   
+                    GenerateInternalFunctionCall(function, parameters); 
                 }
             }
             else if (decl is Field)
             {
+                WriteStartBraceIndent();
                 var field = decl as Field;
 
                 WriteLine("var {0} = (Internal*){1}.ToPointer();",
@@ -865,22 +887,39 @@ namespace CppSharp.Generators.CSharp
             where T : Declaration, ITypedDecl
         {
             PushBlock(CSharpBlockKind.Method);
-            WriteLine("get");
-            WriteStartBraceIndent();
+            Write("get");
 
             if (decl is Function)
             {
                 var function = decl as Function;
-                bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript &&
-                                          function.ReturnType.Type.IsPointerToPrimitiveType();
-                if (isPrimitiveIndexer)
-                    TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer);
-                GenerateInternalFunctionCall(function);
-                if (isPrimitiveIndexer)
-                    TypePrinter.PopContext();
+                if (function.IsPure && Driver.Options.GenerateAbstractImpls)
+                {
+                    Write("; ");
+                    PopBlock(NewLineKind.BeforeNextBlock);
+                    return;
+                }
+                WriteLine("");
+                WriteStartBraceIndent();
+                Method method = function as Method;
+                if (method != null && method.IsOverride && method.IsSynthetized)
+                {
+                    GenerateVirtualTableFunctionCall(function, @class);                    
+                }
+                else
+                {
+                    bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript &&
+                                              function.ReturnType.Type.IsPointerToPrimitiveType();
+                    if (isPrimitiveIndexer)
+                        TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer);
+                    GenerateInternalFunctionCall(function);
+                    if (isPrimitiveIndexer)
+                        TypePrinter.PopContext();   
+                }
             }
             else if (decl is Field)
             {
+                WriteLine("");
+                WriteStartBraceIndent();
                 var field = decl as Field;
 
                 WriteLine("var {0} = (Internal*){1}.ToPointer();",
@@ -905,6 +944,8 @@ namespace CppSharp.Generators.CSharp
             }
             else if (decl is Variable)
             {
+                WriteLine("");
+                WriteStartBraceIndent();
                 var @var = decl as Variable;
                 var libSymbol = GetDeclarationLibrarySymbol(@var);
 
@@ -990,10 +1031,22 @@ namespace CppSharp.Generators.CSharp
                     type = ((PointerType) prop.Type).Pointee;
 
                 if (prop.ExplicitInterfaceImpl == null)
-                    WriteLine("{0}{1} {2}", Helpers.GetAccess(prop.Access),
-                        type, GetPropertyName(prop));
+                {
+                    Write(Helpers.GetAccess(prop.Access));
+                    if (prop.IsStatic)
+                        Write("static ");
+                    if (prop.IsOverride)
+                        Write("override ");
+                    else if (prop.IsPure && Driver.Options.GenerateAbstractImpls)
+                        Write("abstract ");
+                    else if (prop.IsVirtual)
+                        Write("virtual ");
+                    WriteLine("{0} {1}", type, GetPropertyName(prop));
+                }
                 else
+                {
                     WriteLine("{0} {1}.{2}", type, prop.ExplicitInterfaceImpl.Name, GetPropertyName(prop));
+                }
                 WriteStartBraceIndent();
 
                 if (prop.Field != null)
@@ -1044,7 +1097,9 @@ namespace CppSharp.Generators.CSharp
         public void GenerateVTable(Class @class)
         {
             var entries = VTables.GatherVTableMethodEntries(@class);
-            entries = entries.Where(entry => !entry.Method.Ignore).ToList();
+            entries = entries.Where(e => !e.Method.Ignore ||
+                @class.Properties.Any(p => !p.Ignore &&
+                    (p.GetMethod == e.Method || p.SetMethod == e.Method))).ToList();
 
             if (entries.Count == 0)
                 return;
@@ -1203,7 +1258,16 @@ namespace CppSharp.Generators.CSharp
             if (hasReturn)
                 Write("var _ret = ");
 
-            WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals));
+            if (method.IsGenerated)
+            {
+                WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals));              
+            }
+            else
+            {
+                var name = ((Class) method.Namespace).Properties.First(
+                    p => p.GetMethod == method || p.SetMethod == method).Name;
+                WriteLine("target.{0};", name);              
+            }
 
             // TODO: Handle hidden structure return types.
 
diff --git a/src/Generator/Passes/FindSymbolsPass.cs b/src/Generator/Passes/FindSymbolsPass.cs
index e7146d08..36d5ad51 100644
--- a/src/Generator/Passes/FindSymbolsPass.cs
+++ b/src/Generator/Passes/FindSymbolsPass.cs
@@ -12,7 +12,7 @@ namespace CppSharp.Passes
 
             var mangledDecl = decl as IMangledDecl;
             var method = decl as Method;
-            if (mangledDecl != null && !(method != null && method.IsPure) &&
+            if (mangledDecl != null && !(method != null && (method.IsPure || method.IsSynthetized)) &&
                 !VisitMangledDeclaration(mangledDecl))
             {
                 decl.ExplicityIgnored = true;
diff --git a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs
index a15d2c3d..81e2eb4a 100644
--- a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs
+++ b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs
@@ -57,7 +57,8 @@ namespace CppSharp.Passes
                                 {
                                     Name = abstractMethod.Name + "Delegate",
                                     QualifiedType = abstractMethod.GetFunctionType(),
-                                    IgnoreFlags = abstractMethod.IgnoreFlags
+                                    IgnoreFlags = abstractMethod.IgnoreFlags,
+                                    Namespace = internalImpl
                                 };
                 internalImpl.Typedefs.Add(@delegate);
             }
@@ -79,7 +80,7 @@ namespace CppSharp.Passes
             var internalImpl = new Class
                                 {
                                     Name = @class.Name + "Internal",
-                                    Access = AccessSpecifier.Private,
+                                    Access = @class.Access,
                                     Namespace = @class.Namespace
                                 };
             var @base = new BaseClassSpecifier { Type = new TagType(@class) };
diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs
index 3ad2ebbd..6e591fac 100644
--- a/src/Generator/Passes/GetterSetterToPropertyPass.cs
+++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs
@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Reflection;
 using CppSharp.AST;
 
 namespace CppSharp.Passes
@@ -10,6 +13,12 @@ namespace CppSharp.Passes
     /// </summary>
     public class GetterSetterToPropertyPass : TranslationUnitPass
     {
+        private readonly List<Method> setters = new List<Method>();
+        private readonly List<Method> setMethods = new List<Method>();
+        private readonly List<Method> nonSetters = new List<Method>();
+        private readonly HashSet<Method> getters = new HashSet<Method>();
+        private readonly HashSet<string> verbs = new HashSet<string>();
+
         public GetterSetterToPropertyPass()
         {
             Options.VisitClassFields = false;
@@ -21,123 +30,169 @@ namespace CppSharp.Passes
             Options.VisitNamespaceVariables = false;
             Options.VisitFunctionParameters = false;
             Options.VisitTemplateArguments = false;
+            using (var resourceStream = Assembly.GetExecutingAssembly()
+                .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt"))
+            {
+                using (StreamReader streamReader = new StreamReader(resourceStream))
+                    while (!streamReader.EndOfStream)
+                        verbs.Add(streamReader.ReadLine());
+            }
         }
 
-        static bool IsSetter(Function method)
+        public override bool VisitTranslationUnit(TranslationUnit unit)
         {
-            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
-                PrimitiveType.Void);
-
-            var isSetter = method.OriginalName.StartsWith("set",
-                StringComparison.InvariantCultureIgnoreCase);
-
-            return isRetVoid && isSetter && method.Parameters.Count == 1;
+            bool result = base.VisitTranslationUnit(unit);
+            GenerateProperties();
+            return result;
         }
 
-        static bool IsGetter(Function method)
+        public override bool VisitMethodDecl(Method method)
         {
-            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
-                PrimitiveType.Void);
-
-            var isGetter = method.OriginalName.StartsWith("get",
-                StringComparison.InvariantCultureIgnoreCase);
-
-            return !isRetVoid && isGetter && method.Parameters.Count == 0;
+            if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator &&
+                !method.Ignore)
+                DistributeMethod(method);
+            return base.VisitMethodDecl(method);
         }
 
-        Property GetOrCreateProperty(Class @class, string name, QualifiedType type)
+        public void GenerateProperties()
         {
-            var prop = @class.Properties.FirstOrDefault(property => property.Name == name
-                && property.QualifiedType.Equals(type));
-
-            var prop2 = @class.Properties.FirstOrDefault(property => property.Name == name);
-
-            if (prop == null && prop2 != null)
-                Driver.Diagnostics.EmitWarning(DiagnosticId.PropertySynthetized,
-                    "Property {0}::{1} already exist with type {2}", @class.Name, name, type.Type.ToString());
-
-            if (prop != null)
-                return prop;
-
-            prop = new Property
+            GenerateProperties(setters, false);
+            GenerateProperties(setMethods, true);
+
+            foreach (Method getter in 
+                from getter in getters
+                where getter.IsGenerated &&
+                      ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name)
+                select getter)
             {
-                Name = name,
-                Namespace = @class,
-                QualifiedType = type
-            };
-
-            @class.Properties.Add(prop);
-            return prop;
+                // Make it a read-only property
+                GenerateProperty(getter.Namespace, getter);
+            }
         }
 
-        public override bool VisitMethodDecl(Method method)
+        private void GenerateProperties(IEnumerable<Method> settersToUse, bool readOnly)
         {
-            if (AlreadyVisited(method))
-                return false;
-
-            if (ASTUtils.CheckIgnoreMethod(method))
-                return false;
-
-            var @class = method.Namespace as Class;
-
-            if (@class == null || @class.IsIncomplete)
-                return false;
-
-            if (IsGetter(method))
+            foreach (var group in settersToUse.GroupBy(m => m.Namespace))
             {
-                var name = method.Name.Substring("get".Length);
-                var prop = GetOrCreateProperty(@class, name, method.ReturnType);
-                prop.GetMethod = method;
-                prop.Access = method.Access;
-
-                // Do not generate the original method now that we know it is a getter.
-                method.IsGenerated = false;
-
-                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
-                    "Getter created: {0}::{1}", @class.Name, name);
-
-                return false;
+                foreach (var setter in group)
+                {
+                    Class type = (Class) setter.Namespace;
+                    string afterSet = setter.Name.Substring(3);
+                    foreach (var getter in nonSetters.Where(m => m.Namespace == type))
+                    {
+                        if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
+                            getter.ReturnType == setter.Parameters[0].QualifiedType &&
+                            !type.Methods.Any(
+                                m =>
+                                    m != getter &&
+                                    string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
+                        {
+                            GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
+                            goto next;
+                        }
+                    }
+                    Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet });
+                    if (!type.IsInterface && baseVirtualProperty != null)
+                    {
+                        bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                        GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod,
+                            readOnly || isReadOnly ? null : setter);
+                    }
+                    next:
+                    ;
+                }
             }
-
-            if (IsSetter(method) && IsValidSetter(method))
+            foreach (Method nonSetter in nonSetters)
             {
-                var name = method.Name.Substring("set".Length);
-
-                var type = method.Parameters[0].QualifiedType;
-                var prop = GetOrCreateProperty(@class, name, type);
-                prop.SetMethod = method;
-                prop.Access = method.Access;
+                Class type = (Class) nonSetter.Namespace;
+                string name = nonSetter.Name;
+                if (GetFirstWord(name) == "get")
+                    name = name.Substring(3);
+                Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
+                if (!type.IsInterface && baseVirtualProperty != null)
+                {
+                    bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                    if (readOnly == isReadOnly)
+                    {
+                        GenerateProperty(nonSetter.Namespace, nonSetter,
+                            readOnly ? null : baseVirtualProperty.SetMethod);
+                    }
+                }
+            }
+        }
 
-                // Ignore the original method now that we know it is a setter.
-                method.IsGenerated = false;
+        private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null)
+        {
+            Class type = (Class) context;
+            if (type.Properties.All(
+                p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 ||
+                     p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
+            {
+                Property property = new Property();
+                property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0);
+                property.Namespace = type;
+                property.QualifiedType = getter.ReturnType;
+                if (getter.IsOverride || (setter != null && setter.IsOverride))
+                {
+                    Property baseVirtualProperty = type.GetRootBaseProperty(property);
+                    if (baseVirtualProperty.SetMethod == null)
+                        setter = null;
+                    foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
+                        method.Name = "Get" + method.Name;
+                }
+                property.GetMethod = getter;
+                property.SetMethod = setter;
+                property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl;
+                if (property.ExplicitInterfaceImpl == null && setter != null)
+                {
+                    property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl;
+                }
+                // TODO: add comments
+                type.Properties.Add(property);
+                getter.IsGenerated = false;
+                if (setter != null)
+                    setter.IsGenerated = false;
+            }
+        }
 
-                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
-                    "Setter created: {0}::{1}", @class.Name, name);
 
-                return false;
+        private void DistributeMethod(Method method)
+        {
+            if (GetFirstWord(method.Name) == "set" &&
+                method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void))
+            {
+                if (method.Parameters.Count == 1)
+                    setters.Add(method);
+                else
+                    setMethods.Add(method);
+            }
+            else
+            {
+                if (IsGetter(method))
+                    getters.Add(method);
+                if (method.Parameters.Count == 0)
+                    nonSetters.Add(method);
             }
-
-            return false;
         }
 
-        // Check if a matching getter exist or no other setter exists.
-        private bool IsValidSetter(Method method)
+        private bool IsGetter(Method method)
         {
-            var @class = method.Namespace as Class;
-            var name = method.Name.Substring("set".Length);
-
-            if (method.Parameters.Count == 0)
+            if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) ||
+                method.Parameters.Count > 0 || method.IsDestructor)
                 return false;
+            var result = GetFirstWord(method.Name);
+            return result == "get" || result == "is" || result == "has" || 
+                   (result != "to" && result != "new" && !verbs.Contains(result));
+        }
 
-            var type = method.Parameters[0].Type;
-
-            var getter = @class.Methods.FirstOrDefault(m => m.Name == "Get" + name && m.Type.Equals(type));
-
-            var otherSetter = @class.Methods.FirstOrDefault(m => m.Name == method.Name
-                && m.Parameters.Count == 1 
-                && !m.Parameters[0].Type.Equals(type));
-
-            return getter != null || otherSetter == null;
+        private static string GetFirstWord(string name)
+        {
+            List<char> firstVerb = new List<char>
+                                    {
+                                        char.ToLowerInvariant(name[0])
+                                    };
+            firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower));
+            return new string(firstVerb.ToArray());
         }
     }
 }
diff --git a/src/Generator/Passes/MultipleInheritancePass.cs b/src/Generator/Passes/MultipleInheritancePass.cs
index 4651ab83..59199062 100644
--- a/src/Generator/Passes/MultipleInheritancePass.cs
+++ b/src/Generator/Passes/MultipleInheritancePass.cs
@@ -66,9 +66,15 @@ namespace CppSharp.Passes
                 let i = GetInterface(@base, b.Class)
                 select new BaseClassSpecifier { Type = new TagType(i) });
 
-            @interface.Methods.AddRange(@base.Methods.Where(
-                m => !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore));
-            @interface.Properties.AddRange(@base.Properties.Where(p => !p.Ignore));
+            @interface.Methods.AddRange(
+                from m in @base.Methods
+                where !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore
+                select new Method(m) { Namespace = @interface });
+
+            @interface.Properties.AddRange(
+                from property in @base.Properties
+                where !property.Ignore
+                select new Property(property) { Namespace = @interface });
 
             if (@interface.Bases.Count == 0)
             {
diff --git a/src/Generator/Passes/RenamePass.cs b/src/Generator/Passes/RenamePass.cs
index fa180548..df5ba64b 100644
--- a/src/Generator/Passes/RenamePass.cs
+++ b/src/Generator/Passes/RenamePass.cs
@@ -39,6 +39,7 @@ namespace CppSharp.Passes
             if (decl is Enumeration) return true;
             if (decl is Property) return true;
             if (decl is Event) return true;
+            if (decl is TypedefDecl) return true;
             return false;
         }
 
@@ -125,6 +126,14 @@ namespace CppSharp.Passes
             return base.VisitProperty(property);
         }
 
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
+        {
+            if (!Targets.HasFlag(RenameTargets.Delegate))
+                return false;
+
+            return base.VisitTypedefDecl(typedef);
+        }
+
         public override bool VisitMethodDecl(Method method)
         {
             if (!Targets.HasFlag(RenameTargets.Method))
@@ -173,7 +182,8 @@ namespace CppSharp.Passes
         EnumItem  = 1 << 6,
         Event     = 1 << 7,
         Property  = 1 << 8,
-        Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property,
+        Delegate  = 1 << 9,
+        Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property | Delegate,
     }
 
     /// <summary>
diff --git a/src/Generator/Passes/verbs.txt b/src/Generator/Passes/verbs.txt
new file mode 100644
index 00000000..b5a441c9
--- /dev/null
+++ b/src/Generator/Passes/verbs.txt
@@ -0,0 +1,8828 @@
+Africanize
+Afrikanerize
+Americanise
+Americanize
+Anglicise
+Anglicize
+Anglify
+Aryanise
+Aryanize
+Atticise
+Atticize
+Australianize
+Baalize
+Babelise
+Babelize
+Balkanise
+Balkanize
+Bolshevize
+Canadianize
+Cannulate
+Christianise
+Christianize
+Egyptianise
+Egyptianize
+Europeanise
+Europeanize
+Fletcherise
+Fletcherize
+Fordize
+Frenchify
+Gallicise
+Gallicize
+Germanise
+Germanize
+Gnosticise
+Gnosticize
+Gothicise
+Gothicize
+Graecise
+Graecize
+Grecise
+Grecize
+Harveyize
+Hebraise
+Hebraize
+Hellenise
+Hellenize
+Hibernicise
+Hibernicize
+Hinduize
+Hispanicise
+Hispanicize
+Indianise
+Indianize
+Iricise
+Iricize
+Irishise
+Irishize
+Islamise
+Islamize
+Italianise
+Italianize
+Jacobinise
+Jacobinize
+Jesuitise
+Jesuitize
+Judaise
+Judaize
+Latinise
+Latinize
+Listerise
+Listerize
+Magyarize
+Mohammedanize
+Nazify
+Negritise
+Negritize
+Negroise
+Negroize
+Newmanise
+Newmanize
+Normanize
+Northernise
+OK'd
+Occidentalise
+Occidentalize
+Orientalise
+Orientalize
+Pelagianize
+Platonise
+Platonize
+Polonize
+Prussianize
+Romanise
+Romanize
+Russianise
+Russianize
+Sanforize
+Sinicize
+Sinify
+Sovietise
+Tanglewood
+Teutonise
+Teutonize
+Yankeefy
+abase
+abash
+abate
+abbreviate
+abdicate
+abduce
+abduct
+abet
+abhor
+abide
+abirritate
+abjure
+ablactate
+ablate
+abnegate
+abnormalise
+abnormalize
+abolish
+abolitionise
+abolitionize
+abominate
+abort
+abought
+abound
+abrade
+abrase
+abreact
+abridge
+abrogate
+abscind
+abscise
+abscond
+absent
+absolve
+absorb
+absquatulate
+abstain
+absterge
+abut
+aby
+abye
+academise
+academize
+accede
+accelerate
+accentuate
+accept
+accessorize
+acclimate
+acclimatise
+acclimatize
+accommodate
+accompany
+accomplish
+accouter
+accoutre
+accredit
+accrete
+accroach
+accrue
+acculturate
+acculturize
+accumulate
+accuse
+accustom
+acerbate
+acetify
+acetylate
+acetylize
+achieve
+achromatise
+achromatize
+acidify
+acidize
+acidulate
+acierate
+acknowledge
+acquaint
+acquiesce
+acquire
+acquit
+acronymize
+activate
+activize
+actualise
+actualize
+actuate
+acuminate
+acylate
+adapt
+add
+addle
+addrest
+adduce
+adduct
+adffroze
+adffrozen
+adfreeze
+adhere
+adhibit
+adjoin
+adjourn
+adjudge
+adjudicate
+adjure
+adjust
+admeasure
+administer
+administrate
+admire
+admit
+admix
+admonish
+adopt
+adore
+adorn
+adrenalectomize
+adsorb
+adulate
+adulterate
+adumbrate
+advertise
+advertize
+advise
+aerate
+aerify
+aerosolize
+aestivate
+affirm
+afflict
+afford
+afforest
+affranchise
+affreight
+agatize
+agenize
+agglutinate
+aggrade
+aggrandise
+aggrandize
+aggravate
+aggress
+aggrieve
+aggroup
+agist
+agitate
+agnise
+agnize
+agonise
+agonize
+agree
+airmail
+airproof
+albumenise
+albumenize
+albuminise
+albuminize
+alchemise
+alchemize
+alcoholise
+alcoholize
+alienate
+alight
+align
+aline
+alit
+alkalify
+alkalinise
+alkalinize
+alkalise
+alkalize
+allay
+allege
+allegorise
+allegorize
+alleviate
+alligate
+alliterate
+allocate
+allomerize
+allot
+allow
+allude
+alphabetise
+alphabetize
+alter
+altercate
+aluminise
+aluminize
+amalgamate
+amass
+amate
+ambrocate
+ambulate
+ameliorate
+amend
+amerce
+americanize
+amidate
+aminate
+ammonify
+ammonolyze
+amortise
+amortize
+amplify
+amputate
+amuse
+anaesthetize
+anagrammatise
+anagrammatize
+analogise
+analogize
+analyse
+analyze
+anastomose
+anathematise
+anathematize
+anathemize
+anatomise
+anatomize
+anchylose
+ancylose
+anele
+anesthesize
+anesthetize
+anglicise
+anglicize
+angulate
+animadvert
+animalise
+animalize
+animate
+animize
+ankylose
+annihilate
+annotate
+announce
+annoy
+annul
+annunciate
+anodize
+anoint
+antagonise
+antagonize
+antecede
+antevert
+anthologise
+anthologize
+anthropomorphise
+anthropomorphize
+anticipate
+antiquate
+antisepticise
+antisepticize
+aphorise
+aphorize
+apocopate
+apologise
+apologize
+apostatise
+apostatize
+apostrophise
+apostrophize
+apotheose
+apotheosise
+apotheosize
+appal
+appall
+appear
+appease
+append
+apperceive
+appertain
+applaud
+appliquad
+apply
+appoint
+apportion
+appose
+appraise
+appreciate
+apprehend
+apprise
+apprize
+approbate
+appropriate
+approve
+approximate
+arbitrate
+arborise
+arborize
+archaise
+archaize
+argue
+argufy
+arise
+arisen
+aromatise
+aromatize
+arose
+arouse
+arraign
+arrange
+arride
+arrive
+arrogate
+arterialise
+arterialize
+articulate
+artificialize
+arylate
+ascend
+ascertain
+ascribe
+asexualise
+asexualize
+ask
+asperse
+asphyxiate
+aspire
+assail
+assassinate
+assemble
+assert
+assess
+asseverate
+assibilate
+assibiliate
+assimilate
+assoil
+assort
+assuage
+assume
+assure
+astonish
+astound
+astrict
+astringe
+astrogate
+atomise
+atomize
+atone
+attacca
+attain
+attemper
+attend
+attenuate
+attest
+attitudinise
+attitudinize
+attorn
+attract
+attrite
+attune
+aurify
+auscultate
+auspicate
+austemper
+austenitize
+authenticate
+authorise
+authorize
+autolyse
+autolyze
+automate
+automatize
+autotomise
+autotomize
+avenge
+aver
+avert
+avianise
+avianize
+aviate
+avoid
+avouch
+avow
+avulse
+await
+awake
+awaken
+awoke
+azotise
+azotize
+backbit
+backbite
+backbitten
+backcomb
+backdate
+backpedal
+backslap
+backslid
+backslidden
+backslide
+backstab
+backtrack
+backwind
+bacterise
+bacterize
+badmouth
+bald
+balkanize
+balladise
+balladize
+ballocks
+ballyrag
+bamboozle
+bandfile
+bandies
+bandsawn
+banish
+baptise
+baptize
+bar
+barbarianize
+barbarise
+barbarize
+bare
+barf
+barhop
+barnstorm
+baronetise
+baronetize
+baronize
+bartend
+basiate
+basify
+bask
+bastardise
+bastardize
+batfowl
+battologise
+battologize
+beatify
+beautify
+becalm
+became
+bechance
+becharm
+beclasp
+becloud
+become
+becrawl
+becripple
+bedabble
+bedamn
+bedash
+bedaub
+bedaze
+bedazzle
+bedeck
+bedevil
+bedew
+bedight
+bedim
+bedizen
+bedlamise
+bedlamize
+bedrabble
+bedraggle
+bedrench
+been
+beestride
+befall
+befallen
+befell
+befit
+beflag
+befog
+befool
+befoul
+befriend
+befuddle
+began
+begat
+begem
+beget
+begild
+begin
+begird
+begirt
+begot
+begotten
+begrime
+begrudge
+beguile
+begun
+behave
+behead
+beheld
+behold
+behoove
+behove
+bejewel
+belabor
+belabour
+belaud
+beleaguer
+belie
+believe
+belittle
+bellylaugh
+belong
+belove
+bemaul
+bemean
+bemire
+bemoan
+bemock
+bemuddle
+bemuse
+bename
+benday
+beneficiate
+benempt
+benight
+benumb
+benzoylate
+bepaint
+bequeath
+berascal
+berate
+bereareft
+bereave
+berhyme
+berime
+bescreen
+bescribble
+beseech
+beseem
+beset
+beshrew
+besiege
+besmear
+besmirch
+besot
+besought
+bespake
+bespangle
+bespatter
+bespeak
+bespeckle
+bespoken
+bespot
+bespread
+besprinkle
+bestead
+bestialise
+bestialize
+bestir
+bestow
+bestraddle
+bestrew
+bestrewn
+bestrid
+bestridden
+bestride
+bestrode
+bestrow
+bestrown
+bestud
+betake
+betaken
+bete
+bethink
+bethought
+betide
+betoken
+betook
+betray
+betroth
+bewail
+beware
+beweep
+bewhisker
+bewilder
+bewitch
+bewray
+bewwept
+bidden
+bide
+bifurcate
+bind
+birdnest
+birdwatch
+birle
+birthe
+bisect
+bist
+bitten
+bituminise
+bituminize
+blacken
+blacklead
+blackwash
+blanch
+blanco
+blandish
+blaspheme
+blast
+blat
+blate
+blear
+blench
+blent
+bless
+blest
+blew
+blither
+bloodiest
+bloody
+blown
+blub
+blunge
+blunt
+blurt
+bode
+bodge
+bodies
+bodypaint
+boggle
+bogue
+bollix
+bollocks
+bolshevise
+bolshevize
+bombilate
+bombinate
+bonderize
+bonk
+boo
+boohoos
+bootlick
+boresight
+born
+borne
+boswellize
+botanise
+botanize
+bother
+bought
+boult
+boun
+bouse
+bowdlerise
+bowdlerize
+bown
+bowse
+bowstrung
+boxhaul
+brachiate
+braille
+brainwash
+braise
+bravo
+braze
+brazen
+break
+breathalyse
+breathalyze
+breathe
+brecciate
+brei
+brey
+brighten
+brisk
+brisken
+broaden
+broddle
+broider
+broke
+broken
+bromise
+bromize
+brought
+browbeat
+browbeaten
+brutalise
+brutalize
+brutify
+buckjump
+bugger
+build
+built
+bulldoze
+bulletproof
+bully
+bullyrag
+bureaucratize
+burglarise
+burglarize
+burgle
+buries
+burke
+burnt
+bury
+bushwhack
+busy
+buttle
+butylate
+ca'
+cabble
+cachinnate
+cackel
+cagmag
+cajole
+calcify
+calcine
+calculate
+calibrate
+call
+callous
+calorize
+calumniate
+calve
+camphorate
+can
+canalise
+canalize
+cancerate
+cannibalise
+cannibalize
+cannot
+canonise
+canonize
+canoodle
+canst
+cantillate
+capacitate
+capitalise
+capitalize
+capitulate
+caponise
+caponize
+capsize
+capsulize
+captivate
+caramelise
+caramelize
+carbolise
+carbolize
+carbonise
+carbonize
+carbonylate
+carburet
+carburise
+carburize
+carjack
+carnalize
+carnify
+carny
+carries
+cartelize
+carve
+carven
+caseate
+casefy
+caseharden
+castigate
+catabolize
+catalyse
+catalyze
+catechise
+catechize
+categorise
+categorize
+catenate
+catenulate
+cater
+cathect
+catheterise
+catheterize
+catholicise
+catholicize
+caught
+caulk
+cauterise
+cauterize
+cave
+cavort
+cede
+ceil
+celebrate
+cellulate
+cense
+centerpunch
+centralise
+centralize
+centrifugalise
+centrifugalize
+centuple
+cerebrate
+certify
+chackle
+chainstitch
+channelize
+chaptalize
+characterise
+characterize
+chassad
+chasse
+chasten
+chastise
+chastize
+cheapen
+check
+checkmate
+cheerlead
+cheezit
+chelp
+chemisorb
+cherish
+chevies
+chevvy
+chiack
+chide
+chinse
+chirk
+chitter
+chivvy
+chloridize
+chlorinate
+chondrify
+choose
+choreograph
+christen
+christmas
+chromatograph
+chromeplate
+chronologize
+chunter
+chyack
+cicatrise
+cicatrize
+cinchonise
+cinchonize
+cinematize
+circularise
+circularize
+circulate
+circumambulate
+circumcise
+circumfuse
+circumnavigate
+circumnutate
+circumrotate
+circumscribe
+circumstantiate
+circumvallate
+circumvent
+circumvolute
+circumvolve
+cite
+citify
+civilise
+civilize
+clad
+clangour
+clapperclaw
+clapt
+clarify
+clart
+claspt
+classicise
+classicize
+classify
+claucht
+claught
+claver
+claxon
+cleanse
+clearstarch
+cleave
+clem
+clepe
+clept
+clipt
+clitter
+clomb
+clone
+close
+closest
+clothe
+cloven
+cloy
+clubhaul
+clung
+clype
+coact
+coalesce
+coapt
+coarsen
+cocainise
+cocainize
+cockbill
+cockneyfy
+codify
+coedit
+coerce
+coexist
+coextend
+coff
+coft
+coggle
+cogitate
+cognise
+cognize
+cohabit
+cohere
+cohobate
+coiffe
+coincide
+coinsure
+coldcock
+coldcream
+collaborate
+collate
+collectivise
+collectivize
+collide
+colligate
+collimate
+collocate
+collogue
+collude
+colonialise
+colonialize
+colonise
+colonize
+combust
+come
+cometh
+commandeer
+commeasure
+commemorate
+commence
+commend
+commentate
+commercialise
+commercialize
+comminate
+commingle
+comminute
+commisce
+commiserate
+commit
+commix
+commove
+communalise
+communalize
+communicate
+communise
+communize
+commutate
+commute
+compart
+compartmentalise
+compartmentalize
+compassionate
+compel
+compensate
+compete
+compile
+complain
+compleat
+complect
+complete
+complexify
+complicate
+comply
+comport
+compose
+comprehend
+comprise
+comprize
+computerize
+concatenate
+concave
+conceal
+concede
+conceive
+concelebrate
+concenter
+concentre
+conceptualise
+conceptualize
+concertise
+concertize
+conciliate
+concinnate
+conclude
+concoct
+concorporate
+concretize
+concur
+concuss
+condemn
+condense
+condescend
+condole
+condone
+conduce
+confabulate
+confect
+confer
+confess
+confide
+configure
+confirm
+confiscate
+conflate
+conform
+confound
+confront
+confuse
+confute
+conge
+congeal
+congest
+conglobate
+conglobe
+conglutinate
+congratulate
+congregate
+conjoin
+conjure
+connect
+connive
+connote
+conquer
+consecrate
+consider
+consign
+consist
+consolidate
+consonantalize
+consonantise
+consonantize
+conspire
+constellate
+conster
+consternate
+constipate
+constitute
+constitutionalize
+constrain
+constrict
+constringe
+consubstantiate
+consult
+consume
+consummate
+contact
+contain
+containerize
+contaminate
+contemn
+contemplate
+contemporise
+contemporize
+contend
+content
+contextualize
+continue
+contort
+contradict
+contradistinguish
+contraindicate
+contrapose
+contravene
+contribute
+contrive
+controvert
+contuse
+convalesce
+convect
+convene
+conventionalise
+conventionalize
+converge
+convex
+convey
+conveyorize
+convince
+convoke
+convolute
+convolve
+convulse
+coo
+cooccur
+cooee
+cooperate
+coopt
+copolymerise
+copolymerize
+copperbottom
+coprecipitate
+copulate
+copyedit
+copyread
+coquet
+corelate
+coronate
+corrade
+correct
+correspond
+corroborate
+corrode
+corrugate
+corrupt
+coruscate
+cosher
+cosmopolitanise
+cosmopolitanize
+cosponsor
+could
+couldst
+counteract
+counterchallenge
+counterchange
+counterlit
+counterpose
+counterreplies
+countersank
+counterstrike
+countersunk
+countervail
+counterweigh
+covet
+cower
+cowk
+cozen
+cranch
+craunch
+crave
+create
+cremate
+crenelate
+crenellate
+creolize
+crepitate
+crept
+cribble
+cries
+criminalize
+criminate
+crimple
+crispen
+criticise
+criticize
+crizzle
+cronk
+crucify
+cryptanalyze
+crystalize
+crystallise
+crystallize
+cuckoo
+cuitle
+cuittle
+culminate
+cultivate
+cumulate
+curarize
+curdle
+curr
+curst
+curtail
+customise
+customize
+cutinise
+cutinize
+cybernate
+cyclize
+dabble
+dacker
+daggle
+daiker
+dally
+dam
+damaskeen
+damn
+damnify
+dampen
+dampproof
+dandify
+dandle
+daresay
+darken
+darkle
+darn
+dartle
+dash
+datemark
+daunt
+daut
+dawdle
+dawt
+deaccession
+deacetylate
+deactivate
+deaden
+deaerate
+deafen
+dealt
+deaminate
+deaminize
+deave
+debag
+debar
+debark
+debase
+debeak
+debilitate
+debone
+debrief
+debruise
+debunk
+deburr
+debus
+decaffeinate
+decalcify
+decamp
+decancellate
+decant
+decapitate
+decarbonate
+decarbonise
+decarbonylate
+decarboxylate
+decarburise
+decarburize
+decartelize
+decasualise
+decasualize
+deceive
+decelerate
+decenter
+decentralise
+decentralize
+decentre
+decern
+decertify
+dechloridize
+decide
+decimalise
+decimalize
+decimate
+decipher
+declaim
+declare
+declass
+declassify
+declaw
+declutch
+decoct
+decode
+decoke
+decollate
+decolonise
+decolonize
+decolor
+decolorise
+decolorize
+decolourise
+decolourize
+decommission
+decompose
+decompound
+decompress
+deconcentrate
+decongest
+deconsecrate
+deconstruct
+decontaminate
+decontrol
+decorate
+decorticate
+decouple
+decrepitate
+decriminalize
+decry
+decrypt
+decussate
+dedicate
+dedifferentiate
+dedolomitize
+deduce
+deduct
+deek
+deem
+deemphasize
+deepen
+deescalate
+deface
+defalcate
+defame
+defang
+defecate
+defeminise
+defeminize
+defend
+defer
+defervesce
+defibrillate
+defies
+define
+definitise
+definitize
+deflagrate
+deflate
+deflect
+deflocculate
+deflower
+defoliate
+deforce
+deform
+defraud
+defray
+defrock
+defrost
+defuse
+defuze
+defy
+degas
+degauss
+deglamorize
+deglutinate
+deglycerolize
+degold
+degrade
+degrease
+degum
+degust
+dehisce
+dehorn
+dehort
+dehumanise
+dehumanize
+dehumidify
+dehydrate
+dehydroffroze
+dehydroffrozen
+dehydrofreeze
+dehydrogenate
+dehydrogenise
+dehydrogenize
+dehypnotize
+deice
+deify
+deign
+deionize
+deject
+delabialize
+delaminate
+delapidate
+delate
+delead
+delectate
+delegalize
+delete
+deliberate
+delimit
+delimitate
+delineate
+deliquesce
+delist
+deliver
+delocalise
+delocalize
+delouse
+delude
+delve
+demagnetise
+demarcate
+demark
+demasculinise
+demasculinize
+dematerialise
+dematerialize
+demean
+dement
+demilitarise
+demilitarize
+demineralize
+demist
+demit
+demobilise
+demobilize
+democratise
+democratize
+demodulate
+demolish
+demonetise
+demonetize
+demonise
+demonize
+demonstrate
+demoralise
+demoralize
+demote
+demothball
+demount
+demulsify
+demystify
+demythologise
+demythologize
+denasalize
+denationalise
+denationalize
+denaturalise
+denaturalize
+denature
+denaturise
+denaturize
+denazify
+denicotinize
+denigrate
+denitrate
+denitrify
+denominate
+denote
+denounce
+densify
+dentalise
+dentalize
+denuclearize
+denudate
+denude
+denunciate
+deny
+deodorise
+deodorize
+deoxidise
+deoxidize
+deoxygenate
+deoxygenize
+depaint
+depart
+departmentalise
+departmentalize
+depasture
+depend
+depeople
+deperm
+depersonalise
+depersonalize
+depict
+depicture
+depilate
+deplane
+deplete
+deplore
+deploy
+deplumate
+deplume
+depolarise
+depolarize
+depoliticize
+depolymerize
+depone
+depopulate
+deport
+depose
+deprave
+deprecate
+depreciate
+depredate
+depress
+depressurize
+deprive
+depurate
+depute
+deputise
+deputize
+deracinate
+deraign
+derange
+derate
+deration
+deratize
+derecognize
+deregister
+deregulate
+derestrict
+deride
+derive
+dern
+derogate
+derust
+desalinate
+desalinize
+desalt
+descale
+descend
+deschool
+describe
+descry
+deseam
+desecrate
+desegregate
+desensitize
+deserve
+desex
+desexualize
+desicate
+desiccate
+desiderate
+designate
+desilt
+desilver
+desilverize
+desist
+desolate
+desorb
+despise
+despoil
+despumate
+desquamate
+dessicate
+destabilize
+desterilize
+destine
+destool
+destress
+destroy
+desulfur
+desulfurate
+desulfurise
+desulfurize
+desulphurate
+desulphurise
+desulphurize
+desynchronize
+detach
+detain
+detect
+deter
+deterge
+deteriorate
+determine
+detest
+dethrone
+detonate
+detoxify
+detract
+detrain
+detransitivize
+detribalize
+detrude
+detruncate
+detusk
+deuterate
+devaluate
+devalue
+devastate
+develop
+develope
+devest
+devilize
+devitalise
+devitalize
+devitrify
+devocalise
+devocalize
+devoice
+devolatilise
+devolatilize
+devolve
+devote
+devour
+dewater
+diabolise
+diabolize
+diagnose
+diagnosticate
+diagonalize
+dialogize
+dialyse
+dialyze
+diazotize
+dib
+dichotomise
+dichotomize
+did
+didder
+diddle
+didst
+dieselize
+differ
+differentiate
+diffract
+diffuse
+dight
+digitalize
+digitise
+digitize
+dignify
+digress
+dilacerate
+dilapidate
+dilate
+dillydally
+dilute
+dim
+dimerize
+dimidiate
+diminish
+dine
+dingdong
+dink
+diosmose
+diphthongise
+diphthongize
+dipt
+direct
+dirl
+dirty
+disable
+disabuse
+disaccredit
+disaccustom
+disaffect
+disaffiliate
+disaffirm
+disafforest
+disagree
+disallow
+disambiguate
+disannul
+disanoint
+disappear
+disappoint
+disapprove
+disarm
+disarrange
+disarticulate
+disassemble
+disassociate
+disavow
+disband
+disbar
+disbelieve
+disbosom
+disbowel
+disbranch
+disbud
+disburden
+disburse
+disburthen
+discase
+discept
+discern
+discerp
+disclaim
+disclose
+discolor
+discolorize
+discolour
+discombobulate
+discommend
+discommode
+discommon
+discompose
+disconcert
+disconnect
+disconsider
+discontinue
+discourage
+discover
+discreate
+discriminate
+discrown
+discuss
+disembargo
+disembark
+disembarrass
+disembody
+disembogue
+disembosom
+disembowel
+disembroil
+disenable
+disenchant
+disencumber
+disendow
+disenfranchise
+disengage
+disentangle
+disenthral
+disenthrall
+disenthrone
+disentitle
+disentomb
+disentrance
+disentwine
+disestablish
+disfeature
+disfigure
+disforest
+disfranchise
+disfrock
+disfurnish
+disgavel
+disgorge
+disgregate
+disgruntle
+dishabituate
+dishallow
+disharmonise
+disharmonize
+dishearten
+dishelm
+disherit
+dishevel
+dishonour
+disillusionise
+disillusionize
+disimprison
+disincarnate
+disincline
+disinfect
+disinfest
+disinflate
+disinherit
+disinhume
+disintegrate
+disinter
+disinvolve
+disject
+disjoin
+disjoint
+diskjockey
+dislimn
+dislocate
+dislodge
+dismantle
+dismast
+dismember
+dismiss
+disnature
+disobey
+disoblige
+disocclude
+disorganise
+disorganize
+disorient
+disorientate
+disown
+disparage
+dispart
+dispauper
+dispel
+dispend
+dispense
+dispeople
+disperse
+dispirit
+displace
+displant
+displease
+displode
+displume
+dispossess
+dispread
+disprize
+disproportionate
+disprove
+disqualify
+disrate
+disremember
+disrobe
+disroot
+disrupt
+dissassociate
+dissatisfy
+disseat
+dissect
+disseise
+disseize
+dissemble
+disseminate
+dissert
+dissertate
+disserve
+dissever
+dissimilate
+dissimulate
+dissipate
+dissociate
+disspread
+dissuade
+dissyllabise
+dissyllabize
+distain
+distend
+distil
+distill
+distinguish
+distort
+distract
+distrain
+distribute
+disturb
+disunify
+disunite
+disyllabize
+disyoke
+divagate
+divaricate
+diverge
+diversify
+divert
+divest
+divinise
+divinize
+divulgate
+divulge
+divulse
+divvies
+dizen
+dizzy
+doat
+does
+doest
+doeth
+doff
+dogmatise
+dogmatize
+dolomitise
+dolomitize
+domesticate
+domesticize
+domiciliate
+dominate
+domineer
+donate
+done
+dost
+dote
+doth
+doublethought
+dought
+dow
+download
+drabble
+draggle
+dramatise
+dramatize
+drank
+drave
+dreamt
+dree
+dreigh
+drest
+drew
+driech
+driegh
+driven
+dropforge
+dropt
+drouk
+drown
+drumble
+drydock
+dulcify
+dulcorate
+dull
+dumbfound
+dumfound
+dup
+dure
+durst
+dwelt
+dwindle
+dwine
+dynamize
+earn
+easternize
+easy
+eat
+eaten
+eavesdrop
+ebonise
+ebonize
+eche
+economise
+economize
+ectropionize
+edify
+editorialize
+educate
+educe
+edulcorate
+eff
+efface
+effectuate
+effeminise
+effeminize
+effervesce
+effigiate
+effloresce
+effulge
+effuse
+egest
+egotrip
+eject
+eke
+elaborate
+elapse
+elasticate
+elasticize
+elate
+electrify
+electrocute
+electroform
+electrolyse
+electrolyze
+electropolish
+elegise
+elegize
+elevate
+elicit
+elide
+eliminate
+elinguate
+eloign
+elongate
+elope
+elucidate
+elude
+elute
+elutriate
+eluviate
+emaciate
+email
+emanate
+emancipate
+emasculate
+embalm
+embank
+embar
+embark
+embarrass
+embattle
+embay
+embellish
+embezzle
+embitter
+emblaze
+emblazon
+emblematise
+emblematize
+embody
+embolden
+embosk
+embosom
+emboss
+embow
+embowel
+embower
+embrangle
+embrittle
+embrocate
+embroider
+embroil
+embrown
+embrue
+embrute
+embus
+emend
+emendate
+emerge
+emerize
+emigrate
+emit
+emmarble
+emote
+emotionalise
+emotionalize
+empale
+empanel
+empathize
+emphasise
+emphasize
+emplace
+emplane
+empoison
+empolder
+empoverish
+empower
+empt
+empurple
+emulate
+emulsify
+enable
+enact
+enamor
+enamour
+encage
+encamp
+encapsulate
+encapsule
+encarnalise
+encarnalize
+encase
+encash
+enchain
+enchant
+enchase
+encipher
+encircle
+enclasp
+enclose
+enclothe
+encode
+encompass
+encore
+encourage
+encrimson
+encroach
+encrypt
+enculturate
+encumber
+encyst
+end
+endamage
+endanger
+enddamage
+endear
+endorse
+endow
+endue
+endure
+energise
+energize
+enervate
+enface
+enfeeble
+enfeoff
+enfetter
+enflame
+enfold
+enforce
+enfranchise
+enfranchize
+enfuriate
+engage
+engarland
+engender
+engild
+engird
+engirdle
+engirt
+englut
+engorge
+engraft
+engrail
+engrain
+engrave
+engross
+engulf
+enhance
+enhearten
+enigmatize
+enisle
+enjoin
+enjoy
+enkindle
+enlace
+enlarge
+enlighten
+enlist
+enliven
+enmarble
+enmesh
+ennoble
+enolize
+enounce
+enplane
+enquire
+enrage
+enrapture
+enravish
+enregister
+enrich
+enrobe
+enrol
+enroll
+enroot
+ensanguine
+ensconce
+enscroll
+ensepulcher
+ensheathe
+enshrine
+enshroud
+ensile
+ensky
+enslave
+ensnare
+ensnarl
+ensoul
+ensphere
+enspirit
+ensue
+enswathe
+entangle
+enter
+entertain
+enthral
+enthrall
+enthrone
+enthronise
+enthronize
+enthuse
+entice
+entitle
+entoil
+entomb
+entomologise
+entomologize
+entrain
+entrammel
+entrap
+entreasure
+entreat
+entrench
+entrust
+entwine
+entwist
+enucleate
+enumerate
+enunciate
+enure
+envelop
+envenom
+environ
+envisage
+envision
+enweave
+enwind
+enwomb
+enwove
+enwrap
+enwreath
+enwreathe
+enwwove
+enwwoven
+epigrammatise
+epigrammatize
+epilate
+epimerise
+epimerize
+epiphanise
+epiphanize
+episcopise
+episcopize
+epistolise
+epistolize
+epitomise
+epitomize
+equalise
+equalize
+equate
+equilibrate
+equilibrize
+equip
+equiponderate
+equivocate
+eradiate
+eradicate
+erase
+erect
+erode
+err
+eruct
+eructate
+erupt
+escalate
+eschew
+escribe
+espouse
+espy
+essentialize
+establish
+esterify
+estivate
+estop
+estrange
+etch
+eternalise
+eternalize
+eternise
+eternize
+etherealise
+etherealize
+etherialise
+etherialize
+etherify
+etherize
+ethicize
+etiolate
+etymologise
+etymologize
+euhemerise
+euhemerize
+eulogise
+eulogize
+eunuchise
+eunuchize
+euphemise
+euphemize
+euphonise
+euphonize
+europeanize
+evacuate
+evade
+evaginate
+evaluate
+evanesce
+evangelise
+evangelize
+evanish
+eventuate
+evert
+evict
+evince
+eviscerate
+evite
+evoke
+evolve
+ewound
+exacerbate
+exact
+exaggerate
+exalt
+examine
+exasperate
+excavate
+excecate
+excel
+except
+excide
+excite
+exclaim
+exclude
+excogitate
+excoriate
+excorticate
+excrete
+excruciate
+exculpate
+excuss
+exec
+execrate
+execute
+exemplify
+exenterate
+exert
+exeunt
+exfoliate
+exhale
+exhilarate
+exhort
+exhume
+exist
+exit
+exonerate
+exorcise
+exorcize
+expand
+expatiate
+expect
+expectorate
+expeditate
+expedite
+expel
+expend
+experimentalize
+expertize
+expiate
+expire
+expiscate
+explain
+explicate
+explode
+explore
+exposit
+expostulate
+expound
+expropriate
+expunge
+expurgate
+exsanguinate
+exscind
+exsect
+exsert
+exsiccate
+exsolve
+extemporise
+extemporize
+extend
+extenuate
+exteriorise
+exteriorize
+exterminate
+extermine
+externalise
+externalize
+extinguish
+extirpate
+extol
+extort
+extradite
+extrapolate
+extravagate
+extricate
+extrude
+exuberate
+exude
+exult
+exuviate
+fabricate
+facilitate
+factorise
+factorize
+fadge
+faff
+fainaigue
+fallen
+falsify
+familiarise
+familiarize
+famish
+fanaticise
+fanaticize
+fancy
+fankle
+fantasize
+faradise
+faradize
+fascinate
+fast
+fasten
+fatigate
+fatten
+fax
+faze
+fecit
+fecundate
+federalise
+federalize
+federate
+feign
+felicitate
+fellate
+feminise
+feminize
+fenagle
+fertilise
+fertilize
+festinate
+fet
+feudalise
+feudalize
+fictionalize
+fictionise
+fictionize
+fidge
+fiercen
+filch
+filiate
+filmset
+fimbriate
+finagle
+finalize
+finedraw
+finest
+fingerpaint
+finick
+finish
+finnick
+firefang
+fireproof
+fishmouth
+fistulize
+fitcher
+fixate
+fixt
+flabbergast
+flatten
+flay
+fledge
+flee
+flench
+flense
+fletch
+fley
+flichter
+flighter
+flitter
+flocculate
+flog
+floodlit
+floreat
+floruit
+flout
+flown
+fluctuate
+fluidise
+fluidize
+flummox
+flung
+fluoresce
+fluoridate
+fluoridise
+fluoridize
+fluorinate
+flusterate
+flustrate
+flyblew
+flyfish
+flyte
+focalise
+focalize
+focus
+foist
+foliate
+foment
+fondle
+foolproof
+footslog
+forbade
+forbbore
+forbborne
+forbid
+forbore
+forborne
+fordid
+fordo
+fordone
+forebode
+foreclose
+foredate
+foredid
+foredo
+foredone
+foredoom
+forefend
+foreffelt
+foregather
+forego
+forejudge
+foreknew
+foreknow
+foreknown
+foreordain
+foreordinate
+foreran
+forereach
+forerun
+foresaw
+foresee
+foreseen
+foreshadow
+foreshorten
+foreshow
+foreshown
+forespeak
+forestall
+foreswear
+foretell
+foretold
+forewarn
+forewent
+forfend
+forgat
+forgather
+forgave
+forget
+forgive
+forgiven
+forgo
+forgone
+forgot
+forgotten
+forjudge
+formalise
+formalize
+formicate
+formulaize
+formularise
+formularize
+formulate
+formulise
+formulize
+formylate
+fornicate
+forsake
+forsaken
+forsook
+forspeak
+forswear
+forswore
+forsworn
+fortify
+forwent
+fossick
+fossilise
+fossilize
+foster
+fought
+fowent
+foxhunt
+fractionate
+fractionise
+fractionize
+frag
+fragmentise
+fragmentize
+frames
+frap
+fraternise
+fraternize
+fraze
+freeboot
+freeload
+freest
+frenchify
+frequent
+freshen
+fress
+frig
+frighten
+frivol
+frizzes
+froze
+frozen
+fructify
+frustrate
+ftp
+fub
+fuck
+fudge
+fugle
+fulfil
+fulfill
+fulgurate
+fulmine
+fumigate
+fundraise
+furbish
+furcate
+furnish
+further
+fustigate
+gainsaid
+gainsay
+galavant
+gallivant
+galumph
+galvanise
+gan
+gasify
+gastrulate
+gaup
+gave
+gawp
+gee
+gelatinate
+gelatinise
+gelatinize
+geminate
+gemmate
+generalise
+generalize
+generate
+genuflect
+geologize
+geometrise
+geometrize
+germinate
+gestate
+gesticulate
+get
+ghettoize
+ghostwrite
+ghostwritten
+ghostwrote
+giddy
+gie
+giftwrap
+gimblet
+gimme
+girt
+glaca
+glace
+glaciate
+gladden
+glamorize
+glamourise
+glamourize
+glean
+glom
+glorify
+glory
+glottalize
+glug
+gluttonise
+gluttonize
+glycerolize
+gnar
+gnawn
+gobble
+goldplate
+gollop
+golly
+gone
+gonna
+goofproof
+gorgonise
+gorgonize
+goster
+got
+gotta
+gotten
+gourmandize
+govern
+grabble
+gradate
+grangerise
+grangerize
+granitize
+granulate
+graphitize
+gratify
+gratinate
+gratulate
+graven
+gravitate
+grav~ing
+greaten
+grew
+grieve
+gript
+grok
+grovel
+grow
+gruntle
+gufought
+gunkhole
+guttle
+gutturalise
+gutturalize
+guzzle
+gwine
+gyrate
+habilitate
+habituate
+had
+hadst
+hae
+haemagglutinate
+haen
+hagride
+hail
+hale
+hallo
+hallow
+hallucinate
+halogenate
+halt
+halve
+hamshackle
+handbuild
+handcolor
+handpick
+handsew
+handstamp
+handwash
+handwrite
+hanker
+happen
+harass
+hark
+harken
+harmonise
+harmonize
+harrumph
+harry
+harshen
+has
+hast
+hasten
+hath
+haw
+headquarter
+heal
+hear
+hearken
+hearten
+heathenise
+heathenize
+hebetate
+hedgehop
+heeze
+heighten
+heize
+held
+help
+hemagglutinate
+henpeck
+heparinize
+hepatectomize
+hepatise
+hepatize
+herbarize
+herborize
+herry
+hesitate
+het
+heterodyne
+hew
+hewn
+hibernate
+hiccough
+hid
+hide
+hie
+hierarchise
+hierarchize
+higgle
+hight
+hightail
+hinder
+hirsle
+hiss
+hitchhike
+hoarsen
+hobnob
+hocus
+hogtie
+hoick
+hoise
+hoke
+holden
+hollo
+holp
+holpen
+homogenize
+homologate
+homologise
+homologize
+hoodwink
+hooray
+hoot
+hoover
+hornswoggle
+horrify
+horripilate
+hospitalize
+hotfoot
+hotter
+hottest
+housebreak
+housebroke
+housebroken
+houseclean
+housekeep
+housekkept
+hove
+hum
+humanise
+humanize
+humble
+humidify
+humiliate
+hung
+hurrah
+hurries
+hurtle
+hush
+huzzah
+hyalinize
+hybridise
+hybridize
+hydrogenise
+hydrogenize
+hydrolise
+hydrolize
+hydrolyse
+hydrolyze
+hygienize
+hyperbolize
+hyperdeify
+hyperemphasize
+hyperimmunize
+hyperoxygenate
+hyperoxygenize
+hyperrealize
+hypersensitise
+hypersensitize
+hyperventilate
+hypervitalize
+hyphenate
+hyphenise
+hyphenize
+hypnotise
+hypnotize
+hypocopy
+hypophysectomise
+hypophysectomize
+hyposensitize
+hypostasise
+hypostasize
+hypostatise
+hypostatize
+hypothecate
+hypothesise
+hypothesize
+hysterectomize
+iarovize
+idealise
+idealize
+identify
+ideologise
+ideologize
+idiotise
+idiotize
+idle
+idolatrise
+idolatrize
+idolise
+idolize
+ignite
+ignore
+illegalise
+illegalize
+illegitimatise
+illegitimatize
+illiberalise
+illiberalize
+illude
+illume
+illumine
+illustrate
+illuviate
+imagine
+imbalm
+imbark
+imbibe
+imbitter
+imbody
+imbolden
+imbosom
+imbower
+imbrangle
+imbricate
+imbrown
+imbrue
+imbrute
+imbue
+imitate
+immaterialise
+immaterialize
+immerge
+immerse
+immesh
+immigrate
+immingle
+immix
+immobilise
+immobilize
+immolate
+immoralise
+immoralize
+immortalise
+immortalize
+immunise
+immunize
+immure
+impair
+impale
+impanel
+imparadise
+impark
+imparl
+impart
+impassion
+impaste
+impawn
+impeach
+impearl
+impede
+impel
+impend
+imperialise
+imperialize
+imperil
+impersonalise
+impersonalize
+impersonate
+impetrate
+impignorate
+impinge
+implead
+implicate
+implode
+implore
+imply
+impolder
+impone
+importune
+impose
+impound
+impoverish
+impower
+imprecate
+impregnate
+imprison
+impropriate
+improvise
+impugn
+impute
+inactivate
+inarch
+inarm
+inaugurate
+inbreathe
+incage
+incandesce
+incapacitate
+incapsulate
+incarcerate
+incardinate
+incarnadine
+incarnalise
+incarnalize
+incarnate
+incase
+incept
+inchoate
+incinerate
+incise
+incite
+inclasp
+inclose
+include
+incommode
+incorporate
+incrassate
+incriminate
+incrust
+incubate
+inculcate
+inculpate
+incumber
+incur
+incurvate
+indagate
+indebt
+indemnify
+indicate
+indict
+indispose
+indite
+individualise
+individualize
+individuate
+indoctrinate
+indoctrinize
+indorse
+induce
+induct
+indue
+indulge
+indurate
+industrialise
+industrialize
+indwell
+indwelt
+inearth
+infamize
+infect
+infeoff
+infer
+infest
+infibulate
+infinitize
+inflame
+inflate
+inflect
+inflict
+infold
+inform
+infract
+infringe
+infuriate
+infuscate
+infuse
+ingather
+ingeminate
+ingenerate
+ingest
+ingraft
+ingratiate
+ingulf
+ingurgitate
+inhabit
+inhale
+inhere
+inherit
+inhibit
+inhume
+initialize
+inject
+injure
+inlace
+inlaw
+inmesh
+innervate
+innerve
+innoculate
+innovate
+inoculate
+inosculate
+inoxidize
+inquiet
+inquire
+insalivate
+inscribe
+inscroll
+insculp
+inseminate
+insheathe
+inshrine
+insinuate
+insist
+insnare
+insolate
+insolubilize
+insoul
+inspan
+inspect
+insphere
+inspire
+inspirit
+inspissate
+instal
+install
+instantiate
+instate
+instigate
+instil
+instill
+institutionalise
+institutionalize
+instruct
+instrumentate
+insufflate
+insularize
+insulate
+insulinize
+insure
+insurrectionise
+insurrectionize
+inswathe
+integrate
+intellectualise
+intellectualize
+intend
+intenerate
+intensify
+inter
+interaccuse
+interact
+interagglutinate
+interagree
+interanimate
+interarch
+interassure
+interblend
+interblent
+intercalate
+intercede
+interchaff
+interchain
+intercharge
+interchase
+intercheck
+interchoke
+intercircle
+intercirculate
+interclasp
+intercloud
+intercolonize
+intercombine
+intercommon
+intercommunicate
+intercompare
+interconfound
+interconnect
+interconvert
+intercorrelate
+intercreate
+intercrust
+intercurl
+intercut
+interdebate
+interdepend
+interdetermine
+interdevour
+interdifferentiate
+interdiffuse
+interdigitate
+interdistinguish
+interembrace
+interentangle
+interfere
+interfile
+interfiltrate
+interflow
+interfold
+interfuse
+intergossip
+intergraft
+intergrapple
+interhybridize
+interindicate
+interinfluence
+interinsert
+interinvolve
+interiorise
+interiorize
+interjaculate
+interject
+interjectionalise
+interjectionalize
+interjoin
+interknit
+interknot
+interlace
+interlaid
+interlain
+interlaminate
+interlap
+interlard
+interleave
+interlibel
+interlie
+interline
+interlineate
+interlocate
+interlope
+interlot
+intermarry
+intermat
+intermaze
+intermeasure
+intermeddle
+intermeet
+intermelt
+intermention
+intermesh
+intermigrate
+intermingle
+intermit
+intermix
+intermmet
+internalise
+internalize
+internationalise
+internationalize
+interoscillate
+interosculate
+interpage
+interpave
+interpeal
+interpellate
+interpenetrate
+interpermeate
+interpervade
+interplait
+interplant
+interplead
+interpledge
+interplight
+interpolate
+interpolish
+interpollinate
+interpose
+interpour
+interpret
+interproduce
+interquarrel
+interradiate
+interran
+interreceive
+interreflect
+interreign
+interrelate
+interresist
+interrhyme
+interrogate
+interrule
+interrun
+intersalute
+interscribe
+intersect
+interseminate
+interset
+intershade
+intershock
+intershoot
+intersituate
+intersoil
+intersole
+intersperse
+intersprinkle
+intersqueeze
+intersshot
+interstimulate
+interstratify
+interstreak
+interstrive
+interstriven
+interstrove
+intertalk
+intertangle
+intertinge
+intertouch
+intertrace
+intervary
+intervein
+intervene
+intervisit
+intervolve
+interwar
+interweld
+interwhiff
+interwhistle
+interwind
+interwork
+interwound
+interwove
+interwoven
+interwrap
+interwreathe
+interwwrought
+inthral
+inthrall
+inthrone
+intimidate
+intitle
+intitule
+intomb
+intonate
+intone
+intort
+intoxicate
+intransitivize
+intreat
+intrench
+introduce
+intromit
+introspect
+intrude
+intrust
+intubate
+intuit
+intumesce
+intussuscept
+intwine
+intwist
+inundate
+inure
+inurn
+invade
+invaginate
+invalidate
+inveigh
+inveigle
+invent
+invest
+investigate
+invigilate
+invigorate
+invocate
+invoke
+involve
+inweave
+inwind
+inwrap
+inwreathe
+iodinate
+iodise
+ionate
+ionise
+ionize
+iridectomise
+iridectomize
+iridesce
+iridize
+irk
+ironize
+irradiate
+irrate
+irrationalise
+irrationalize
+irrigate
+irritate
+irrupt
+is
+isochronize
+isolate
+isomerize
+italicize
+itemize
+iterate
+itinerate
+iwound
+jactitate
+jaculate
+jampack
+jargonise
+jargonize
+jarovize
+jarp
+jauk
+jaywalk
+jee
+jellify
+jemmies
+jeopardise
+jeopardize
+jigsawn
+jinglejangle
+join
+jollify
+journalise
+journalize
+joypop
+jubilate
+jugulate
+jump
+jumpstart
+justify
+justle
+juxtapose
+kaolinise
+kaolinize
+katalyze
+keelhaul
+kep
+keppen
+kept
+keratinize
+keypunch
+kibbitz
+kibitz
+kidnap
+kindle
+kippen
+kithe
+kittle
+kittler
+kittlest
+knead
+knelt
+knew
+kvetch
+kyanise
+kyanize
+kyoodle
+kythe
+labialise
+labialize
+labilize
+labiovelarise
+labiovelarize
+lacerate
+lactonize
+lade
+laden
+ladyfy
+laicise
+laicize
+laid
+laik
+lain
+lall
+lallygag
+lambast
+lambaste
+landslid
+landslidden
+languish
+laparotomize
+lapidate
+lapidify
+largen
+larn
+larrup
+laryngectomize
+lase
+latensify
+latinise
+latinize
+lave
+laveer
+lavish
+leant
+leapt
+learn
+learnt
+legalise
+legalize
+legendize
+legislate
+legitimate
+legitimatise
+legitimatize
+legitimise
+legitimize
+lend
+lengthen
+lenify
+lenticulate
+lessen
+lethargise
+lethargize
+letterspace
+levigate
+levitate
+lexicalize
+liaise
+liberalise
+liberalize
+liberate
+librate
+lichenise
+lichenize
+ligate
+lighten
+lignify
+liken
+limn
+linearise
+linearize
+linger
+lionise
+lionize
+lipread
+liquate
+liquefy
+liquesce
+liquidate
+liquidise
+liquidize
+liquify
+listen
+literalise
+literalize
+litigate
+live
+liven
+lixiviate
+load
+loathe
+localise
+localize
+locate
+locomote
+logicise
+logicize
+login
+logroll
+loiter
+lollop
+lollygag
+loosen
+loosest
+lose
+louden
+lour
+lowe
+lowse
+lubricate
+lucubrate
+lumine
+luminesce
+lustrate
+luteinize
+luxate
+luxuriate
+lynch
+lyophilize
+lyricise
+lyricize
+lyse
+macadamize
+macerate
+machicolate
+machinate
+macrame
+maculate
+mad
+madden
+made
+maffick
+maffle
+magnetise
+magnetize
+magnify
+mainline
+maintain
+make
+maladminister
+maledict
+malign
+malinger
+malleablize
+malleate
+maltreat
+mammer
+man
+manducate
+manent
+manet
+manhandle
+manipulate
+manouevre
+manumit
+marage
+marbelize
+marbleize
+marginate
+marinate
+maringue
+marry
+marsupialise
+marsupialize
+martemper
+martyrise
+martyrize
+masculinize
+masticate
+masturbate
+materialise
+materialize
+maternalise
+maternalize
+matronize
+maturate
+mature
+maun
+maunder
+maximize
+mayest
+mayst
+meant
+mechanize
+meddle
+mediate
+mediatise
+mediatize
+medicate
+meditate
+melanize
+mellow
+melodize
+melodramatise
+melodramatize
+memorialise
+memorialize
+memorize
+menstruate
+meow
+mercerize
+mercurate
+mercurialise
+mercurialize
+mercurify
+merge
+meseems
+mesmerize
+met
+metabolise
+metabolize
+metallise
+metallize
+metamorphose
+metaphysicize
+metastasize
+metathesize
+methinks
+methodise
+methodize
+methought
+metricate
+metricise
+metricize
+metrify
+metrize
+miaou
+miaul
+mibound
+miche
+micrify
+microminiaturize
+micturate
+migrate
+milden
+mildewproof
+militarise
+militarize
+militate
+mimeo
+mineralise
+mineralize
+mingle
+miniate
+miniaturise
+miniaturize
+minify
+minimise
+minimize
+misact
+misadapt
+misadd
+misaddress
+misaddrest
+misadjust
+misadvise
+misadvize
+misallege
+misallot
+misally
+misalphabetize
+misanalyze
+misapply
+misappoint
+misappraise
+misapprehend
+misappropriate
+misarticulate
+misassert
+misassign
+misauthorize
+misaver
+misaward
+misbecame
+misbecome
+misbehave
+misbelieve
+misbestow
+misbill
+misbind
+misbrand
+misbrew
+misbuild
+misbuilt
+miscalculate
+miscall
+miscarry
+miscast
+miscategorize
+misce
+miscegenate
+miscensure
+mischaracterize
+mischarge
+mischoose
+misclaim
+misclass
+misclassify
+miscoin
+miscompute
+misconceive
+misconjecture
+misconjugate
+misconstrue
+miscounsel
+miscreate
+miscut
+misdealt
+misdeem
+misdefine
+misdeliver
+misdemean
+misderive
+misdescribe
+misdid
+misdirect
+misdivide
+misdo
+misdone
+misdoubt
+misdraw
+misdrawn
+misdrew
+misedit
+miseducate
+misemphasize
+misesteem
+misfield
+misfile
+misfocus
+misform
+misframe
+misfunction
+misgauge
+misgave
+misgive
+misgiven
+misgovern
+misgrade
+misgraft
+misguage
+misguide
+mishandle
+mishear
+misidentify
+misinfer
+misinform
+misinstruct
+misintend
+misinterpret
+misjoin
+misjudge
+misknew
+misknow
+misknown
+mislabel
+mislaid
+mislay
+mislead
+mislearn
+mislocate
+mismade
+mismake
+mismanage
+mismarry
+mismate
+mismeasure
+mismount
+misname
+misnarrate
+misnavigate
+misnumber
+misoccupy
+misorganize
+mispage
+misparse
+mispatch
+misperceive
+misperform
+misphrase
+misplace
+misplant
+misplead
+mispresent
+misprise
+misprize
+misproduce
+mispronounce
+mispropose
+misprovoke
+mispunctuate
+mispurchase
+misqualify
+misquote
+misrate
+misread
+misrecollect
+misrefer
+misreflect
+misreform
+misregulate
+misrehearse
+misrelate
+misrely
+misremember
+misrender
+misrepresent
+misreprint
+misreward
+missample
+missang
+misseat
+misseem
+missend
+missent
+misship
+missort
+missound
+misspace
+misspeak
+misspell
+misspend
+misspoke
+misspoken
+misstart
+misstate
+missteer
+misstyle
+missung
+missuppose
+missyllabify
+mistaught
+misteach
+misterm
+misthread
+misthrew
+misthrow
+misthrown
+mistime
+mistitle
+mistook
+mistrace
+mistranscribe
+mistranslate
+mistreat
+mistryst
+mistune
+mistutor
+mistype
+misunderstand
+misvalue
+miswire
+misword
+misworship
+miswrite
+miswritten
+miswrote
+miszone
+mitch
+mithridatise
+mithridatize
+mitigate
+mittatur
+mixt
+mobilise
+mobilize
+modernise
+modernize
+modge
+modify
+modulate
+moisten
+moisturize
+moither
+molest
+mollify
+molten
+monetize
+mongrelise
+mongrelize
+monologuize
+monophthongize
+monopolise
+monopolize
+monotonize
+monumentalise
+monumentalize
+moo
+mooch
+moos
+moralise
+moralize
+mortify
+mosey
+mosh
+mothproof
+motivate
+motorise
+motorize
+mourn
+mown
+mudcap
+mudwrestle
+multigraph
+multiply
+mumm
+mummify
+mump
+munch
+mundify
+municipalise
+municipalize
+munite
+murdabad
+mure
+mussitate
+mutate
+mutilate
+mutualise
+mutualize
+muzz
+mysticize
+mystify
+mythicise
+mythicize
+mythify
+mythologize
+mythopoetise
+mythopoetize
+nab
+namedrop
+naphthalise
+naphthalize
+narcotise
+narcotize
+narrate
+nasale
+nasalise
+nasalize
+nationalize
+naturalize
+nauseate
+navigate
+nazify
+neaten
+nebulise
+nebulize
+necessitate
+necrose
+necrotise
+necrotize
+nectarise
+nectarize
+negate
+negociate
+negotiate
+neologise
+neologize
+neoterize
+nephrectomise
+nephrectomize
+nesslerise
+nesslerize
+netmail
+neutralize
+nickelise
+nickelize
+nicotinise
+nicotinize
+nictate
+nictitate
+nidificate
+nidify
+nig
+niggardise
+niggardize
+niggle
+nigrify
+nill
+nitpick
+nitrify
+nitrogenise
+nitrogenize
+nix
+nobble
+nomadise
+nomadize
+nominalize
+nominate
+normalise
+normalize
+nosedive
+notarize
+notate
+notify
+nourish
+novelise
+novelize
+nucleate
+nullify
+numb
+numerate
+nutate
+nutrify
+nuzzle
+o.d.
+obduce
+obelise
+obelize
+obey
+obfuscate
+objectify
+objectivize
+objurgate
+obligate
+oblige
+obliterate
+obnounce
+obnubilate
+obsecrate
+observe
+obsess
+obsolesce
+obtain
+obtest
+obtrude
+obturate
+obumbrate
+obvert
+obviate
+occidentalize
+occlude
+occupy
+occur
+odorize
+offend
+officialize
+officiate
+offsaddle
+oink
+ok
+omit
+onlaid
+ontologise
+oophorectomize
+opacify
+opalesce
+opalize
+ope
+open
+operate
+operatize
+opine
+oppilate
+oppose
+oppress
+oppugn
+opsonize
+opt
+optimize
+orate
+orchestrate
+ordain
+order
+organise
+organize
+orientalize
+orientate
+originate
+orthogonalize
+orthographise
+orthographize
+oscillate
+osculate
+ossify
+ostracize
+oufought
+oust
+out
+outact
+outambush
+outargue
+outawe
+outbabble
+outbake
+outbalance
+outban
+outbanter
+outbar
+outbargain
+outbark
+outbarter
+outbat
+outbatter
+outbawl
+outbeam
+outbeg
+outbelch
+outbellow
+outbend
+outbent
+outbetter
+outbid
+outbidden
+outblaze
+outbleat
+outbless
+outblew
+outbloom
+outblossom
+outblot
+outblow
+outblown
+outbluff
+outblunder
+outblush
+outbluster
+outboast
+outbow
+outbowl
+outbox
+outbrag
+outbranch
+outbrave
+outbray
+outbrazen
+outbreathe
+outbribe
+outbridge
+outbrought
+outbud
+outbuild
+outbuilt
+outbulge
+outbulk
+outbully
+outburn
+outbustle
+outbuzz
+outcall
+outcant
+outcaper
+outcarol
+outcavil
+outcharm
+outchase
+outchatter
+outcheat
+outchide
+outclamor
+outclass
+outcompass
+outcompliment
+outcourt
+outcrawl
+outcreep
+outcrept
+outcricket
+outcrow
+outcull
+outcure
+outcurse
+outcut
+outdance
+outdare
+outdate
+outdazzle
+outdespatch
+outdevil
+outdid
+outdispatch
+outdistance
+outdo
+outdodge
+outdrank
+outdraw
+outdrawn
+outdress
+outdrew
+outdrink
+outdrive
+outdriven
+outdrove
+outdwell
+outdwelt
+outeat
+outeate
+outeaten
+outecho
+outedge
+outequivocate
+outfable
+outface
+outfame
+outfast
+outfawn
+outfeast
+outfence
+outferret
+outfight
+outfigure
+outfish
+outflame
+outflank
+outflare
+outflash
+outflatter
+outflee
+outflew
+outfloat
+outflourish
+outflown
+outflung
+outfly
+outfool
+outfoot
+outfox
+outfroth
+outfrown
+outgabble
+outgain
+outgallop
+outgamble
+outgame
+outgas
+outgaze
+outgeneral
+outglare
+outgleam
+outglitter
+outgloom
+outglow
+outgnaw
+outgone
+outgreen
+outgrew
+outgrin
+outgrow
+outgrown
+outguess
+outgun
+outgush
+outhammer
+outhasten
+outhear
+outhire
+outhiss
+outhit
+outhorror
+outhowl
+outhumor
+outhunt
+outhurl
+outhyperbolize
+outinvent
+outissue
+outjest
+outjet
+outjinx
+outjockey
+outjourney
+outjuggle
+outjump
+outjut
+outkick
+outkill
+outkiss
+outlabor
+outlaid
+outlance
+outlash
+outlast
+outlaugh
+outlaunch
+outlead
+outleap
+outlearn
+outlengthen
+outlighten
+outlimn
+outlinger
+outlip
+outlive
+outlove
+outluster
+outmalaprop
+outman
+outmaneuver
+outmaneuvre
+outmanoeuvre
+outmarch
+outmarry
+outmaster
+outmatch
+outmate
+outmeasure
+outmode
+outmount
+outmouth
+outmove
+outnumber
+outpace
+outpaint
+outpass
+outpeep
+outpeople
+outperform
+outpick
+outpipe
+outpitch
+outpity
+outplan
+outplay
+outplease
+outplod
+outplot
+outpoint
+outpoison
+outpoll
+outpop
+outpopulate
+outpractice
+outpraise
+outpray
+outpreen
+outprice
+outproduce
+outpromise
+outpry
+outpull
+outpurl
+outpursue
+outpush
+outquaff
+outquery
+outquestion
+outquibble
+outquote
+outrace
+outrail
+outran
+outrang
+outrange
+outrank
+outrant
+outrap
+outrate
+outrave
+outread
+outreason
+outreckon
+outredden
+outreign
+outrhyme
+outrib
+outrick
+outridden
+outrig
+outrival
+outroar
+outrode
+outrogue
+outromance
+outroot
+outrove
+outrow
+outrun
+outrung
+outsaid
+outsail
+outsaint
+outsally
+outsang
+outsat
+outsatisfy
+outsavor
+outsaw
+outsay
+outscent
+outscold
+outscore
+outscorn
+outscream
+outsearch
+outsee
+outseek
+outseen
+outsell
+outshame
+outshape
+outshine
+outshone
+outshoulder
+outshout
+outshove
+outshow
+outshower
+outshown
+outshriek
+outshrill
+outsift
+outsigh
+outsin
+outsit
+outskill
+outskip
+outskirmish
+outslander
+outslang
+outslid
+outslide
+outslink
+outsmart
+outsmell
+outsmile
+outsnatch
+outsnore
+outsoar
+outsold
+outsonet
+outsophisticate
+outsought
+outsound
+outsparkle
+outspat
+outspeak
+outspell
+outspill
+outspin
+outspirit
+outspit
+outsplendor
+outspoke
+outsport
+outsprang
+outsprint
+outsprue
+outspurn
+outspurt
+outspy
+outstagger
+outstand
+outstank
+outstare
+outstartle
+outstate
+outstature
+outstay
+outsteal
+outsteam
+outstep
+outstink
+outstole
+outstolen
+outstood
+outstorm
+outstrain
+outstream
+outstretch
+outstridden
+outstride
+outstrike
+outstrip
+outstrive
+outstriven
+outstrode
+outstrove
+outstruck
+outstrut
+outstudy
+outstung
+outstunt
+outsuck
+outsuffer
+outsulk
+outsum
+outsung
+outswagger
+outswam
+outswarm
+outswear
+outsweep
+outsweeten
+outswim
+outswindle
+outswirl
+outswum
+outswung
+outtalk
+outtear
+outtease
+outtell
+outthieve
+outthink
+outthought
+outthreaten
+outthrew
+outthrob
+outthrown
+outthunder
+outthwack
+outtinkle
+outtire
+outtoil
+outtold
+outtongue
+outtower
+outtrade
+outtravel
+outtrick
+outtrot
+outtrump
+outttore
+outttorn
+outtyrannize
+outvalue
+outvanish
+outvaunt
+outvelvet
+outvenom
+outvictor
+outvie
+outvigil
+outvociferate
+outvoice
+outvote
+outvoyage
+outwait
+outwalk
+outwallop
+outwander
+outwar
+outwarble
+outwaste
+outwater
+outwave
+outwear
+outweary
+outweave
+outweep
+outweigh
+outwell
+outwent
+outwhirl
+outwiggle
+outwile
+outwill
+outwind
+outwish
+outwit
+outword
+outworn
+outwrangle
+outwrench
+outwrestle
+outwriggle
+outwrite
+outwrung
+outwwept
+outwwove
+outwwoven
+outyell
+outyelp
+outyield
+ovariectomize
+ovenbake
+overabound
+overabsorb
+overabstain
+overabuse
+overaccelerate
+overaccentuate
+overaccumulate
+overachieve
+overact
+overactivate
+overadorn
+overadvance
+overaffirm
+overafflict
+overaggravate
+overagitate
+overalcoholize
+overallegorize
+overanalyze
+overannotate
+overapplaud
+overappraise
+overarch
+overargue
+overassert
+overassess
+overassume
+overate
+overattenuate
+overawe
+overbait
+overbake
+overballast
+overbank
+overbbore
+overbborne
+overbear
+overbill
+overblame
+overblanch
+overbleach
+overblow
+overboil
+overbook
+overborrow
+overbought
+overbrace
+overbrag
+overbrake
+overbroaden
+overbroil
+overbrown
+overbrowse
+overbrush
+overbrutalize
+overbuild
+overbuilt
+overcame
+overcapitalise
+overcapitalize
+overcensor
+overcentralize
+overchafe
+overchase
+overcherish
+overchill
+overcivilize
+overclaim
+overclog
+overclothe
+overcloud
+overcloy
+overclutter
+overcolor
+overcome
+overcommend
+overcommercialize
+overcompensate
+overcomplicate
+overconcentrate
+overcondense
+overconsume
+overcontract
+overcontribute
+overcook
+overcorrect
+overcorrupt
+overcredit
+overcriticize
+overcrop
+overcrowd
+overcull
+overcultivate
+overcumber
+overdazzle
+overdeal
+overdebate
+overdebilitate
+overdecorate
+overdedicate
+overdeepen
+overdeliberate
+overdepress
+overderide
+overdescribe
+overdevelop
+overdid
+overdiffuse
+overdigest
+overdignify
+overdilate
+overdilute
+overdiscipline
+overdiscount
+overdiscourage
+overdiscuss
+overdistend
+overdistort
+overdiversify
+overdo
+overdomesticate
+overdominate
+overdone
+overdoubt
+overdoze
+overdrain
+overdramatize
+overdraw
+overdredge
+overdrink
+overdriven
+overdrove
+overdye
+overeat
+overeate
+overeaten
+overedit
+overeditorialize
+overeducate
+overelate
+overembellish
+overembroider
+overemotionalize
+overemphasize
+overemploy
+overemulate
+overexaggerate
+overexcite
+overexercise
+overexert
+overexpand
+overexpect
+overexpend
+overexplain
+overexpose
+overexpress
+overextend
+overeye
+overfag
+overfatigue
+overfatten
+overfavor
+overfeast
+overfeel
+overfeminize
+overfill
+overfilter
+overfish
+overfix
+overflatten
+overflavor
+overflew
+overflog
+overflood
+overflour
+overflown
+overfly
+overfondle
+overformalize
+overfreight
+overfrighten
+overfurnish
+overgamble
+overgarnish
+overgarrison
+overgeneralise
+overgeneralize
+overgesticulate
+overgild
+overgilt
+overgird
+overglance
+overglut
+overgoad
+overgorge
+overgovern
+overgrade
+overgratify
+overgraze
+overgrew
+overgrieve
+overgrow
+overgrown
+overhand
+overhandicap
+overhandle
+overharass
+overharden
+overhasten
+overheap
+overhear
+overhonor
+overhumanize
+overhung
+overhunt
+overhurry
+overidealize
+overidentify
+overillustrate
+overimitate
+overimmunize
+overimport
+overimpose
+overimpress
+overincline
+overindulge
+overindustrialize
+overinflate
+overinfluence
+overinhibit
+overinsist
+overinstruct
+overinsure
+overintellectualize
+overintensify
+overinvest
+overinvolve
+overiodize
+overirrigate
+overjade
+overjoy
+overkick
+overlactate
+overlaid
+overlain
+overland
+overlard
+overlather
+overlaud
+overleap
+overlearn
+overlegislate
+overliberalize
+overlie
+overlimit
+overlinger
+overlive
+overloan
+overlove
+overlubricate
+overmagnify
+overmanage
+overmarch
+overmaster
+overmeddle
+overmelt
+overmerit
+overmill
+overmitigate
+overmix
+overmobilize
+overmodernize
+overmodify
+overmoisten
+overmonopolize
+overmoralize
+overmortgage
+overmourn
+overmultiply
+overmystify
+overnationalize
+overneglect
+overneutralize
+overnormalize
+overnourish
+overnurse
+overobject
+overobjectify
+overoffend
+overornament
+overoxidize
+overpack
+overpaid
+overpamper
+overpark
+overpay
+overpenalize
+overpeople
+overpersecute
+overpersuade
+overpet
+overphilosophize
+overpictorialize
+overpitch
+overplant
+overplay
+overplease
+overplow
+overply
+overpoeticize
+overpolice
+overpolish
+overpollinate
+overpopulate
+overpower
+overpratice
+overpreoccupy
+overpress
+overprice
+overprize
+overproduce
+overpromise
+overpronounce
+overprotect
+overprotract
+overprove
+overprovide
+overprovoke
+overprune
+overpsychologize
+overpublicize
+overpunish
+overpurchase
+overqualify
+overrake
+overran
+overrank
+overrate
+overrationalize
+overreach
+overreact
+overreduce
+overrefine
+overregiment
+overregulate
+overrelax
+overrepresent
+overrepress
+overreprimand
+overresist
+overrestrain
+overrestrict
+overreward
+overripen
+overroast
+overromanticize
+overrule
+oversalt
+oversate
+oversaturate
+oversaw
+overscore
+overscrub
+overscruple
+overseason
+oversecrete
+oversecure
+oversee
+overseen
+oversell
+oversensitize
+oversentimentalize
+overset
+oversettle
+oversew
+oversewn
+overshade
+overshadow
+overshine
+overshone
+overshorten
+overshrink
+oversimplify
+oversleep
+overslept
+overslip
+overslipt
+oversoak
+oversoap
+oversocialize
+oversoften
+oversold
+oversolidify
+overspecialize
+overspeculate
+overspend
+overspice
+overspilt
+overspread
+oversshot
+overstaff
+overstarch
+overstate
+overstay
+oversteer
+overstep
+overstiffen
+overstimulate
+overstir
+overstore
+overstraighten
+overstrengthen
+overstress
+overstretch
+overstridden
+overstride
+overstrike
+overstrive
+overstriven
+overstrode
+overstrove
+overstuff
+oversubscribe
+oversup
+oversystematize
+overtake
+overtask
+overtaught
+overtax
+overteach
+overtheorize
+overthrong
+overtinsel
+overtipple
+overtire
+overtoil
+overtook
+overtop
+overtorture
+overtrade
+overtrim
+overtrouble
+overtrump
+overtrust
+overtwist
+overunionize
+overurbanize
+overurge
+overvalue
+overvary
+overventilate
+overwatch
+overweary
+overween
+overweigh
+overwet
+overwhelm
+overwhip
+overwind
+overwinter
+overwore
+overworn
+overwrite
+overwrote
+overwwrought
+ovewound
+oviposit
+ovulate
+owe
+own
+oxidate
+oxidise
+oxidize
+oxigenise
+oxygenize
+ozonize
+pacificate
+pacify
+paganise
+paganize
+paginate
+paid
+palatalise
+palatalize
+palladinize
+palladiumize
+palladize
+palliate
+palpate
+palpebrate
+palpitate
+palter
+pamper
+pamphletize
+panegyrize
+parabolise
+parabolize
+paraffinize
+parallelise
+parallelize
+paralyse
+paralyze
+parasitize
+parathyroidectomize
+parboil
+parch
+parchmentize
+pardi
+pardon
+pare
+parenthesize
+parochialise
+parries
+parse
+partake
+partaken
+partialise
+particularise
+particularize
+partook
+pass
+pasteurise
+pasteurize
+pastoralize
+patinate
+patinize
+patronise
+patronize
+pauperise
+pauperize
+pave
+pectize
+peculate
+peculiarise
+peculiarize
+peddle
+pedestrianise
+pedestrianize
+peduncular
+peise
+pelorize
+penalise
+penalize
+pend
+penetrate
+peninsulate
+pent
+pepsinate
+peptize
+peptonise
+peptonize
+perambulate
+perceive
+perchlorinate
+percuss
+perdure
+peregrinate
+perennate
+perfectivise
+perforate
+perform
+perfuse
+perhydrogenize
+perish
+peritonealize
+perjure
+perjurious
+permeate
+permutate
+permute
+perorate
+peroxidize
+perpetrate
+perpetuate
+perplex
+persecute
+persevere
+persist
+personalize
+personate
+personify
+perspire
+persuade
+pertain
+perturb
+peruse
+pervade
+pester
+petrify
+pettifog
+pettle
+phagocytize
+phagocytose
+phenomenalize
+phenomenize
+philander
+philanthropise
+philanthropize
+philosophise
+philosophize
+phlebotomise
+phlebotomize
+phonate
+phonemicize
+phosphatise
+phosphatize
+phosphorate
+phosphoresce
+phosphorise
+phosphorylate
+photocompose
+photoengrave
+photosensitize
+photoset
+photostat
+photosynthesize
+phrenogrady
+piala
+pickeer
+pictorialise
+picturize
+pigstick
+pilfer
+pimproll
+pinge
+pinkify
+pish
+pize
+placate
+plagiarise
+plagiarize
+planish
+plasmolyse
+plasticise
+plasticize
+platinise
+platinize
+platitudinise
+platitudinize
+playact
+pleach
+plead
+please
+plebeianise
+plebeianize
+plenish
+plim
+ploat
+plonk
+plop
+plunk
+pluralise
+pluralize
+poach
+podsolize
+podzolize
+poeticise
+poeticize
+poetize
+poind
+polarize
+polemicise
+polemicize
+polemize
+politicalize
+politicise
+politicize
+politick
+pollinate
+pollinize
+pollute
+polychromatic
+polychromize
+polymerize
+ponder
+pop
+popple
+popularise
+popularize
+populate
+porcelainize
+porphyrize
+porrect
+portend
+portray
+poss
+possess
+post
+postdate
+postheat
+postmultiply
+postpone
+postsign
+posturise
+posturize
+potentiate
+powderize
+powdery
+powerwash
+practise
+praelect
+pray
+preabsorb
+preaccept
+preaccommodate
+preaccomplish
+preaccount
+preaccredit
+preaccumulate
+preaccuse
+preaccustom
+preach
+preachify
+preacknowledge
+preacquaint
+preacquire
+preacquit
+preact
+preadapt
+preadhere
+preadjourn
+preadjust
+preadmire
+preadmit
+preadmonish
+preadopt
+preadorn
+preadvertise
+preadvise
+preaffect
+preaffirm
+preafflict
+preage
+preaggravate
+preagitate
+preagree
+preallege
+preallot
+preallow
+preallude
+prealter
+preannex
+preannounce
+preanticipate
+preapply
+preappoint
+preapprise
+preapprize
+preapprove
+prearm
+prearrange
+prearrest
+preascertain
+preassemble
+preassert
+preassign
+preassume
+preassure
+preattune
+preaver
+prebade
+prebalance
+preballot
+prebargain
+prebelieve
+prebenefit
+prebeset
+prebestow
+prebetray
+prebill
+prebless
+preboil
+prebreathe
+preburn
+precalculate
+precapture
+precast
+precchose
+precchosen
+precede
+precelebrate
+precensure
+precertify
+precess
+prechallenge
+precharge
+prechart
+prechill
+prechloroform
+prechoose
+precirculate
+precite
+preclassify
+preclean
+preclose
+preclothe
+preclude
+precogitate
+precognize
+precoil
+precollapse
+precollect
+precollude
+precombine
+precommit
+precommune
+precommunicate
+precompare
+precompel
+precompensate
+precompile
+precomplicate
+precompound
+precomprehend
+precompress
+preconceal
+preconcede
+preconceive
+preconcentrate
+preconcert
+preconclude
+preconcur
+precondemn
+precondense
+preconduct
+preconfer
+preconfess
+preconfide
+preconfigure
+preconfine
+preconfirm
+preconform
+preconfound
+preconfuse
+precongratulate
+preconize
+preconjecture
+preconquer
+preconsecrate
+preconsider
+preconsign
+preconsolidate
+preconspire
+preconstitute
+preconstruct
+preconsult
+preconsume
+precontain
+precontemn
+precontemplate
+precontend
+precontribute
+precontrive
+preconvert
+preconvey
+preconvict
+preconvince
+precook
+precool
+precorrect
+precorrespond
+precorrupt
+precover
+precredit
+precriticize
+precultivate
+predamn
+predate
+predeceive
+predecide
+predeclare
+predecline
+predecree
+prededicate
+prededuct
+predefend
+predefine
+predefray
+predefy
+predeliberate
+predelineate
+predeliver
+predelude
+predemand
+predemonstrate
+predeny
+predeplete
+predepreciate
+predeprive
+prederive
+predescend
+predescribe
+predesert
+predeserve
+predesign
+predesignate
+predestinate
+predestine
+predestroy
+predetach
+predetail
+predetain
+predetect
+predetermine
+predevelop
+predevise
+predevour
+predict
+predictate
+predigest
+prediminish
+predine
+predirect
+predisagree
+prediscern
+prediscipline
+predisclose
+prediscourage
+prediscover
+prediscriminate
+prediscuss
+predismiss
+predisperse
+predisplace
+predispose
+predisrupt
+predissolve
+predissuade
+predistinguish
+predistribute
+predisturb
+predivert
+predivide
+predominate
+predonate
+predoom
+predraw
+predrawn
+predrew
+predrill
+predrive
+predriven
+predrove
+predry
+preduplicate
+predwell
+preedit
+preeducate
+preelect
+preeliminate
+preembarrass
+preembody
+preemploy
+preemptive
+preenable
+preenact
+preenclose
+preencourage
+preendorse
+preenforce
+preengage
+preenjoy
+preenlarge
+preenlighten
+preenlist
+preenroll
+preentail
+preenter
+preentertain
+preentitle
+preenumerate
+preenvelop
+preequip
+preerect
+preerupt
+preestablish
+preesteem
+preevade
+preevaporate
+preexact
+preexamine
+preexcept
+preexchange
+preexcite
+preexclude
+preexcuse
+preexecute
+preexempt
+preexhaust
+preexist
+preexpand
+preexpect
+preexpend
+preexplain
+preexplode
+preexpose
+preexpound
+preexpress
+preextend
+preextinguish
+preextract
+prefabricate
+prefer
+prefertilize
+preffroze
+preffrozen
+prefigure
+prefinance
+preflatter
+preforgave
+preforgive
+preforgiven
+preformulate
+prefreeze
+prefulfill
+prefurnish
+pregain
+pregalvanize
+pregather
+pregenerate
+pregrade
+pregratify
+pregreet
+preguard
+preguide
+prehandle
+preharden
+preheal
+preheat
+prehend
+prehesitate
+preidentify
+preilluminate
+preillustrate
+preimagine
+preimbibe
+preimbue
+preimitate
+preimpair
+preimpart
+preimpose
+preimpress
+preimprove
+preinaugurate
+preincline
+preinclude
+preincorporate
+preindemnify
+preindicate
+preindispose
+preinduce
+preindulge
+preinfect
+preinfer
+preinflict
+preinform
+preinhabit
+preinhere
+preinherit
+preinitial
+preinscribe
+preinsert
+preinsinuate
+preinspect
+preinspire
+preinstall
+preinstill
+preinstruct
+preinsulate
+preinsult
+preinsure
+preintend
+preintercede
+preinterpret
+preintimate
+preinvent
+preinvest
+preinvestigate
+preinvite
+preinvolve
+preisolate
+prejudge
+prejustify
+prekindle
+preknew
+preknit
+preknow
+preknown
+prelaunch
+prelect
+preliberate
+prelimitate
+preliquidate
+prelocate
+premade
+premaintain
+premake
+premanifest
+premanufacture
+premarry
+premeasure
+premedicate
+premeditate
+premerit
+premiate
+premillennialise
+premillennialize
+preminister
+premisrepresent
+premodel
+premodify
+premonish
+premonopolize
+premortify
+premuster
+prenecessitate
+preneglect
+prenegotiate
+prenominate
+prenote
+prenotify
+preobject
+preobligate
+preoblige
+preobserve
+preobstruct
+preobtain
+preobtrude
+preobviate
+preoccupy
+preoccur
+preoffend
+preomit
+preopen
+preoperate
+preoppose
+preoppress
+preordain
+preorganize
+preoutfit
+preoverthrew
+preoverthrown
+prepackage
+prepare
+prepartake
+prepartaken
+prepartook
+prepave
+prepay
+prepenetrate
+prepersuade
+preperuse
+preplace
+preplan
+preplant
+prepledge
+preplot
+preponderate
+preportray
+prepossess
+prepractice
+prepractise
+preprice
+preprofess
+prepromote
+prepronounce
+preprove
+preprovide
+preprovoke
+prepublish
+prepunish
+prepurpose
+prequalify
+prequestion
+prequote
+prerealize
+prereceipt
+prereceive
+prerecite
+prereckon
+prerecognize
+prerecommend
+prereconcile
+prerecord
+preredeem
+prerefer
+prerefine
+prerefuse
+preregister
+preregulate
+prereject
+prerejoice
+prerelate
+preremit
+preremove
+preremunerate
+prerent
+prerepresent
+prerequire
+preresemble
+preresolve
+preresort
+prerespire
+prerestrain
+prerestrict
+prereveal
+prerevise
+preroute
+presanctify
+presatisfy
+presaw
+prescind
+prescribe
+prescriptivist
+presecure
+presee
+preseen
+presentence
+preseparate
+preset
+presettle
+presharpen
+preship
+preshorten
+preshow
+preside
+presift
+presignify
+presmooth
+presolicit
+presolve
+prespecialize
+prespecify
+prespeculate
+prespread
+presprinkle
+prespur
+pressurize
+prestandardize
+presteam
+prestimulate
+prestraighten
+prestrengthen
+prestress
+prestudy
+presubdue
+presubject
+presubmit
+presubordinate
+presubscribe
+presubsist
+presubstitute
+presuffer
+presuggest
+presume
+presupervise
+presupplicate
+presuppose
+presuppress
+presurround
+presuspect
+presuspend
+presustain
+presympathize
+pretabulate
+pretaught
+preteach
+pretell
+pretempt
+pretend
+pretermit
+pretestify
+prethreaten
+pretire
+pretold
+pretorture
+pretrain
+pretransact
+pretranscribe
+pretranslate
+pretransmit
+pretransport
+pretry
+prettify
+pretypify
+preunderstand
+preunderstood
+preundertake
+preundertaken
+preundertook
+preunite
+preutilize
+prevacate
+prevaccinate
+prevail
+prevalue
+prevaricate
+prevent
+preverify
+previolate
+previse
+prevoid
+prewarm
+prewarn
+preweigh
+prewhip
+prewire
+prewrap
+pries
+prim
+primp
+prink
+print
+prioritize
+privatize
+proclaim
+procrastinate
+procreate
+procure
+profane
+profess
+professionalise
+professionalize
+prognosticate
+prohibit
+proletarianise
+proletarise
+proletarize
+proliferate
+prologise
+prologize
+prologos
+prologuise
+prologuize
+prolong
+prolongate
+promote
+promulgate
+promulge
+pronate
+pronk
+pronominalize
+pronounce
+proofread
+propagandise
+propagandize
+propagate
+propel
+propend
+prophesy
+propitiate
+propone
+proportionate
+propose
+propound
+prorate
+prorogue
+proscribe
+prosect
+prosecute
+proselytise
+proselytize
+prosper
+prostrate
+protect
+protract
+protrude
+protuberate
+prove
+proven
+provide
+provoke
+prussianise
+prussianize
+psych
+psychoanalyse
+psychoanalyze
+psychologize
+ptyalize
+publicise
+publicize
+publish
+pule
+pull
+pullulate
+pulsate
+pulverise
+pulverize
+pummel
+punctuate
+punish
+pupate
+purify
+purloin
+purpurate
+pursue
+purvey
+push
+pustulate
+putrefy
+pyalla
+quadrisect
+quaff
+qualify
+quantify
+quantize
+quartersaw
+quash
+quell
+quench
+quetch
+quicken
+quiesce
+quieten
+quit
+quizzes
+quo
+quote
+quoth
+racemize
+radiate
+radioactivate
+rainproof
+rals
+ramify
+ran
+randomize
+rang
+rankle
+ransack
+rarefy
+rarify
+rase
+ratify
+ratiocinate
+rationalise
+rationalize
+ratten
+ravin
+ravish
+raze
+rbound
+reabandon
+reabridge
+reabsorb
+reaccede
+reaccelerate
+reaccent
+reaccentuate
+reaccept
+reacclaim
+reacclimate
+reacclimatize
+reaccommodate
+reaccompany
+reaccredit
+reaccumulate
+reaccuse
+reaccustom
+reacidify
+reacknowledge
+reacquaint
+reacquire
+react
+reactivate
+read
+readapt
+readd
+readdress
+readiest
+readjourn
+readjudicate
+readjust
+readmit
+readopt
+readorn
+readvertise
+readvertize
+readvise
+readvocate
+reaffect
+reaffiliate
+reaffirm
+reafforest
+reaggregate
+reagitate
+realienate
+realign
+realine
+realise
+realize
+reallege
+reallocate
+reallot
+realter
+reamalgamate
+reamass
+reamend
+reanalyze
+reanchor
+reanimate
+reannex
+reannotate
+reannounce
+reanoint
+reantagonize
+reap
+reapologize
+reappeal
+reappear
+reapplaud
+reapply
+reappoint
+reapportion
+reappraise
+reapprehend
+reapproach
+reappropriate
+reapprove
+rearbitrate
+reargue
+rearise
+rearisen
+rearm
+rearose
+rearouse
+rearrange
+rearticulate
+reascend
+reasonless
+reassail
+reassemble
+reassent
+reassert
+reassess
+reassign
+reassimilate
+reassist
+reassociate
+reassort
+reassume
+reassure
+reast
+reattach
+reattack
+reattain
+reattempt
+reattest
+reattire
+reattract
+reattribute
+reauthenticate
+reauthorize
+reave
+reavow
+reawake
+reawaken
+reawoke
+rebait
+rebake
+rebalance
+rebale
+rebandage
+rebank
+rebaptize
+rebathe
+rebellow
+rebend
+rebent
+rebill
+rebind
+rebleach
+reblend
+reblister
+reblock
+rebloom
+reblossom
+reboard
+reboil
+rebolt
+reboot
+rebrace
+rebrand
+rebrew
+rebrighten
+rebroaden
+rebrush
+rebuckle
+rebudget
+rebuild
+rebury
+rebut
+rebutton
+recable
+recage
+recalcitrate
+recalculate
+recalesce
+recalk
+recampaign
+recancel
+recane
+recant
+recapitalize
+recapitulate
+recarpet
+recarry
+recarve
+recatalog
+recatalogue
+recategorize
+recaution
+recchose
+recchosen
+recede
+receive
+recelebrate
+recement
+recensor
+recentralize
+recertify
+rechallenge
+rechannel
+recharge
+rechart
+recharter
+rechoose
+rechristen
+recidivate
+reciprocate
+recircle
+recirculate
+recite
+reck
+reckon
+reclasp
+reclass
+reclassify
+reclean
+recleanse
+reclimb
+recline
+reclothe
+recoagulate
+recoat
+recode
+recodify
+recognise
+recognize
+recoin
+recollect
+recolonise
+recolonize
+recolor
+recolour
+recomb
+recombine
+recomfort
+recommence
+recommend
+recommit
+recompare
+recompensate
+recompile
+recompose
+recompound
+recompute
+reconceal
+reconcentrate
+reconcile
+recondemn
+recondense
+recondition
+reconduct
+reconfer
+reconfine
+reconfirm
+reconfiscate
+reconform
+reconfront
+reconfuse
+reconnect
+reconnoiter
+reconquer
+reconsecrate
+reconsent
+reconsider
+reconsign
+reconsole
+reconsolidate
+reconstruct
+reconsult
+recontemplate
+recontend
+recontest
+recontract
+reconvene
+reconverge
+reconvert
+reconvict
+recook
+recool
+recopy
+recorrect
+recost
+recostume
+recounsel
+recover
+recrate
+recreate
+recriminate
+recriticize
+recross
+recrown
+recrudesce
+recrystallise
+recrystallize
+rectify
+recultivate
+recuperate
+recur
+recurve
+recuse
+recut
+redact
+redamage
+redare
+redarn
+redate
+redden
+redebit
+redecay
+redeceive
+redecide
+redeclare
+redecline
+redecorate
+rededicate
+redeem
+redefine
+redefy
+redelegate
+redelete
+redeliberate
+redeliver
+redemand
+redemonstrate
+redeny
+redepend
+redeploy
+redepreciate
+redescend
+redescribe
+redesert
+redesign
+redesignate
+redetermine
+redevelop
+redictate
+redid
+redifferentiate
+rediffuse
+redig
+redigest
+redilate
+redintegrate
+redip
+redirect
+redisburse
+redischarge
+rediscipline
+rediscover
+rediscuss
+redisinfect
+redismiss
+redispatch
+redisperse
+redisplay
+redispose
+redispute
+redissect
+redissolve
+redistill
+redistinguish
+redistribute
+redistrict
+redivert
+redivide
+redline
+redo
+redock
+redocket
+redocument
+redominate
+redone
+redound
+redraw
+redrawn
+redrew
+redrill
+redrive
+redriven
+redroop
+redrove
+redrug
+redry
+reduce
+redug
+reduplicate
+redust
+redye
+reearn
+reecho
+reedify
+reedit
+reeducate
+reeject
+reelect
+reelevate
+reem
+reemanate
+reembark
+reembellish
+reembody
+reembrace
+reemerge
+reemigrate
+reemit
+reemphasize
+reemploy
+reenact
+reenclose
+reencourage
+reendorse
+reendow
+reenergize
+reenforce
+reengage
+reengrave
+reengross
+reenjoin
+reenjoy
+reenlarge
+reenlighten
+reenslave
+reenter
+reenumerate
+reenunciate
+reequip
+reerect
+reerupt
+reest
+reestablish
+reevacuate
+reevaluate
+reevidence
+reexamine
+reexcavate
+reexchange
+reexecute
+reexercise
+reexhibit
+reexpand
+reexpel
+reexperience
+reexplain
+reexplicate
+reexplore
+reexpose
+reexpress
+reface
+refamiliarize
+refashion
+refasten
+refect
+refederalize
+refederate
+refeel
+refertilize
+reffelt
+reffroze
+reffrozen
+refile
+refilm
+refilter
+refinance
+refind
+refine
+refire
+refix
+reflate
+reflect
+refloat
+reflow
+refocus
+refold
+reforecast
+reforest
+reforfeit
+reforge
+reformulate
+refortify
+reforward
+refract
+refracture
+reframe
+refreeze
+refresh
+refreshen
+refrigerate
+refrustrate
+refry
+reft
+refuel
+refunction
+refurbish
+refurnish
+refute
+regain
+regalvanize
+regamble
+regarment
+regarnish
+regarrison
+regather
+regauge
+regave
+regear
+regel
+regelate
+regenerate
+regerminate
+regild
+regionalize
+regird
+registrate
+regive
+regiven
+reglaze
+reglorify
+reglue
+regorge
+regovern
+regrab
+regradate
+regrade
+regraft
+regraph
+regrasp
+regrate
+regrease
+regreet
+regrew
+regrind
+regrip
+reground
+regroup
+regrow
+regrown
+reguide
+regularize
+regulate
+regurgitate
+rehabilitate
+rehammer
+rehandle
+rehang
+reharden
+reharmonize
+reharness
+reharvest
+rehaul
+rehear
+rehearse
+reheel
+rehem
+rehid
+rehidden
+rehide
+rehinge
+rehire
+rehone
+rehonor
+rehospitalize
+rehouse
+rehumanize
+rehumiliate
+rehung
+rehypnotize
+rehypothecate
+reice
+reidentify
+reify
+reignite
+reilluminate
+reillustrate
+reimage
+reimburse
+reimplant
+reimplement
+reimply
+reimpose
+reimpregnate
+reimpress
+reimprint
+reimprison
+reinaugurate
+reincarnate
+reincite
+reincline
+reinclude
+reincorporate
+reincrease
+reincur
+reindex
+reindicate
+reindict
+reindoctrinate
+reindorse
+reinduce
+reinduct
+reindulge
+reindustrialize
+reinfect
+reinfer
+reinfest
+reinfiltrate
+reinflame
+reinflate
+reinfluence
+reinforce
+reinform
+reinfuse
+reinhabit
+reinherit
+reinject
+reinjure
+reink
+reinoculate
+reinquire
+reinscribe
+reinsert
+reinsist
+reinspect
+reinspire
+reinstall
+reinstate
+reinstitute
+reinstruct
+reinsulate
+reinsure
+reintegrate
+reinter
+reinterpret
+reinterrogate
+reinterrupt
+reintervene
+reintrench
+reintroduce
+reinvade
+reinvent
+reinvest
+reinvestigate
+reinvigorate
+reinvite
+reinvoke
+reinvolve
+reirrigate
+reisolate
+reist
+reitemize
+reiterate
+reive
+rejail
+rejeopardize
+rejig
+rejigger
+rejoice
+rejoin
+rejudge
+rejustify
+rejuvenate
+rejuvenesce
+rejuvenise
+rejuvenize
+rekindle
+reknead
+reknit
+reknock
+reknot
+relabel
+relace
+relacquer
+reladle
+relaid
+relance
+reland
+relatch
+relate
+relativize
+relaunch
+relaunder
+relax
+relead
+relearn
+relegate
+relend
+relent
+relet
+reletter
+relevel
+relever
+relevy
+reliberate
+relicense
+relieve
+relight
+relimit
+reline
+relink
+relinquish
+reliquefy
+reliquidate
+relist
+relisten
+relitigate
+relive
+relocate
+relose
+relost
+relower
+relubricate
+reluct
+relume
+rely
+relyric
+remagnetize
+remagnify
+remail
+remaim
+remain
+reman
+remanifest
+remanufacture
+remap
+remarket
+remarry
+remarshal
+remaster
+remasticate
+rematerialize
+rematriculate
+remeasure
+remediate
+remelt
+remember
+rememorize
+remend
+remention
+remerge
+remigrate
+remilitarize
+remill
+remind
+remingle
+reminisce
+remint
+remix
+remobilize
+remodel
+remodify
+remodulate
+remold
+remollify
+remonetise
+remonetize
+remonstrate
+remortgage
+remultiply
+remunerate
+renail
+rename
+renationalize
+renavigate
+rend
+renegate
+renegotiate
+reneutralize
+renew
+renominate
+renormalize
+renotarize
+renotice
+renotify
+renourish
+renovate
+renullify
+renumber
+renumerate
+reobject
+reobligate
+reoblige
+reobserve
+reobtain
+reoccupy
+reoccur
+reoffend
+reoil
+reopen
+reoperate
+reoppose
+reoppress
+reorchestrate
+reordain
+reorganise
+reorganize
+reorient
+reorientate
+reornament
+reoutfit
+reoutline
+reoxidise
+reoxidize
+repacify
+repack
+repackage
+repad
+repaginate
+repanel
+repaper
+repark
+repaste
+repatch
+repatrol
+repatronize
+repattern
+repave
+repawn
+repay
+repeddle
+repel
+repen
+repenalize
+repent
+repeople
+reperceive
+reperform
+reperuse
+rephrase
+repick
+repin
+repine
+replace
+replan
+replane
+replant
+replaster
+replate
+replead
+repledge
+replenish
+replete
+replicate
+replot
+replow
+replume
+replunge
+repoint
+repolarize
+reponder
+repone
+repopularize
+repopulate
+reportion
+reposit
+repossess
+repost
+repostpone
+repostulate
+repot
+repour
+repractice
+repraise
+reprehend
+repremise
+reprepare
+represcribe
+represent
+repress
+reprice
+reprime
+reprobe
+reprocess
+reproclaim
+reproduce
+reprogram
+reproject
+repromise
+repromulgate
+reproportion
+repropose
+reprosecute
+reprove
+reprovision
+reprune
+republicanise
+republicanize
+republish
+repudiate
+repugn
+repunctuate
+repunish
+repurify
+repurpose
+repursue
+requalify
+requestion
+requicken
+require
+requite
+requote
+reradiate
+reran
+rerank
+rerate
+reread
+rereel
+reregister
+reregulate
+rerent
+rerise
+rerisen
+reroll
+rerose
+reroute
+resaddle
+resail
+resalt
+resalute
+resample
+resanction
+resat
+resawn
+rescale
+reschedule
+reschool
+rescind
+rescrub
+rescrutinize
+reseal
+reseason
+reseat
+resecure
+reseek
+resegregate
+reseize
+reselect
+resell
+resemble
+resend
+resensitize
+resent
+reseparate
+reservice
+reset
+resettle
+resew
+resewn
+reshake
+reshaken
+reshape
+reshare
+resharpen
+reshave
+reshew
+reshift
+reshine
+reshingle
+reshod
+reshoe
+reshook
+reshoot
+reshorten
+reshoulder
+reshow
+reshower
+reshut
+resicken
+reside
+resift
+resight
+resign
+resignal
+resile
+resilver
+resimmer
+resinate
+resinify
+resit
+resituate
+resize
+resketch
+reslander
+resmooth
+resmudge
+resoak
+resoften
+resoil
+resold
+resolder
+resole
+resolicit
+resolidify
+resonate
+resorb
+resought
+resound
+resow
+resown
+respace
+respade
+respecify
+respice
+respire
+resplice
+resprang
+respray
+respread
+resprinkle
+resquander
+resshot
+restab
+restabilize
+restable
+restack
+restaff
+restage
+restain
+restamp
+restart
+restate
+restation
+resterilize
+restimulate
+restipulate
+restir
+restitch
+restitute
+restock
+restore
+restraighten
+restrain
+restrap
+restrengthen
+restress
+restricken
+restrict
+restrive
+restriven
+restrove
+restruck
+restructure
+restrung
+restuff
+restung
+restyle
+resubject
+resublimate
+resublime
+resubmerge
+resubmit
+resubscribe
+resubstantiate
+resulfurize
+resulphurize
+resummon
+resupply
+resuppress
+resurface
+resurge
+resurrect
+resuscitate
+resuspend
+reswallow
+reswear
+resweep
+resweeten
+reswell
+reswept
+reswore
+resymbolize
+resynthesize
+resynthetize
+resystematize
+ret
+retabulate
+retack
+retain
+retaliate
+retan
+retape
+retar
+retariff
+retaste
+retaught
+retax
+reteach
+retear
+retelegraph
+retelephone
+retelevise
+retell
+retemper
+retestify
+rethank
+rethatch
+rethaw
+rethicken
+rethought
+rethread
+rethreaten
+rethresh
+retick
+reticulate
+retie
+retighten
+retile
+retill
+retime
+retin
+retinge
+retint
+retire
+retiringly
+retitle
+retoast
+retold
+retool
+retotal
+retrace
+retrack
+retract
+retrade
+retrain
+retranscribe
+retranslate
+retransmit
+retransplant
+retraverse
+retrench
+retroact
+retrocede
+retrofit
+retrograde
+retrogress
+retroject
+retry
+rettore
+rettorn
+retune
+returf
+retwine
+retwist
+retype
+reune
+reunify
+reunite
+reupholster
+reuse
+reutilise
+reutilize
+reutter
+revacate
+revaccinate
+revalidate
+revalorize
+revaluate
+revalue
+revaporize
+revarnish
+revegetate
+revend
+reventilate
+reverberate
+reverify
+revest
+revet
+reveto
+revibrate
+revictual
+revile
+revindicate
+reviolate
+revisit
+revisualize
+revitalise
+revitalize
+revive
+revivify
+revoice
+revolutionise
+revolutionize
+revolve
+rewake
+rewaken
+rewarm
+rewarn
+rewarrant
+rewash
+rewater
+rewax
+reweaken
+rewear
+reweave
+reweigh
+reweld
+rewet
+rewiden
+rewin
+rewire
+reword
+rework
+rewound
+rewrap
+rewritten
+rewrote
+rewwore
+rewwove
+reyoke
+rezone
+rfound
+rhapsodize
+rhubarb
+rid
+ridden
+right
+righten
+rigidify
+rile
+ripen
+risen
+ritualize
+rive
+riven
+rob
+robotize
+roentgenize
+roger
+roil
+roister
+roleplay
+romanize
+romanticize
+roneo
+roose
+rootle
+rotate
+roughen
+roust
+routinize
+royalise
+royalize
+rubberise
+rubberize
+rubberstamp
+rubify
+rubricate
+ruckle
+ruddle
+ruggedize
+ruminate
+runtgenize
+ruralise
+ruralize
+rusticate
+rwound
+saccarify
+sad
+sadden
+sain
+saith
+salify
+salinate
+salivate
+saltate
+sanctify
+sanitise
+sanitize
+sank
+saponify
+sate
+satiate
+satirise
+satirize
+satisfy
+saturate
+saute
+save
+sawn
+say
+scabble
+scandalise
+scandalize
+scant
+scarify
+scart
+scavenge
+schematise
+schematize
+schillerize
+schlep
+schmoose
+schreinerize
+scintillate
+scissor
+scorify
+scram
+scramb
+scranch
+scraunch
+scriech
+scrimp
+scrimpy
+scrimshank
+scrouge
+scrounge
+scrump
+scrutinise
+scrutinize
+scry
+sculpsit
+sculpt
+scummy
+scurries
+seals
+secede
+secern
+secernate
+seclude
+secondguess
+secrete
+sectarianise
+sectarianize
+sectionalise
+sectionalize
+secularise
+secularize
+secundus
+secure
+sedate
+seduce
+seel
+seem
+seen
+segregate
+segue
+seise
+seize
+select
+sensationalise
+sensibilize
+sensify
+sensitize
+sensualize
+sent
+sentimentalise
+sentimentalize
+septuple
+sequester
+sequestrate
+serialise
+serialize
+sermonise
+sermonize
+serpentinize
+serrate
+serry
+set
+setup
+sever
+severalize
+sew
+sewn
+sexualize
+shadowbox
+shaken
+shall
+shalt
+shamanize
+shapen
+sharecrop
+sharpen
+sharpshoot
+sheathe
+shellac
+shelve
+shend
+shent
+sherardize
+shew
+shies
+shit
+shlep
+shmooze
+shod
+shodden
+shone
+shoo
+shoot
+shoplift
+shorn
+shorten
+shortlist
+should
+shouldst
+show
+shown
+shrank
+shrill
+shrinkwrap
+shrive
+shrivel
+shrove
+shrunk
+shrunken
+shun
+shush
+sibilate
+sic
+sicken
+sift
+sightsee
+signa
+signalise
+signalize
+signetur
+signify
+sile
+silicify
+silverise
+silverplate
+simonize
+simplify
+simulate
+singularize
+sipe
+siss
+sit
+sitten
+situate
+siver
+sizz
+skee
+skeletonise
+skeletonize
+sken
+sket
+skiddoo
+skimp
+skintle
+skip
+skitter
+skive
+skreak
+skreigh
+skriech
+skriegh
+skydive
+skyjack
+skywrite
+skywritten
+skywrote
+slacken
+slake
+slank
+slay
+sleek
+sleepwalk
+slenderize
+slept
+slid
+slidden
+slim
+slimmest
+slow
+slubber
+slunk
+smarten
+smite
+smitten
+smoodge
+smoothen
+smote
+smuggle
+snap
+snarf
+snig
+snip
+snowk
+snuck
+snuggest
+sny
+sober
+socialise
+socialize
+sociologize
+sod
+sodden
+sodomize
+soften
+solarize
+sold
+solemnify
+solemnize
+solicit
+solidarize
+solidify
+soliloquise
+soliloquize
+solmizate
+solubilize
+solve
+sonnetise
+sonnetize
+sool
+soothe
+soothsaid
+soothsay
+sorcerize
+sorn
+sought
+soundproof
+sovietize
+sown
+spae
+spag
+spake
+spang
+sparest
+sparge
+sparkplug
+spay
+speak
+specialise
+specialize
+specify
+spectate
+speculate
+speechify
+spelbound
+spellbind
+spelunk
+spend
+spent
+sphacelate
+spiderweb
+spiflicate
+spilt
+spirantize
+spiritize
+spiritualize
+splenectomize
+spoilt
+spoken
+spoliate
+spondaize
+sporulate
+spotweld
+spraddle
+sprang
+sprauchle
+spreadeagle
+sprucest
+spruik
+sprung
+spue
+spun
+squeaky
+squeg
+squinnies
+stabilise
+stabilize
+stablish
+stacher
+stagnate
+standardise
+standardize
+stargaze
+start
+starve
+steady
+steepen
+stellify
+sterilise
+sterilize
+stickle
+stiffen
+stigmatize
+stipulate
+stoke
+stolen
+stonewall
+stonewash
+stonker
+stood
+stopt
+stot
+stow
+straighten
+straiten
+strangle
+strangulate
+stratify
+stravaig
+streetwalk
+strengthen
+strew
+strewn
+striate
+stridulate
+stript
+strive
+strode
+strome
+strook
+strove
+strow
+strown
+stroy
+struck
+strung
+stuck
+stultify
+stung
+stunk
+stupefy
+stupify
+stylise
+stylize
+stylopize
+subadministrate
+subaerate
+subcompensate
+subconnect
+subcontrol
+subcool
+subdate
+subdemonstrate
+subdivide
+subduce
+subduct
+subdue
+subedit
+subendorse
+subentitle
+suberise
+suberize
+subgape
+subinfer
+subinfeudate
+subinform
+subinitial
+subinsert
+subintroduce
+subirrigate
+subjectify
+subjoin
+subjugate
+submerge
+submerse
+subminiaturize
+submit
+suborn
+subrogate
+subscribe
+subserve
+subside
+subsidize
+subsist
+subspecialize
+substandardize
+substantialize
+substantiate
+substantivize
+subsume
+subtend
+subterraneanize
+subtilise
+subtilize
+subtract
+suburbanise
+suburbanize
+subvene
+subvert
+succumb
+succuss
+suckle
+sue
+suffer
+suffice
+sufflate
+suffocate
+suffumigate
+suffuse
+sugarcoat
+sugg
+suggest
+sulfatize
+sulfurette
+sulfurize
+sullies
+sulphatize
+sulphurate
+sulphuret
+sulphurette
+sulphurize
+summarise
+summarize
+summate
+summerize
+summon
+sunbathe
+sunburnt
+sunday
+sung
+sunken
+superabhor
+superabound
+superaccrue
+superaccumulate
+superactivate
+superadd
+superannuate
+superassume
+superastonish
+superbuild
+supercharge
+supercool
+superemphasize
+superendorse
+superendow
+superengrave
+supererogate
+superestablish
+superexalt
+superexert
+superexpand
+superextend
+superextol
+superextoll
+superfulfill
+superfuse
+supergovern
+supergratify
+supergravitate
+superheat
+superhumanize
+superillustrate
+superimpend
+superimply
+superimpose
+superinduce
+superinfer
+superinfuse
+superinscribe
+superinsist
+superintend
+superlie
+supermanifest
+supermoisten
+supernaturalise
+supernaturalize
+superobject
+superordain
+superoxygenate
+superpose
+superqualify
+superquote
+superrefine
+supersatisfy
+supersaturate
+superscribe
+supersede
+supersensitise
+supersensitize
+supersimplify
+supersolicit
+superspecialize
+superstimulate
+superstruct
+supersubsist
+supersulfurize
+supersulphurize
+supertempt
+supertrain
+supervene
+supervise
+supinate
+supplant
+supple
+supplely
+supplicate
+suppose
+suppress
+suppurate
+surmount
+surpass
+survive
+suspend
+suspire
+suss
+sustain
+susurrate
+swaggi
+swam
+swang
+sweal
+sweeten
+swept
+swinge
+swith
+swive
+swiver
+swollen
+swonk
+swonken
+swore
+sworn
+swosh
+swum
+swung
+syllabicate
+syllabify
+syllabise
+syllabize
+syllogize
+symbolise
+symbolize
+symmetrise
+symmetrize
+sympathise
+sympathize
+symphonise
+symphonize
+synchronise
+synchronize
+syncopate
+syncretize
+synonymise
+synonymize
+synopsise
+synopsize
+synthesise
+synthesize
+synthetise
+syntonise
+syntonize
+sypher
+syphilize
+systematise
+systematize
+systemise
+systemize
+ta'en
+tabularise
+tabularize
+tabulate
+take
+tallyho
+tame
+tantalise
+tantalize
+tapdance
+tarmac
+tarries
+tarry
+tartarize
+taught
+tauten
+tautologise
+tautologize
+tautomerize
+teargas
+teem
+teethe
+telecommunicate
+telefax
+telepathize
+televise
+televize
+tellurize
+temporise
+temporize
+tempt
+tend
+tenderise
+tenderize
+tepefy
+tergiversate
+terminate
+terrasse
+terrify
+territorialise
+territorialize
+terrorise
+terrorize
+tesselate
+tessellate
+testify
+testimonialize
+tetanise
+tetanize
+thank
+theatricalise
+theatricalize
+theologise
+theologize
+theorise
+theorize
+thermalize
+thicken
+thieve
+thig
+thin
+thirl
+thoriate
+thraw
+threap
+threaten
+threw
+thrive
+thrombose
+throve
+thrown
+thurify
+thwack
+ties
+tighten
+timber
+tink
+tintinnabulate
+tippytoe
+titillate
+titivate
+titrate
+tittivate
+told
+tolerate
+tonguetie
+took
+topdress
+topple
+torn
+torrefy
+tost
+totalitarianize
+totalize
+touch
+toughen
+traduce
+traject
+trammel
+tranquilize
+tranquillize
+transact
+transcend
+transcendentalize
+transchange
+transcribe
+transdialect
+transduce
+transect
+transelementate
+transessentiate
+transfeature
+transfigure
+transfix
+transfuse
+transgress
+tranship
+transilluminate
+transistorize
+transitivize
+translate
+transliterate
+translocate
+transmade
+transmake
+transmigrate
+transmit
+transmogrify
+transmold
+transmould
+transmute
+transpierce
+transpirate
+transpire
+transpour
+transshape
+transshift
+transship
+transubstantiate
+transude
+transvalue
+traumatize
+treck
+triangulate
+trichinise
+trichinize
+tries
+trimmest
+trisect
+tritiate
+trivialise
+trivialize
+troat
+trod
+trodden
+trode
+trog
+trollies
+tropicalise
+tropicalize
+troubleshoot
+troublesshot
+trounce
+trow
+truncate
+try
+tubercularise
+tubercularize
+tuberculinise
+tuberculinize
+tuberculise
+tubulate
+tumefy
+tut
+tutoyer
+tweedle
+tweet
+tweeze
+twotime
+typecast
+typeset
+typewrite
+typewritten
+typewrote
+typify
+tyrannise
+tyrannize
+ubound
+uglify
+ulcerate
+ululate
+unaccustom
+unarm
+unbait
+unbale
+unbandage
+unbar
+unbarbarise
+unbarbarize
+unbarricade
+unbay
+unbeard
+unbelt
+unbench
+unbend
+unbent
+unberth
+unbind
+unbit
+unblade
+unblock
+unbolster
+unbolt
+unbonnet
+unbosom
+unbottle
+unbottom
+unbound
+unbox
+unbrace
+unbraid
+unbridle
+unbrooch
+unbrutalise
+unbrutalize
+unbrutise
+unbrutize
+unbuckle
+unbud
+unbuild
+unbuilt
+unburden
+unbutton
+uncake
+uncalk
+uncanonise
+uncanonize
+uncap
+uncase
+uncask
+uncatholicise
+uncatholicize
+unchain
+unchair
+unchapter
+unchariot
+unchurch
+unchurn
+uncinch
+uncivilize
+unclasp
+unclench
+unclinch
+unclip
+uncloak
+unclog
+unclose
+unclothe
+unclutter
+uncoat
+uncoffin
+uncoil
+uncollar
+uncolonise
+uncolonize
+uncondition
+unconfirm
+unconfound
+uncongeal
+uncoop
+uncore
+uncork
+uncorrect
+uncouple
+uncover
+uncrate
+uncredit
+uncrib
+uncross
+uncrown
+uncurb
+uncurd
+uncurl
+undam
+undarken
+undeceive
+undemocratise
+undemocratize
+underachieve
+underact
+underbake
+underbalance
+underballast
+underbank
+underbid
+underbillow
+underboil
+underboom
+underbrew
+underbuild
+underbuilt
+underbuy
+undercanvass
+undercapitalize
+undercarry
+undercarve
+underconsume
+undercool
+undercorrect
+undercrawl
+underdevelop
+underdevelope
+underdid
+underdig
+underdo
+underdraw
+underdrawn
+underdrew
+underdry
+underdug
+undereat
+undereate
+undereaten
+underexercise
+underexpose
+underfinance
+underfortify
+underfurnish
+undergarnish
+undergird
+undergnaw
+undergo
+undergone
+undergrow
+underhang
+underhatch
+underheat
+underhorse
+underjoin
+underlaid
+underlap
+underlet
+underlie
+underload
+underman
+undermeasure
+undermine
+undernourish
+underoxidise
+underoxidize
+underpaid
+underpay
+underpeep
+underpeer
+underpin
+underplant
+underplay
+underpopulate
+underprice
+underprize
+underproduce
+underprop
+underquote
+underran
+underrate
+underrealise
+underrealize
+underreckon
+underrecompense
+underrepresent
+underroast
+undersaw
+undersee
+underseen
+undersell
+undershone
+undershoot
+undershorten
+undersign
+undersleep
+underslept
+undersold
+underspecify
+underspend
+underspent
+undersplice
+underspread
+undersshot
+understand
+understate
+understeer
+understood
+understrew
+understricken
+understrike
+understruck
+understudies
+understuff
+undersweep
+underswept
+undertake
+undertaught
+underteach
+undertest
+underthaw
+undertook
+undertrade
+undertrain
+undertrump
+undertruss
+undervalue
+underventilate
+underwash
+underwent
+underwind
+underwork
+underwrite
+underwritten
+underwrote
+undid
+undistend
+undo
+undock
+undouble
+undrape
+undraw
+undrawn
+undrest
+undrew
+undulate
+unearth
+unedge
+unequalise
+unequalize
+unfasten
+unfeminise
+unfeminize
+unfence
+unfetter
+unfeudalise
+unfeudalize
+unffroze
+unfile
+unfit
+unfix
+unflank
+unfloor
+unfold
+unfork
+unfree
+unfreeze
+unfrill
+unfringe
+unfrock
+unfrost
+unfurl
+ungag
+ungarland
+ungarter
+ungird
+ungirdle
+ungirt
+ungladden
+ungloom
+unglue
+ungrip
+unhaft
+unhair
+unhallow
+unhand
+unhandcuff
+unharden
+unharmonise
+unharmonize
+unharness
+unhasp
+unhedge
+unhelm
+unhinge
+unhitch
+unhood
+unhook
+unhorse
+unhouse
+unhuddle
+unhull
+unhumanise
+unhumanize
+unhusk
+unhypnotise
+unhypnotize
+unice
+uniformise
+uniformize
+unify
+uninsulate
+unionise
+unionize
+unisolate
+unitize
+universalise
+universalize
+unjam
+unjoin
+unkennel
+unkink
+unknit
+unknot
+unlabialise
+unlabialize
+unlace
+unlade
+unlash
+unlatch
+unlax
+unlay
+unlead
+unleaf
+unlearn
+unleash
+unlimber
+unlink
+unlive
+unload
+unlocalise
+unlocalize
+unlock
+unloop
+unloose
+unmade
+unmake
+unman
+unmap
+unmarbelize
+unmarbleize
+unmask
+unmast
+unmate
+unmerge
+unmesh
+unmew
+unmiter
+unmitre
+unmix
+unmoisten
+unmold
+unmoor
+unmortgage
+unmortise
+unmould
+unmuffle
+unmuzzle
+unmysticise
+unmysticize
+unnaturalise
+unnaturalize
+unnerve
+unneutralise
+unneutralize
+unpack
+unpaganize
+unpaste
+unpedestal
+unpeg
+unpen
+unpeople
+unpick
+unpictorialise
+unpictorialize
+unpile
+unpin
+unplait
+unplan
+unplaster
+unplug
+unpocket
+unpot
+unprison
+unpuzzle
+unquote
+unrack
+unravel
+unrealise
+unrealize
+unreckon
+unreeel
+unreel
+unreeve
+unrhyme
+unriddle
+unrig
+unrip
+unrobe
+unroll
+unroof
+unroot
+unround
+unrrove
+unruffle
+unrust
+unsaddle
+unsay
+unscabbard
+unscramble
+unscrew
+unseal
+unseam
+unseat
+unsectarianize
+unsell
+unsensitise
+unsensitize
+unsepulcher
+unsepulchre
+unsettle
+unsex
+unshackle
+unshade
+unsheathe
+unship
+unshroud
+unsnap
+unsnarl
+unsold
+unsolder
+unsole
+unsort
+unspan
+unspeak
+unspell
+unsphere
+unstaple
+unstate
+unsteady
+unsteel
+unstep
+unstick
+unstop
+unstopper
+unstrain
+unstrap
+unstuff
+unsubstantialize
+unswathe
+unswear
+unswivel
+unswore
+unsworn
+untack
+untangle
+unteach
+unthaw
+unthicken
+unthink
+unthorn
+unthought
+unthread
+unthrone
+untidy
+untie
+untighten
+untilt
+untranquilize
+untranquillise
+untread
+untrodden
+untruss
+unttrod
+untuck
+untune
+untwine
+untwist
+unveil
+unvoice
+unvulgarise
+unvulgarize
+unwall
+unweave
+unwedge
+unwheel
+unwig
+unwind
+unwire
+unwish
+unwomb
+unwound
+unwrap
+unwreathe
+unwrinkle
+unwwove
+unwwoven
+unyoke
+unzip
+unzone
+upbbore
+upbborne
+upbear
+upbraid
+upbuild
+upbuilt
+upchuck
+updo
+upend
+upfold
+upgather
+upheave
+upheld
+uphhove
+uphold
+upholster
+upload
+upraise
+uprear
+uprisen
+uproot
+uprose
+uprouse
+upswell
+upswept
+upswollen
+uptear
+upthrew
+upthrown
+uptilt
+uptorn
+upttore
+upttorn
+urbanise
+urbanize
+urinate
+urticate
+uspoke
+uspoken
+usurp
+uti
+utilise
+utilize
+utter
+vacate
+vaccinate
+vacillate
+validate
+valorise
+valorize
+valuate
+vamoose
+vamose
+vandalise
+vandalize
+vanquish
+vaporize
+vapourise
+vapourize
+variegate
+variolate
+vary
+vasectomise
+vasectomize
+vassalize
+vaticinate
+vegetate
+velarize
+velcro
+vellicate
+vend
+venerate
+venge
+ventilate
+ventriloquise
+ventriloquize
+verbalise
+verbalize
+verbify
+verify
+vermiculate
+verminate
+vernacularise
+vernacularize
+vernalise
+vernalize
+versify
+vesicate
+vesiculate
+vex
+vibrate
+victimise
+victimize
+vide
+videotape
+vilify
+vilipend
+vindicate
+vinify
+vinylate
+violate
+visualize
+vitalise
+vitalize
+vitaminize
+vitiate
+vitrify
+vitriolize
+vituperate
+vivify
+vivisect
+vocalize
+vociferate
+volatilise
+volatilize
+volcanize
+vouchsafe
+vulcanise
+vulcanize
+vulgarise
+vulgarize
+wair
+wait
+waitlist
+waive
+wanna
+warn
+was
+wast
+waul
+wawl
+waxen
+waylay
+weaken
+weary
+weatherproof
+weatherstrip
+ween
+weighman
+weightlift
+welch
+well
+wend
+went
+wept
+were
+wert
+westernise
+westernize
+whack
+wheedle
+wheelabrate
+whelm
+whicker
+whiffle
+whipsawn
+whipt
+whirry
+whist
+whistlestop
+whiten
+whizz
+widen
+wield
+wifely
+wilder
+windsurf
+winterize
+wiredraw
+wiredrawn
+wiredrew
+wis
+wist
+withdraw
+withdrawn
+withdrew
+wither
+withhold
+withstand
+withstood
+wive
+woke
+woken
+womanise
+womanize
+woo
+wooden
+woof
+woolgather
+wore
+worn
+worrit
+worsen
+wot
+would
+wouldst
+wove
+woven
+wow
+wrawl
+wreak
+wreathe
+write
+writhen
+wrote
+wrought
+wrung
+xerox
+yaff
+yap
+yarovize
+yclad
+yclept
+yean
+yearn
+yirr
+youthen
+zap
+zincify
+zindabad
+zipping
\ No newline at end of file
diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs
index bcd8639e..bbfe8be0 100644
--- a/tests/Basic/Basic.Tests.cs
+++ b/tests/Basic/Basic.Tests.cs
@@ -112,17 +112,17 @@ public class BasicTests
     public void TestAbstractReturnType()
     {
         var returnsAbstractFoo = new ReturnsAbstractFoo();
-        var abstractFoo = returnsAbstractFoo.getFoo();
-        Assert.AreEqual(abstractFoo.pureFunction(), 5);
-        Assert.AreEqual(abstractFoo.pureFunction1(), 10);
-        Assert.AreEqual(abstractFoo.pureFunction2(), 15);
+        var abstractFoo = returnsAbstractFoo.Foo;
+        Assert.AreEqual(abstractFoo.pureFunction, 5);
+        Assert.AreEqual(abstractFoo.pureFunction1, 10);
+        Assert.AreEqual(abstractFoo.pureFunction2, 15);
     }
 
     [Test]
     public void TestANSI()
     {
         Foo foo = new Foo();
-        Assert.That(foo.GetANSI(), Is.EqualTo("ANSI"));
+        Assert.That(foo.ANSI, Is.EqualTo("ANSI"));
     }
 }
  
\ No newline at end of file
diff --git a/tests/VTables/VTables.Tests.cs b/tests/VTables/VTables.Tests.cs
index 6e932713..c3343154 100644
--- a/tests/VTables/VTables.Tests.cs
+++ b/tests/VTables/VTables.Tests.cs
@@ -4,10 +4,13 @@ using VTables;
 
 public class FooDerived : Foo
 {
-    public override int vfoo()
+    public override int vfoo
     {
-        Console.WriteLine("Hello from FooDerived");
-        return 10;
+        get
+        {
+            Console.WriteLine("Hello from FooDerived");
+            return 10;
+        }
     }
 }
 
@@ -18,8 +21,8 @@ public class VTablesTests
     public void TestFoo()
     {
         var foo = new Foo();
-        Assert.That(foo.vfoo(), Is.EqualTo(5));
-        Assert.That(foo.Vbar(), Is.EqualTo(3));
+        Assert.That(foo.vfoo, Is.EqualTo(5));
+        Assert.That(foo.Vbar, Is.EqualTo(3));
         Assert.That(foo.CallFoo(), Is.EqualTo(7));
 
         var foo2 = new FooDerived();

From fcb1ab67ca1956ceaead39b86c57054dea76b1f7 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Wed, 2 Oct 2013 21:54:03 +0300
Subject: [PATCH 2/6] Added tests for properties.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 .../Passes/GetterSetterToPropertyPass.cs      | 43 +++++++++++++++----
 tests/Basic/Basic.Tests.cs                    |  2 +-
 tests/CSharpTemp/CSharpTemp.Tests.cs          | 23 ++++++++--
 tests/CSharpTemp/CSharpTemp.cpp               | 30 +++++++++++++
 tests/CSharpTemp/CSharpTemp.h                 | 29 +++++++++++++
 5 files changed, 113 insertions(+), 14 deletions(-)

diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs
index 6e591fac..98b5d945 100644
--- a/src/Generator/Passes/GetterSetterToPropertyPass.cs
+++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Text;
 using CppSharp.AST;
 
 namespace CppSharp.Passes
@@ -77,15 +79,19 @@ namespace CppSharp.Passes
                 foreach (var setter in group)
                 {
                     Class type = (Class) setter.Namespace;
-                    string afterSet = setter.Name.Substring(3);
+                    StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3));
+                    if (char.IsLower(setter.Name[0]))
+                        nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]);
+                    string afterSet = nameBuilder.ToString();
                     foreach (var getter in nonSetters.Where(m => m.Namespace == type))
                     {
-                        if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
+                        string name = GetPropertyName(getter.Name);
+                        if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
                             getter.ReturnType == setter.Parameters[0].QualifiedType &&
                             !type.Methods.Any(
                                 m =>
                                     m != getter &&
-                                    string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
+                                    string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
                         {
                             GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
                             goto next;
@@ -105,9 +111,7 @@ namespace CppSharp.Passes
             foreach (Method nonSetter in nonSetters)
             {
                 Class type = (Class) nonSetter.Namespace;
-                string name = nonSetter.Name;
-                if (GetFirstWord(name) == "get")
-                    name = name.Substring(3);
+                string name = GetPropertyName(nonSetter.Name);
                 Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
                 if (!type.IsInterface && baseVirtualProperty != null)
                 {
@@ -129,7 +133,7 @@ namespace CppSharp.Passes
                      p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
             {
                 Property property = new Property();
-                property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0);
+                property.Name = GetPropertyName(getter.Name);
                 property.Namespace = type;
                 property.QualifiedType = getter.ReturnType;
                 if (getter.IsOverride || (setter != null && setter.IsOverride))
@@ -138,7 +142,7 @@ namespace CppSharp.Passes
                     if (baseVirtualProperty.SetMethod == null)
                         setter = null;
                     foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
-                        method.Name = "Get" + method.Name;
+                        method.Name = "get" + method.Name;
                 }
                 property.GetMethod = getter;
                 property.SetMethod = setter;
@@ -155,6 +159,26 @@ namespace CppSharp.Passes
             }
         }
 
+        private static string GetPropertyName(string name)
+        {
+            if (GetFirstWord(name) == "get")
+            {
+                if (char.IsLower(name[0]))
+                {
+                    if (name.Length == 4)
+                    {
+                        return char.ToLowerInvariant(
+                            name[3]).ToString(CultureInfo.InvariantCulture);
+                    }
+                    return char.ToLowerInvariant(
+                        name[3]).ToString(CultureInfo.InvariantCulture) +
+                                    name.Substring(4);
+                }
+                return name.Substring(3);
+            }
+            return name;
+        }
+
 
         private void DistributeMethod(Method method)
         {
@@ -191,7 +215,8 @@ namespace CppSharp.Passes
                                     {
                                         char.ToLowerInvariant(name[0])
                                     };
-            firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower));
+            firstVerb.AddRange(name.Skip(1).TakeWhile(
+                c => char.IsLower(c) || !char.IsLetterOrDigit(c)));
             return new string(firstVerb.ToArray());
         }
     }
diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs
index bbfe8be0..abcf515e 100644
--- a/tests/Basic/Basic.Tests.cs
+++ b/tests/Basic/Basic.Tests.cs
@@ -112,7 +112,7 @@ public class BasicTests
     public void TestAbstractReturnType()
     {
         var returnsAbstractFoo = new ReturnsAbstractFoo();
-        var abstractFoo = returnsAbstractFoo.Foo;
+        var abstractFoo = returnsAbstractFoo.foo;
         Assert.AreEqual(abstractFoo.pureFunction, 5);
         Assert.AreEqual(abstractFoo.pureFunction1, 10);
         Assert.AreEqual(abstractFoo.pureFunction2, 15);
diff --git a/tests/CSharpTemp/CSharpTemp.Tests.cs b/tests/CSharpTemp/CSharpTemp.Tests.cs
index fe6289ea..e24d3629 100644
--- a/tests/CSharpTemp/CSharpTemp.Tests.cs
+++ b/tests/CSharpTemp/CSharpTemp.Tests.cs
@@ -45,19 +45,34 @@ public class CSharpTempTests
     public void TestMultipleInheritance()
     {
         Baz baz = new Baz();
-        Assert.That(baz.method(), Is.EqualTo(1));
+        Assert.That(baz.method, Is.EqualTo(1));
         var bar = (IBar) baz;
-        Assert.That(bar.method(), Is.EqualTo(2));
+        Assert.That(bar.method, Is.EqualTo(2));
         Assert.That(baz[0], Is.EqualTo(50));
         bar[0] = new Foo { A = 1000 };
         Assert.That(bar[0].A, Is.EqualTo(1000));
-        Assert.That(baz.farAwayFunc(), Is.EqualTo(20));
+        Assert.That(baz.farAwayFunc, Is.EqualTo(20));
         Assert.That(baz.takesQux(baz), Is.EqualTo(20));
-        Assert.That(baz.returnQux().farAwayFunc(), Is.EqualTo(20));
+        Assert.That(baz.returnQux().farAwayFunc, Is.EqualTo(20));
         int cast = baz;
         Assert.That(cast, Is.EqualTo(500));
         var nested = new Baz.Nested();
         int nestedCast = nested;
         Assert.That(nestedCast, Is.EqualTo(300));
     }
+
+    [Test]
+    public void TestProperties()
+    {
+        var proprietor = new Proprietor();
+        proprietor.value = 20;
+        Assert.That(proprietor.value, Is.EqualTo(20));
+        proprietor.prop = 50;
+        Assert.That(proprietor.prop, Is.EqualTo(50));
+        var p = new P();
+        p.value = 20;
+        Assert.That(p.value, Is.EqualTo(30));
+        p.prop = 50;
+        Assert.That(p.prop, Is.EqualTo(150));
+    }
 }
\ No newline at end of file
diff --git a/tests/CSharpTemp/CSharpTemp.cpp b/tests/CSharpTemp/CSharpTemp.cpp
index d030f5af..ab01784a 100644
--- a/tests/CSharpTemp/CSharpTemp.cpp
+++ b/tests/CSharpTemp/CSharpTemp.cpp
@@ -65,3 +65,33 @@ Baz::operator int() const
 {
     return 500;
 }
+
+int AbstractProprietor::getValue()
+{
+    return m_value;
+}
+
+void AbstractProprietor::setProp(long property)
+{
+    m_property = property;
+}
+
+void Proprietor::setValue(int value)
+{
+    m_value = value;
+}
+
+long Proprietor::prop()
+{
+    return m_property;
+}
+
+void P::setValue(int value)
+{
+    m_value = value + 10;
+}
+
+long P::prop()
+{
+    return m_property + 100;
+}
diff --git a/tests/CSharpTemp/CSharpTemp.h b/tests/CSharpTemp/CSharpTemp.h
index 529a9589..f5faeb10 100644
--- a/tests/CSharpTemp/CSharpTemp.h
+++ b/tests/CSharpTemp/CSharpTemp.h
@@ -63,3 +63,32 @@ struct QByteArrayDataPtr
 {
     QByteArrayData* ptr;
 };
+
+class DLL_API AbstractProprietor
+{
+public:
+    virtual int getValue();
+    virtual void setValue(int value) = 0;
+
+    virtual long prop() = 0;
+    virtual void setProp(long prop);
+
+protected:
+    int m_value;
+    long m_property;
+};
+
+class DLL_API Proprietor : public AbstractProprietor
+{
+public:
+    virtual void setValue(int value);
+
+    virtual long prop();
+};
+
+class DLL_API P : Proprietor
+{
+public:
+    virtual void setValue(int value);
+    virtual long prop();
+};

From 27f8e28036752a4d01f1fee4bed83e8cfce5b848 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Wed, 2 Oct 2013 22:44:08 +0300
Subject: [PATCH 3/6] Fixed the generation of v-table calls to property
 setters. Ignored methods that are only named "get" and similar, as
 properties.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 .../Generators/CSharp/CSharpTextTemplate.cs       | 15 ++++++++++++---
 .../Passes/GetterSetterToPropertyPass.cs          |  5 +++--
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
index 984c1194..e7bd048c 100644
--- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
+++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
@@ -1264,9 +1264,18 @@ namespace CppSharp.Generators.CSharp
             }
             else
             {
-                var name = ((Class) method.Namespace).Properties.First(
-                    p => p.GetMethod == method || p.SetMethod == method).Name;
-                WriteLine("target.{0};", name);              
+                var property = ((Class) method.Namespace).Properties.FirstOrDefault(
+                    p => p.GetMethod == method);
+                if (property == null)
+                {
+                    property = ((Class) method.Namespace).Properties.First(
+                        p => p.SetMethod == method);
+                    WriteLine("target.{0} = {1};", property.Name, string.Join(", ", marshals));
+                }
+                else
+                {
+                    WriteLine("target.{0};", property.Name);
+                }
             }
 
             // TODO: Handle hidden structure return types.
diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs
index 98b5d945..5bf2b77c 100644
--- a/src/Generator/Passes/GetterSetterToPropertyPass.cs
+++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs
@@ -182,7 +182,7 @@ namespace CppSharp.Passes
 
         private void DistributeMethod(Method method)
         {
-            if (GetFirstWord(method.Name) == "set" &&
+            if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 &&
                 method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void))
             {
                 if (method.Parameters.Count == 1)
@@ -205,7 +205,8 @@ namespace CppSharp.Passes
                 method.Parameters.Count > 0 || method.IsDestructor)
                 return false;
             var result = GetFirstWord(method.Name);
-            return result == "get" || result == "is" || result == "has" || 
+            return (result.Length < method.Name.Length &&
+                    (result == "get" || result == "is" || result == "has")) ||
                    (result != "to" && result != "new" && !verbs.Contains(result));
         }
 

From 19bae92f9b60727beef6723d2b7fb4c0fa039045 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Thu, 3 Oct 2013 01:38:58 +0300
Subject: [PATCH 4/6] Added a fake option so that the build stays healthy since
 the C++/CLI-back-end does not properly support properties yet.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 src/Generator/Driver.cs        |  4 +++-
 tests/Basic/Basic.Tests.cs     | 10 +++++-----
 tests/CSharpTemp/CSharpTemp.cs |  1 +
 tests/VTables/VTables.Tests.cs | 13 +++++--------
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs
index deca3f22..6c790857 100644
--- a/src/Generator/Driver.cs
+++ b/src/Generator/Driver.cs
@@ -158,7 +158,8 @@ namespace CppSharp
                 TranslationUnitPasses.AddPass(new MultipleInheritancePass());
                 TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass());
             }
-            TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass());
+            if (Options.GenerateProperties)
+                TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass());
         }
 
         public void ProcessCode()
@@ -289,6 +290,7 @@ namespace CppSharp
         public bool GenerateVirtualTables;
         public bool GenerateAbstractImpls;
         public bool GenerateInterfacesForMultipleInheritance;
+        public bool GenerateProperties;
         public bool GenerateInternalImports;
         public string IncludePrefix;
         public bool WriteOnlyWhenChanged;
diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs
index abcf515e..bcd8639e 100644
--- a/tests/Basic/Basic.Tests.cs
+++ b/tests/Basic/Basic.Tests.cs
@@ -112,17 +112,17 @@ public class BasicTests
     public void TestAbstractReturnType()
     {
         var returnsAbstractFoo = new ReturnsAbstractFoo();
-        var abstractFoo = returnsAbstractFoo.foo;
-        Assert.AreEqual(abstractFoo.pureFunction, 5);
-        Assert.AreEqual(abstractFoo.pureFunction1, 10);
-        Assert.AreEqual(abstractFoo.pureFunction2, 15);
+        var abstractFoo = returnsAbstractFoo.getFoo();
+        Assert.AreEqual(abstractFoo.pureFunction(), 5);
+        Assert.AreEqual(abstractFoo.pureFunction1(), 10);
+        Assert.AreEqual(abstractFoo.pureFunction2(), 15);
     }
 
     [Test]
     public void TestANSI()
     {
         Foo foo = new Foo();
-        Assert.That(foo.ANSI, Is.EqualTo("ANSI"));
+        Assert.That(foo.GetANSI(), Is.EqualTo("ANSI"));
     }
 }
  
\ No newline at end of file
diff --git a/tests/CSharpTemp/CSharpTemp.cs b/tests/CSharpTemp/CSharpTemp.cs
index 19c40511..b5abc376 100644
--- a/tests/CSharpTemp/CSharpTemp.cs
+++ b/tests/CSharpTemp/CSharpTemp.cs
@@ -13,6 +13,7 @@ namespace CppSharp.Tests
         public override void SetupPasses(Driver driver)
         {
             driver.Options.GenerateInterfacesForMultipleInheritance = true;
+            driver.Options.GenerateProperties = true;
         }
 
         static class Program
diff --git a/tests/VTables/VTables.Tests.cs b/tests/VTables/VTables.Tests.cs
index c3343154..6e932713 100644
--- a/tests/VTables/VTables.Tests.cs
+++ b/tests/VTables/VTables.Tests.cs
@@ -4,13 +4,10 @@ using VTables;
 
 public class FooDerived : Foo
 {
-    public override int vfoo
+    public override int vfoo()
     {
-        get
-        {
-            Console.WriteLine("Hello from FooDerived");
-            return 10;
-        }
+        Console.WriteLine("Hello from FooDerived");
+        return 10;
     }
 }
 
@@ -21,8 +18,8 @@ public class VTablesTests
     public void TestFoo()
     {
         var foo = new Foo();
-        Assert.That(foo.vfoo, Is.EqualTo(5));
-        Assert.That(foo.Vbar, Is.EqualTo(3));
+        Assert.That(foo.vfoo(), Is.EqualTo(5));
+        Assert.That(foo.Vbar(), Is.EqualTo(3));
         Assert.That(foo.CallFoo(), Is.EqualTo(7));
 
         var foo2 = new FooDerived();

From f086dd9051a26be467bf2a2629bb0a572453eac3 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Thu, 3 Oct 2013 18:55:41 +0300
Subject: [PATCH 5/6] Commented newly created properties.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 .../Passes/GetterSetterToPropertyPass.cs       | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs
index 5bf2b77c..fc14ed78 100644
--- a/src/Generator/Passes/GetterSetterToPropertyPass.cs
+++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs
@@ -151,7 +151,22 @@ namespace CppSharp.Passes
                 {
                     property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl;
                 }
-                // TODO: add comments
+                if (getter.Comment != null)
+                {
+                    var comment = new RawComment();
+                    comment.Kind = getter.Comment.Kind;
+                    comment.BriefText = getter.Comment.BriefText;
+                    comment.Text = getter.Comment.Text;
+                    comment.FullComment = new FullComment();
+                    comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks);
+                    if (setter != null && setter.Comment != null)
+                    {
+                        comment.BriefText += Environment.NewLine + setter.Comment.BriefText;
+                        comment.Text += Environment.NewLine + setter.Comment.Text;
+                        comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks);
+                    }
+                    property.Comment = comment;
+                }
                 type.Properties.Add(property);
                 getter.IsGenerated = false;
                 if (setter != null)
@@ -179,7 +194,6 @@ namespace CppSharp.Passes
             return name;
         }
 
-
         private void DistributeMethod(Method method)
         {
             if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 &&

From f348a80c32077328fefd6c1efab6b4dbae2388f0 Mon Sep 17 00:00:00 2001
From: Dimitar Dobrev <dpldobrev@yahoo.com>
Date: Fri, 4 Oct 2013 23:34:23 +0300
Subject: [PATCH 6/6] Moved the improved property pass to a new class. Added
 the list of verbs as a resource in premake.

Signed-off-by: Dimitar Dobrev <dpldobrev@yahoo.com>
---
 src/Generator/Driver.cs                       |   2 +-
 src/Generator/Generator.lua                   |   5 +-
 .../Generators/CSharp/CSharpTextTemplate.cs   |  36 ++-
 .../GetterSetterToPropertyAdvancedPass.cs     | 245 +++++++++++++++
 .../Passes/GetterSetterToPropertyPass.cs      | 279 ++++++------------
 5 files changed, 363 insertions(+), 204 deletions(-)
 create mode 100644 src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs

diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs
index 6c790857..7fa742a8 100644
--- a/src/Generator/Driver.cs
+++ b/src/Generator/Driver.cs
@@ -159,7 +159,7 @@ namespace CppSharp
                 TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass());
             }
             if (Options.GenerateProperties)
-                TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass());
+                TranslationUnitPasses.AddPass(new GetterSetterToPropertyAdvancedPass());
         }
 
         public void ProcessCode()
diff --git a/src/Generator/Generator.lua b/src/Generator/Generator.lua
index bfe88b43..f8fcb194 100644
--- a/src/Generator/Generator.lua
+++ b/src/Generator/Generator.lua
@@ -4,7 +4,10 @@ project "CppSharp.Generator"
   language "C#"
   location "."
 
-  files   { "**.cs", "**.bmp", "**.resx", "**.config" }
+  files   { "**.cs", "**.bmp", "**.resx", "**.config", "**verbs.txt" }
   excludes { "Filter.cs" }
   
   links { "System", "System.Core", "CppSharp.AST", "CppSharp.Parser" }
+  
+  configuration '**verbs.txt'
+    buildaction "Embed"
diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
index e7bd048c..a4033148 100644
--- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
+++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs
@@ -898,7 +898,7 @@ namespace CppSharp.Generators.CSharp
                     PopBlock(NewLineKind.BeforeNextBlock);
                     return;
                 }
-                WriteLine("");
+                NewLine();
                 WriteStartBraceIndent();
                 Method method = function as Method;
                 if (method != null && method.IsOverride && method.IsSynthetized)
@@ -918,7 +918,7 @@ namespace CppSharp.Generators.CSharp
             }
             else if (decl is Field)
             {
-                WriteLine("");
+                NewLine();
                 WriteStartBraceIndent();
                 var field = decl as Field;
 
@@ -944,7 +944,7 @@ namespace CppSharp.Generators.CSharp
             }
             else if (decl is Variable)
             {
-                WriteLine("");
+                NewLine();
                 WriteStartBraceIndent();
                 var @var = decl as Variable;
                 var libSymbol = GetDeclarationLibrarySymbol(@var);
@@ -1264,18 +1264,7 @@ namespace CppSharp.Generators.CSharp
             }
             else
             {
-                var property = ((Class) method.Namespace).Properties.FirstOrDefault(
-                    p => p.GetMethod == method);
-                if (property == null)
-                {
-                    property = ((Class) method.Namespace).Properties.First(
-                        p => p.SetMethod == method);
-                    WriteLine("target.{0} = {1};", property.Name, string.Join(", ", marshals));
-                }
-                else
-                {
-                    WriteLine("target.{0};", property.Name);
-                }
+                InvokeProperty(method, marshals);
             }
 
             // TODO: Handle hidden structure return types.
@@ -1306,6 +1295,23 @@ namespace CppSharp.Generators.CSharp
             }
         }
 
+        private void InvokeProperty(Declaration method, IEnumerable<string> marshals)
+        {
+            var property = ((Class) method.Namespace).Properties.FirstOrDefault(
+                p => p.GetMethod == method);
+            if (property == null)
+            {
+                property = ((Class) method.Namespace).Properties.First(
+                    p => p.SetMethod == method);
+                WriteLine("target.{0} = {1};", SafeIdentifier(property.Name),
+                    string.Join(", ", marshals));
+            }
+            else
+            {
+                WriteLine("target.{0};", SafeIdentifier(property.Name));
+            }
+        }
+
         private void GenerateVTableMethodDelegates(Class @class, Method method)
         {
             PushBlock(CSharpBlockKind.VTableDelegate);
diff --git a/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs b/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs
new file mode 100644
index 00000000..aa16af61
--- /dev/null
+++ b/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs
@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using CppSharp.AST;
+
+namespace CppSharp.Passes
+{
+    class GetterSetterToPropertyAdvancedPass : TranslationUnitPass
+    {
+        // collect all types of methods first to be able to match pairs and detect virtuals and overrides;
+        // (a property needs to) be virtual or an override if either of its constituent methods are such)
+        private readonly List<Method> setters = new List<Method>();
+        private readonly List<Method> setMethods = new List<Method>();
+        private readonly List<Method> nonSetters = new List<Method>();
+        private readonly HashSet<Method> getters = new HashSet<Method>();
+        private static readonly HashSet<string> verbs = new HashSet<string>();
+
+        static GetterSetterToPropertyAdvancedPass()
+        {
+            LoadVerbs();
+        }
+
+        private static void LoadVerbs()
+        {
+            using (var resourceStream = Assembly.GetExecutingAssembly()
+                .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt"))
+            {
+                using (StreamReader streamReader = new StreamReader(resourceStream))
+                    while (!streamReader.EndOfStream)
+                        verbs.Add(streamReader.ReadLine());
+            }
+        }
+
+        public GetterSetterToPropertyAdvancedPass()
+        {
+            Options.VisitClassFields = false;
+            Options.VisitClassProperties = false;
+            Options.VisitNamespaceEnums = false;
+            Options.VisitNamespaceTemplates = false;
+            Options.VisitNamespaceTypedefs = false;
+            Options.VisitNamespaceEvents = false;
+            Options.VisitNamespaceVariables = false;
+            Options.VisitFunctionParameters = false;
+            Options.VisitTemplateArguments = false;
+        }
+
+        public override bool VisitTranslationUnit(TranslationUnit unit)
+        {
+            bool result = base.VisitTranslationUnit(unit);
+            GenerateProperties();
+            return result;
+        }
+
+        public override bool VisitMethodDecl(Method method)
+        {
+            if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator &&
+                !method.Ignore)
+                DistributeMethod(method);
+            return base.VisitMethodDecl(method);
+        }
+
+        public void GenerateProperties()
+        {
+            GenerateProperties(setters, false);
+            GenerateProperties(setMethods, true);
+
+            foreach (Method getter in 
+                from getter in getters
+                where getter.IsGenerated &&
+                      ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name)
+                select getter)
+            {
+                // Make it a read-only property
+                GenerateProperty(getter.Namespace, getter);
+            }
+        }
+
+        private void GenerateProperties(IEnumerable<Method> settersToUse, bool readOnly)
+        {
+            foreach (var group in settersToUse.GroupBy(m => m.Namespace))
+            {
+                foreach (var setter in group)
+                {
+                    Class type = (Class) setter.Namespace;
+                    StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3));
+                    if (char.IsLower(setter.Name[0]))
+                        nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]);
+                    string afterSet = nameBuilder.ToString();
+                    foreach (var getter in nonSetters.Where(m => m.Namespace == type))
+                    {
+                        string name = GetPropertyName(getter.Name);
+                        if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
+                            getter.ReturnType == setter.Parameters[0].QualifiedType &&
+                            !type.Methods.Any(
+                                m =>
+                                    m != getter &&
+                                    string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
+                        {
+                            GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
+                            goto next;
+                        }
+                    }
+                    Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet });
+                    if (!type.IsInterface && baseVirtualProperty != null)
+                    {
+                        bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                        GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod,
+                            readOnly || isReadOnly ? null : setter);
+                    }
+                    next:
+                    ;
+                }
+            }
+            foreach (Method nonSetter in nonSetters)
+            {
+                Class type = (Class) nonSetter.Namespace;
+                string name = GetPropertyName(nonSetter.Name);
+                Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
+                if (!type.IsInterface && baseVirtualProperty != null)
+                {
+                    bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                    if (readOnly == isReadOnly)
+                    {
+                        GenerateProperty(nonSetter.Namespace, nonSetter,
+                            readOnly ? null : baseVirtualProperty.SetMethod);
+                    }
+                }
+            }
+        }
+
+        private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null)
+        {
+            Class type = (Class) context;
+            if (type.Properties.All(
+                p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 ||
+                     p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
+            {
+                Property property = new Property();
+                property.Name = GetPropertyName(getter.Name);
+                property.Namespace = type;
+                property.QualifiedType = getter.ReturnType;
+                if (getter.IsOverride || (setter != null && setter.IsOverride))
+                {
+                    Property baseVirtualProperty = type.GetRootBaseProperty(property);
+                    if (baseVirtualProperty.SetMethod == null)
+                        setter = null;
+                    foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
+                        method.Name = "get" + method.Name;
+                }
+                property.GetMethod = getter;
+                property.SetMethod = setter;
+                property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl;
+                if (property.ExplicitInterfaceImpl == null && setter != null)
+                {
+                    property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl;
+                }
+                if (getter.Comment != null)
+                {
+                    var comment = new RawComment();
+                    comment.Kind = getter.Comment.Kind;
+                    comment.BriefText = getter.Comment.BriefText;
+                    comment.Text = getter.Comment.Text;
+                    comment.FullComment = new FullComment();
+                    comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks);
+                    if (setter != null && setter.Comment != null)
+                    {
+                        comment.BriefText += Environment.NewLine + setter.Comment.BriefText;
+                        comment.Text += Environment.NewLine + setter.Comment.Text;
+                        comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks);
+                    }
+                    property.Comment = comment;
+                }
+                type.Properties.Add(property);
+                getter.IsGenerated = false;
+                if (setter != null)
+                    setter.IsGenerated = false;
+            }
+        }
+
+        private static string GetPropertyName(string name)
+        {
+            if (GetFirstWord(name) == "get")
+            {
+                if (char.IsLower(name[0]))
+                {
+                    if (name.Length == 4)
+                    {
+                        return char.ToLowerInvariant(
+                            name[3]).ToString(CultureInfo.InvariantCulture);
+                    }
+                    return char.ToLowerInvariant(
+                        name[3]).ToString(CultureInfo.InvariantCulture) +
+                                    name.Substring(4);
+                }
+                return name.Substring(3);
+            }
+            return name;
+        }
+
+        private void DistributeMethod(Method method)
+        {
+            if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 &&
+                method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void))
+            {
+                if (method.Parameters.Count == 1)
+                    setters.Add(method);
+                else
+                    setMethods.Add(method);
+            }
+            else
+            {
+                if (IsGetter(method))
+                    getters.Add(method);
+                if (method.Parameters.Count == 0)
+                    nonSetters.Add(method);
+            }
+        }
+
+        private bool IsGetter(Method method)
+        {
+            if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) ||
+                method.Parameters.Count > 0 || method.IsDestructor)
+                return false;
+            var result = GetFirstWord(method.Name);
+            return (result.Length < method.Name.Length &&
+                    (result == "get" || result == "is" || result == "has")) ||
+                   (result != "to" && result != "new" && !verbs.Contains(result));
+        }
+
+        private static string GetFirstWord(string name)
+        {
+            List<char> firstVerb = new List<char>
+                                    {
+                                        char.ToLowerInvariant(name[0])
+                                    };
+            firstVerb.AddRange(name.Skip(1).TakeWhile(
+                c => char.IsLower(c) || !char.IsLetterOrDigit(c)));
+            return new string(firstVerb.ToArray());
+        }
+    }
+}
diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs
index fc14ed78..3ad2ebbd 100644
--- a/src/Generator/Passes/GetterSetterToPropertyPass.cs
+++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs
@@ -1,10 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
 using System.Linq;
-using System.Reflection;
-using System.Text;
 using CppSharp.AST;
 
 namespace CppSharp.Passes
@@ -15,12 +10,6 @@ namespace CppSharp.Passes
     /// </summary>
     public class GetterSetterToPropertyPass : TranslationUnitPass
     {
-        private readonly List<Method> setters = new List<Method>();
-        private readonly List<Method> setMethods = new List<Method>();
-        private readonly List<Method> nonSetters = new List<Method>();
-        private readonly HashSet<Method> getters = new HashSet<Method>();
-        private readonly HashSet<string> verbs = new HashSet<string>();
-
         public GetterSetterToPropertyPass()
         {
             Options.VisitClassFields = false;
@@ -32,207 +21,123 @@ namespace CppSharp.Passes
             Options.VisitNamespaceVariables = false;
             Options.VisitFunctionParameters = false;
             Options.VisitTemplateArguments = false;
-            using (var resourceStream = Assembly.GetExecutingAssembly()
-                .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt"))
-            {
-                using (StreamReader streamReader = new StreamReader(resourceStream))
-                    while (!streamReader.EndOfStream)
-                        verbs.Add(streamReader.ReadLine());
-            }
         }
 
-        public override bool VisitTranslationUnit(TranslationUnit unit)
+        static bool IsSetter(Function method)
         {
-            bool result = base.VisitTranslationUnit(unit);
-            GenerateProperties();
-            return result;
-        }
+            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
+                PrimitiveType.Void);
 
-        public override bool VisitMethodDecl(Method method)
-        {
-            if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator &&
-                !method.Ignore)
-                DistributeMethod(method);
-            return base.VisitMethodDecl(method);
-        }
+            var isSetter = method.OriginalName.StartsWith("set",
+                StringComparison.InvariantCultureIgnoreCase);
 
-        public void GenerateProperties()
-        {
-            GenerateProperties(setters, false);
-            GenerateProperties(setMethods, true);
-
-            foreach (Method getter in 
-                from getter in getters
-                where getter.IsGenerated &&
-                      ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name)
-                select getter)
-            {
-                // Make it a read-only property
-                GenerateProperty(getter.Namespace, getter);
-            }
+            return isRetVoid && isSetter && method.Parameters.Count == 1;
         }
 
-        private void GenerateProperties(IEnumerable<Method> settersToUse, bool readOnly)
+        static bool IsGetter(Function method)
         {
-            foreach (var group in settersToUse.GroupBy(m => m.Namespace))
-            {
-                foreach (var setter in group)
-                {
-                    Class type = (Class) setter.Namespace;
-                    StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3));
-                    if (char.IsLower(setter.Name[0]))
-                        nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]);
-                    string afterSet = nameBuilder.ToString();
-                    foreach (var getter in nonSetters.Where(m => m.Namespace == type))
-                    {
-                        string name = GetPropertyName(getter.Name);
-                        if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
-                            getter.ReturnType == setter.Parameters[0].QualifiedType &&
-                            !type.Methods.Any(
-                                m =>
-                                    m != getter &&
-                                    string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
-                        {
-                            GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
-                            goto next;
-                        }
-                    }
-                    Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet });
-                    if (!type.IsInterface && baseVirtualProperty != null)
-                    {
-                        bool isReadOnly = baseVirtualProperty.SetMethod == null;
-                        GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod,
-                            readOnly || isReadOnly ? null : setter);
-                    }
-                    next:
-                    ;
-                }
-            }
-            foreach (Method nonSetter in nonSetters)
-            {
-                Class type = (Class) nonSetter.Namespace;
-                string name = GetPropertyName(nonSetter.Name);
-                Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
-                if (!type.IsInterface && baseVirtualProperty != null)
-                {
-                    bool isReadOnly = baseVirtualProperty.SetMethod == null;
-                    if (readOnly == isReadOnly)
-                    {
-                        GenerateProperty(nonSetter.Namespace, nonSetter,
-                            readOnly ? null : baseVirtualProperty.SetMethod);
-                    }
-                }
-            }
-        }
+            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
+                PrimitiveType.Void);
 
-        private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null)
-        {
-            Class type = (Class) context;
-            if (type.Properties.All(
-                p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 ||
-                     p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
-            {
-                Property property = new Property();
-                property.Name = GetPropertyName(getter.Name);
-                property.Namespace = type;
-                property.QualifiedType = getter.ReturnType;
-                if (getter.IsOverride || (setter != null && setter.IsOverride))
-                {
-                    Property baseVirtualProperty = type.GetRootBaseProperty(property);
-                    if (baseVirtualProperty.SetMethod == null)
-                        setter = null;
-                    foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
-                        method.Name = "get" + method.Name;
-                }
-                property.GetMethod = getter;
-                property.SetMethod = setter;
-                property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl;
-                if (property.ExplicitInterfaceImpl == null && setter != null)
-                {
-                    property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl;
-                }
-                if (getter.Comment != null)
-                {
-                    var comment = new RawComment();
-                    comment.Kind = getter.Comment.Kind;
-                    comment.BriefText = getter.Comment.BriefText;
-                    comment.Text = getter.Comment.Text;
-                    comment.FullComment = new FullComment();
-                    comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks);
-                    if (setter != null && setter.Comment != null)
-                    {
-                        comment.BriefText += Environment.NewLine + setter.Comment.BriefText;
-                        comment.Text += Environment.NewLine + setter.Comment.Text;
-                        comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks);
-                    }
-                    property.Comment = comment;
-                }
-                type.Properties.Add(property);
-                getter.IsGenerated = false;
-                if (setter != null)
-                    setter.IsGenerated = false;
-            }
+            var isGetter = method.OriginalName.StartsWith("get",
+                StringComparison.InvariantCultureIgnoreCase);
+
+            return !isRetVoid && isGetter && method.Parameters.Count == 0;
         }
 
-        private static string GetPropertyName(string name)
+        Property GetOrCreateProperty(Class @class, string name, QualifiedType type)
         {
-            if (GetFirstWord(name) == "get")
+            var prop = @class.Properties.FirstOrDefault(property => property.Name == name
+                && property.QualifiedType.Equals(type));
+
+            var prop2 = @class.Properties.FirstOrDefault(property => property.Name == name);
+
+            if (prop == null && prop2 != null)
+                Driver.Diagnostics.EmitWarning(DiagnosticId.PropertySynthetized,
+                    "Property {0}::{1} already exist with type {2}", @class.Name, name, type.Type.ToString());
+
+            if (prop != null)
+                return prop;
+
+            prop = new Property
             {
-                if (char.IsLower(name[0]))
-                {
-                    if (name.Length == 4)
-                    {
-                        return char.ToLowerInvariant(
-                            name[3]).ToString(CultureInfo.InvariantCulture);
-                    }
-                    return char.ToLowerInvariant(
-                        name[3]).ToString(CultureInfo.InvariantCulture) +
-                                    name.Substring(4);
-                }
-                return name.Substring(3);
-            }
-            return name;
+                Name = name,
+                Namespace = @class,
+                QualifiedType = type
+            };
+
+            @class.Properties.Add(prop);
+            return prop;
         }
 
-        private void DistributeMethod(Method method)
+        public override bool VisitMethodDecl(Method method)
         {
-            if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 &&
-                method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void))
+            if (AlreadyVisited(method))
+                return false;
+
+            if (ASTUtils.CheckIgnoreMethod(method))
+                return false;
+
+            var @class = method.Namespace as Class;
+
+            if (@class == null || @class.IsIncomplete)
+                return false;
+
+            if (IsGetter(method))
             {
-                if (method.Parameters.Count == 1)
-                    setters.Add(method);
-                else
-                    setMethods.Add(method);
+                var name = method.Name.Substring("get".Length);
+                var prop = GetOrCreateProperty(@class, name, method.ReturnType);
+                prop.GetMethod = method;
+                prop.Access = method.Access;
+
+                // Do not generate the original method now that we know it is a getter.
+                method.IsGenerated = false;
+
+                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
+                    "Getter created: {0}::{1}", @class.Name, name);
+
+                return false;
             }
-            else
+
+            if (IsSetter(method) && IsValidSetter(method))
             {
-                if (IsGetter(method))
-                    getters.Add(method);
-                if (method.Parameters.Count == 0)
-                    nonSetters.Add(method);
+                var name = method.Name.Substring("set".Length);
+
+                var type = method.Parameters[0].QualifiedType;
+                var prop = GetOrCreateProperty(@class, name, type);
+                prop.SetMethod = method;
+                prop.Access = method.Access;
+
+                // Ignore the original method now that we know it is a setter.
+                method.IsGenerated = false;
+
+                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
+                    "Setter created: {0}::{1}", @class.Name, name);
+
+                return false;
             }
+
+            return false;
         }
 
-        private bool IsGetter(Method method)
+        // Check if a matching getter exist or no other setter exists.
+        private bool IsValidSetter(Method method)
         {
-            if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) ||
-                method.Parameters.Count > 0 || method.IsDestructor)
+            var @class = method.Namespace as Class;
+            var name = method.Name.Substring("set".Length);
+
+            if (method.Parameters.Count == 0)
                 return false;
-            var result = GetFirstWord(method.Name);
-            return (result.Length < method.Name.Length &&
-                    (result == "get" || result == "is" || result == "has")) ||
-                   (result != "to" && result != "new" && !verbs.Contains(result));
-        }
 
-        private static string GetFirstWord(string name)
-        {
-            List<char> firstVerb = new List<char>
-                                    {
-                                        char.ToLowerInvariant(name[0])
-                                    };
-            firstVerb.AddRange(name.Skip(1).TakeWhile(
-                c => char.IsLower(c) || !char.IsLetterOrDigit(c)));
-            return new string(firstVerb.ToArray());
+            var type = method.Parameters[0].Type;
+
+            var getter = @class.Methods.FirstOrDefault(m => m.Name == "Get" + name && m.Type.Equals(type));
+
+            var otherSetter = @class.Methods.FirstOrDefault(m => m.Name == method.Name
+                && m.Parameters.Count == 1 
+                && !m.Parameters[0].Type.Equals(type));
+
+            return getter != null || otherSetter == null;
         }
     }
 }