diff --git a/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs b/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs
index dcf4b76..a01a138 100644
--- a/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs
+++ b/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs
@@ -128,7 +128,7 @@
                             {
                                 Boolean match = isText
                                                     ? filter.Condition(row.Cell(kp.Key).GetString())
-                                                    : row.Cell(kp.Key).DataType == XLCellValues.Number &&
+                                                    : row.Cell(kp.Key).DataType == XLDataType.Number &&
                                                       filter.Condition(row.Cell(kp.Key).GetDouble());
                                 if (firstFilter)
                                 {
diff --git a/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs b/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs
index a045910..a624708 100644
--- a/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs
+++ b/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs
@@ -206,7 +206,7 @@
                         }
 
                         var cell = row.Cell(_column);
-                        if (cell.DataType != XLCellValues.Number || !condition(cell.GetDouble())) continue;
+                        if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) continue;
                         row.WorksheetRow().Unhide();
                         foundOne = true;
                     }
@@ -224,7 +224,7 @@
             {
                 using (var subColumn = column.Column(2, column.CellCount()))
                 {
-                    var cellsUsed = subColumn.CellsUsed(c => c.DataType == XLCellValues.Number);
+                    var cellsUsed = subColumn.CellsUsed(c => c.DataType == XLDataType.Number);
                     if (takeTop)
                     {
                         if (type == XLTopBottomType.Items)
@@ -284,7 +284,7 @@
                         }
 
                         var cell = row.Cell(_column);
-                        if (cell.DataType != XLCellValues.Number || !condition(cell.GetDouble())) continue;
+                        if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) continue;
                         row.WorksheetRow().Unhide();
                         foundOne = true;
                     }
@@ -304,17 +304,17 @@
             {
                 using (var subColumn = column.Column(2, column.CellCount()))
                 {
-                    Double average = subColumn.CellsUsed(c => c.DataType == XLCellValues.Number).Select(c => c.GetDouble()).Average();
+                    Double average = subColumn.CellsUsed(c => c.DataType == XLDataType.Number).Select(c => c.GetDouble()).Average();
 
                     if (aboveAverage)
                     {
                         return
-                            subColumn.CellsUsed(c => c.DataType == XLCellValues.Number).
+                            subColumn.CellsUsed(c => c.DataType == XLDataType.Number).
                                 Select(c => c.GetDouble()).Where(c => c > average).Distinct();
                     }
 
                     return
-                        subColumn.CellsUsed(c => c.DataType == XLCellValues.Number).
+                        subColumn.CellsUsed(c => c.DataType == XLDataType.Number).
                             Select(c => c.GetDouble()).Where(c => c < average).Distinct();
 
                 }
@@ -371,7 +371,7 @@
             {
                 Boolean match = isText
                                     ? condition(row.Cell(_column).GetString())
-                                    : row.Cell(_column).DataType == XLCellValues.Number &&
+                                    : row.Cell(_column).DataType == XLDataType.Number &&
                                         condition(row.Cell(_column).GetDouble());
                 if (match)
                     row.WorksheetRow().Unhide();
@@ -390,4 +390,4 @@
         public IXLFilterColumn SetDynamicValue(Double value) { DynamicValue = value; return this; }
 
     }
-}
\ No newline at end of file
+}
diff --git a/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs b/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs
index f9d2bd3..1f11d83 100644
--- a/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs
+++ b/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs
@@ -46,7 +46,7 @@
                     if ((isText && condition(row.Cell(_column).GetString())) || (
                                                                                     !isText &&
                                                                                     row.Cell(_column).DataType ==
-                                                                                    XLCellValues.Number &&
+                                                                                    XLDataType.Number &&
                                                                                     condition(
                                                                                         row.Cell(_column).GetValue<T>()))
                         )
diff --git a/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs b/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs
index 43fce93..075e4d3 100644
--- a/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs
+++ b/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs
@@ -17,6 +17,8 @@
             ce.RegisterFunction("ABS", 1, Abs);
             ce.RegisterFunction("ACOS", 1, Acos);
             ce.RegisterFunction("ACOSH", 1, Acosh);
+            ce.RegisterFunction("ACOT", 1, Acot);
+            ce.RegisterFunction("ACOTH", 1, Acoth);
             ce.RegisterFunction("ASIN", 1, Asin);
             ce.RegisterFunction("ASINH", 1, Asinh);
             ce.RegisterFunction("ATAN", 1, Atan);
@@ -28,6 +30,8 @@
             ce.RegisterFunction("COS", 1, Cos);
             ce.RegisterFunction("COSH", 1, Cosh);
             ce.RegisterFunction("COT", 1, Cot);
+            ce.RegisterFunction("COTH", 1, Coth);
+            ce.RegisterFunction("CSC", 1, Csc);
             ce.RegisterFunction("CSCH", 1, Csch);
             ce.RegisterFunction("DECIMAL", 2, MathTrig.Decimal);
             ce.RegisterFunction("DEGREES", 1, Degrees);
@@ -61,6 +65,8 @@
             ce.RegisterFunction("ROUND", 2, Round);
             ce.RegisterFunction("ROUNDDOWN", 2, RoundDown);
             ce.RegisterFunction("ROUNDUP", 1, 2, RoundUp);
+            ce.RegisterFunction("SEC", 1, Sec);
+            ce.RegisterFunction("SECH", 1, Sech);
             ce.RegisterFunction("SERIESSUM", 4, SeriesSum);
             ce.RegisterFunction("SIGN", 1, Sign);
             ce.RegisterFunction("SIN", 1, Sin);
@@ -131,6 +137,24 @@
             return 1 / tan;
         }
 
+        private static object Coth(List<Expression> p)
+        {
+            double input = p[0];
+            if (input == 0)
+                throw new DivisionByZeroException();
+
+            return 1 / Math.Tanh(input);
+        }
+
+        private static object Csc(List<Expression> p)
+        {
+            double input = p[0];
+            if (input == 0)
+                throw new DivisionByZeroException();
+
+            return 1 / Math.Sin(input);
+        }
+
         private static object Csch(List<Expression> p)
         {
             if (Math.Abs((double)p[0].Evaluate()) < Double.Epsilon)
@@ -463,6 +487,27 @@
             return XLMath.ACosh(p[0]);
         }
 
+        private static object Acot(List<Expression> p)
+        {
+            double x = Math.Atan(1.0 / p[0]);
+
+            // Acot in Excel calculates the modulus of the function above.
+            // as the % operator is not the modulus, but the remainder, we have to calculate the modulus by hand:
+            while (x < 0)
+                x = x + Math.PI;
+
+            return x;
+        }
+
+        private static object Acoth(List<Expression> p)
+        {
+            double number = p[0];
+            if (Math.Abs(number) < 1)
+                throw new NumberException();
+
+            return 0.5 * Math.Log((number + 1) / (number - 1));
+        }
+
         private static object Asinh(List<Expression> p)
         {
             return XLMath.ASinh(p[0]);
@@ -699,6 +744,20 @@
             return Math.Floor(value * Math.Pow(10, digits)) / Math.Pow(10, digits);
         }
 
