diff --git a/src/builtin/PRED_$call_2.java b/src/builtin/PRED_$call_2.java
index d036dae..bad81e4 100644
--- a/src/builtin/PRED_$call_2.java
+++ b/src/builtin/PRED_$call_2.java
@@ -50,9 +50,6 @@
 		try {
             return engine.pcl.predicate(Prolog.BUILTIN, functor, cont, args);
 		} catch (ExistenceException e2) {
-		    if ((engine.getUnknown()).equals("fail"))
-			return engine.fail();
-
 		    Term what = new StructureTerm(SYM_COLON_2,
 		       a1,
 		       new StructureTerm(SYM_SLASH_2,
diff --git a/src/builtin/PRED_$get_prolog_impl_flag_2.java b/src/builtin/PRED_$get_prolog_impl_flag_2.java
index 8b314e9..1004c7f 100644
--- a/src/builtin/PRED_$get_prolog_impl_flag_2.java
+++ b/src/builtin/PRED_$get_prolog_impl_flag_2.java
@@ -7,17 +7,8 @@
    @version 1.0
 */
 class PRED_$get_prolog_impl_flag_2 extends Predicate.P2 {
-    private static final SymbolTerm TRUE                      = SymbolTerm.intern("true");
-    private static final SymbolTerm FALSE                     = SymbolTerm.intern("false");
-    private static final SymbolTerm BOUNDED                   = SymbolTerm.intern("bounded");
-    private static final SymbolTerm MAX_INTEGER               = SymbolTerm.intern("max_integer");
-    private static final SymbolTerm MIN_INTEGER               = SymbolTerm.intern("min_integer");
-    private static final SymbolTerm INTEGER_ROUNDING_FUNCTION = SymbolTerm.intern("integer_rounding_function");
-    private static final SymbolTerm CHAR_CONVERSION           = SymbolTerm.intern("char_conversion");
-    private static final SymbolTerm DEBUG                     = SymbolTerm.intern("debug");
-    private static final SymbolTerm MAX_ARITY                 = SymbolTerm.intern("max_arity");
-    private static final SymbolTerm UNKNOWN                   = SymbolTerm.intern("unknown");
-    private static final SymbolTerm DOUBLE_QUOTES             = SymbolTerm.intern("double_quotes");
+    private static final SymbolTerm DEBUG = SymbolTerm.intern("debug");
+    private static final SymbolTerm MAX_ARITY = SymbolTerm.intern("max_arity");
 
     public PRED_$get_prolog_impl_flag_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -33,38 +24,12 @@
 	a1 = a1.dereference();
 	a2 = a2.dereference();
 
-	if (a1.equals(BOUNDED)) {
-	    if (engine.isBounded()) {
-		if (! a2.unify(TRUE, engine.trail))
-		    return engine.fail();
-	    } else {
-		if (! a2.unify(FALSE, engine.trail))
-		    return engine.fail();
-	    }
-	} else if (a1.equals(MAX_INTEGER)) {
-	    if (! a2.unify(new IntegerTerm(engine.getMaxInteger()), engine.trail))
-		return engine.fail();
-	} else if (a1.equals(MIN_INTEGER)) {
-	    if (! a2.unify(new IntegerTerm(engine.getMinInteger()), engine.trail))
-		return engine.fail();
-	} else if (a1.equals(INTEGER_ROUNDING_FUNCTION)) {
-	    if (! a2.unify(SymbolTerm.intern(engine.getIntegerRoundingFunction()), engine.trail))
-		return engine.fail();
-	} else if (a1.equals(CHAR_CONVERSION)) {
-	    if (! a2.unify(SymbolTerm.intern(engine.getCharConversion()), engine.trail))
-		return engine.fail();
-	} else if (a1.equals(DEBUG)) {
+	if (a1.equals(DEBUG)) {
 	    if (! a2.unify(SymbolTerm.intern(engine.getDebug()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(MAX_ARITY)) {
 	    if (! a2.unify(new IntegerTerm(engine.getMaxArity()), engine.trail))
 		return engine.fail();
-	} else if (a1.equals(UNKNOWN)) {
-	    if (! a2.unify(SymbolTerm.intern(engine.getUnknown()), engine.trail))
-		return engine.fail();
-	} else if (a1.equals(DOUBLE_QUOTES)) {
-	    if (! a2.unify(SymbolTerm.intern(engine.getDoubleQuotes()), engine.trail))
-		return engine.fail();
 	} else {
 	    return engine.fail();
 	}
diff --git a/src/builtin/PRED_$set_prolog_impl_flag_2.java b/src/builtin/PRED_$set_prolog_impl_flag_2.java
index 222f656..77b2142 100644
--- a/src/builtin/PRED_$set_prolog_impl_flag_2.java
+++ b/src/builtin/PRED_$set_prolog_impl_flag_2.java
@@ -7,10 +7,7 @@
    @version 1.0
 */
 class PRED_$set_prolog_impl_flag_2 extends Predicate.P2 {
-    private static final SymbolTerm CHAR_CONVERSION   = SymbolTerm.intern("char_conversion");
     private static final SymbolTerm DEBUG             = SymbolTerm.intern("debug");
-    private static final SymbolTerm UNKNOWN           = SymbolTerm.intern("unknown");
-    private static final SymbolTerm DOUBLE_QUOTES     = SymbolTerm.intern("double_quotes");
 
     public PRED_$set_prolog_impl_flag_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -26,22 +23,10 @@
 	a1 = a1.dereference();
 	a2 = a2.dereference();
 
-	if (a1.equals(CHAR_CONVERSION)) {
-	    if (! a2.isSymbol())
-		return engine.fail();
-	    engine.setCharConversion(((SymbolTerm)a2).name());
-	} else if (a1.equals(DEBUG)) {
+	if (a1.equals(DEBUG)) {
 	    if (! a2.isSymbol())
 		return engine.fail();
 	    engine.setDebug(((SymbolTerm)a2).name());
-	} else if (a1.equals(UNKNOWN)) {
-	    if (! a2.isSymbol())
-		return engine.fail();
-	    engine.setUnknown(((SymbolTerm)a2).name());
-	} else if (a1.equals(DOUBLE_QUOTES)) {
-	    if (! a2.isSymbol())
-		return engine.fail();
-	    engine.setDoubleQuotes(((SymbolTerm)a2).name());
 	} else {
 	    return engine.fail();
 	}
diff --git a/src/builtin/builtins.pl b/src/builtin/builtins.pl
index 8e116cb..d0e99c9 100644
--- a/src/builtin/builtins.pl
+++ b/src/builtin/builtins.pl
@@ -1569,12 +1569,8 @@
 current_prolog_flag(Flag, Term) :- 
 	illarg(type(atom), current_prolog_flag(Flag,Term), 1).
 
-'$prolog_impl_flag'(max_integer, _, changeable(no)).
-'$prolog_impl_flag'(min_integer, _, changeable(no)).
 '$prolog_impl_flag'(debug, [on,off], changeable(yes)).
 '$prolog_impl_flag'(max_arity, _, changeable(no)).
-'$prolog_impl_flag'(unknown, [error,fail,warning], changeable(yes)).
-'$prolog_impl_flag'(double_quotes, [chars,codes,atom], changeable(no)).
 
 :- public halt/0.
 :- public abort/0.
diff --git a/src/lang/Prolog.java b/src/lang/Prolog.java
index 5b62ee8..23e9755 100644
--- a/src/lang/Prolog.java
+++ b/src/lang/Prolog.java
@@ -55,24 +55,10 @@
      */
     public int halt;
 
-    /** <font color="red">Not supported yet</font>. Prolog implementation flag: <code>bounded</code>. */
-    protected boolean bounded = false;
-    /** Prolog implementation flag: <code>max_integer</code>. */
-    protected static final int maxInteger = Integer.MAX_VALUE;
-    /** Prolog implementation flag: <code>min_integer</code>. */
-    protected static final int minInteger = Integer.MIN_VALUE;
-    /** Prolog implementation flag: <code>integer_rounding_function</code>. */
-    protected String integerRoundingFunction = "down";
-    /** <font color="red">Not supported yet</font>. Prolog implementation flag: <code>char_conversion</code>. */
-    protected String charConversion;
     /** Prolog implementation flag: <code>debug</code>. */
     protected String debug;
     /** Prolog implementation flag: <code>max_arity</code>. */
     protected int maxArity = 255;
-    /** Prolog implementation flag: <code>unknown</code>. */
-    protected String unknown;
-    /** <font color="red">Not supported yet</font>. Prolog implementation flag: <code>double_quotes</code>. */
-    protected String doubleQuotes;
 
     /** Holds an exception term for <code>catch/3</code> and <code>throw/1</code>. */
     protected Term exception;
@@ -179,12 +165,7 @@
 	stack.push(initialFrame);
 
 	halt = 0;
-
-	charConversion  = "off";
-	debug           = "off";
-	unknown         = "error";
-	doubleQuotes    = "codes";
-
+	debug = "off";
 	exception = NONE;
 	startRuntime = features.contains(Feature.STATISTICS_RUNTIME)
 	    ? System.currentTimeMillis()
@@ -348,23 +329,6 @@
     /** Returns the current time stamp of choice point frame. */
     public long    getCPFTimeStamp() { return CPFTimeStamp; }
 
-    /** Returns the value of Prolog implementation flag: <code>bounded</code>. */
-    public boolean isBounded() { return bounded; }
-
-    /** Returns the value of Prolog implementation flag: <code>max_integer</code>. */
-    public int getMaxInteger() { return maxInteger; }
-
-    /** Returns the value of Prolog implementation flag: <code>min_integer</code>. */
-    public int getMinInteger() { return minInteger; }
-
-    /** Returns the value of Prolog implementation flag: <code>integer_rounding_function</code>. */
-    public String getIntegerRoundingFunction() { return integerRoundingFunction; }
-
-    /** Returns the value of Prolog implementation flag: <code>char_conversion</code>. */
-    public String getCharConversion() { return charConversion; }
-    /** Sets the value of Prolog implementation flag: <code>char_conversion</code>. */
-    public void setCharConversion(String mode) { charConversion = mode;}
-
     /** Returns the value of Prolog implementation flag: <code>debug</code>. */
     public String getDebug() { return debug; }
     /** Sets the value of Prolog implementation flag: <code>debug</code>. */
@@ -373,16 +337,6 @@
     /** Returns the value of Prolog implementation flag: <code>max_arity</code>. */
     public int getMaxArity() { return maxArity; }
 
-    /** Returns the value of Prolog implementation flag: <code>unknown</code>. */
-    public String getUnknown() { return unknown; }
-    /** Sets the value of Prolog implementation flag: <code>unknown</code>. */
-    public void setUnknown(String mode) { unknown = mode;}
-
-    /** Returns the value of Prolog implementation flag: <code>double_quotes</code>. */
-    public String getDoubleQuotes() { return doubleQuotes; }
-    /** Sets the value of Prolog implementation flag: <code>double_quotes</code>. */
-    public void setDoubleQuotes(String mode) { doubleQuotes = mode;}
-
     /** Returns the value of <code>exception</code>. This is used in <code>catch/3</code>. */
     public Term getException() { return exception; }
     /** Sets the value of <code>exception</code>. This is used in <code>throw/1</code>. */
