diff --git a/Mage.Tests/src/test/java/mage/ManaSymbolTest.java b/Mage.Tests/src/test/java/mage/ManaSymbolTest.java
index 695a56dfcc0..bef292a27b8 100644
--- a/Mage.Tests/src/test/java/mage/ManaSymbolTest.java
+++ b/Mage.Tests/src/test/java/mage/ManaSymbolTest.java
@@ -34,7 +34,7 @@ public class ManaSymbolTest {
         assertTrue(w.isMonocolored());
 
         assertEquals(null, w.getManaSymbol1());
-        assertEquals(null, w.getManaSymbol1());
+        assertEquals(null, w.getManaSymbol2());
     }
 
     @Test
@@ -62,7 +62,7 @@ public class ManaSymbolTest {
         assertTrue(u.isMonocolored());
 
         assertEquals(null, u.getManaSymbol1());
-        assertEquals(null, u.getManaSymbol1());
+        assertEquals(null, u.getManaSymbol2());
     }
 
 
@@ -91,7 +91,7 @@ public class ManaSymbolTest {
         assertTrue(b.isMonocolored());
 
         assertEquals(null, b.getManaSymbol1());
-        assertEquals(null, b.getManaSymbol1());
+        assertEquals(null, b.getManaSymbol2());
     }
 
     @Test
@@ -119,7 +119,7 @@ public class ManaSymbolTest {
         assertTrue(r.isMonocolored());
 
         assertEquals(null, r.getManaSymbol1());
-        assertEquals(null, r.getManaSymbol1());
+        assertEquals(null, r.getManaSymbol2());
     }
 
 
@@ -148,7 +148,208 @@ public class ManaSymbolTest {
         assertTrue(g.isMonocolored());
 
         assertEquals(null, g.getManaSymbol1());
-        assertEquals(null, g.getManaSymbol1());
+        assertEquals(null, g.getManaSymbol2());
     }
 