+        private static object Sec(List<Expression> p)
+        {
+            double number;
+            if (double.TryParse(p[0], out number))
+                return 1.0 / Math.Cos(number);
+            else
+                throw new CellValueException();
+        }
+
+        private static object Sech(List<Expression> p)
+        {
+            return 1.0 / Math.Cosh(p[0]);
+        }
+
         private static object SeriesSum(List<Expression> p)
         {
             var x = (Double)p[0];
diff --git a/ClosedXML/Excel/Cells/IXLCell.cs b/ClosedXML/Excel/Cells/IXLCell.cs
index 17fdf43..28309e3 100644
--- a/ClosedXML/Excel/Cells/IXLCell.cs
+++ b/ClosedXML/Excel/Cells/IXLCell.cs
@@ -5,7 +5,7 @@
 
 namespace ClosedXML.Excel
 {
-    public enum XLCellValues { Text, Number, Boolean, DateTime, TimeSpan }
+    public enum XLDataType { Text, Number, Boolean, DateTime, TimeSpan }
 
     public enum XLTableCellType { None, Header, Data, Total }
 
@@ -51,7 +51,7 @@
         /// The type of the cell's data.
         /// </value>
         /// <exception cref="ArgumentException"></exception>
-        XLCellValues DataType { get; set; }
+        XLDataType DataType { get; set; }
 
         /// <summary>
         /// Sets the type of this cell's data.
@@ -60,7 +60,7 @@
         /// </summary>
         /// <param name="dataType">Type of the data.</param>
         /// <returns></returns>
-        IXLCell SetDataType(XLCellValues dataType);
+        IXLCell SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Sets the cell's value.
diff --git a/ClosedXML/Excel/Cells/IXLCells.cs b/ClosedXML/Excel/Cells/IXLCells.cs
index d17a1c0..e42a5ae 100644
--- a/ClosedXML/Excel/Cells/IXLCells.cs
+++ b/ClosedXML/Excel/Cells/IXLCells.cs
@@ -26,9 +26,9 @@
         /// The type of the cell's data.
         /// </value>
         /// <exception cref="ArgumentException"></exception>
-        XLCellValues DataType { set; }
+        XLDataType DataType { set; }
 
-        IXLCells SetDataType(XLCellValues dataType);
+        IXLCells SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these cells.
diff --git a/ClosedXML/Excel/Cells/XLCell.cs b/ClosedXML/Excel/Cells/XLCell.cs
index fa03857..39e00c1 100644
--- a/ClosedXML/Excel/Cells/XLCell.cs
+++ b/ClosedXML/Excel/Cells/XLCell.cs
@@ -70,7 +70,7 @@
         internal string _cellValue = String.Empty;
 
         private XLComment _comment;
-        internal XLCellValues _dataType;
+        internal XLDataType _dataType;
         private XLHyperlink _hyperlink;
         private XLRichText _richText;
         private Int32? _styleCacheId;
@@ -219,20 +219,20 @@
             if (value is String || value is char)
             {
                 _cellValue = value.ToString();
-                _dataType = XLCellValues.Text;
+                _dataType = XLDataType.Text;
                 if (_cellValue.Contains(Environment.NewLine) && !GetStyleForRead().Alignment.WrapText)
                     Style.Alignment.WrapText = true;
             }
             else if (value is TimeSpan)
             {
                 _cellValue = value.ToString();
-                _dataType = XLCellValues.TimeSpan;
+                _dataType = XLDataType.TimeSpan;
                 if (style.NumberFormat.Format == String.Empty && style.NumberFormat.NumberFormatId == 0)
                     Style.NumberFormat.NumberFormatId = 46;
             }
             else if (value is DateTime)
             {
-                _dataType = XLCellValues.DateTime;
+                _dataType = XLDataType.DateTime;
                 var dtTest = (DateTime)Convert.ChangeType(value, typeof(DateTime));
                 if (style.NumberFormat.Format == String.Empty && style.NumberFormat.NumberFormatId == 0)
                     Style.NumberFormat.NumberFormatId = dtTest.Date == dtTest ? 14 : 22;
@@ -245,23 +245,23 @@
                     || Double.IsInfinity((Double)Convert.ChangeType(value, typeof(Double)))))
                 {
                     _cellValue = value.ToString();
-                    _dataType = XLCellValues.Text;
+                    _dataType = XLDataType.Text;
                 }
                 else
                 {
-                    _dataType = XLCellValues.Number;
+                    _dataType = XLDataType.Number;
                     _cellValue = ((Double)Convert.ChangeType(value, typeof(Double))).ToInvariantString();
                 }
             }
             else if (value is Boolean)
             {
-                _dataType = XLCellValues.Boolean;
+                _dataType = XLDataType.Boolean;
                 _cellValue = (Boolean)Convert.ChangeType(value, typeof(Boolean)) ? "1" : "0";
             }
             else
             {
                 _cellValue = Convert.ToString(value);
-                _dataType = XLCellValues.Text;
+                _dataType = XLDataType.Text;
             }
 
             return this;
@@ -320,11 +320,11 @@
                 cValue = _cellValue;
             }
 
-            if (_dataType == XLCellValues.Boolean)
+            if (_dataType == XLDataType.Boolean)
                 return (cValue != "0").ToString();
-            if (_dataType == XLCellValues.TimeSpan)
+            if (_dataType == XLDataType.TimeSpan)
                 return cValue;
-            if (_dataType == XLCellValues.DateTime || IsDateFormat())
+            if (_dataType == XLDataType.DateTime || IsDateFormat())
             {
                 double dTest;
                 if (Double.TryParse(cValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out dTest)
@@ -337,7 +337,7 @@
                 return cValue;
             }
 
-            if (_dataType == XLCellValues.Number)
+            if (_dataType == XLDataType.Number)
             {
                 double dTest;
                 if (Double.TryParse(cValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out dTest))
@@ -395,10 +395,10 @@
 
                 var cellValue = HasRichText ? _richText.ToString() : _cellValue;
 
-                if (_dataType == XLCellValues.Boolean)
+                if (_dataType == XLDataType.Boolean)
                     return cellValue != "0";
 
-                if (_dataType == XLCellValues.DateTime)
+                if (_dataType == XLDataType.DateTime)
                 {
                     Double d;
                     if (Double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out d)
@@ -406,14 +406,14 @@
                         return DateTime.FromOADate(d);
                 }
 
-                if (_dataType == XLCellValues.Number)
+                if (_dataType == XLDataType.Number)
                 {
                     Double d;
                     if (double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out d))
                         return d;
                 }
 
-                if (_dataType == XLCellValues.TimeSpan)
+                if (_dataType == XLDataType.TimeSpan)
                 {
                     TimeSpan t;
                     if (TimeSpan.TryParse(cellValue, out t))
@@ -884,13 +884,13 @@
             set { SetStyle(value); }
         }
 
-        public IXLCell SetDataType(XLCellValues dataType)
+        public IXLCell SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
         }
 
-        public XLCellValues DataType
+        public XLDataType DataType
         {
             get { return _dataType; }
             set
@@ -905,7 +905,7 @@
 
                 if (_cellValue.Length > 0)
                 {
-                    if (value == XLCellValues.Boolean)
+                    if (value == XLDataType.Boolean)
                     {
                         bool bTest;
                         if (Boolean.TryParse(_cellValue, out bTest))
@@ -913,7 +913,7 @@
                         else
                             _cellValue = _cellValue == "0" || String.IsNullOrEmpty(_cellValue) ? "0" : "1";
                     }
-                    else if (value == XLCellValues.DateTime)
+                    else if (value == XLDataType.DateTime)
                     {
                         DateTime dtTest;
                         double dblTest;
@@ -932,7 +932,7 @@
                         if (style.NumberFormat.Format == String.Empty && style.NumberFormat.NumberFormatId == 0)
                             Style.NumberFormat.NumberFormatId = _cellValue.Contains('.') ? 22 : 14;
                     }
-                    else if (value == XLCellValues.TimeSpan)
+                    else if (value == XLDataType.TimeSpan)
                     {
                         TimeSpan tsTest;
                         if (TimeSpan.TryParse(_cellValue, out tsTest))
@@ -957,7 +957,7 @@
                             }
                         }
                     }
-                    else if (value == XLCellValues.Number)
+                    else if (value == XLDataType.Number)
                     {
                         double dTest;
                         if (Double.TryParse(_cellValue, XLHelper.NumberStyle, CultureInfo.InvariantCulture, out dTest))
@@ -972,9 +972,9 @@
                     }
                     else
                     {
-                        if (_dataType == XLCellValues.Boolean)
+                        if (_dataType == XLDataType.Boolean)
                             _cellValue = (_cellValue != "0").ToString();
-                        else if (_dataType == XLCellValues.TimeSpan)
+                        else if (_dataType == XLDataType.TimeSpan)
                             _cellValue = BaseDate.Add(GetTimeSpan()).ToOADate().ToInvariantString();
                     }
                 }
@@ -1554,7 +1554,7 @@
                     field.TotalsRowFunction = XLTotalsRowFunction.None;
                     field.TotalsRowLabel = value.ToString();
                     this._cellValue = value.ToString();
-                    this.DataType = XLCellValues.Text;
+                    this.DataType = XLDataType.Text;
                     return true;
                 }
             }
@@ -1686,7 +1686,7 @@
         private bool IsDateFormat()
         {
             var style = GetStyleForRead();
-            return _dataType == XLCellValues.Number
+            return _dataType == XLDataType.Number
                    && String.IsNullOrWhiteSpace(style.NumberFormat.Format)
                    && ((style.NumberFormat.NumberFormatId >= 14
                         && style.NumberFormat.NumberFormatId <= 22)
@@ -1717,7 +1717,7 @@
                 return false;
 
             _richText = asRichString;
-            _dataType = XLCellValues.Text;
+            _dataType = XLDataType.Text;
             return true;
         }
 
@@ -1812,7 +1812,7 @@
                 val = value.ToString();
             _richText = null;
             if (val.Length == 0)
-                _dataType = XLCellValues.Text;
+                _dataType = XLDataType.Text;
             else
             {
                 double dTest;
@@ -1822,14 +1822,14 @@
                 var style = GetStyleForRead();
                 if (style.NumberFormat.Format == "@")
                 {
-                    _dataType = XLCellValues.Text;
+                    _dataType = XLDataType.Text;
                     if (val.Contains(Environment.NewLine) && !style.Alignment.WrapText)
                         Style.Alignment.WrapText = true;
                 }
                 else if (val[0] == '\'')
                 {
                     val = val.Substring(1, val.Length - 1);
-                    _dataType = XLCellValues.Text;
+                    _dataType = XLDataType.Text;
                     if (val.Contains(Environment.NewLine) && !style.Alignment.WrapText)
                         Style.Alignment.WrapText = true;
                 }
@@ -1838,15 +1838,15 @@
                     if (!(value is TimeSpan) && TimeSpan.TryParse(val, out tsTest))
                         val = tsTest.ToString();
 
-                    _dataType = XLCellValues.TimeSpan;
+                    _dataType = XLDataType.TimeSpan;
                     if (style.NumberFormat.Format == String.Empty && style.NumberFormat.NumberFormatId == 0)
                         Style.NumberFormat.NumberFormatId = 46;
                 }
                 else if (val.Trim() != "NaN" && Double.TryParse(val, XLHelper.NumberStyle, XLHelper.ParseCulture, out dTest))
-                    _dataType = XLCellValues.Number;
+                    _dataType = XLDataType.Number;
                 else if (DateTime.TryParse(val, out dtTest) && dtTest >= BaseDate)
                 {
-                    _dataType = XLCellValues.DateTime;
+                    _dataType = XLDataType.DateTime;
 
                     if (style.NumberFormat.Format == String.Empty && style.NumberFormat.NumberFormatId == 0)
                         Style.NumberFormat.NumberFormatId = dtTest.Date == dtTest ? 14 : 22;
@@ -1864,12 +1864,12 @@
                 }
                 else if (Boolean.TryParse(val, out bTest))
                 {
-                    _dataType = XLCellValues.Boolean;
+                    _dataType = XLDataType.Boolean;
                     val = bTest ? "1" : "0";
                 }
                 else
                 {
-                    _dataType = XLCellValues.Text;
+                    _dataType = XLDataType.Text;
                     if (val.Contains(Environment.NewLine) && !style.Alignment.WrapText)
                         Style.Alignment.WrapText = true;
                 }
diff --git a/ClosedXML/Excel/Cells/XLCells.cs b/ClosedXML/Excel/Cells/XLCells.cs
index c8fef10..bde0c7f 100644
--- a/ClosedXML/Excel/Cells/XLCells.cs
+++ b/ClosedXML/Excel/Cells/XLCells.cs
@@ -184,13 +184,13 @@
             set { this.ForEach<XLCell>(c => c.Value = value); }
         }
 
