diff --git a/org.eclipse.vex.sdk.feature/.settings/org.eclipse.core.resources.prefs b/org.eclipse.vex.sdk.feature/.settings/org.eclipse.core.resources.prefs
index 3750df1..3d916f2 100644
--- a/org.eclipse.vex.sdk.feature/.settings/org.eclipse.core.resources.prefs
+++ b/org.eclipse.vex.sdk.feature/.settings/org.eclipse.core.resources.prefs
@@ -1,3 +1,2 @@
-#Sun Dec 16 16:57:57 EST 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
+eclipse.preferences.version=1
+encoding/<project>=Cp1252
diff --git a/org.eclipse.vex.sdk.feature/.settings/org.eclipse.m2e.core.prefs b/org.eclipse.vex.sdk.feature/.settings/org.eclipse.m2e.core.prefs
new file mode 100644
index 0000000..14b697b
--- /dev/null
+++ b/org.eclipse.vex.sdk.feature/.settings/org.eclipse.m2e.core.prefs
@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