+    @Test
+    public void shouldCreateGenericManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol x = ManaSymbol.X;
+
+        // then
+        assertEquals("{X}", x.toString());
+        assertFalse(x.isBlue());
+        assertFalse(x.isWhite());
+        assertFalse(x.isBlack());
+        assertFalse(x.isRed());
+        assertFalse(x.isGreen());
+        assertFalse(x.isColored());
+        assertFalse(x.isSnow());
+        assertFalse(x.isPhyrexian());
+        assertFalse(x.isHybrid());
+        assertFalse(x.isPrimary());
+        assertFalse(x.isMonocolored());
+
+        assertTrue(x.isGeneric());
+        assertTrue(x.isColorless());
+
+        assertEquals(null, x.getManaSymbol1());
+        assertEquals(null, x.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateNumericManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol numeric = ManaSymbol.NUMERIC;
+
+        // then
+        assertEquals("{N/A}", numeric.toString());
+        assertFalse(numeric.isBlue());
+        assertFalse(numeric.isWhite());
+        assertFalse(numeric.isBlack());
+        assertFalse(numeric.isRed());
+        assertFalse(numeric.isGreen());
+        assertFalse(numeric.isColored());
+        assertFalse(numeric.isSnow());
+        assertFalse(numeric.isPhyrexian());
+        assertFalse(numeric.isHybrid());
+        assertFalse(numeric.isPrimary());
+        assertFalse(numeric.isMonocolored());
+
+        assertTrue(numeric.isGeneric());
+        assertTrue(numeric.isColorless());
+
+        assertEquals(null, numeric.getManaSymbol1());
+        assertEquals(null, numeric.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateMonoColoredHybridWManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol monoHybridW = ManaSymbol.MONOCOLORED_HYBRID_W;
+
+        // then
+        assertEquals("{2/W}", monoHybridW.toString());
+        assertFalse(monoHybridW.isBlue());
+        assertFalse(monoHybridW.isBlack());
+        assertFalse(monoHybridW.isRed());
+        assertFalse(monoHybridW.isGreen());
+        assertFalse(monoHybridW.isSnow());
+        assertFalse(monoHybridW.isPhyrexian());
+        assertFalse(monoHybridW.isPrimary());
+        assertFalse(monoHybridW.isGeneric());
+        assertFalse(monoHybridW.isColorless());
+
+        assertTrue(monoHybridW.isMonocolored());
+        assertTrue(monoHybridW.isHybrid());
+        assertTrue(monoHybridW.isWhite());
+        assertTrue(monoHybridW.isColored());
+
+        assertEquals(ManaSymbol.W, monoHybridW.getManaSymbol1());
+        assertEquals(null, monoHybridW.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateMonoColoredHybridUManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol monoHybridU = ManaSymbol.MONOCOLORED_HYBRID_U;
+
+        // then
+        assertEquals("{2/U}", monoHybridU.toString());
+        assertFalse(monoHybridU.isWhite());
+        assertFalse(monoHybridU.isBlack());
+        assertFalse(monoHybridU.isRed());
+        assertFalse(monoHybridU.isGreen());
+        assertFalse(monoHybridU.isSnow());
+        assertFalse(monoHybridU.isPhyrexian());
+        assertFalse(monoHybridU.isPrimary());
+        assertFalse(monoHybridU.isGeneric());
+        assertFalse(monoHybridU.isColorless());
+
+        assertTrue(monoHybridU.isMonocolored());
+        assertTrue(monoHybridU.isHybrid());
+        assertTrue(monoHybridU.isBlue());
+        assertTrue(monoHybridU.isColored());
+
+        assertEquals(ManaSymbol.U, monoHybridU.getManaSymbol1());
+        assertEquals(null, monoHybridU.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateMonoColoredHybridBManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol monoHybridB = ManaSymbol.MONOCOLORED_HYBRID_B;
+
+        // then
+        assertEquals("{2/B}", monoHybridB.toString());
+        assertFalse(monoHybridB.isBlue());
+        assertFalse(monoHybridB.isWhite());
+        assertFalse(monoHybridB.isRed());
+        assertFalse(monoHybridB.isGreen());
+        assertFalse(monoHybridB.isSnow());
+        assertFalse(monoHybridB.isPhyrexian());
+        assertFalse(monoHybridB.isPrimary());
+        assertFalse(monoHybridB.isGeneric());
+        assertFalse(monoHybridB.isColorless());
+
+        assertTrue(monoHybridB.isMonocolored());
+        assertTrue(monoHybridB.isHybrid());
+        assertTrue(monoHybridB.isBlack());
+        assertTrue(monoHybridB.isColored());
+
+        assertEquals(ManaSymbol.B, monoHybridB.getManaSymbol1());
+        assertEquals(null, monoHybridB.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateMonoColoredHybridRManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol monoHybridR = ManaSymbol.MONOCOLORED_HYBRID_R;
+
+        // then
+        assertEquals("{2/R}", monoHybridR.toString());
+        assertFalse(monoHybridR.isBlack());
+        assertFalse(monoHybridR.isBlue());
+        assertFalse(monoHybridR.isWhite());
+        assertFalse(monoHybridR.isGreen());
+        assertFalse(monoHybridR.isSnow());
+        assertFalse(monoHybridR.isPhyrexian());
+        assertFalse(monoHybridR.isPrimary());
+        assertFalse(monoHybridR.isGeneric());
+        assertFalse(monoHybridR.isColorless());
+
+        assertTrue(monoHybridR.isMonocolored());
+        assertTrue(monoHybridR.isHybrid());
+        assertTrue(monoHybridR.isRed());
+        assertTrue(monoHybridR.isColored());
+
+        assertEquals(ManaSymbol.R, monoHybridR.getManaSymbol1());
+        assertEquals(null, monoHybridR.getManaSymbol2());
+    }
+
+
+    @Test
+    public void shouldCreateMonoColoredHybridGManaSymbol() {
+        // given
+
+        // when
+        ManaSymbol monoHybridG = ManaSymbol.MONOCOLORED_HYBRID_G;
+
+        // then
+        assertEquals("{2/G}", monoHybridG.toString());
+        assertFalse(monoHybridG.isBlack());
+        assertFalse(monoHybridG.isBlue());
+        assertFalse(monoHybridG.isWhite());
+        assertFalse(monoHybridG.isRed());
+        assertFalse(monoHybridG.isSnow());
+        assertFalse(monoHybridG.isPhyrexian());
+        assertFalse(monoHybridG.isPrimary());
+        assertFalse(monoHybridG.isGeneric());
+        assertFalse(monoHybridG.isColorless());
+
+        assertTrue(monoHybridG.isMonocolored());
+        assertTrue(monoHybridG.isHybrid());
+        assertTrue(monoHybridG.isGreen());
+        assertTrue(monoHybridG.isColored());
+
+        assertEquals(ManaSymbol.G, monoHybridG.getManaSymbol1());
+        assertEquals(null, monoHybridG.getManaSymbol2());
+    }
 }
\ No newline at end of file
diff --git a/Mage/src/mage/ManaSymbol.java b/Mage/src/mage/ManaSymbol.java
index bb02c7dee1b..9037e0bd2af 100644
--- a/Mage/src/mage/ManaSymbol.java
+++ b/Mage/src/mage/ManaSymbol.java
@@ -72,11 +72,11 @@ public enum ManaSymbol {
     HYBRID_RW("{R/W}", R, W, Type.HYBRID, Type.COLORED),
     HYBRID_GW("{G/W}", G, W, Type.HYBRID, Type.COLORED),
     HYBRID_GU("{G/U}", G, U, Type.HYBRID, Type.COLORED),
-    MONOCOLORED_HYBRID_W("{2/W}", W, Type.HYBRID, Type.MONOCOLORED),
-    MONOCOLORED_HYBRID_U("{2/U}", U, Type.HYBRID, Type.MONOCOLORED),
-    MONOCOLORED_HYBRID_B("{2/B}", B, Type.HYBRID, Type.MONOCOLORED),
-    MONOCOLORED_HYBRID_R("{2/R}", R, Type.HYBRID, Type.MONOCOLORED),
-    MONOCOLORED_HYBRID_G("{2/G}", G, Type.HYBRID, Type.MONOCOLORED),
+    MONOCOLORED_HYBRID_W("{2/W}", W, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
+    MONOCOLORED_HYBRID_U("{2/U}", U, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
+    MONOCOLORED_HYBRID_B("{2/B}", B, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
+    MONOCOLORED_HYBRID_R("{2/R}", R, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
+    MONOCOLORED_HYBRID_G("{2/G}", G, Type.HYBRID, Type.MONOCOLORED, Type.COLORED),
     PHYREXIAN_W("{W/P}", W, Type.PHYREXIAN, Type.COLORED),
     PHYREXIAN_G("{G/P}", G, Type.PHYREXIAN, Type.COLORED),
     PHYREXIAN_R("{R/P}", R, Type.PHYREXIAN, Type.COLORED),