-        public IXLCells SetDataType(XLCellValues dataType)
+        public IXLCells SetDataType(XLDataType dataType)
         {
             this.ForEach<XLCell>(c => c.DataType = dataType);
             return this;
         }
 
-        public XLCellValues DataType
+        public XLDataType DataType
         {
             set { this.ForEach<XLCell>(c => c.DataType = value); }
         }
diff --git a/ClosedXML/Excel/Columns/IXLColumn.cs b/ClosedXML/Excel/Columns/IXLColumn.cs
index d0c64fd..1021190 100644
--- a/ClosedXML/Excel/Columns/IXLColumn.cs
+++ b/ClosedXML/Excel/Columns/IXLColumn.cs
@@ -166,7 +166,7 @@
         /// </summary>
         IXLColumn AddVerticalPageBreak();
 
-        IXLColumn SetDataType(XLCellValues dataType);
+        IXLColumn SetDataType(XLDataType dataType);
 
         IXLColumn ColumnLeft();
         IXLColumn ColumnLeft(Int32 step);
diff --git a/ClosedXML/Excel/Columns/IXLColumns.cs b/ClosedXML/Excel/Columns/IXLColumns.cs
index a362fca..9be1cf5 100644
--- a/ClosedXML/Excel/Columns/IXLColumns.cs
+++ b/ClosedXML/Excel/Columns/IXLColumns.cs
@@ -112,7 +112,7 @@
         /// </summary>
         IXLColumns AddVerticalPageBreaks();
 
-        IXLColumns SetDataType(XLCellValues dataType);
+        IXLColumns SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these columns.
diff --git a/ClosedXML/Excel/Columns/XLColumn.cs b/ClosedXML/Excel/Columns/XLColumn.cs
index ff70d31..fdf669d 100644
--- a/ClosedXML/Excel/Columns/XLColumn.cs
+++ b/ClosedXML/Excel/Columns/XLColumn.cs
@@ -647,7 +647,7 @@
             return this;
         }
 
-        public IXLColumn SetDataType(XLCellValues dataType)
+        public IXLColumn SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
diff --git a/ClosedXML/Excel/Columns/XLColumns.cs b/ClosedXML/Excel/Columns/XLColumns.cs
index 570f2fc..9f5b571 100644
--- a/ClosedXML/Excel/Columns/XLColumns.cs
+++ b/ClosedXML/Excel/Columns/XLColumns.cs
@@ -207,7 +207,7 @@
             return this;
         }
 
-        public IXLColumns SetDataType(XLCellValues dataType)
+        public IXLColumns SetDataType(XLDataType dataType)
         {
             _columns.ForEach(c => c.DataType = dataType);
             return this;
diff --git a/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs b/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs
index 77f37ff..21ae91e 100644
--- a/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs
+++ b/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs
@@ -80,13 +80,15 @@
 
         private static IEnumerable<ParsedHeaderFooterElement> ParseFormattedHeaderFooterText(string text)
         {
+            Func<int, bool> IsAtPositionIndicator = i => i < text.Length - 1 && text[i] == '&' && (new char[] { 'L', 'C', 'R' }.Contains(text[i + 1]));
+
             var parsedElements = new List<ParsedHeaderFooterElement>();
             var currentPosition = 'L'; // default is LEFT
             var hfElement = "";
 
             for (int i = 0; i < text.Length; i++)
             {
-                if (i < text.Length - 1 && text[i] == '&' && (new char[] { 'L', 'C', 'R' }.Contains(text[i + 1])))
+                if (IsAtPositionIndicator(i))
                 {
                     if ("" != hfElement) parsedElements.Add(new ParsedHeaderFooterElement()
                     {
@@ -99,7 +101,13 @@
                     hfElement = "";
                 }
 
-                hfElement += text[i];
+                if (i < text.Length)
+                {
+                    if (IsAtPositionIndicator(i))
+                        i--;
+                    else
+                        hfElement += text[i];
+                }
             }
 
             if ("" != hfElement)
diff --git a/ClosedXML/Excel/Ranges/IXLBaseCollection.cs b/ClosedXML/Excel/Ranges/IXLBaseCollection.cs
index ea38cb1..ef6b851 100644
--- a/ClosedXML/Excel/Ranges/IXLBaseCollection.cs
+++ b/ClosedXML/Excel/Ranges/IXLBaseCollection.cs
@@ -66,7 +66,7 @@
         /// <param name="includeFormats">if set to <c>true</c> will return all cells with a value or a style different than the default.</param>
         IXLCells CellsUsed(Boolean includeFormats);
 
-        TMultiple SetDataType(XLCellValues dataType);
+        TMultiple SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these ranges.
diff --git a/ClosedXML/Excel/Ranges/IXLRange.cs b/ClosedXML/Excel/Ranges/IXLRange.cs
index 945c0c9..291e290 100644
--- a/ClosedXML/Excel/Ranges/IXLRange.cs
+++ b/ClosedXML/Excel/Ranges/IXLRange.cs
@@ -274,7 +274,7 @@
 
         IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true);
 
-        IXLRange SetDataType(XLCellValues dataType);
+        IXLRange SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of this range.
diff --git a/ClosedXML/Excel/Ranges/IXLRangeBase.cs b/ClosedXML/Excel/Ranges/IXLRangeBase.cs
index b0dd238..3c5d25e 100644
--- a/ClosedXML/Excel/Ranges/IXLRangeBase.cs
+++ b/ClosedXML/Excel/Ranges/IXLRangeBase.cs
@@ -39,7 +39,7 @@
         ///   The type of the cell's data.
         /// </value>
         /// <exception cref = "ArgumentException"></exception>
-        XLCellValues DataType { set; }
+        XLDataType DataType { set; }
 
         /// <summary>
         ///   Sets the cells' formula with A1 references.
diff --git a/ClosedXML/Excel/Ranges/IXLRangeColumn.cs b/ClosedXML/Excel/Ranges/IXLRangeColumn.cs
index c70a5ff..3e701bf 100644
--- a/ClosedXML/Excel/Ranges/IXLRangeColumn.cs
+++ b/ClosedXML/Excel/Ranges/IXLRangeColumn.cs
@@ -84,7 +84,7 @@
         IXLRangeColumn Column(IXLCell start, IXLCell end);
         IXLRangeColumns Columns(String columns);
 
-        IXLRangeColumn SetDataType(XLCellValues dataType);
+        IXLRangeColumn SetDataType(XLDataType dataType);
 
         IXLRangeColumn ColumnLeft();
         IXLRangeColumn ColumnLeft(Int32 step);
diff --git a/ClosedXML/Excel/Ranges/IXLRangeColumns.cs b/ClosedXML/Excel/Ranges/IXLRangeColumns.cs
index 80b22e9..89c820e 100644
--- a/ClosedXML/Excel/Ranges/IXLRangeColumns.cs
+++ b/ClosedXML/Excel/Ranges/IXLRangeColumns.cs
@@ -35,7 +35,7 @@
 
         IXLStyle Style { get; set; }
 
-        IXLRangeColumns SetDataType(XLCellValues dataType);
+        IXLRangeColumns SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these columns.
diff --git a/ClosedXML/Excel/Ranges/IXLRangeRow.cs b/ClosedXML/Excel/Ranges/IXLRangeRow.cs
index c13753c..7c34ad3 100644
--- a/ClosedXML/Excel/Ranges/IXLRangeRow.cs
+++ b/ClosedXML/Excel/Ranges/IXLRangeRow.cs
@@ -92,7 +92,7 @@
         IXLRangeRow Row(IXLCell start, IXLCell end);
         IXLRangeRows Rows(String rows);
 
-        IXLRangeRow SetDataType(XLCellValues dataType);
+        IXLRangeRow SetDataType(XLDataType dataType);
 
         IXLRangeRow RowAbove();
         IXLRangeRow RowAbove(Int32 step);
diff --git a/ClosedXML/Excel/Ranges/IXLRangeRows.cs b/ClosedXML/Excel/Ranges/IXLRangeRows.cs
index 6c2da5a..cc3e3df 100644
--- a/ClosedXML/Excel/Ranges/IXLRangeRows.cs
+++ b/ClosedXML/Excel/Ranges/IXLRangeRows.cs
@@ -34,7 +34,7 @@
 
         IXLStyle Style { get; set; }
 
-        IXLRangeRows SetDataType(XLCellValues dataType);
+        IXLRangeRows SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these rows.
diff --git a/ClosedXML/Excel/Ranges/IXLRanges.cs b/ClosedXML/Excel/Ranges/IXLRanges.cs
index 48aeaff..f767b18 100644
--- a/ClosedXML/Excel/Ranges/IXLRanges.cs
+++ b/ClosedXML/Excel/Ranges/IXLRanges.cs
@@ -82,7 +82,7 @@
         /// <param name="includeFormats">if set to <c>true</c> will return all cells with a value or a style different than the default.</param>
         IXLCells CellsUsed(Boolean includeFormats);
 
-        IXLRanges SetDataType(XLCellValues dataType);
+        IXLRanges SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these ranges.
diff --git a/ClosedXML/Excel/Ranges/XLRange.cs b/ClosedXML/Excel/Ranges/XLRange.cs
index 1991c89..7950c82 100644
--- a/ClosedXML/Excel/Ranges/XLRange.cs
+++ b/ClosedXML/Excel/Ranges/XLRange.cs
@@ -327,7 +327,7 @@
                                           lastColumnNumber);
         }
 
-        public IXLRange SetDataType(XLCellValues dataType)
+        public IXLRange SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
diff --git a/ClosedXML/Excel/Ranges/XLRangeBase.cs b/ClosedXML/Excel/Ranges/XLRangeBase.cs
index ab227be..1994897 100644
--- a/ClosedXML/Excel/Ranges/XLRangeBase.cs
+++ b/ClosedXML/Excel/Ranges/XLRangeBase.cs
@@ -251,7 +251,7 @@
             set { Cells().ForEach(c => c.Value = value); }
         }
 
