diff --git a/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj b/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
index f06a575..f00bb8e 100644
--- a/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
@@ -145,6 +145,26 @@
     <Compile Include="Excel\Cells\XLCellsCollection.cs" />
     <Compile Include="Excel\Comments\IXLComment.cs" />
     <Compile Include="Excel\Comments\XLComment.cs" />
+    <Compile Include="Excel\ConditionalFormats\Save\IXLCFConverter.cs" />
+    <Compile Include="Excel\ConditionalFormats\Save\XLCFBeginsWithConverter.cs" />
+    <Compile Include="Excel\ConditionalFormats\Save\XLCFColorScaleConverter.cs" />
+    <Compile Include="Excel\ConditionalFormats\Save\XLCFConverters.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLConditionalFormats.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFDataBarMax.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFDataBarMin.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFColorScaleMax.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFColorScaleMax.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFColorScaleMid.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFColorScaleMin.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFDataBarMax.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFDataBarMin.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLCFIconSet.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLConditionalFormat.cs" />
+    <Compile Include="Excel\ConditionalFormats\IXLConditionalFormats.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFColorScaleMid.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFColorScaleMin.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLCFIconSet.cs" />
+    <Compile Include="Excel\ConditionalFormats\XLConditionalFormat.cs" />
     <Compile Include="Excel\Drawings\IXLDrawingPosition.cs" />
     <Compile Include="Excel\Drawings\Style\XLDrawingFont.cs" />
     <Compile Include="Excel\Drawings\Style\IXLDrawingFont.cs" />
@@ -160,6 +180,7 @@
     <Compile Include="Excel\Coordinates\XLSheetRange.cs" />
     <Compile Include="Excel\Coordinates\XLSheetPoint.cs" />
     <Compile Include="Excel\Drawings\XLDrawingPosition.cs" />
+    <Compile Include="Excel\Misc\XLDictionary.cs" />
     <Compile Include="Excel\Misc\XLIdManager.cs" />
     <Compile Include="Excel\PivotTables\PivotValues\XLPivotValueCombination.cs" />
     <Compile Include="Excel\PivotTables\PivotValues\IXLPivotValueCombination.cs" />
@@ -199,7 +220,6 @@
     <Compile Include="Excel\Drawings\Style\XLDrawingSize.cs" />
     <Compile Include="Excel\Drawings\Style\XLDrawingStyle.cs" />
     <Compile Include="Excel\Drawings\Style\XLDrawingWeb.cs" />
-    <Compile Include="Excel\Style\Dictionary.cs" />
     <Compile Include="Excel\Style\IXLNumberFormatBase.cs" />
     <Compile Include="Excel\Tables\XLTableRange.cs" />
     <Compile Include="Excel\Tables\IXLTableRange.cs" />
@@ -334,6 +354,7 @@
   <ItemGroup>
     <None Include="ClosedXML.snk" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/AutoFilters/XLFilter.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/AutoFilters/XLFilter.cs
