Index: /Code/ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java
===================================================================
--- /Code/ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java	(revision 66)
+++ /Code/ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java	(revision 67)
@@ -1,4 +1,5 @@
 package de.uni_hildesheim.sse.trans.convert;
 
+import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -83,8 +84,8 @@
         
         List<ConstraintSyntaxTree> parts = new ArrayList<ConstraintSyntaxTree>();
-        // for each combination of the variables (true or false)
-        // TODO: only works for up to 16 vars
         if (declarationArray.length >= 16) {
-            System.out.println("Skipping too long Constraint");
+            System.out.println("Handling big constraint: " + declarationArray.length);
+            handleBigConstraint(originalConstraint, declarationArray, config, parts);
+            System.out.println("Done.");
         } else {
             handleSmallConstraint(originalConstraint, declarationArray, config, parts);
@@ -109,4 +110,5 @@
         EvaluationVisitor evalVisitor = new EvaluationVisitor();
         evalVisitor.init(config, null, false, null);
+        // for each combination of the variables (true or false)
         for (int i = 0; i < Math.pow(2, declarationArray.length); i++) {
             boolean[] state = new boolean[declarationArray.length];
@@ -119,4 +121,67 @@
                  */
                 if ((i & (1 << j)) != 0) {
+                    state[j] = true;
+                    try {
+                        decisionVar.setValue(BooleanValue.TRUE, AssignmentState.ASSIGNED);
+                    } catch (ConfigurationException e) {
+                        // TODO
+                        LOGGER.exception(e);
+                    }
+                } else {
+                    state[j] = false;
+                    try {
+                        decisionVar.setValue(BooleanValue.FALSE, AssignmentState.ASSIGNED);
+                    } catch (ConfigurationException e) {
+                        // TODO
+                        LOGGER.exception(e);
+                    }
+                }
+            }
+            
+            // get the result
+            originalConstraint.accept(evalVisitor);
+            boolean result = evalVisitor.constraintFulfilled();
+            
+            // if the result it false, add the negated combination to the list of expressions
+            if (!result) {
+                parts.add(createNegatedORExpression(declarationArray, state)); 
+            }
+            
+            // 1 * init() + n * clearResult() is much faster than n * (init() + clear())
+            evalVisitor.clearResult();
+        }
+    }
+    
+    /**
+     * Converts a constraint into a CNF formula.
+     * This constraint can have any number of {@link AbstractVariable}s, but for small constraints
+     * {@link MaxTermConverter#handleSmallConstraint} is recommended.
+     * @param originalConstraint The constraint which shall be converted into CNF formula.
+     *     this constraint may consists only of AND, OR, and NOT operations.
+     * @param declarationArray The {@link AbstractVariable}s, which are used inside the <tt>originalConstraint</tt>.
+     * @param config A temporary {@link Configuration} containing only <tt>originalConstraint</tt>
+     *     and <tt>declarationArray</tt>
+     * @param parts An empty list, where the resulting disjunctions terms of the CNF formula shall be added to
+     */
+    protected void handleBigConstraint(ConstraintSyntaxTree originalConstraint, AbstractVariable[] declarationArray,
+            Configuration config, List<ConstraintSyntaxTree> parts) {
+        
+        EvaluationVisitor evalVisitor = new EvaluationVisitor();
+        evalVisitor.init(config, null, false, null);
+        // for each combination of the variables (true or false)
+        for (BigInteger i = new BigInteger("0"); i.compareTo(new BigInteger("2").pow(declarationArray.length)) == -1;
+                i = i.add(new BigInteger("1"))) {
+            if (i.mod(new BigInteger("1000")).compareTo(new BigInteger("0")) == 0) {
+                System.out.println(i + "/" + new BigInteger("2").pow(declarationArray.length));
+            }
+            boolean[] state = new boolean[declarationArray.length];
+            for (int j = 0; j < state.length; j++) {
+                IDecisionVariable decisionVar = config.getDecision(declarationArray[j]);
+                /*
+                 * i is a bit-field where each bit represents one variable
+                 * j is the current variable
+                 * To test if variable #j is true check if the bit #j in i is 0 or 1
+                 */
+                if (i.testBit(j)) {
                     state[j] = true;
                     try {
Index: /Code/ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/MaxTermConverterTest.java
===================================================================
--- /Code/ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/MaxTermConverterTest.java	(revision 66)
+++ /Code/ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/MaxTermConverterTest.java	(revision 67)
@@ -70,5 +70,5 @@
         ConstraintFinder finder = new ConstraintFinder(testProject);
         for (Constraint c : finder.getConstraints()) {
-            testConstraint(c.getConsSyntax());
+            testConstraintOnlyContainsORandNOT(c.getConsSyntax());
         }
     }
@@ -78,10 +78,45 @@
      * @param tree The constraint to be tested.
      */
-    private void testConstraint(ConstraintSyntaxTree tree) {
+    private void testConstraintOnlyContainsORandNOT(ConstraintSyntaxTree tree) {
         if (tree instanceof OCLFeatureCall) {
             OCLFeatureCall call = (OCLFeatureCall) tree;
             Assert.assertTrue(call.getOperation().equals(OclKeyWords.OR)
                     || call.getOperation().equals(OclKeyWords.NOT));
-            testConstraint(call.getOperand());
+            testConstraintOnlyContainsORandNOT(call.getOperand());
+        }
+    }
+    
+    /**
+     * Tests the convert method with a constraint with more than 15 variables.
+     */
+    @Test
+    public void testConvertWithBigConstraint() {
+        Variable[] vars = new Variable[18];
+        for (int i = 0; i < vars.length; i++) {
+            vars[i] = new Variable(new DecisionVariableDeclaration((char) ('a' + i) + "", BooleanType.TYPE, null));
+        }
+        
+        ConstraintSyntaxTree term = vars[0];
+        for (int i = 1; i < vars.length; i++) {
+            if (Math.random() > 0.5) {
+                term = new OCLFeatureCall(term, OclKeyWords.OR, vars[i]);
+            } else {
+                term = new OCLFeatureCall(term, OclKeyWords.OR, new OCLFeatureCall(vars[i], OclKeyWords.NOT));
+            }
+        }
+        
+        Project testProject = new Project("TestProject");
+        Constraint constraint = new Constraint(testProject);
+        try {
+            constraint.setConsSyntax(term);
+        } catch (CSTSemanticException e) {
+            Assert.fail(e.getMessage());
+        }
+        
+        new MaxTermConverter().convert(constraint);
+        
+        ConstraintFinder finder = new ConstraintFinder(testProject);
+        for (Constraint c : finder.getConstraints()) {
+            testConstraintOnlyContainsORandNOT(c.getConsSyntax());
         }
     }