-        public XLCellValues DataType
+        public XLDataType DataType
         {
             set { Cells().ForEach(c => c.DataType = value); }
         }
diff --git a/ClosedXML/Excel/Ranges/XLRangeColumn.cs b/ClosedXML/Excel/Ranges/XLRangeColumn.cs
index 34710ea..ae85bf2 100644
--- a/ClosedXML/Excel/Ranges/XLRangeColumn.cs
+++ b/ClosedXML/Excel/Ranges/XLRangeColumn.cs
@@ -175,7 +175,7 @@
             return retVal;
         }
 
-        public IXLRangeColumn SetDataType(XLCellValues dataType)
+        public IXLRangeColumn SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
@@ -253,13 +253,13 @@
                 {
                     if (thisCell.DataType == otherCell.DataType)
                     {
-                        if (thisCell.DataType == XLCellValues.Text)
+                        if (thisCell.DataType == XLDataType.Text)
                         {
                             comparison = e.MatchCase
                                              ? thisCell.InnerText.CompareTo(otherCell.InnerText)
                                              : String.Compare(thisCell.InnerText, otherCell.InnerText, true);
                         }
-                        else if (thisCell.DataType == XLCellValues.TimeSpan)
+                        else if (thisCell.DataType == XLDataType.TimeSpan)
                             comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
                         else
                             comparison = Double.Parse(thisCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture).CompareTo(Double.Parse(otherCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture));
diff --git a/ClosedXML/Excel/Ranges/XLRangeColumns.cs b/ClosedXML/Excel/Ranges/XLRangeColumns.cs
index 5c78861..f2481ed 100644
--- a/ClosedXML/Excel/Ranges/XLRangeColumns.cs
+++ b/ClosedXML/Excel/Ranges/XLRangeColumns.cs
@@ -83,7 +83,7 @@
             return cells;
         }
 
-        public IXLRangeColumns SetDataType(XLCellValues dataType)
+        public IXLRangeColumns SetDataType(XLDataType dataType)
         {
             _ranges.ForEach(c => c.DataType = dataType);
             return this;
diff --git a/ClosedXML/Excel/Ranges/XLRangeRow.cs b/ClosedXML/Excel/Ranges/XLRangeRow.cs
index a579975..9b6be16 100644
--- a/ClosedXML/Excel/Ranges/XLRangeRow.cs
+++ b/ClosedXML/Excel/Ranges/XLRangeRow.cs
@@ -174,7 +174,7 @@
             return retVal;
         }
 
-        public IXLRangeRow SetDataType(XLCellValues dataType)
+        public IXLRangeRow SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
@@ -247,13 +247,13 @@
                 {
                     if (thisCell.DataType == otherCell.DataType)
                     {
-                        if (thisCell.DataType == XLCellValues.Text)
+                        if (thisCell.DataType == XLDataType.Text)
                         {
                             comparison = e.MatchCase
                                              ? thisCell.InnerText.CompareTo(otherCell.InnerText)
                                              : String.Compare(thisCell.InnerText, otherCell.InnerText, true);
                         }
-                        else if (thisCell.DataType == XLCellValues.TimeSpan)
+                        else if (thisCell.DataType == XLDataType.TimeSpan)
                             comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
                         else
                             comparison = Double.Parse(thisCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture).CompareTo(Double.Parse(otherCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture));
diff --git a/ClosedXML/Excel/Ranges/XLRangeRows.cs b/ClosedXML/Excel/Ranges/XLRangeRows.cs
index 205d04b..bbd51f8 100644
--- a/ClosedXML/Excel/Ranges/XLRangeRows.cs
+++ b/ClosedXML/Excel/Ranges/XLRangeRows.cs
@@ -83,7 +83,7 @@
             return cells;
         }
 
-        public IXLRangeRows SetDataType(XLCellValues dataType)
+        public IXLRangeRows SetDataType(XLDataType dataType)
         {
             _ranges.ForEach(c => c.DataType = dataType);
             return this;
diff --git a/ClosedXML/Excel/Ranges/XLRanges.cs b/ClosedXML/Excel/Ranges/XLRanges.cs
index 2fc41c0..7942134 100644
--- a/ClosedXML/Excel/Ranges/XLRanges.cs
+++ b/ClosedXML/Excel/Ranges/XLRanges.cs
@@ -160,7 +160,7 @@
             return cells;
         }
 
-        public IXLRanges SetDataType(XLCellValues dataType)
+        public IXLRanges SetDataType(XLDataType dataType)
         {
             _ranges.ForEach(c => c.DataType = dataType);
             return this;
diff --git a/ClosedXML/Excel/Rows/IXLRow.cs b/ClosedXML/Excel/Rows/IXLRow.cs
index 70816fb..a89ddda 100644
--- a/ClosedXML/Excel/Rows/IXLRow.cs
+++ b/ClosedXML/Excel/Rows/IXLRow.cs
@@ -177,7 +177,7 @@
         /// </summary>
         IXLRow AddHorizontalPageBreak();
 
-        IXLRow SetDataType(XLCellValues dataType);
+        IXLRow SetDataType(XLDataType dataType);
 
         IXLRow RowAbove();
         IXLRow RowAbove(Int32 step);
diff --git a/ClosedXML/Excel/Rows/IXLRows.cs b/ClosedXML/Excel/Rows/IXLRows.cs
index 5249e64..5f4c6bc 100644
--- a/ClosedXML/Excel/Rows/IXLRows.cs
+++ b/ClosedXML/Excel/Rows/IXLRows.cs
@@ -112,7 +112,7 @@
         /// </summary>
         IXLRows AddHorizontalPageBreaks();
 
-        IXLRows SetDataType(XLCellValues dataType);
+        IXLRows SetDataType(XLDataType dataType);
 
         /// <summary>
         /// Clears the contents of these rows.
diff --git a/ClosedXML/Excel/Rows/XLRow.cs b/ClosedXML/Excel/Rows/XLRow.cs
index a847178..cae1b8e 100644
--- a/ClosedXML/Excel/Rows/XLRow.cs
+++ b/ClosedXML/Excel/Rows/XLRow.cs
@@ -577,7 +577,7 @@
             return this;
         }
 
-        public IXLRow SetDataType(XLCellValues dataType)
+        public IXLRow SetDataType(XLDataType dataType)
         {
             DataType = dataType;
             return this;
diff --git a/ClosedXML/Excel/Rows/XLRows.cs b/ClosedXML/Excel/Rows/XLRows.cs
index f44cb48..27583d1 100644
--- a/ClosedXML/Excel/Rows/XLRows.cs
+++ b/ClosedXML/Excel/Rows/XLRows.cs
@@ -203,7 +203,7 @@
             return this;
         }
 
-        public IXLRows SetDataType(XLCellValues dataType)
+        public IXLRows SetDataType(XLDataType dataType)
         {
             _rows.ForEach(c => c.DataType = dataType);
             return this;
diff --git a/ClosedXML/Excel/Tables/XLTable.cs b/ClosedXML/Excel/Tables/XLTable.cs
index 6eefffc..f97685a 100644
--- a/ClosedXML/Excel/Tables/XLTable.cs
+++ b/ClosedXML/Excel/Tables/XLTable.cs
@@ -100,7 +100,7 @@
                     {
                         name = GetUniqueName("Column", cellPos + 1, true);
                         cell.SetValue(name);
-                        cell.DataType = XLCellValues.Text;
+                        cell.DataType = XLDataType.Text;
                     }
                     if (_fieldNames.ContainsKey(name))
                         throw new ArgumentException("The header row contains more than one field name '" + name + "'.");
@@ -383,7 +383,7 @@
                     if (!c.IsEmpty() && newHeaders.Contains(f.Name))
                     {
                         f.TotalsRowLabel = c.GetFormattedString();
-                        c.DataType = XLCellValues.Text;
+                        c.DataType = XLDataType.Text;
                     }
                 }
 
@@ -395,7 +395,7 @@
                         var c = this.TotalsRow().Cell(f.Index + 1);
                         if (!String.IsNullOrWhiteSpace(f.TotalsRowLabel))
                         {
-                            c.DataType = XLCellValues.Text;
+                            c.DataType = XLDataType.Text;
 
                             //Remove previous row's label
                             var oldTotalsCell = this.Worksheet.Cell(oldTotalsRowNumber, f.Column.ColumnNumber());
@@ -404,7 +404,7 @@
                         }
 
                         if (f.TotalsRowFunction != XLTotalsRowFunction.None)
-                            c.DataType = XLCellValues.Number;
+                            c.DataType = XLDataType.Number;
                     }
                 }
             }