index 1f0f639..cf3d8b6 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/AutoFilters/XLFilter.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/AutoFilters/XLFilter.cs
@@ -6,7 +6,7 @@
 namespace ClosedXML.Excel
 {
     public enum XLConnector { And, Or }
-    internal enum XLFilterOperator { Equal, NotEqual, GreaterThan, LessThan, EqualOrGreaterThan, EqualOrLessThan }
+    public enum XLFilterOperator { Equal, NotEqual, GreaterThan, LessThan, EqualOrGreaterThan, EqualOrLessThan }
     internal class XLFilter
     {
         public XLFilter(XLFilterOperator op = XLFilterOperator.Equal)
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs
new file mode 100644
index 0000000..bd1d315
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public interface IXLCFColorScaleMax
+    {
+        void Maximum(XLCFContentType type, String value, IXLColor color);
+        void HighestValue(IXLColor color);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs
new file mode 100644
index 0000000..e04cb1c
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public interface IXLCFColorScaleMid
+    {
+        IXLCFColorScaleMax Midpoint(XLCFContentType type, String value, IXLColor color);
+        void Maximum(XLCFContentType type, String value, IXLColor color);
+        void HighestValue(IXLColor color);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs
new file mode 100644
index 0000000..aaad72a
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public enum XLCFContentType { Number, Percent, Formula, Percentile, Minimum, Maximum }
+    public interface IXLCFColorScaleMin
+    {
+        IXLCFColorScaleMid Minimum(XLCFContentType type, String value, IXLColor color);
+        IXLCFColorScaleMid LowestValue(IXLColor color);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs
new file mode 100644
index 0000000..b5627e5
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public interface IXLCFDataBarMax
+    {
+        void Maximum(XLCFContentType type, String value);
+        void HighestValue();
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs
new file mode 100644
index 0000000..968606a
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public interface IXLCFDataBarMin
+    {
+        IXLCFDataBarMax Minimum(XLCFContentType type, String value);
+        IXLCFDataBarMax LowestValue();
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs
new file mode 100644
index 0000000..f67b986
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public enum XLCFIconSetOperator {GreaterThan, EqualOrGreaterThan}
+    public interface IXLCFIconSet
+    {
+        IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, String value, XLCFContentType type);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs
new file mode 100644
index 0000000..db8c94e
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public enum XLTimePeriod
+    {
+        Yesterday,
+        Today,
+        Tomorrow,
+        InTheLast7Days,
+        LastWeek,
+        ThisWeek,
+        NextWeek,
+        LastMonth,
+        ThisMonth,
+        NextMonth
+    }
+    public enum XLIconSetStyle
+    {
+        ThreeArrows,
+        ThreeArrowsGray,
+        ThreeFlags,
+        ThreeTrafficLights1,
+        ThreeTrafficLights2,
+        ThreeSigns,
+        ThreeSymbols,
+        ThreeSymbols2,
+        FourArrows,
+        FourArrowsGray,
+        FourRedToBlack,
+        FourRating,
+        FourTrafficLights,
+        FiveArrows,
+        FiveArrowsGray,
+        FiveRating,
+        FiveQuarters
+    }
+    public enum XLConditionalFormatType
+    {
+        Expression,
+        CellIs,
+        ColorScale,
+        DataBar,
+        IconSet,
+        Top10,
+        UniqueValues,
+        DuplicateValues,
+        ContainsText,
+        NotContainsText,
+        BeginsWith,
+        EndsWith,
+        ContainsBlanks,
+        NotContainsBlanks,
+        ContainsErrors,
+        NotContainsErrors,
+        TimePeriod,
+        AboveAverage
+    }
+    public enum XLCFOperator { Equal, NotEqual, GreaterThan, LessThan, EqualOrGreaterThan, EqualOrLessThan, Between, NotBetween, Contains, NotContains, StartsWith, EndsWith }
+    public interface IXLConditionalFormat
+    {
+        IXLStyle Style { get; set; }
+
+        IXLStyle WhenIsBlank();
+        IXLStyle WhenNotBlank();
+        IXLStyle WhenIsError();
+        IXLStyle WhenNotError();
+        IXLStyle WhenDateIs(XLTimePeriod timePeriod );
+        IXLStyle WhenContains(String value);
+        IXLStyle WhenNotContains(String value);
+        IXLStyle WhenStartsWith(String value);
+        IXLStyle WhenEndsWith(String value);
+        IXLStyle WhenEqualTo(String value);
+        IXLStyle WhenNotEqualTo(String value);
+        IXLStyle WhenGreaterThan(String value);
+        IXLStyle WhenLessThan(String value);
+        IXLStyle WhenEqualOrGreaterThan(String value);
+        IXLStyle WhenEqualOrLessThan(String value);
+        IXLStyle WhenBetween(String minValue, String maxValue);
+        IXLStyle WhenNotBetween(String minValue, String maxValue);
+        IXLStyle WhenIsDuplicate();
+        IXLStyle WhenNotDuplicate();
+        IXLStyle WhenIsTrue(String formula);
+        IXLStyle WhenIsTop(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items);
+        IXLStyle WhenIsBottom(Int32 value, XLTopBottomType topBottomType);
+
+        IXLCFColorScaleMin ColorScale();
+        IXLCFDataBarMin DataBar(IXLColor color);
+        IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, Boolean reverseIconOrder = false, Boolean showIconOnly = false);
+
+        XLConditionalFormatType ConditionalFormatType { get; }
+        XLIconSetStyle IconSetStyle { get; }
+        XLTimePeriod TimePeriod { get; }
+        Boolean ReverseIconOrder { get; }
+        Boolean ShowIconOnly { get; }
+        IXLRange Range { get; set; }
+
+        XLDictionary<String> Values { get; }
+        XLDictionary<IXLColor> Colors { get; }
+        XLDictionary<XLCFContentType> ContentTypes { get; }
+        XLDictionary<XLCFIconSetOperator> IconSetOperators { get; }
+        
+        XLCFOperator Operator { get; }
+        Boolean Bottom { get;  }
+        Boolean Percent { get; }
+        
+    }
+}
+    
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormats.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormats.cs
new file mode 100644
index 0000000..091f9eb
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormats.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public interface IXLConditionalFormats: IEnumerable<IXLConditionalFormat>
+    {
+        void Add(IXLConditionalFormat conditionalFormat);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs
new file mode 100644
index 0000000..d885fea
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DocumentFormat.OpenXml.Spreadsheet;
+
+namespace ClosedXML.Excel
+{
+    internal interface IXLCFConverter
+    {
+        ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context);
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFBeginsWithConverter.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFBeginsWithConverter.cs
new file mode 100644
index 0000000..fb206b9
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFBeginsWithConverter.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DocumentFormat.OpenXml.Spreadsheet;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFBeginsWithConverter: IXLCFConverter
+    {
+        public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context)
+        {
+            String val = cf.Values[1];
+            var conditionalFormattingRule = new ConditionalFormattingRule {FormatId = (UInt32)context.DifferentialFormats[cf.Style] , Operator = cf.Operator.ToOpenXml(), Text = val ,Type = cf.ConditionalFormatType.ToOpenXml(), Priority = priority };
+
+            var formula = new Formula {Text = "LEFT(" + cf.Range.RangeAddress.FirstAddress.ToStringRelative(false) + "," + val.Length.ToString() + ")=\"" + val + "\""};
+
+            conditionalFormattingRule.Append(formula);
+
+            return conditionalFormattingRule;
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs
new file mode 100644
index 0000000..183310e
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Spreadsheet;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFColorScaleConverter:IXLCFConverter
+    {
+        public ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context)
+        {
+            var conditionalFormattingRule = new ConditionalFormattingRule { Type = cf.ConditionalFormatType.ToOpenXml(), Priority = priority };
+            
+            var colorScale = new ColorScale();
+            for(Int32 i = 1; i <= cf.Values.Count; i++)
+            {
+                var conditionalFormatValueObject = new ConditionalFormatValueObject { Type = cf.ContentTypes[i].ToOpenXml(), Val = cf.Values[i] };
+                colorScale.Append(conditionalFormatValueObject);
+            }
+
+            for (Int32 i = 1; i <= cf.Values.Count; i++)
+            {
+                Color color = new Color { Rgb = cf.Colors[i].Color.ToHex() };
+                colorScale.Append(color);
+            }
+
+            conditionalFormattingRule.Append(colorScale);
+
+            return conditionalFormattingRule;
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs
new file mode 100644
index 0000000..1de99f2
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DocumentFormat.OpenXml.Spreadsheet;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFConverters
+    {
+        private static readonly Dictionary<XLConditionalFormatType, IXLCFConverter> Converters;
+        static XLCFConverters()
+        {
+            Converters = new Dictionary<XLConditionalFormatType, IXLCFConverter>();
+            Converters.Add(XLConditionalFormatType.ColorScale, new XLCFColorScaleConverter());
+            Converters.Add(XLConditionalFormatType.BeginsWith, new XLCFBeginsWithConverter());
+        }
+        public static ConditionalFormattingRule Convert(IXLConditionalFormat conditionalFormat, Int32 priority, XLWorkbook.SaveContext context)
+        {
+            return Converters[conditionalFormat.ConditionalFormatType].Convert(conditionalFormat, priority, context);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs
new file mode 100644
index 0000000..cef3f58
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFColorScaleMax : IXLCFColorScaleMax
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFColorScaleMax(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+
+        public void Maximum(XLCFContentType type, String value, IXLColor color)
+        {
+            _conditionalFormat.Values.Add(value);
+            _conditionalFormat.Colors.Add(color);
+            _conditionalFormat.ContentTypes.Add(type);
+        }
+        public void HighestValue(IXLColor color)
+        {
+            Maximum(XLCFContentType.Maximum, "0", color);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs
new file mode 100644
index 0000000..40fbf22
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFColorScaleMid : IXLCFColorScaleMid
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFColorScaleMid(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+        public IXLCFColorScaleMax Midpoint(XLCFContentType type, String value, IXLColor color)
+        {
+            _conditionalFormat.Values.Add(value);
+            _conditionalFormat.Colors.Add(color);
+            _conditionalFormat.ContentTypes.Add(type);
+            return new XLCFColorScaleMax(_conditionalFormat);
+        }
+        public void Maximum(XLCFContentType type, String value, IXLColor color)
+        {
+            Midpoint(type, value, color);
+        }
+        public void HighestValue(IXLColor color)
+        {
+            Midpoint(XLCFContentType.Maximum, "0", color);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs
new file mode 100644
index 0000000..f9cfb44
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFColorScaleMin : IXLCFColorScaleMin
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFColorScaleMin(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+
+        public IXLCFColorScaleMid Minimum(XLCFContentType type, String value, IXLColor color)
+        {
+            _conditionalFormat.Values.Initialize(value);
+            _conditionalFormat.Colors.Initialize(color);
+            _conditionalFormat.ContentTypes.Initialize(type);
+            return new XLCFColorScaleMid(_conditionalFormat);
+        }
+
+        public IXLCFColorScaleMid LowestValue(IXLColor color)
+        {
+            return Minimum(XLCFContentType.Minimum, "0", color);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs
new file mode 100644
index 0000000..4079d58
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFDataBarMax : IXLCFDataBarMax
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFDataBarMax(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+
+        public void Maximum(XLCFContentType type, String value)
+        {
+            _conditionalFormat.ContentTypes.Add(type);
+            _conditionalFormat.Values.Add(value);
+        }
+
+        public void HighestValue()
+        {
+            Maximum(XLCFContentType.Maximum, "0");
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs
new file mode 100644
index 0000000..c7399d4
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFDataBarMin : IXLCFDataBarMin
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFDataBarMin(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+
+        public IXLCFDataBarMax Minimum(XLCFContentType type, String value)
+        {
+            _conditionalFormat.ContentTypes.Initialize(type);
+            _conditionalFormat.Values.Initialize(value);
+            return new XLCFDataBarMax(_conditionalFormat);
+        }
+
+        public IXLCFDataBarMax LowestValue()
+        {
+            return Minimum(XLCFContentType.Minimum, "0");
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs
new file mode 100644
index 0000000..c9914b7
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLCFIconSet : IXLCFIconSet
+    {
+        private readonly XLConditionalFormat _conditionalFormat;
+        public XLCFIconSet(XLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormat = conditionalFormat;
+        }
+        public IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, String value, XLCFContentType type)
+        {
+            _conditionalFormat.IconSetOperators.Add(setOperator);
+            _conditionalFormat.Values.Add(value);
+            _conditionalFormat.ContentTypes.Add(type);
+            return new XLCFIconSet(_conditionalFormat);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs
new file mode 100644
index 0000000..b80a2cd
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs
@@ -0,0 +1,239 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLConditionalFormat: IXLConditionalFormat, IXLStylized
+    {
+        
+        public XLConditionalFormat(XLRange range)
+        {
+            Range = range;
+            Style = new XLStyle(this, range.Worksheet.Style);
+            Values = new XLDictionary<String>();
+            Colors = new XLDictionary<IXLColor>();
+            ContentTypes = new XLDictionary<XLCFContentType>();
+            IconSetOperators = new XLDictionary<XLCFIconSetOperator>();
+        }
+        private IXLStyle _style;
+        private Int32 _styleCacheId;
+        public IXLStyle Style { get { return GetStyle(); } set { SetStyle(value); } }
+        private IXLStyle GetStyle()
+        {
+            //return _style ?? (_style = new XLStyle(this, Worksheet.Workbook.GetStyleById(_styleCacheId)));
+            if (_style != null)
+                return _style;
+
+            return _style = new XLStyle(this, Range.Worksheet.Workbook.GetStyleById(_styleCacheId));
+        }
+        private void SetStyle(IXLStyle styleToUse)
+        {
+            _styleCacheId = Range.Worksheet.Workbook.GetStyleId(styleToUse);
+            _style = null;
+            StyleChanged = false;
+        }
+
+        public IEnumerable<IXLStyle> Styles
+        {
+            get
+            {
+                UpdatingStyle = true;
+                yield return Style;
+                UpdatingStyle = false;
+            }
+        }
+
+        public bool UpdatingStyle { get; set; }
+
+        public IXLStyle InnerStyle { get; set; }
+
+        public IXLRanges RangesUsed
+        {
+            get { return new XLRanges(); }
+        }
+
+        public bool StyleChanged { get; set; }
+        public IXLRange Range { get; set; }
+        public XLConditionalFormatType ConditionalFormatType { get; set; }
+        public XLTimePeriod TimePeriod { get; private set; }
+        public XLIconSetStyle IconSetStyle { get; private set; }
+        public XLDictionary<String> Values { get; private set; }
+        public XLDictionary<IXLColor> Colors { get; private set; }
+        public XLDictionary<XLCFContentType> ContentTypes { get; private set; }
+        public XLDictionary<XLCFIconSetOperator> IconSetOperators { get; private set; }
+
+        public XLCFOperator Operator { get; private set; }
+        public Boolean Bottom { get; private set; }
+        public Boolean Percent { get; private set; }
+        public Boolean ReverseIconOrder { get; private set; }
+        public Boolean ShowIconOnly { get; private set; }
+
+        public IXLStyle WhenIsBlank()
+        {
+            ConditionalFormatType = XLConditionalFormatType.ContainsBlanks;
+            return Style;
+        }
+        public IXLStyle WhenNotBlank()
+        {
+            ConditionalFormatType = XLConditionalFormatType.NotContainsBlanks;
+            return Style;
+        }
+        public IXLStyle WhenIsError()
+        {
+            ConditionalFormatType = XLConditionalFormatType.ContainsErrors;
+            return Style;
+        }
+        public IXLStyle WhenNotError()
+        {
+            ConditionalFormatType = XLConditionalFormatType.NotContainsErrors;
+            return Style;
+        }
+        public IXLStyle WhenDateIs(XLTimePeriod timePeriod)
+        {
+            TimePeriod = timePeriod;
+            ConditionalFormatType = XLConditionalFormatType.TimePeriod;
+            return Style;
+        }
+        public IXLStyle WhenContains(String value)
+        {
+            Values.Initialize(value);
+            ConditionalFormatType = XLConditionalFormatType.ContainsText;
+            return Style;
+        }
+        public IXLStyle WhenNotContains(String value)
+        {
+            Values.Initialize(value);
+            ConditionalFormatType = XLConditionalFormatType.NotContainsText;
+            return Style;
+        }
+        public IXLStyle WhenStartsWith(String value)
+        {
+            Values.Initialize(value);
+            ConditionalFormatType = XLConditionalFormatType.BeginsWith;
+            Operator = XLCFOperator.StartsWith;
+            return Style;
+        }
+        public IXLStyle WhenEndsWith(String value)
+        {
+            Values.Initialize(value);
+            ConditionalFormatType = XLConditionalFormatType.EndsWith;
+            return Style;
+        }
+        public IXLStyle WhenEqualTo(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.Equal;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenNotEqualTo(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.NotEqual;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenGreaterThan(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.GreaterThan;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenLessThan(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.LessThan;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenEqualOrGreaterThan(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.EqualOrGreaterThan;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenEqualOrLessThan(String value)
+        {
+            Values.Initialize(value);
+            Operator = XLCFOperator.EqualOrLessThan;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenBetween(String minValue, String maxValue)
+        {
+            Values.Initialize(minValue);
+            Values.Add(maxValue);
+            Operator = XLCFOperator.Between;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenNotBetween(String minValue, String maxValue)
+        {
+            Values.Initialize(minValue);
+            Values.Add(maxValue);
+            Operator = XLCFOperator.NotBetween;
+            ConditionalFormatType = XLConditionalFormatType.CellIs;
+            return Style;
+        }
+        public IXLStyle WhenIsDuplicate()
+        {
+            ConditionalFormatType = XLConditionalFormatType.DuplicateValues;
+            return Style;
+        }
+        public IXLStyle WhenNotDuplicate()
+        {
+            ConditionalFormatType = XLConditionalFormatType.UniqueValues;
+            return Style;
+        }
+        public IXLStyle WhenIsTrue(String formula)
+        {
+            Values.Initialize(formula);
+            ConditionalFormatType = XLConditionalFormatType.Expression;
+            return Style;
+        }
+        public IXLStyle WhenIsTop(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items)
+        {
+            Values.Initialize(value.ToString());
+            Percent = topBottomType == XLTopBottomType.Percent;
+            ConditionalFormatType = XLConditionalFormatType.Top10;
+            Bottom = false;
+            return Style;
+        }
+        public IXLStyle WhenIsBottom(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items)
+        {
+            Values.Initialize(value.ToString());
+            Percent = topBottomType == XLTopBottomType.Percent;
+            ConditionalFormatType = XLConditionalFormatType.Top10;
+            Bottom = true;
+            return Style;
+        }
+        
+        public IXLCFColorScaleMin ColorScale()
+        {
+            ConditionalFormatType = XLConditionalFormatType.ColorScale;
+            return new XLCFColorScaleMin(this);
+        }
+        public IXLCFDataBarMin DataBar(IXLColor color)
+        {
+            Colors.Initialize(color);
+            ConditionalFormatType = XLConditionalFormatType.DataBar;
+            return new XLCFDataBarMin(this);
+        }
+        public IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, Boolean reverseIconOrder = false, Boolean showIconOnly = false)
+        {
+            IconSetOperators.Clear();
+            Values.Clear();
+            ContentTypes.Clear();
+            ConditionalFormatType = XLConditionalFormatType.IconSet;
+            IconSetStyle = iconSetStyle;
+            ReverseIconOrder = reverseIconOrder;
+            ShowIconOnly = showIconOnly;
+            return new XLCFIconSet(this);
+        }
+    }
+}
+
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs
new file mode 100644
index 0000000..d4b60bf
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    internal class XLConditionalFormats: IXLConditionalFormats
+    {
+        private readonly List<IXLConditionalFormat> _conditionalFormats = new List<IXLConditionalFormat>();
+        public void Add(IXLConditionalFormat conditionalFormat)
+        {
+            _conditionalFormats.Add(conditionalFormat);
+        }
+
+        public IEnumerator<IXLConditionalFormat> GetEnumerator()
+        {
+            return _conditionalFormats.GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/EnumConverter.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/EnumConverter.cs
index 5d2867d..d85a9b0 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/EnumConverter.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/EnumConverter.cs
@@ -533,6 +533,75 @@
                 #endregion
             }
         }
+        public static ConditionalFormatValues ToOpenXml(this XLConditionalFormatType value)
+        {
+            switch (value)
+            {
+                case XLConditionalFormatType.Expression: return ConditionalFormatValues.Expression;
+                case XLConditionalFormatType.CellIs: return ConditionalFormatValues.CellIs;
+                case XLConditionalFormatType.ColorScale: return ConditionalFormatValues.ColorScale;
+                case XLConditionalFormatType.DataBar: return ConditionalFormatValues.DataBar;
+                case XLConditionalFormatType.IconSet: return ConditionalFormatValues.IconSet;
+                case XLConditionalFormatType.Top10: return ConditionalFormatValues.Top10;
+                case XLConditionalFormatType.UniqueValues: return ConditionalFormatValues.UniqueValues;
+                case XLConditionalFormatType.DuplicateValues: return ConditionalFormatValues.DuplicateValues;
+                case XLConditionalFormatType.ContainsText: return ConditionalFormatValues.ContainsText;
+                case XLConditionalFormatType.NotContainsText: return ConditionalFormatValues.NotContainsText;
+                case XLConditionalFormatType.BeginsWith: return ConditionalFormatValues.BeginsWith;
+                case XLConditionalFormatType.EndsWith: return ConditionalFormatValues.EndsWith;
+                case XLConditionalFormatType.ContainsBlanks: return ConditionalFormatValues.ContainsBlanks;
+                case XLConditionalFormatType.NotContainsBlanks: return ConditionalFormatValues.NotContainsBlanks;
+                case XLConditionalFormatType.ContainsErrors: return ConditionalFormatValues.ContainsErrors;
+                case XLConditionalFormatType.NotContainsErrors: return ConditionalFormatValues.NotContainsErrors;
+                case XLConditionalFormatType.TimePeriod: return ConditionalFormatValues.TimePeriod;
+                case XLConditionalFormatType.AboveAverage: return ConditionalFormatValues.AboveAverage;
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
+
+        public static ConditionalFormatValueObjectValues ToOpenXml(this XLCFContentType value)
+        {
+            switch (value)
+            {
+                case XLCFContentType.Number: return ConditionalFormatValueObjectValues.Number;
+                case XLCFContentType.Percent: return ConditionalFormatValueObjectValues.Percent;
+                case XLCFContentType.Maximum: return ConditionalFormatValueObjectValues.Max;
+                case XLCFContentType.Minimum: return ConditionalFormatValueObjectValues.Min;
+                case XLCFContentType.Formula: return ConditionalFormatValueObjectValues.Formula;
+                case XLCFContentType.Percentile: return ConditionalFormatValueObjectValues.Percentile;
+
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
+        public static ConditionalFormattingOperatorValues ToOpenXml(this XLCFOperator value)
+        {
+            switch (value)
+            {
+                case XLCFOperator.LessThan: return ConditionalFormattingOperatorValues.LessThan;
+                case XLCFOperator.EqualOrLessThan: return ConditionalFormattingOperatorValues.LessThanOrEqual;
+                case XLCFOperator.Equal: return ConditionalFormattingOperatorValues.Equal;
+                case XLCFOperator.NotEqual: return ConditionalFormattingOperatorValues.NotEqual;
+                case XLCFOperator.EqualOrGreaterThan: return ConditionalFormattingOperatorValues.GreaterThanOrEqual;
+                case XLCFOperator.GreaterThan: return ConditionalFormattingOperatorValues.GreaterThan;
+                case XLCFOperator.Between: return ConditionalFormattingOperatorValues.Between;
+                case XLCFOperator.NotBetween: return ConditionalFormattingOperatorValues.NotBetween;
+                case XLCFOperator.Contains : return ConditionalFormattingOperatorValues.ContainsText;
+                case XLCFOperator.NotContains: return ConditionalFormattingOperatorValues.NotContains;
+                case XLCFOperator.StartsWith: return ConditionalFormattingOperatorValues.BeginsWith;
+                case XLCFOperator.EndsWith: return ConditionalFormattingOperatorValues.EndsWith;
+
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
         #endregion
         #region To ClosedXml
         public static XLFontUnderlineValues ToClosedXml(this UnderlineValues value)
@@ -1062,7 +1131,76 @@
                 #endregion
             }
         }
+        public static XLConditionalFormatType ToClosedXml(this ConditionalFormatValues value)
+        {
+            switch (value)
+            {
+                case ConditionalFormatValues.Expression: return XLConditionalFormatType.Expression;
+                case ConditionalFormatValues.CellIs: return XLConditionalFormatType.CellIs;
+                case ConditionalFormatValues.ColorScale: return XLConditionalFormatType.ColorScale;
+                case ConditionalFormatValues.DataBar: return XLConditionalFormatType.DataBar;
+                case ConditionalFormatValues.IconSet: return XLConditionalFormatType.IconSet;
+                case ConditionalFormatValues.Top10: return XLConditionalFormatType.Top10;
+                case ConditionalFormatValues.UniqueValues: return XLConditionalFormatType.UniqueValues;
+                case ConditionalFormatValues.DuplicateValues: return XLConditionalFormatType.DuplicateValues;
+                case ConditionalFormatValues.ContainsText: return XLConditionalFormatType.ContainsText;
+                case ConditionalFormatValues.NotContainsText: return XLConditionalFormatType.NotContainsText;
+                case ConditionalFormatValues.BeginsWith: return XLConditionalFormatType.BeginsWith;
+                case ConditionalFormatValues.EndsWith: return XLConditionalFormatType.EndsWith;
+                case ConditionalFormatValues.ContainsBlanks: return XLConditionalFormatType.ContainsBlanks;
+                case ConditionalFormatValues.NotContainsBlanks: return XLConditionalFormatType.NotContainsBlanks;
+                case ConditionalFormatValues.ContainsErrors: return XLConditionalFormatType.ContainsErrors;
+                case ConditionalFormatValues.NotContainsErrors: return XLConditionalFormatType.NotContainsErrors;
+                case ConditionalFormatValues.TimePeriod: return XLConditionalFormatType.TimePeriod;
+                case ConditionalFormatValues.AboveAverage: return XLConditionalFormatType.AboveAverage;
 
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
+
+        public static XLCFContentType ToClosedXml(this ConditionalFormatValueObjectValues value)
+        {
+            switch (value)
+            {
+                case ConditionalFormatValueObjectValues.Number: return XLCFContentType.Number;
+                case ConditionalFormatValueObjectValues.Percent: return XLCFContentType.Percent;
+                case ConditionalFormatValueObjectValues.Max: return XLCFContentType.Maximum;
+                case ConditionalFormatValueObjectValues.Min: return XLCFContentType.Minimum;
+                case ConditionalFormatValueObjectValues.Formula: return XLCFContentType.Formula;
+                case ConditionalFormatValueObjectValues.Percentile: return XLCFContentType.Percentile;
+
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
+        public static XLCFOperator ToClosedXml(this ConditionalFormattingOperatorValues value)
+        {
+            switch (value)
+            {
+                case ConditionalFormattingOperatorValues.LessThan: return XLCFOperator.LessThan;
+                case ConditionalFormattingOperatorValues.LessThanOrEqual: return XLCFOperator.EqualOrLessThan;
+                case ConditionalFormattingOperatorValues.Equal: return XLCFOperator.Equal;
+                case ConditionalFormattingOperatorValues.NotEqual: return XLCFOperator.NotEqual;
+                case ConditionalFormattingOperatorValues.GreaterThanOrEqual: return XLCFOperator.EqualOrGreaterThan;
+                case ConditionalFormattingOperatorValues.GreaterThan: return XLCFOperator.GreaterThan;
+                case ConditionalFormattingOperatorValues.Between: return XLCFOperator.Between;
+                case ConditionalFormattingOperatorValues.NotBetween: return XLCFOperator.NotBetween;
+                case ConditionalFormattingOperatorValues.ContainsText: return XLCFOperator.Contains;
+                case ConditionalFormattingOperatorValues.NotContains: return XLCFOperator.NotContains;
+                case ConditionalFormattingOperatorValues.BeginsWith: return XLCFOperator.StartsWith;
+                case ConditionalFormattingOperatorValues.EndsWith: return XLCFOperator.EndsWith;
+
+                #region default
+                default:
+                    throw new ApplicationException("Not implemented value!");
+                #endregion
+            }
+        }
         #endregion
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/IXLWorksheet.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/IXLWorksheet.cs
index 623aeb5..c063fba 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/IXLWorksheet.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/IXLWorksheet.cs
@@ -360,5 +360,6 @@
         IXLColumns ColumnsUsed(Func<IXLColumn, Boolean> predicate);
 
         IXLRanges MergedRanges { get; }
+        IXLConditionalFormats ConditionalFormats { get; }
     }
 }
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Misc/XLDictionary.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Misc/XLDictionary.cs
new file mode 100644
index 0000000..6d289e8
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Misc/XLDictionary.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ClosedXML.Excel
+{
+    public class XLDictionary<T>: Dictionary<Int32, T>
+    {
+        public void Initialize(T value)
+        {
+            if (Count > 0)
+                Clear();
+
+            Add(value);
+        }
+
+        public void Add(T value)
+        {
+            Add(Count + 1, value);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/IXLRangeBase.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/IXLRangeBase.cs
index ed77823..6601043 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/IXLRangeBase.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/IXLRangeBase.cs
@@ -64,7 +64,6 @@
 
         IXLHyperlinks Hyperlinks { get; }
 
-        IXLDataValidation SetDataValidation();
 
         /// <summary>
         ///   Returns the collection of cells.
@@ -238,6 +237,9 @@
         //IXLChart CreateChart(Int32 firstRow, Int32 firstColumn, Int32 lastRow, Int32 lastColumn);
 
         IXLAutoFilter SetAutoFilter();
-        
+
+        IXLDataValidation SetDataValidation();
+
+        IXLConditionalFormat AddConditionalFormat();
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
index 583d321..160ec36 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
@@ -1870,5 +1870,15 @@
         {
             return DataValidation;
         }
+
+        public IXLConditionalFormat AddConditionalFormat()
+        {
+            using (var asRange = AsRange())
+            {
+                var cf = new XLConditionalFormat(asRange);
+                Worksheet.ConditionalFormats.Add(cf);
+                return cf;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Style/XLStyle.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Style/XLStyle.cs
index 9b3aba4..bb74c50 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Style/XLStyle.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Style/XLStyle.cs
@@ -22,7 +22,7 @@
                 Border = new XLBorder(container, null);
                 Fill = new XLFill(container);
                 NumberFormat = new XLNumberFormat(container, null);
-                Protection = new XLProtection(container, null);
+                Protection = new XLProtection(container);
             }
 
             DateFormat = NumberFormat;
@@ -58,42 +58,35 @@
         {
             var sb = new StringBuilder();
             sb.Append("Font:");
-            sb.Append(Font.ToString());
+            sb.Append(Font);
             sb.Append(" Fill:");
-            sb.Append(Fill.ToString());
+            sb.Append(Fill);
             sb.Append(" Border:");
-            sb.Append(Border.ToString());
+            sb.Append(Border);
             sb.Append(" NumberFormat: ");
-            sb.Append(NumberFormat.ToString());
+            sb.Append(NumberFormat);
             sb.Append(" Alignment: ");
-            sb.Append(Alignment.ToString());
+            sb.Append(Alignment);
             sb.Append(" Protection: ");
-            sb.Append(Protection.ToString());
+            sb.Append(Protection);
             return sb.ToString();
         }
 
         public bool Equals(IXLStyle other)
         {
             return
-            //    this.Font.GetHashCode().Equals(other.Font.GetHashCode()) 
-            //&&  this.Fill.GetHashCode().Equals(other.Fill.GetHashCode())
-            //&& this.Border.GetHashCode().Equals(other.Border.GetHashCode())
-            //&& this.NumberFormat.GetHashCode().Equals(other.NumberFormat.GetHashCode())
-            //&& this.Alignment.GetHashCode().Equals(other.Alignment.GetHashCode())
-            //&& this.Protection.GetHashCode().Equals(other.Protection.GetHashCode()) 
-
-                this.Font.Equals(other.Font)
-            &&  this.Fill.Equals(other.Fill)
-            &&  this.Border.Equals(other.Border)
-            &&  this.NumberFormat.Equals(other.NumberFormat)
-            &&  this.Alignment.Equals(other.Alignment)
-            &&  this.Protection.Equals(other.Protection)
+                Font.Equals(other.Font)
+            &&  Fill.Equals(other.Fill)
+            &&  Border.Equals(other.Border)
+            &&  NumberFormat.Equals(other.NumberFormat)
+            &&  Alignment.Equals(other.Alignment)
+            &&  Protection.Equals(other.Protection)
             ;
         }
 
         public override bool Equals(object obj)
         {
-            return this.Equals((XLStyle)obj);
+            return Equals((XLStyle)obj);
         }
 
         public override int GetHashCode()
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
index 1272af8..de578ec 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
@@ -8,7 +8,7 @@
     public partial class XLWorkbook
     {
         #region Nested type: SaveContext
-        private sealed class SaveContext
+        internal sealed class SaveContext
         {
             #region Private fields
             [DebuggerBrowsable(DebuggerBrowsableState.Never)]
@@ -60,17 +60,18 @@
                 [DebuggerStepThrough]
                 set { _tableId = value; }
             }
+            public Dictionary<IXLStyle, Int32> DifferentialFormats = new Dictionary<IXLStyle, int>();
             #endregion
         }
         #endregion
         #region Nested type: RelType
-        private enum RelType
+        internal enum RelType
         {
             Workbook//, Worksheet
         }
         #endregion
         #region Nested type: RelIdGenerator
-        private sealed class RelIdGenerator
+        internal sealed class RelIdGenerator
         {
             private readonly Dictionary<RelType, List<String>> _relIds = new Dictionary<RelType, List<String>>();
             public String GetNext(RelType relType)
@@ -108,35 +109,35 @@
         }
         #endregion
         #region Nested type: FontInfo
-        private struct FontInfo
+        internal struct FontInfo
         {
             public UInt32 FontId;
             public IXLFont Font;
         };
         #endregion
         #region Nested type: FillInfo
-        private struct FillInfo
+        internal struct FillInfo
         {
             public UInt32 FillId;
             public IXLFill Fill;
         }
         #endregion
         #region Nested type: BorderInfo
-        private struct BorderInfo
+        internal struct BorderInfo
         {
             public UInt32 BorderId;
             public IXLBorder Border;
         }
         #endregion
         #region Nested type: NumberFormatInfo
-        private struct NumberFormatInfo
+        internal struct NumberFormatInfo
         {
             public Int32 NumberFormatId;
             public IXLNumberFormat NumberFormat;
         }
         #endregion
         #region Nested type: StyleInfo
-        private struct StyleInfo
+        internal struct StyleInfo
         {
             public UInt32 StyleId;
             public UInt32 FontId;
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
index daa26ba..294e6c7 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
@@ -1817,10 +1817,48 @@
             context.SharedStyles.Clear();
             newSharedStyles.ForEach(kp => context.SharedStyles.Add(kp.Key, kp.Value));
 
-            //TableStyles tableStyles1 = new TableStyles() { Count = (UInt32Value)0U, DefaultTableStyle = "TableStyleMedium9", DefaultPivotStyle = "PivotStyleLight16" };
-            //workbookStylesPart.Stylesheet.AppendChild(tableStyles1);
+            AddDifferentialFormats(workbookStylesPart, context);
         }
 
+        private void AddDifferentialFormats(WorkbookStylesPart workbookStylesPart, SaveContext context)
+        {
+            if (workbookStylesPart.Stylesheet.DifferentialFormats == null)
+                workbookStylesPart.Stylesheet.DifferentialFormats = new DifferentialFormats();
+
+            var differentialFormats = workbookStylesPart.Stylesheet.DifferentialFormats;
+
+            foreach(var ws in Worksheets)
+            {
+                foreach(var cf in ws.ConditionalFormats)
+                {
+                    if(!context.DifferentialFormats.ContainsKey(cf.Style))
+                        AddDifferentialFormat(workbookStylesPart.Stylesheet.DifferentialFormats, cf, context);
+                }
+            }
+
+            differentialFormats.Count = (UInt32) differentialFormats.Count();
+        }
+
+        private void AddDifferentialFormat(DifferentialFormats differentialFormats, IXLConditionalFormat cf, SaveContext context)
+        {
+            var differentialFormat = new DifferentialFormat();
+            differentialFormat.Append(GetNewFont(new FontInfo {Font = cf.Style.Font}));
+            differentialFormat.Append(new NumberingFormat
+                                          {
+                                              NumberFormatId = (UInt32)(differentialFormats.Count() + 164),
+                                              FormatCode = cf.Style.NumberFormat.Format
+                                          });
+        
+            differentialFormat.Append(GetNewFill(new FillInfo {Fill = cf.Style.Fill}));
+            differentialFormat.Append(GetNewBorder(new BorderInfo { Border = cf.Style.Border }));
+
+            differentialFormats.Append(differentialFormat);
+
+            context.DifferentialFormats.Add(cf.Style, differentialFormats.Count() - 1);
+        }
+
+
+
         private static void ResolveRest(WorkbookStylesPart workbookStylesPart, SaveContext context)
         {
             if (workbookStylesPart.Stylesheet.CellFormats == null)
@@ -3041,6 +3079,41 @@
 
             #endregion
 
+            #region Conditional Formatting
+            if (!xlWorksheet.ConditionalFormats.Any())
+            {
+                worksheetPart.Worksheet.RemoveAllChildren<ConditionalFormatting>();
+                cm.SetElement(XLWSContentManager.XLWSContents.ConditionalFormatting, null);
+            }
+            else
+            {
+                var previousElement = cm.GetPreviousElementFor(XLWSContentManager.XLWSContents.ConditionalFormatting);
+
+
+                //if (!worksheetPart.Worksheet.Elements<ConditionalFormatting>().Any())
+                //{
+                //    var previousElement = cm.GetPreviousElementFor(XLWSContentManager.XLWSContents.ConditionalFormatting);
+                //    worksheetPart.Worksheet.InsertAfter(new ConditionalFormatting(), previousElement);
+                //}
+
+                //var conditionalFormats = worksheetPart.Worksheet.Elements<ConditionalFormatting>().First();
+                //cm.SetElement(XLWSContentManager.XLWSContents.ConditionalFormatting, conditionalFormats);
+                ////conditionalFormats.RemoveAllChildren<ConditionalFormat>();
+                Int32 priority = 0;
+                foreach (var cf in xlWorksheet.ConditionalFormats)
+                {
+                    priority++;
+                    var conditionalFormatting = new ConditionalFormatting { SequenceOfReferences = new ListValue<StringValue> { InnerText = cf.Range.RangeAddress.ToStringRelative(false) } };
+                    conditionalFormatting.Append(XLCFConverters.Convert(cf, priority, context));
+                    
+                    worksheetPart.Worksheet.InsertAfter(conditionalFormatting, previousElement);
+                    previousElement = conditionalFormatting;
+                    cm.SetElement(XLWSContentManager.XLWSContents.ConditionalFormatting, conditionalFormatting);
+                }
+            }
+
+            #endregion
+
             #region DataValidations
 
             if (!xlWorksheet.DataValidations.Any(d => d.IsDirty()))
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorksheet.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorksheet.cs
index 79b9de8..ec44544 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorksheet.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorksheet.cs
@@ -56,6 +56,7 @@
             PivotTables = new XLPivotTables();
             Protection = new XLSheetProtection();
             AutoFilter = new XLAutoFilter();
+            ConditionalFormats = new XLConditionalFormats();
             Workbook = workbook;
             SetStyle(workbook.Style);
             Internals = new XLWorksheetInternals(new XLCellsCollection(), new XLColumnsCollection(),
@@ -1297,5 +1298,7 @@
         }
 
         public IXLRanges MergedRanges { get { return Internals.MergedRanges; } }
+
+        public IXLConditionalFormats ConditionalFormats { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Examples/ClosedXML_Examples.csproj b/ClosedXML/ClosedXML/ClosedXML_Examples/ClosedXML_Examples.csproj
index bc19451..1bb81a3 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Examples/ClosedXML_Examples.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML_Examples/ClosedXML_Examples.csproj
@@ -135,6 +135,7 @@
     <Compile Include="Columns\DeletingColumns.cs" />
     <Compile Include="Comments\AddingComments.cs" />
     <Compile Include="Comments\EditingComments.cs" />
+    <Compile Include="ConditionalFormatting\ConditionalFormatting.cs" />
     <Compile Include="Delete\DeleteFewWorksheets.cs" />
     <Compile Include="IXLExample.cs" />
     <Compile Include="Misc\CopyingRowsAndColumns.cs" />
diff --git a/ClosedXML/ClosedXML/ClosedXML_Examples/Columns/ColumnCells.cs b/ClosedXML/ClosedXML/ClosedXML_Examples/Columns/ColumnCells.cs
index 3254600..f4ccf50 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Examples/Columns/ColumnCells.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Examples/Columns/ColumnCells.cs
@@ -6,40 +6,7 @@
 {
     public class ColumnCells : IXLExample
     {
-        #region Variables
 
-        // Public
-
-        // Private
-
-
-        #endregion
-
-        #region Properties
-
-        // Public
-
-        // Private
-
-        // Override
-
-
-        #endregion
-
-        #region Events
-
-        // Public
-
-        // Private
-
-        // Override
-
-
-        #endregion
-
-        #region Methods
-
-        // Public
         public void Create(String filePath)
         {
             var workbook = new XLWorkbook();
@@ -61,11 +28,5 @@
             workbook.SaveAs(filePath);
         }
 
-        // Private
-
-        // Override
-
-
-        #endregion
     }
 }
diff --git a/ClosedXML/ClosedXML/ClosedXML_Examples/ConditionalFormatting/ConditionalFormatting.cs b/ClosedXML/ClosedXML/ClosedXML_Examples/ConditionalFormatting/ConditionalFormatting.cs
new file mode 100644
index 0000000..a737048
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML_Examples/ConditionalFormatting/ConditionalFormatting.cs
@@ -0,0 +1,69 @@
+using System;
+using ClosedXML.Excel;
+
+
+namespace ClosedXML_Examples
+{
+    public class CFColorScaleLowMidHigh : IXLExample
+    {
+        public void Create(String filePath)
+        {
+            var workbook = new XLWorkbook();
+            var ws = workbook.AddWorksheet("Sheet1");
+
+            ws.FirstCell().SetValue(1)
+                .CellBelow().SetValue(1)
+                .CellBelow().SetValue(2)
+                .CellBelow().SetValue(3);
+
+            ws.RangeUsed().AddConditionalFormat().ColorScale()
+                .LowestValue(XLColor.Red)
+                .Midpoint(XLCFContentType.Percent, "50", XLColor.Yellow) 
+                .HighestValue(XLColor.Green);
+
+            workbook.SaveAs(filePath);
+        }
+    }
+
+    public class CFColorScaleLowHigh : IXLExample
+    {
+
+        public void Create(String filePath)
+        {
+            var workbook = new XLWorkbook();
+            var ws = workbook.AddWorksheet("Sheet1");
+
+            ws.FirstCell().SetValue(1)
+                .CellBelow().SetValue(1)
+                .CellBelow().SetValue(2)
+                .CellBelow().SetValue(3);
+
+            ws.RangeUsed().AddConditionalFormat().ColorScale()
+                .Minimum(XLCFContentType.Number, "2", XLColor.Red)
+                .Maximum(XLCFContentType.Percentile, "90", XLColor.Green);
+
+            workbook.SaveAs(filePath);
+        }
+    }
+
+    public class CFStartsWith : IXLExample
+    {
+        public void Create(String filePath)
+        {
+            var workbook = new XLWorkbook();
+            var ws = workbook.AddWorksheet("Sheet1");
+
+            ws.FirstCell().SetValue("Hello")
+                .CellBelow().SetValue("Hellos")
+                .CellBelow().SetValue("Hell")
+                .CellBelow().SetValue("Holl");
+
+            ws.RangeUsed().AddConditionalFormat().WhenStartsWith("Hell")
+                .Fill.SetBackgroundColor(XLColor.Red)
+                .Border.SetOutsideBorder(XLBorderStyleValues.Thick)
+                .Border.SetOutsideBorderColor(XLColor.Blue);
+
+            workbook.SaveAs(filePath);
+        }
+    }
+}
diff --git a/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj b/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
index fb92392..e772bc6 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
@@ -213,6 +213,66 @@
     <Compile Include="..\ClosedXML\Excel\Comments\XLComment.cs">
       <Link>Excel\Comments\XLComment.cs</Link>
     </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFColorScaleMax.cs">
+      <Link>Excel\ConditionalFormats\IXLCFColorScaleMax.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFColorScaleMid.cs">
+      <Link>Excel\ConditionalFormats\IXLCFColorScaleMid.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFColorScaleMin.cs">
+      <Link>Excel\ConditionalFormats\IXLCFColorScaleMin.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFDataBarMax.cs">
+      <Link>Excel\ConditionalFormats\IXLCFDataBarMax.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFDataBarMin.cs">
+      <Link>Excel\ConditionalFormats\IXLCFDataBarMin.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLCFIconSet.cs">
+      <Link>Excel\ConditionalFormats\IXLCFIconSet.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLConditionalFormat.cs">
+      <Link>Excel\ConditionalFormats\IXLConditionalFormat.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\IXLConditionalFormats.cs">
+      <Link>Excel\ConditionalFormats\IXLConditionalFormats.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\Save\IXLCFConverter.cs">
+      <Link>Excel\ConditionalFormats\Save\IXLCFConverter.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\Save\XLCFBeginsWithConverter.cs">
+      <Link>Excel\ConditionalFormats\Save\XLCFBeginsWithConverter.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\Save\XLCFColorScaleConverter.cs">
+      <Link>Excel\ConditionalFormats\Save\XLCFColorScaleConverter.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\Save\XLCFConverters.cs">
+      <Link>Excel\ConditionalFormats\Save\XLCFConverters.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFColorScaleMax.cs">
+      <Link>Excel\ConditionalFormats\XLCFColorScaleMax.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFColorScaleMid.cs">
+      <Link>Excel\ConditionalFormats\XLCFColorScaleMid.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFColorScaleMin.cs">
+      <Link>Excel\ConditionalFormats\XLCFColorScaleMin.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFDataBarMax.cs">
+      <Link>Excel\ConditionalFormats\XLCFDataBarMax.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFDataBarMin.cs">
+      <Link>Excel\ConditionalFormats\XLCFDataBarMin.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLCFIconSet.cs">
+      <Link>Excel\ConditionalFormats\XLCFIconSet.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLConditionalFormat.cs">
+      <Link>Excel\ConditionalFormats\XLConditionalFormat.cs</Link>
+    </Compile>
+    <Compile Include="..\ClosedXML\Excel\ConditionalFormats\XLConditionalFormats.cs">
+      <Link>Excel\ConditionalFormats\XLConditionalFormats.cs</Link>
+    </Compile>
     <Compile Include="..\ClosedXML\Excel\Coordinates\IXLAddress.cs">
       <Link>Excel\Coordinate\IXLAddress.cs</Link>
     </Compile>
@@ -369,6 +429,9 @@
     <Compile Include="..\ClosedXML\Excel\IXLWorksheets.cs">
       <Link>Excel\IXLWorksheets.cs</Link>
     </Compile>
+    <Compile Include="..\ClosedXML\Excel\Misc\XLDictionary.cs">
+      <Link>Excel\Misc\XLDictionary.cs</Link>
+    </Compile>
     <Compile Include="..\ClosedXML\Excel\Misc\XLIdManager.cs">
       <Link>Excel\Misc\XLIdManager.cs</Link>
     </Compile>