diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedBooleanSequenceIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedBooleanSequenceIntention.kt
index a7e571850fa..f77cd4b4d4b 100644
--- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedBooleanSequenceIntention.kt
+++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedBooleanSequenceIntention.kt
@@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.jet.lang.psi.JetParenthesizedExpression
 import org.jetbrains.jet.lang.psi.JetPsiUtil
 import org.jetbrains.jet.lang.psi.JetExpression
-import java.util.ArrayList
+import java.util.LinkedList
 
 
 public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingIntention<JetBinaryExpression>(
@@ -52,8 +52,8 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingIntention<
 
         val elements = splitBooleanSequence(element)!!
         val bareExpressions = elements.map { prefixExpression -> prefixExpression.getBaseExpression()!!.getText() }
-        val negatedExpression = bareExpressions.subList(0, bareExpressions.size()-1).foldRight(
-                "!(${bareExpressions.last()}", { negated, expression -> "$expression $operatorText $negated"}
+        val negatedExpression = bareExpressions.subList(0, bareExpressions.lastIndex).foldRight(
+                "!(${bareExpressions.last()}", { negated, expression -> "$expression $operatorText $negated" }
         )
 
         val newExpression = JetPsiFactory.createExpression(element.getProject(), "$negatedExpression)")
@@ -66,12 +66,12 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingIntention<
         }
     }
 
-    fun splitBooleanSequence(expression: JetBinaryExpression) : List<JetPrefixExpression>? {
-        val itemList = ArrayList<JetPrefixExpression>()
+    fun splitBooleanSequence(expression: JetBinaryExpression): List<JetPrefixExpression>? {
+        val itemList = LinkedList<JetPrefixExpression>()
         val firstOperator = expression.getOperationToken()
-        var currentItem : JetBinaryExpression? = expression
+        var currentItem: JetBinaryExpression? = expression
 
-        while(currentItem != null) {
+        while (currentItem != null) {
             if (currentItem!!.getOperationToken() != firstOperator) return null //Boolean sequence must be homogenous
 
             val rightChild = currentItem!!.getRight() as? JetPrefixExpression ?: return null
@@ -79,7 +79,8 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingIntention<
             val leftChild = currentItem!!.getLeft()
             if (leftChild is JetPrefixExpression) {
                 itemList.add(leftChild as JetPrefixExpression)
-            } else if (leftChild !is JetBinaryExpression) {
+            }
+            else if (leftChild !is JetBinaryExpression) {
                 return null
             }
 
diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
index d015ce484a8..6a75fbb403c 100644
--- a/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
+++ b/idea/src/org/jetbrains/jet/plugin/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt
@@ -29,9 +29,10 @@ import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.psi.JetConstantExpression
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
 import java.util.ArrayList
+import java.util.LinkedList
 
 public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingIntention<JetPrefixExpression>(
-        "convert.negated.expression.with.demorgans.law",javaClass()
+        "convert.negated.expression.with.demorgans.law", javaClass()
 ) {
 
     override fun isApplicableTo(element: JetPrefixExpression): Boolean {
@@ -53,7 +54,7 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
     override fun applyTo(element: JetPrefixExpression, editor: Editor) {
         val parenthesizedExpression = element.getBaseExpression() as JetParenthesizedExpression
         val baseExpression = parenthesizedExpression.getExpression() as JetBinaryExpression
-        val operatorText = when(baseExpression.getOperationToken()){
+        val operatorText = when(baseExpression.getOperationToken()) {
             JetTokens.ANDAND -> JetTokens.OROR.getValue()
             JetTokens.OROR -> JetTokens.ANDAND.getValue()
             else -> throw IllegalArgumentException(
@@ -61,29 +62,27 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
         }
         val elements = splitBooleanSequence(baseExpression)
         val negatedElements = elements!!.map { exp -> handleSpecial(exp) }
-        val negatedExpression = negatedElements.subList(0,negatedElements.size()-1).foldRight(
-                "${negatedElements.last()}",{negated, exp-> "$exp $operatorText $negated"})
+        val negatedExpression = negatedElements.subList(0, negatedElements.lastIndex).foldRight(
+                "${negatedElements.last()}", { negated, exp -> "$exp $operatorText $negated" })
 
-        val newExpression = JetPsiFactory.createExpression(element.getProject(),negatedExpression)
+        val newExpression = JetPsiFactory.createExpression(element.getProject(), negatedExpression)
         element.replace(newExpression)
     }
 
-    fun handleSpecial(expression: JetExpression) : String {
+    fun handleSpecial(expression: JetExpression): String {
         return when(expression) {
-            JetTokens.TRUE_KEYWORD -> JetTokens.FALSE_KEYWORD.getValue()
-            JetTokens.FALSE_KEYWORD -> JetTokens.TRUE_KEYWORD.getValue()
             is JetSimpleNameExpression, is JetConstantExpression, is JetPrefixExpression,
             is JetParenthesizedExpression -> "!${expression.getText()}"
             else -> "!(${expression.getText()})"
         }
     }
 
-    fun splitBooleanSequence(expression: JetBinaryExpression) : List<JetExpression>? {
-        val itemList = ArrayList<JetExpression>()
+    fun splitBooleanSequence(expression: JetBinaryExpression): List<JetExpression>? {
+        val itemList = LinkedList<JetExpression>()
         val firstOperator = expression.getOperationToken()
-        var currentItem : JetExpression? = expression
+        var currentItem: JetExpression? = expression
 
-        while(currentItem as? JetBinaryExpression != null) {
+        while (currentItem as? JetBinaryExpression != null) {
             val remainingExpression = currentItem as JetBinaryExpression
             val operation = remainingExpression.getOperationToken()
             if (!(operation == JetTokens.ANDAND || operation == JetTokens.OROR)) break