@@ -545,7 +545,7 @@
             if (setAutofilter)
                 InitializeAutoFilter();
 
-            AsRange().Row(1).DataType = XLCellValues.Text;
+            AsRange().Row(1).DataType = XLDataType.Text;
 
             if (RowCount() == 1)
                 InsertRowsBelow(1);
@@ -678,7 +678,7 @@
                 _showHeaderRow = value;
 
                 if (_showHeaderRow)
-                    HeadersRow().DataType = XLCellValues.Text;
+                    HeadersRow().DataType = XLDataType.Text;
             }
         }
 
@@ -789,23 +789,23 @@
                     var c = f.Column.Cells().Skip(this.ShowHeaderRow ? 1 : 0).First();
                     switch (c.DataType)
                     {
-                        case XLCellValues.Text:
+                        case XLDataType.Text:
                             type = typeof(String);
                             break;
 
-                        case XLCellValues.Boolean:
+                        case XLDataType.Boolean:
                             type = typeof(Boolean);
                             break;
 
-                        case XLCellValues.DateTime:
+                        case XLDataType.DateTime:
                             type = typeof(DateTime);
                             break;
 
-                        case XLCellValues.TimeSpan:
+                        case XLDataType.TimeSpan:
                             type = typeof(TimeSpan);
                             break;
 
-                        case XLCellValues.Number:
+                        case XLDataType.Number:
                             type = typeof(Double);
                             break;
                     }
diff --git a/ClosedXML/Excel/Tables/XLTableField.cs b/ClosedXML/Excel/Tables/XLTableField.cs
index ed65bed..4ddcd73 100644
--- a/ClosedXML/Excel/Tables/XLTableField.cs
+++ b/ClosedXML/Excel/Tables/XLTableField.cs
@@ -194,7 +194,7 @@
 
                 cell.FormulaA1 = "SUBTOTAL(" + formula + ",[" + Name + "])";
                 var lastCell = table.LastRow().Cell(Index + 1);
-                if (lastCell.DataType != XLCellValues.Text)
+                if (lastCell.DataType != XLDataType.Text)
                 {
                     cell.DataType = lastCell.DataType;
                     cell.Style.NumberFormat = lastCell.Style.NumberFormat;
diff --git a/ClosedXML/Excel/XLWorkbook_Load.cs b/ClosedXML/Excel/XLWorkbook_Load.cs
index 2e9c4cd..375f0ec 100644
--- a/ClosedXML/Excel/XLWorkbook_Load.cs
+++ b/ClosedXML/Excel/XLWorkbook_Load.cs
@@ -1327,7 +1327,7 @@
                     else
                         xlCell._cellValue = String.Empty;
 
-                    xlCell._dataType = XLCellValues.Text;
+                    xlCell._dataType = XLDataType.Text;
                     xlCell.ShareString = false;
                 }
                 else if (cell.DataType == CellValues.SharedString)
@@ -1340,19 +1340,19 @@
                     else
                         xlCell._cellValue = String.Empty;
 
-                    xlCell._dataType = XLCellValues.Text;
+                    xlCell._dataType = XLDataType.Text;
                 }
                 else if (cell.DataType == CellValues.Date)
                 {
                     if (cell.CellValue != null && !String.IsNullOrWhiteSpace(cell.CellValue.Text))
                         xlCell._cellValue = Double.Parse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture).ToInvariantString();
-                    xlCell._dataType = XLCellValues.DateTime;
+                    xlCell._dataType = XLDataType.DateTime;
                 }
                 else if (cell.DataType == CellValues.Boolean)
                 {
                     if (cell.CellValue != null)
                         xlCell._cellValue = cell.CellValue.Text;
-                    xlCell._dataType = XLCellValues.Boolean;
+                    xlCell._dataType = XLDataType.Boolean;
                 }
                 else if (cell.DataType == CellValues.Number)
                 {
@@ -1360,7 +1360,7 @@
                         xlCell._cellValue = Double.Parse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture).ToInvariantString();
 
                     if (s == null)
-                        xlCell._dataType = XLCellValues.Number;
+                        xlCell._dataType = XLDataType.Number;
                     else
                         xlCell.DataType = GetDataTypeFromCell(xlCell.Style.NumberFormat);
                 }
@@ -1369,7 +1369,7 @@
             {
                 if (s == null)
                 {
-                    xlCell._dataType = XLCellValues.Number;
+                    xlCell._dataType = XLDataType.Number;
                 }
                 else
                 {
@@ -1678,29 +1678,29 @@
             }
         }
 
-        private static XLCellValues GetDataTypeFromCell(IXLNumberFormat numberFormat)
+        private static XLDataType GetDataTypeFromCell(IXLNumberFormat numberFormat)
         {
             var numberFormatId = numberFormat.NumberFormatId;
             if (numberFormatId == 46U)
-                return XLCellValues.TimeSpan;
+                return XLDataType.TimeSpan;
             else if ((numberFormatId >= 14 && numberFormatId <= 22) ||
                      (numberFormatId >= 45 && numberFormatId <= 47))
-                return XLCellValues.DateTime;
+                return XLDataType.DateTime;
             else if (numberFormatId == 49)
-                return XLCellValues.Text;
+                return XLDataType.Text;
             else
             {
                 if (!String.IsNullOrWhiteSpace(numberFormat.Format))
                 {
                     var dataType = GetDataTypeFromFormat(numberFormat.Format);
-                    return dataType.HasValue ? dataType.Value : XLCellValues.Number;
+                    return dataType.HasValue ? dataType.Value : XLDataType.Number;
                 }
                 else
-                    return XLCellValues.Number;
+                    return XLDataType.Number;
             }
         }
 
-        private static XLCellValues? GetDataTypeFromFormat(String format)
+        private static XLDataType? GetDataTypeFromFormat(String format)
         {
             int length = format.Length;
             String f = format.ToLower();
@@ -1710,9 +1710,9 @@
                 if (c == '"')
                     i = f.IndexOf('"', i + 1);
                 else if (c == '0' || c == '#' || c == '?')
-                    return XLCellValues.Number;
+                    return XLDataType.Number;
                 else if (c == 'y' || c == 'm' || c == 'd' || c == 'h' || c == 's')
-                    return XLCellValues.DateTime;
+                    return XLDataType.DateTime;
             }
             return null;
         }
diff --git a/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs b/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
index c4a9961..35f43af 100644
--- a/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
+++ b/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs
@@ -150,7 +150,7 @@
 
         internal struct PivotTableFieldInfo
         {
-            public XLCellValues DataType;
+            public XLDataType DataType;
             public Boolean MixedDataType;
             public IEnumerable<Object> DistinctValues;
         }
diff --git a/ClosedXML/Excel/XLWorkbook_Save.cs b/ClosedXML/Excel/XLWorkbook_Save.cs
index 4979c7d..3569a34 100644
--- a/ClosedXML/Excel/XLWorkbook_Save.cs
+++ b/ClosedXML/Excel/XLWorkbook_Save.cs
@@ -65,20 +65,20 @@
         {
             switch (xlCell.DataType)
             {
-                case XLCellValues.Text:
+                case XLDataType.Text:
                     {
                         return xlCell.ShareString ? CvSharedString : CvInlineString;
                     }
-                case XLCellValues.Number:
+                case XLDataType.Number:
                     return CvNumber;
 
-                case XLCellValues.DateTime:
+                case XLDataType.DateTime:
                     return CvDate;
 
-                case XLCellValues.Boolean:
+                case XLDataType.Boolean:
                     return CvBoolean;
 
-                case XLCellValues.TimeSpan:
+                case XLDataType.TimeSpan:
                     return CvNumber;
 
                 default:
@@ -871,12 +871,12 @@
                     Worksheets.Cast<XLWorksheet>().SelectMany(
                         w =>
                             w.Internals.CellsCollection.GetCells(
-                                c => ((c.DataType == XLCellValues.Text && c.ShareString) || c.HasRichText)
+                                c => ((c.DataType == XLDataType.Text && c.ShareString) || c.HasRichText)
                                      && (c as XLCell).InnerText.Length > 0
                                      && String.IsNullOrWhiteSpace(c.FormulaA1)
                                 )))
             {
-                c.DataType = XLCellValues.Text;
+                c.DataType = XLDataType.Text;
                 if (c.HasRichText)
                 {
                     if (newRichStrings.ContainsKey(c.RichText))
@@ -2032,13 +2032,13 @@
                 var types = fieldValueCells.Select(cell => cell.DataType).Distinct();
 
 
-                if (types.Count() == 1 && types.Single() == XLCellValues.Number)
+                if (types.Count() == 1 && types.Single() == XLDataType.Number)
                 {
                     sharedItems.ContainsSemiMixedTypes = false;
                     sharedItems.ContainsString = false;
                     sharedItems.ContainsNumber = true;
 
-                    ptfi.DataType = XLCellValues.Number;
+                    ptfi.DataType = XLDataType.Number;
                     ptfi.MixedDataType = false;
                     ptfi.DistinctValues = fieldValueCells
                             .Select(cell => cell.GetDouble())
@@ -2059,14 +2059,14 @@
                     sharedItems.MinValue = (double)ptfi.DistinctValues.Min();
                     sharedItems.MaxValue = (double)ptfi.DistinctValues.Max();
                 }
-                else if (types.Count() == 1 && types.Single() == XLCellValues.DateTime)
+                else if (types.Count() == 1 && types.Single() == XLDataType.DateTime)
                 {
                     sharedItems.ContainsSemiMixedTypes = false;
                     sharedItems.ContainsString = false;
                     sharedItems.ContainsNumber = false;
                     sharedItems.ContainsDate = true;
 
-                    ptfi.DataType = XLCellValues.DateTime;
+                    ptfi.DataType = XLDataType.DateTime;
                     ptfi.MixedDataType = false;
                     ptfi.DistinctValues = fieldValueCells
                             .Select(cell => cell.GetDateTime())
@@ -2094,7 +2094,7 @@
                         ptfi.DataType = types.First();
                         ptfi.MixedDataType = types.Count() > 1;
 
-                        if (!ptfi.MixedDataType && ptfi.DataType == XLCellValues.Text)
+                        if (!ptfi.MixedDataType && ptfi.DataType == XLDataType.Text)
                             ptfi.DistinctValues = fieldValueCells
                                 .Select(cell => cell.Value)
                                 .Cast<String>()
@@ -2338,7 +2338,7 @@
 
                     if (labelOrFilterField.SelectedValues.Count == 1)
                     {
-                        if (ptfi.MixedDataType || ptfi.DataType == XLCellValues.Text)
+                        if (ptfi.MixedDataType || ptfi.DataType == XLDataType.Text)
                         {
                             var values = ptfi.DistinctValues
                                 .Select(v => v.ToString().ToLower())
@@ -2347,7 +2347,7 @@
                             if (values.Contains(selectedValue))
                                 pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue));
                         }
-                        else if (ptfi.DataType == XLCellValues.DateTime)
+                        else if (ptfi.DataType == XLDataType.DateTime)
                         {
                             var values = ptfi.DistinctValues
                                 .Select(v => Convert.ToDateTime(v))
@@ -2356,7 +2356,7 @@
                             if (values.Contains(selectedValue))
                                 pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue));
                         }
-                        else if (ptfi.DataType == XLCellValues.Number)
+                        else if (ptfi.DataType == XLDataType.Number)
                         {
                             var values = ptfi.DistinctValues
                                 .Select(v => Convert.ToDouble(v))
@@ -4662,7 +4662,7 @@
                             else
                             {
                                 cell.CellFormula = null;
-                                cell.DataType = xlCell.DataType == XLCellValues.DateTime ? null : GetCellValueType(xlCell);
+                                cell.DataType = xlCell.DataType == XLDataType.DateTime ? null : GetCellValueType(xlCell);
                             }
 
                             if (evaluateFormulae || field != null || !xlCell.HasFormula)
@@ -5306,7 +5306,7 @@
             }
 
             var dataType = xlCell.DataType;
-            if (dataType == XLCellValues.Text)
+            if (dataType == XLDataType.Text)
             {
                 if (xlCell.InnerText.Length == 0)
                     openXmlCell.CellValue = null;
@@ -5329,7 +5329,7 @@
                     }
                 }
             }
-            else if (dataType == XLCellValues.TimeSpan)
+            else if (dataType == XLDataType.TimeSpan)
             {
                 var timeSpan = xlCell.GetTimeSpan();
                 var cellValue = new CellValue();
@@ -5337,7 +5337,7 @@
                     XLCell.BaseDate.Add(timeSpan).ToOADate().ToInvariantString();
                 openXmlCell.CellValue = cellValue;
             }
-            else if (dataType == XLCellValues.DateTime || dataType == XLCellValues.Number)
+            else if (dataType == XLDataType.DateTime || dataType == XLDataType.Number)
             {
                 if (!String.IsNullOrWhiteSpace(xlCell.InnerText))
                 {
diff --git a/ClosedXML_Examples/Loading/ChangingBasicTable.cs b/ClosedXML_Examples/Loading/ChangingBasicTable.cs
index a10c7a4..c64d0d3 100644
--- a/ClosedXML_Examples/Loading/ChangingBasicTable.cs
+++ b/ClosedXML_Examples/Loading/ChangingBasicTable.cs
@@ -28,7 +28,7 @@
                 foreach (var cell in rngNumbers.Cells())
                 {
                     string formattedString = cell.GetFormattedString();
-                    cell.DataType = XLCellValues.Text;
+                    cell.DataType = XLDataType.Text;
                     cell.Value = formattedString + " Dollars";
                 }
 
diff --git a/ClosedXML_Examples/Misc/DataTypes.cs b/ClosedXML_Examples/Misc/DataTypes.cs
index a396328..e50b3ba 100644
--- a/ClosedXML_Examples/Misc/DataTypes.cs
+++ b/ClosedXML_Examples/Misc/DataTypes.cs
@@ -113,67 +113,67 @@
 
             ws.Cell(++ro, co).Value = "Date to Text:";
             ws.Cell(ro, co + 1).Value = new DateTime(2010, 9, 2);
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "DateTime to Text:";
             ws.Cell(ro, co + 1).Value = new DateTime(2010, 9, 2, 13, 45, 22);
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "Boolean to Text:";
             ws.Cell(ro, co + 1).Value = true;
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "Number to Text:";
             ws.Cell(ro, co + 1).Value = 123.45;
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "TimeSpan to Text:";
             ws.Cell(ro, co + 1).Value = new TimeSpan(33, 45, 22);
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "Text to Date:";
             ws.Cell(ro, co + 1).Value = "'" + new DateTime(2010, 9, 2).ToString();
-            ws.Cell(ro, co + 1).DataType = XLCellValues.DateTime;
+            ws.Cell(ro, co + 1).DataType = XLDataType.DateTime;
 
             ws.Cell(++ro, co).Value = "Text to DateTime:";
             ws.Cell(ro, co + 1).Value = "'" + new DateTime(2010, 9, 2, 13, 45, 22).ToString();
-            ws.Cell(ro, co + 1).DataType = XLCellValues.DateTime;
+            ws.Cell(ro, co + 1).DataType = XLDataType.DateTime;
 
             ws.Cell(++ro, co).Value = "Text to Boolean:";
             ws.Cell(ro, co + 1).Value = "'" + true.ToString();
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Boolean;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Boolean;
 
             ws.Cell(++ro, co).Value = "Text to Number:";
             ws.Cell(ro, co + 1).Value = "'123.45";
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Number;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Number;
 
             ws.Cell(++ro, co).Value = "@ format to Number:";
             ws.Cell(ro, co + 1).Style.NumberFormat.Format = "@";
             ws.Cell(ro, co + 1).Value = 123.45;
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Number;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Number;
 
             ws.Cell(++ro, co).Value = "Text to TimeSpan:";
             ws.Cell(ro, co + 1).Value = "'" + new TimeSpan(33, 45, 22).ToString();
-            ws.Cell(ro, co + 1).DataType = XLCellValues.TimeSpan;
+            ws.Cell(ro, co + 1).DataType = XLDataType.TimeSpan;
 
             ro++;
 
             ws.Cell(++ro, co).Value = "Formatted Date to Text:";
             ws.Cell(ro, co + 1).Value = new DateTime(2010, 9, 2);
             ws.Cell(ro, co + 1).Style.DateFormat.Format = "yyyy-MM-dd";
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ws.Cell(++ro, co).Value = "Formatted Number to Text:";
             ws.Cell(ro, co + 1).Value = 12345.6789;
             ws.Cell(ro, co + 1).Style.NumberFormat.Format = "#,##0.00";
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
 
             ro++;
 
             ws.Cell(++ro, co).Value = "Blank Text:";
             ws.Cell(ro, co + 1).Value = 12345.6789;
             ws.Cell(ro, co + 1).Style.NumberFormat.Format = "#,##0.00";
-            ws.Cell(ro, co + 1).DataType = XLCellValues.Text;
+            ws.Cell(ro, co + 1).DataType = XLDataType.Text;
             ws.Cell(ro, co + 1).Value = "";
 
             ro++;
@@ -192,17 +192,17 @@
             // workbook.GetSharedStrings()
 
             ws.Cell(++ro, co)
-                .SetDataType(XLCellValues.Text)
-                .SetDataType(XLCellValues.Boolean)
-                .SetDataType(XLCellValues.DateTime)
-                .SetDataType(XLCellValues.Number)
-                .SetDataType(XLCellValues.TimeSpan)
-                .SetDataType(XLCellValues.Text)
-                .SetDataType(XLCellValues.TimeSpan)
-                .SetDataType(XLCellValues.Number)
-                .SetDataType(XLCellValues.DateTime)
-                .SetDataType(XLCellValues.Boolean)
-                .SetDataType(XLCellValues.Text);
+                .SetDataType(XLDataType.Text)
+                .SetDataType(XLDataType.Boolean)
+                .SetDataType(XLDataType.DateTime)
+                .SetDataType(XLDataType.Number)
+                .SetDataType(XLDataType.TimeSpan)
+                .SetDataType(XLDataType.Text)
+                .SetDataType(XLDataType.TimeSpan)
+                .SetDataType(XLDataType.Number)
+                .SetDataType(XLDataType.DateTime)
+                .SetDataType(XLDataType.Boolean)
+                .SetDataType(XLDataType.Text);
 
             ws.Columns(2, 3).AdjustToContents();
 
diff --git a/ClosedXML_Examples/Misc/LambdaExpressions.cs b/ClosedXML_Examples/Misc/LambdaExpressions.cs
index 7b5e4f3..5e2721b 100644
--- a/ClosedXML_Examples/Misc/LambdaExpressions.cs
+++ b/ClosedXML_Examples/Misc/LambdaExpressions.cs
@@ -32,7 +32,7 @@
                 //        .ForEach(c => c.Style.Fill.BackgroundColor = XLColor.LightGray); // Fill with a light gray
 
                 var cells = rngData.Cells();
-                var filtered = cells.Where(c => c.DataType == XLCellValues.Text);
+                var filtered = cells.Where(c => c.DataType == XLDataType.Text);
                 var list = filtered.ToList();
                 foreach (var c in list)
                 {
diff --git a/ClosedXML_Tests/Excel/CalcEngine/MathTrigTests.cs b/ClosedXML_Tests/Excel/CalcEngine/MathTrigTests.cs
index 8c95b10..5d258b4 100644
--- a/ClosedXML_Tests/Excel/CalcEngine/MathTrigTests.cs
+++ b/ClosedXML_Tests/Excel/CalcEngine/MathTrigTests.cs
@@ -12,6 +12,63 @@
     {
         private readonly double tolerance = 1e-10;
 
+        [TestCase(-10, 3.041924001)]
+        [TestCase(-9, 3.030935432)]
+        [TestCase(-8, 3.017237659)]
+        [TestCase(-7, 2.999695599)]
+        [TestCase(-6, 2.976443976)]
+        [TestCase(-5, 2.944197094)]
+        [TestCase(-4, 2.89661399)]
+        [TestCase(-3, 2.819842099)]
+        [TestCase(-2, 2.677945045)]
+        [TestCase(-1, 2.35619449)]
+        [TestCase(0, 1.570796327)]
+        [TestCase(1, 0.785398163)]
+        [TestCase(2, 0.463647609)]
+        [TestCase(3, 0.321750554)]
+        [TestCase(4, 0.244978663)]
+        [TestCase(5, 0.19739556)]
+        [TestCase(6, 0.165148677)]
+        [TestCase(7, 0.141897055)]
+        [TestCase(8, 0.124354995)]
+        [TestCase(9, 0.110657221)]
+        [TestCase(10, 0.099668652)]
+        public void Acot_ReturnsCorrectValue(double input, double expectedResult)
+        {
+            var actual = (double)XLWorkbook.EvaluateExpr(string.Format(@"ACOT({0})", input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedResult, actual, tolerance * 10);
+        }
+
+        [TestCase(-10, -0.100335348)]
+        [TestCase(-9, -0.111571776)]
+        [TestCase(-8, -0.125657214)]
+        [TestCase(-7, -0.143841036)]
+        [TestCase(-6, -0.168236118)]
+        [TestCase(-5, -0.202732554)]
+        [TestCase(-4, -0.255412812)]
+        [TestCase(-3, -0.34657359)]
+        [TestCase(-2, -0.549306144)]
+        [TestCase(2, 0.549306144)]
+        [TestCase(3, 0.34657359)]
+        [TestCase(4, 0.255412812)]
+        [TestCase(5, 0.202732554)]
+        [TestCase(6, 0.168236118)]
+        [TestCase(7, 0.143841036)]
+        [TestCase(8, 0.125657214)]
+        [TestCase(9, 0.111571776)]
+        [TestCase(10, 0.100335348)]
+        public void Acoth_ReturnsCorrectValue(double input, double expectedResult)
+        {
+            var actual = (double)XLWorkbook.EvaluateExpr(string.Format(@"ACOTH({0})", input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedResult, actual, tolerance * 10);
+        }
+
+        [Theory]
+        public void Acoth_ForPlusMinusXSmallerThan1_ThrowsNumberException([Range(-0.9, 0.9, 0.1)] double input)
+        {
+            Assert.Throws<NumberException>(() => XLWorkbook.EvaluateExpr(string.Format(@"ACOTH({0})", input.ToString(CultureInfo.InvariantCulture))));
+        }
+
         [TestCase(4, 3, 20)]
         [TestCase(10, 3, 220)]
         [TestCase(0, 0, 1)]
@@ -79,6 +136,71 @@
             Assert.Throws<DivisionByZeroException>(() => XLWorkbook.EvaluateExpr("COT(0)"));
         }
 
+        [TestCase(-10, -1.000000004)]
+        [TestCase(-9, -1.00000003)]
+        [TestCase(-8, -1.000000225)]
+        [TestCase(-7, -1.000001663)]
+        [TestCase(-6, -1.000012289)]
+        [TestCase(-5, -1.000090804)]
+        [TestCase(-4, -1.00067115)]
+        [TestCase(-3, -1.004969823)]
+        [TestCase(-2, -1.037314721)]
+        [TestCase(-1, -1.313035285)]
+        [TestCase(1, 1.313035285)]
+        [TestCase(2, 1.037314721)]
+        [TestCase(3, 1.004969823)]
+        [TestCase(4, 1.00067115)]
+        [TestCase(5, 1.000090804)]
+        [TestCase(6, 1.000012289)]
+        [TestCase(7, 1.000001663)]
+        [TestCase(8, 1.000000225)]
+        [TestCase(9, 1.00000003)]
+        [TestCase(10, 1.000000004)]
+        public void Coth_Examples(double input, double expected)
+        {
+            var actual = (double)XLWorkbook.EvaluateExpr(string.Format(@"COTH({0})", input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expected, actual, tolerance * 10.0);
+        }
+
+        [Test]
+        public void Cot_On0_ThrowsDivisionByZeroException()
+        {
+            Assert.Throws<DivisionByZeroException>(() => XLWorkbook.EvaluateExpr(@"COTH(0)"));
+        }
+
+        [TestCase(-10, 1.838163961)]
+        [TestCase(-9, -2.426486644)]
+        [TestCase(-8, -1.010756218)]
+        [TestCase(-7, -1.522101063)]
+        [TestCase(-6, 3.578899547)]
+        [TestCase(-5, 1.042835213)]
+        [TestCase(-4, 1.321348709)]
+        [TestCase(-3, -7.086167396)]
+        [TestCase(-2, -1.09975017)]
+        [TestCase(-1, -1.188395106)]
+        [TestCase(1, 1.188395106)]
+        [TestCase(2, 1.09975017)]
+        [TestCase(3, 7.086167396)]
+        [TestCase(4, -1.321348709)]
+        [TestCase(5, -1.042835213)]
+        [TestCase(6, -3.578899547)]
+        [TestCase(7, 1.522101063)]
+        [TestCase(8, 1.010756218)]
+        [TestCase(9, 2.426486644)]
+        [TestCase(10, -1.838163961)]
+        public void Csc_ReturnsCorrectValues(double input, double expected)
+        {
+            var actual = (double)XLWorkbook.EvaluateExpr(string.Format(@"CSC({0})", input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expected, actual, tolerance * 10);
+        }
+
+        [Test]
+        public void Csc_On0_ThrowsDivisionByZeroException()
+        {
+            Assert.Throws<DivisionByZeroException>(() => XLWorkbook.EvaluateExpr(@"CSC(0)"));
+        }
+
+
         [TestCase("FF", 16, 255)]
         [TestCase("111", 2, 7)]
         [TestCase("zap", 36, 45745)]
@@ -217,6 +339,97 @@
             Assert.AreEqual(0.7, actual, tolerance);
         }
 
+        [TestCase(0, 1)]
+        [TestCase(0.3, 1.0467516)]
+        [TestCase(0.6, 1.21162831)]
+        [TestCase(0.9, 1.60872581)]
+        [TestCase(1.2, 2.759703601)]
+        [TestCase(1.5, 14.1368329)]
+        [TestCase(1.8, -4.401367872)]
+        [TestCase(2.1, -1.980801656)]
+        [TestCase(2.4, -1.356127641)]
+        [TestCase(2.7, -1.10610642)]
+        [TestCase(3.0, -1.010108666)]
+        [TestCase(3.3, -1.012678974)]
+        [TestCase(3.6, -1.115127532)]
+        [TestCase(3.9, -1.377538917)]
+        [TestCase(4.2, -2.039730601)]
+        [TestCase(4.5, -4.743927548)]
+        [TestCase(4.8, 11.42870421)]
+        [TestCase(5.1, 2.645658426)]
+        [TestCase(5.4, 1.575565187)]
+        [TestCase(5.7, 1.198016873)]
+        [TestCase(6.0, 1.041481927)]
+        [TestCase(6.3, 1.000141384)]
+        [TestCase(6.6, 1.052373922)]
+        [TestCase(6.9, 1.225903187)]
+        [TestCase(7.2, 1.643787029)]
+        [TestCase(7.5, 2.884876262)]
+        [TestCase(7.8, 18.53381902)]
+        [TestCase(8.1, -4.106031636)]
+        [TestCase(8.4, -1.925711244)]
+        [TestCase(8.7, -1.335743646)]
+        [TestCase(9.0, -1.097537906)]
+        [TestCase(9.3, -1.007835594)]
+        [TestCase(9.6, -1.015550252)]
+        [TestCase(9.9, -1.124617578)]
+        [TestCase(10.2, -1.400039323)]
+        [TestCase(10.5, -2.102886109)]
+        [TestCase(10.8, -5.145888341)]
+        [TestCase(11.1, 9.593612018)]
+        [TestCase(11.4, 2.541355049)]
+        [TestCase(45, 1.90359)]
+        [TestCase(30, 6.48292)]
+        public void Sec_ReturnsCorrectNumber(double input, double expectedOutput)
+        {
+            double result = (double)XLWorkbook.EvaluateExpr(
+                string.Format(
+                    @"SEC({0})",
+                    input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedOutput, result, 0.00001);
+
+            // as the secant is symmetric for positive and negative numbers, let's assert twice:
+            double resultForNegative = (double)XLWorkbook.EvaluateExpr(
+                string.Format(
+                    @"SEC({0})",
+                    (-input).ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedOutput, resultForNegative, 0.00001);
+        }
+
+        [Test]
+        public void Sec_ThrowsCellValueExceptionOnNonNumericValue()
+        {
+            Assert.Throws<CellValueException>(() => XLWorkbook.EvaluateExpr(
+                string.Format(
+                    @"SEC(number)")));
+        }
+
+        [TestCase(-9, 0.00024682)]
+        [TestCase(-8, 0.000670925)]
+        [TestCase(-7, 0.001823762)]
+        [TestCase(-6, 0.004957474)]
+        [TestCase(-5, 0.013475282)]
+        [TestCase(-4, 0.036618993)]
+        [TestCase(-3, 0.099327927)]
+        [TestCase(-2, 0.265802229)]
+        [TestCase(-1, 0.648054274)]
+        [TestCase(0, 1)]
+        public void Sech_ReturnsCorrectNumber(double input, double expectedOutput)
+        {
+            double result = (double)XLWorkbook.EvaluateExpr(
+                string.Format(
+                    @"SECH({0})",
+                    input.ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedOutput, result, 0.00001);
+
+            // as the secant is symmetric for positive and negative numbers, let's assert twice:
+            double resultForNegative = (double)XLWorkbook.EvaluateExpr(
+                string.Format(
+                    @"SECH({0})",
+                    (-input).ToString(CultureInfo.InvariantCulture)));
+            Assert.AreEqual(expectedOutput, resultForNegative, 0.00001);
+        }
+
         /// <summary>
         /// refers to Example 1 from the Excel documentation,
         /// <see cref="https://support.office.com/en-us/article/SUMIF-function-169b8c99-c05c-4483-a712-1697a653039b?ui=en-US&amp;rs=en-US&amp;ad=US"/>
diff --git a/ClosedXML_Tests/Excel/Cells/XLCellTests.cs b/ClosedXML_Tests/Excel/Cells/XLCellTests.cs
index 161f17a..007b492 100644
--- a/ClosedXML_Tests/Excel/Cells/XLCellTests.cs
+++ b/ClosedXML_Tests/Excel/Cells/XLCellTests.cs
@@ -60,7 +60,7 @@
             var doubleList = new List<Double> { 1.0 / 0.0 };
 
             cell.Value = doubleList;
-            Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
+            Assert.AreNotEqual(XLDataType.Number, cell.DataType);
         }
 
         [Test]
@@ -71,7 +71,7 @@
             var doubleList = new List<Double> { 0.0 / 0.0 };
 
             cell.Value = doubleList;
-            Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
+            Assert.AreNotEqual(XLDataType.Number, cell.DataType);
         }
 
         [Test]
@@ -169,7 +169,7 @@
             IXLCell cell = ws.Cell("A1");
             cell.Value = "NaN";
 
-            Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
+            Assert.AreNotEqual(XLDataType.Number, cell.DataType);
         }
 
         [Test]
@@ -179,7 +179,7 @@
             IXLCell cell = ws.Cell("A1");
             cell.Value = "Nan";
 
-            Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
+            Assert.AreNotEqual(XLDataType.Number, cell.DataType);
         }
 
         [Test]
@@ -241,7 +241,7 @@
             IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
             DateTime outValue;
             var date = 5545454;
-            ws.FirstCell().SetValue(date).DataType = XLCellValues.DateTime;
+            ws.FirstCell().SetValue(date).DataType = XLDataType.DateTime;
             bool success = ws.FirstCell().TryGetValue(out outValue);
             Assert.IsFalse(success);
         }
@@ -414,7 +414,7 @@
 
                 cell.Value = "Test";
                 Assert.AreEqual("Test", cell.Value);
-                Assert.AreEqual(XLCellValues.Text, cell.DataType);
+                Assert.AreEqual(XLDataType.Text, cell.DataType);
 
                 string s = null;
                 cell.SetValue(s);
diff --git a/ClosedXML_Tests/Excel/Loading/LoadingTests.cs b/ClosedXML_Tests/Excel/Loading/LoadingTests.cs
index 5b1fc42..3a4acdf 100644
--- a/ClosedXML_Tests/Excel/Loading/LoadingTests.cs
+++ b/ClosedXML_Tests/Excel/Loading/LoadingTests.cs
@@ -125,7 +125,7 @@
                 var ws = wb.Worksheets.First();
                 foreach (var cell in ws.CellsUsed())
                 {
-                    Assert.AreEqual(XLCellValues.DateTime, cell.DataType);
+                    Assert.AreEqual(XLDataType.DateTime, cell.DataType);
                 }
             }
         }
diff --git a/ClosedXML_Tests/Excel/Misc/FormulaTests.cs b/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
index 3ff4c55..f514295 100644
--- a/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
+++ b/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
@@ -112,7 +112,7 @@
             {
                 var ws = wb.AddWorksheet("Sheet1");
                 ws.Cell("A1").Value = new DateTime(2016, 1, 1);
-                ws.Cell("A1").DataType = XLCellValues.DateTime;
+                ws.Cell("A1").DataType = XLDataType.DateTime;
 
                 ws.Cell("A2").FormulaA1 = @"=IF(A1 = """", ""A"", ""B"")";
                 var actual = ws.Cell("A2").Value;
diff --git a/ClosedXML_Tests/Excel/PageSetup/HeaderFooterTests.cs b/ClosedXML_Tests/Excel/PageSetup/HeaderFooterTests.cs
index 18fe221..002df23 100644
--- a/ClosedXML_Tests/Excel/PageSetup/HeaderFooterTests.cs
+++ b/ClosedXML_Tests/Excel/PageSetup/HeaderFooterTests.cs
@@ -33,5 +33,19 @@
             var newHeader = ws.PageSetup.Header.Center.GetText(XLHFOccurrence.EvenPages);
             Assert.AreEqual("Changed header", newHeader);
         }
+
+        [TestCase("")]
+        [TestCase("&L&C&\"Arial\"&9 19-10-2017 \n&9&\"Arial\" &P    &N &R")] // https://github.com/ClosedXML/ClosedXML/issues/563
+        public void CanSetHeaderFooter(string s)
+        {
+            using (var wb = new XLWorkbook())
+            {
+                var ws = wb.AddWorksheet("Sheet1");
+                {
+                    var header = ws.PageSetup.Header as XLHeaderFooter;
+                    header.SetInnerText(XLHFOccurrence.AllPages, s);
+                }
+            }
+        }
     }
 }
diff --git a/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs b/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
index 0bef674..ab15754 100644
--- a/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
+++ b/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
@@ -18,7 +18,7 @@
             IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
             IXLCell cell = ws.Cell(1, 1);
             cell.RichText.AddText("12");
-            cell.DataType = XLCellValues.Number;
+            cell.DataType = XLDataType.Number;
 
             Assert.AreEqual(12.0, cell.GetDouble());
 
@@ -30,7 +30,7 @@
 
             Assert.AreEqual("1234", cell.GetString());
 
-            Assert.AreEqual(XLCellValues.Number, cell.DataType);
+            Assert.AreEqual(XLDataType.Number, cell.DataType);
 
             Assert.AreEqual(1234.0, cell.GetDouble());
         }
@@ -147,11 +147,11 @@
 
             Assert.AreEqual(true, cell.HasRichText);
 
-            cell.DataType = XLCellValues.Text;
+            cell.DataType = XLDataType.Text;
 
             Assert.AreEqual(true, cell.HasRichText);
 
-            cell.DataType = XLCellValues.Number;
+            cell.DataType = XLDataType.Number;
 
             Assert.AreEqual(false, cell.HasRichText);