diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
index 30c1832..db7739e 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
@@ -1,133 +1,185 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace ClosedXML.Excel
+namespace ClosedXML.Excel
 {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Data;
+    using System.Linq;
+    using System.Reflection;
+    using System.Text;
+    using System.Text.RegularExpressions;
+
     internal partial class XLCell : IXLCell, IXLStylized
     {
         public static readonly DateTime BaseDate = new DateTime(1899, 12, 30);
-        #region Fields
-        private readonly XLWorksheet m_worksheet;
-        private XLRichText m_richText;
-        private XLHyperlink m_hyperlink;
+        private static Dictionary<int, string> _formatCodes;
 
-        internal String m_cellValue = String.Empty;
-        internal XLCellValues m_dataType;
+        private static readonly Regex _a1Regex = new Regex(
+            @"(?<=\W)(\$?[a-zA-Z]{1,3}\$?\d{1,7})(?=\W)" // A1
+            + @"|(?<=\W)(\d{1,7}:\d{1,7})(?=\W)" // 1:1
+            + @"|(?<=\W)([a-zA-Z]{1,3}:[a-zA-Z]{1,3})(?=\W)"); // A:A
+
+        private static readonly Regex _a1SimpleRegex = new Regex(
+            @"(?<=\W)" // Start with non word
+            + @"(" // Start Group to pick
+            + @"(" // Start Sheet Name, optional
+            + @"("
+            + @"\'[^\[\]\*/\\\?:]+\'" // Sheet name with special characters, surrounding apostrophes are required
+            + @"|"
+            + @"\'?\w+\'?" // Sheet name with letters and numbers, surrounding apostrophes are optional
+            + @")"
+            + @"!)?" // End Sheet Name, optional
+            + @"(" // Start range
+            + @"\$?[a-zA-Z]{1,3}\$?\d{1,7}" // A1 Address 1
+            + @"(:\$?[a-zA-Z]{1,3}\$?\d{1,7})?" // A1 Address 2, optional
+            + @"|"
+            + @"(\d{1,7}:\d{1,7})" // 1:1
+            + @"|"
+            + @"([a-zA-Z]{1,3}:[a-zA-Z]{1,3})" // A:A
+            + @")" // End Range
+            + @")" // End Group to pick
+            + @"(?=\W)" // End with non word
+            );
+
+        private static readonly Regex a1RowRegex = new Regex(
+            @"(\d{1,7}:\d{1,7})" // 1:1
+            );
+
+        private static readonly Regex a1ColumnRegex = new Regex(
+            @"([a-zA-Z]{1,3}:[a-zA-Z]{1,3})" // A:A
+            );
+
+        private static readonly Regex r1c1Regex = new Regex(
+            @"(?<=\W)([Rr]\[?-?\d{0,7}\]?[Cc]\[?-?\d{0,7}\]?)(?=\W)" // R1C1
+            + @"|(?<=\W)([Rr]\[?-?\d{0,7}\]?:[Rr]\[?-?\d{0,7}\]?)(?=\W)" // R:R
+            + @"|(?<=\W)([Cc]\[?-?\d{0,5}\]?:[Cc]\[?-?\d{0,5}\]?)(?=\W)"); // C:C
+
+        #region Fields
+
+        private readonly XLWorksheet _worksheet;
+
+        internal string _cellValue = String.Empty;
+        internal XLCellValues _dataType;
+        private XLHyperlink _hyperlink;
+        private XLRichText _richText;
+
         #endregion
+
         #region Constructor
+
         public XLCell(XLWorksheet worksheet, XLAddress address, IXLStyle defaultStyle)
         {
             Address = address;
             ShareString = true;
 
             if (defaultStyle == null)
-            {
                 m_style = new XLStyle(this, worksheet.Style);
-            }
             else
-            {
                 m_style = new XLStyle(this, defaultStyle);
-            }
 
-            m_worksheet = worksheet;
+            _worksheet = worksheet;
         }
+
         #endregion
+
+        public bool SettingHyperlink;
+        public int SharedStringId;
+        private string m_formulaA1;
+        private string m_formulaR1C1;
+        private IXLStyle m_style;
+
+        public XLWorksheet Worksheet
+        {
+            get { return _worksheet; }
+        }
+
+        public XLAddress Address { get; internal set; }
+
+        public string InnerText
+        {
+            get
+            {
+                if (HasRichText)
+                    return _richText.ToString();
+                else if (StringExtensions.IsNullOrWhiteSpace(_cellValue))
+                    return FormulaA1;
+                else
+                    return _cellValue;
+            }
+        }
+
+        #region IXLCell Members
+
         IXLWorksheet IXLCell.Worksheet
         {
             get { return Worksheet; }
         }
-        public XLWorksheet Worksheet
-        {
-            get { return m_worksheet; }
-        }
 
         IXLAddress IXLCell.Address
         {
             get { return Address; }
         }
-        public XLAddress Address { get; internal set; }
-        public String InnerText
-        {
-            get 
-            {
-                if (HasRichText)
-                    return m_richText.ToString();
-                else if (StringExtensions.IsNullOrWhiteSpace(m_cellValue))
-                    return FormulaA1;
-                else
-                    return m_cellValue;
-            }
-        }
+
         public IXLRange AsRange()
         {
-            return m_worksheet.Range(Address, Address);
+            return _worksheet.Range(Address, Address);
         }
+
         public IXLCell SetValue<T>(T value)
         {
             FormulaA1 = String.Empty;
-            m_richText = null;
+            _richText = null;
             if (value is String)
             {
-                m_cellValue = value.ToString();
-                m_dataType = XLCellValues.Text;
-                if (m_cellValue.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
-                {
+                _cellValue = value.ToString();
+                _dataType = XLCellValues.Text;
+                if (_cellValue.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
                     Style.Alignment.WrapText = true;
-                }
             }
             else if (value is TimeSpan)
             {
-                m_cellValue = value.ToString();
-                m_dataType = XLCellValues.TimeSpan;
+                _cellValue = value.ToString();
+                _dataType = XLCellValues.TimeSpan;
                 Style.NumberFormat.NumberFormatId = 46;
             }
             else if (value is DateTime)
             {
-                m_dataType = XLCellValues.DateTime;
-                DateTime dtTest = (DateTime) Convert.ChangeType(value, typeof (DateTime));
+                _dataType = XLCellValues.DateTime;
+                var dtTest = (DateTime)Convert.ChangeType(value, typeof(DateTime));
                 if (dtTest.Date == dtTest)
-                {
                     Style.NumberFormat.NumberFormatId = 14;
-                }
                 else
-                {
                     Style.NumberFormat.NumberFormatId = 22;
-                }
 
-                m_cellValue = dtTest.ToOADate().ToString();
+                _cellValue = dtTest.ToOADate().ToString();
             }
             else if (
-                    value is sbyte
-                    || value is byte
-                    || value is char
-                    || value is short
-                    || value is ushort
-                    || value is int
-                    || value is uint
-                    || value is long
-                    || value is ulong
-                    || value is float
-                    || value is double
-                    || value is decimal
-                    )
+                value is sbyte
+                || value is byte
+                || value is char
+                || value is short
+                || value is ushort
+                || value is int
+                || value is uint
+                || value is long
+                || value is ulong
+                || value is float
+                || value is double
+                || value is decimal
+                )
             {
-                m_dataType = XLCellValues.Number;
-                m_cellValue = value.ToString();
+                _dataType = XLCellValues.Number;
+                _cellValue = value.ToString();
             }
             else if (value is Boolean)
             {
-                m_dataType = XLCellValues.Boolean;
-                m_cellValue = (Boolean) Convert.ChangeType(value, typeof (Boolean)) ? "1" : "0";
+                _dataType = XLCellValues.Boolean;
+                _cellValue = (Boolean)Convert.ChangeType(value, typeof(Boolean)) ? "1" : "0";
             }
             else
             {
-                m_cellValue = value.ToString();
-                m_dataType = XLCellValues.Text;
+                _cellValue = value.ToString();
+                _dataType = XLCellValues.Text;
             }
 
             return this;
@@ -138,128 +190,105 @@
             if (!StringExtensions.IsNullOrWhiteSpace(FormulaA1))
                 return (T)Convert.ChangeType(String.Empty, typeof(T));
             if (Value is TimeSpan)
+            {
                 if (typeof(T) == typeof(String))
                     return (T)Convert.ChangeType(Value.ToString(), typeof(T));
                 else
                     return (T)Value;
+            }
+
             if (Value is IXLRichText)
                 return (T)RichText;
             return (T)Convert.ChangeType(Value, typeof(T));
         }
-        public String GetString()
+
+        public string GetString()
         {
-            return GetValue<String>();
+            return GetValue<string>();
         }
-        public Double GetDouble()
+
+        public double GetDouble()
         {
-            return GetValue<Double>();
+            return GetValue<double>();
         }
-        public Boolean GetBoolean()
+
+        public bool GetBoolean()
         {
-            return GetValue<Boolean>();
+            return GetValue<bool>();
         }
+
         public DateTime GetDateTime()
         {
             return GetValue<DateTime>();
         }
+
         public TimeSpan GetTimeSpan()
         {
             return GetValue<TimeSpan>();
         }
+
         public IXLRichText GetRichText()
         {
             return RichText;
         }
-        public String GetFormattedString()
-        {
-            String cValue;
-            if (StringExtensions.IsNullOrWhiteSpace(FormulaA1))
-            {
-                cValue = m_cellValue;
-            }
-            else
-            {
-                cValue = GetString();
-            }
 
-            if (m_dataType == XLCellValues.Boolean)
-            {
+        public string GetFormattedString()
+        {
+            string cValue;
+            if (StringExtensions.IsNullOrWhiteSpace(FormulaA1))
+                cValue = _cellValue;
+            else
+                cValue = GetString();
+
+            if (_dataType == XLCellValues.Boolean)
                 return (cValue != "0").ToString();
-            }
-            if (m_dataType == XLCellValues.TimeSpan)
-            {
+            if (_dataType == XLCellValues.TimeSpan)
                 return cValue;
-            }
-            if (m_dataType == XLCellValues.DateTime || IsDateFormat())
+            if (_dataType == XLCellValues.DateTime || IsDateFormat())
             {
-                Double dTest;
+                double dTest;
                 if (Double.TryParse(cValue, out dTest))
                 {
-                    String format = GetFormat();
+                    string format = GetFormat();
                     return DateTime.FromOADate(dTest).ToString(format);
                 }
+
                 return cValue;
             }
-            if (m_dataType == XLCellValues.Number)
+
+            if (_dataType == XLCellValues.Number)
             {
-                Double dTest;
+                double dTest;
                 if (Double.TryParse(cValue, out dTest))
                 {
-                    String format = GetFormat();
+                    string format = GetFormat();
                     return dTest.ToString(format);
                 }
+
                 return cValue;
             }
+
             return cValue;
         }
 
-        private bool IsDateFormat()
-        {
-            return (m_dataType == XLCellValues.Number
-                    && StringExtensions.IsNullOrWhiteSpace(Style.NumberFormat.Format)
-                    && ((Style.NumberFormat.NumberFormatId >= 14
-                         && Style.NumberFormat.NumberFormatId <= 22)
-                        || (Style.NumberFormat.NumberFormatId >= 45
-                            && Style.NumberFormat.NumberFormatId <= 47)));
-        }
 
-        private String GetFormat()
-        {
-            String format;
-            if (StringExtensions.IsNullOrWhiteSpace(Style.NumberFormat.Format))
-            {
-                var formatCodes = GetFormatCodes();
-                format = formatCodes[Style.NumberFormat.NumberFormatId];
-            }
-            else
-            {
-                format = Style.NumberFormat.Format;
-            }
-            return format;
-        }
-
-        
-        public Object Value
+        public object Value
         {
             get
             {
-                var fA1 = FormulaA1;
+                string fA1 = FormulaA1;
                 if (!StringExtensions.IsNullOrWhiteSpace(fA1))
                 {
                     if (fA1[0] == '{')
-                    {
                         fA1 = fA1.Substring(1, fA1.Length - 2);
-                    }
 
-                    String sName;
-                    String cAddress;
+                    string sName;
+                    string cAddress;
                     if (fA1.Contains('!'))
                     {
                         sName = fA1.Substring(0, fA1.IndexOf('!'));
                         if (sName[0] == '\'')
-                        {
                             sName = sName.Substring(1, sName.Length - 2);
-                        }
 
                         cAddress = fA1.Substring(fA1.IndexOf('!') + 1);
                     }
@@ -269,43 +298,34 @@
                         cAddress = fA1;
                     }
 
-                    if (m_worksheet.Internals.Workbook.WorksheetsInternal.Any<XLWorksheet>(w => w.Name.ToLower().Equals(sName.ToLower()))
+                    if (_worksheet.Internals.Workbook.WorksheetsInternal.Any<XLWorksheet>(
+                        w => w.Name.ToLower().Equals(sName.ToLower()))
                         && ExcelHelper.IsValidA1Address(cAddress)
-                            )
-                    {
-                        return m_worksheet.Internals.Workbook.Worksheet(sName).Cell(cAddress).Value;
-                    }
+                        )
+                        return _worksheet.Internals.Workbook.Worksheet(sName).Cell(cAddress).Value;
                     return fA1;
                 }
-                if (m_dataType == XLCellValues.Boolean)
+
+                if (_dataType == XLCellValues.Boolean)
+                    return _cellValue != "0";
+                else if (_dataType == XLCellValues.DateTime)
+                    return DateTime.FromOADate(Double.Parse(_cellValue));
+                else if (_dataType == XLCellValues.Number)
+                    return Double.Parse(_cellValue);
+                else if (_dataType == XLCellValues.TimeSpan)
                 {
-                    return m_cellValue != "0";
-                }
-                else if (m_dataType == XLCellValues.DateTime)
-                {
-                    return DateTime.FromOADate(Double.Parse(m_cellValue));
-                }
-                else if (m_dataType == XLCellValues.Number)
-                {
-                    return Double.Parse(m_cellValue);
-                }
-                else if (m_dataType == XLCellValues.TimeSpan)
-                {
-                    //return (DateTime.FromOADate(Double.Parse(cellValue)) - baseDate);
-                    return TimeSpan.Parse(m_cellValue);
+                    // return (DateTime.FromOADate(Double.Parse(cellValue)) - baseDate);
+                    return TimeSpan.Parse(_cellValue);
                 }
                 else
                 {
-                    if (m_richText == null)
-                    {
-                        return m_cellValue;
-                    }
+                    if (_richText == null)
+                        return _cellValue;
                     else
-                    {
-                        return m_richText.ToString();
-                    }
+                        return _richText.ToString();
                 }
             }
+
             set
             {
                 FormulaA1 = String.Empty;
@@ -314,146 +334,60 @@
                     if (!SetRange(value))
                     {
                         if (!SetRichText(value))
-                        {
                             SetValue(value);
-                        }
                     }
                 }
             }
         }
 
-        private bool SetRichText(object value)
-        {
-            var asRichString = value as XLRichText;
-            if (asRichString == null)
-            {
-                return false;
-            }
-            else
-            {
-                m_richText = asRichString;
-                m_dataType = XLCellValues.Text;
-                return true;
-            }
-        }
-
-        private Boolean SetRange(Object rangeObject)
-        {
-            var asRange = rangeObject as XLRangeBase;
-            if (asRange == null)
-            {
-                var tmp = rangeObject as XLCell;
-                if (tmp != null)
-                {
-                    asRange = tmp.AsRange() as XLRangeBase;
-                }
-            }
-
-            if (asRange != null)
-            {
-                Int32 maxRows;
-                Int32 maxColumns;
-                if (asRange is XLRow || asRange is XLColumn)
-                {
-                    var lastCellUsed = asRange.LastCellUsed(true);
-                    maxRows = lastCellUsed.Address.RowNumber;
-                    maxColumns = lastCellUsed.Address.ColumnNumber;
-                    //if (asRange is XLRow)
-                    //{
-                    //    worksheet.Range(Address.RowNumber, Address.ColumnNumber,  , maxColumns).Clear();
-                    //}
-                }
-                else
-                {
-                    maxRows = asRange.RowCount();
-                    maxColumns = asRange.ColumnCount();
-                    m_worksheet.Range(Address.RowNumber, Address.ColumnNumber, maxRows, maxColumns).Clear();
-                }
-
-                for (var ro = 1; ro <= maxRows; ro++)
-                {
-                    for (var co = 1; co <= maxColumns; co++)
-                    {
-                        var sourceCell = asRange.Cell(ro, co);
-                        var targetCell = m_worksheet.Cell(Address.RowNumber + ro - 1, Address.ColumnNumber + co - 1);
-                        targetCell.CopyFrom(sourceCell);
-                        //targetCell.Style = sourceCell.style;
-                    }
-                }
-                var rangesToMerge = new List<IXLRange>();
-                foreach (var mergedRange in (asRange.Worksheet).Internals.MergedRanges)
-                {
-                    if (asRange.Contains(mergedRange))
-                    {
-                        var initialRo = Address.RowNumber +
-                                        (mergedRange.FirstAddress.RowNumber - asRange.RangeAddress.FirstAddress.RowNumber);
-                        var initialCo = Address.ColumnNumber +
-                                        (mergedRange.FirstAddress.ColumnNumber - asRange.RangeAddress.FirstAddress.ColumnNumber);
-                        rangesToMerge.Add(m_worksheet.Range(initialRo,
-                                                            initialCo,
-                                                            initialRo + mergedRange.RowCount - 1,
-                                                            initialCo + mergedRange.ColumnCount - 1));
-                    }
-                }
-                rangesToMerge.ForEach(r => r.Merge());
-
-                return true;
-            }
-            return false;
-        }
-
-        private Boolean SetEnumerable(Object collectionObject)
-        {
-            var asEnumerable = collectionObject as IEnumerable;
-            return InsertData(asEnumerable) != null;
-        }
-
         public IXLTable InsertTable(IEnumerable data)
         {
             return InsertTable(data, null, true);
         }
-        public IXLTable InsertTable(IEnumerable data, Boolean createTable)
+
+        public IXLTable InsertTable(IEnumerable data, bool createTable)
         {
             return InsertTable(data, null, createTable);
         }
-        public IXLTable InsertTable(IEnumerable data, String tableName)
+
+        public IXLTable InsertTable(IEnumerable data, string tableName)
         {
             return InsertTable(data, tableName, true);
         }
-        public IXLTable InsertTable(IEnumerable data, String tableName, Boolean createTable)
+
+        public IXLTable InsertTable(IEnumerable data, string tableName, bool createTable)
         {
-            if (data != null && data.GetType() != typeof (String))
+            if (data != null && data.GetType() != typeof(String))
             {
-                Int32 co;
-                Int32 ro = Address.RowNumber + 1;
-                Int32 fRo = Address.RowNumber;
-                Boolean hasTitles = false;
-                Int32 maxCo = 0;
-                Boolean isDataTable = false;
-                foreach (var m in data)
+                int co;
+                int ro = Address.RowNumber + 1;
+                int fRo = Address.RowNumber;
+                bool hasTitles = false;
+                int maxCo = 0;
+                bool isDataTable = false;
+                foreach (object m in data)
                 {
                     co = Address.ColumnNumber;
 
-                    if (m.GetType().IsPrimitive || m.GetType() == typeof (String) || m.GetType() == typeof (DateTime))
+                    if (m.GetType().IsPrimitive || m.GetType() == typeof(String) || m.GetType() == typeof(DateTime))
                     {
                         if (!hasTitles)
                         {
-                            String fieldName = GetFieldName(m.GetType().GetCustomAttributes(true));
+                            string fieldName = GetFieldName(m.GetType().GetCustomAttributes(true));
                             if (StringExtensions.IsNullOrWhiteSpace(fieldName))
-                            {
                                 fieldName = m.GetType().Name;
-                            }
 
                             SetValue(fieldName, fRo, co);
                             hasTitles = true;
                             co = Address.ColumnNumber;
                         }
+
                         SetValue(m, ro, co);
                         co++;
                     }
                     else if (m.GetType().IsArray)
                     {
-                        foreach (var item in (Array) m)
+                        foreach (object item in (Array)m)
                         {
                             SetValue(item, ro, co);
                             co++;
@@ -462,22 +396,23 @@
                     else if (isDataTable || (m as DataRow) != null)
                     {
                         if (!isDataTable)
-                        {
                             isDataTable = true;
-                        }
                         if (!hasTitles)
                         {
                             foreach (DataColumn column in (m as DataRow).Table.Columns)
                             {
-                                var fieldName = StringExtensions.IsNullOrWhiteSpace(column.Caption) ? column.ColumnName : column.Caption;
+                                string fieldName = StringExtensions.IsNullOrWhiteSpace(column.Caption)
+                                                       ? column.ColumnName
+                                                       : column.Caption;
                                 SetValue(fieldName, fRo, co);
                                 co++;
                             }
+
                             co = Address.ColumnNumber;
                             hasTitles = true;
                         }
 
-                        foreach (var item in (m as DataRow).ItemArray)
+                        foreach (object item in (m as DataRow).ItemArray)
                         {
                             SetValue(item, ro, co);
                             co++;
@@ -489,96 +424,89 @@
                         var propertyInfo = m.GetType().GetProperties();
                         if (!hasTitles)
                         {
-                            foreach (var info in fieldInfo)
+                            foreach (FieldInfo info in fieldInfo)
                             {
                                 if ((info as IEnumerable) == null)
                                 {
-                                    String fieldName = GetFieldName(info.GetCustomAttributes(true));
+                                    string fieldName = GetFieldName(info.GetCustomAttributes(true));
                                     if (StringExtensions.IsNullOrWhiteSpace(fieldName))
-                                    {
                                         fieldName = info.Name;
-                                    }
 
                                     SetValue(fieldName, fRo, co);
                                 }
+
                                 co++;
                             }
 
-                            foreach (var info in propertyInfo)
+                            foreach (PropertyInfo info in propertyInfo)
                             {
                                 if ((info as IEnumerable) == null)
                                 {
-                                    String fieldName = GetFieldName(info.GetCustomAttributes(true));
+                                    string fieldName = GetFieldName(info.GetCustomAttributes(true));
                                     if (StringExtensions.IsNullOrWhiteSpace(fieldName))
-                                    {
                                         fieldName = info.Name;
-                                    }
 
                                     SetValue(fieldName, fRo, co);
                                 }
+
                                 co++;
                             }
+
                             co = Address.ColumnNumber;
                             hasTitles = true;
                         }
 
-                        foreach (var info in fieldInfo)
+                        foreach (FieldInfo info in fieldInfo)
                         {
                             SetValue(info.GetValue(m), ro, co);
                             co++;
                         }
 
-                        foreach (var info in propertyInfo)
+                        foreach (PropertyInfo info in propertyInfo)
                         {
                             if ((info as IEnumerable) == null)
-                            {
                                 SetValue(info.GetValue(m, null), ro, co);
-                            }
                             co++;
                         }
                     }
 
                     if (co > maxCo)
-                    {
                         maxCo = co;
-                    }
 
                     ro++;
                 }
+
                 ClearMerged(ro - 1, maxCo - 1);
-                var range = m_worksheet.Range(
-                        Address.RowNumber,
-                        Address.ColumnNumber,
-                        ro - 1,
-                        maxCo - 1);
+                var range = _worksheet.Range(
+                    Address.RowNumber, 
+                    Address.ColumnNumber, 
+                    ro - 1, 
+                    maxCo - 1);
 
                 if (createTable)
-                {
                     return tableName == null ? range.CreateTable() : range.CreateTable(tableName);
-                }
                 return tableName == null ? range.AsTable() : range.AsTable(tableName);
             }
+
             return null;
         }
 
         public IXLRange InsertData(IEnumerable data)
         {
-            if (data != null && data.GetType() != typeof (String))
+            if (data != null && data.GetType() != typeof(String))
             {
-                Int32 ro = Address.RowNumber;
-                Int32 maxCo = 0;
-                foreach (var m in data)
+                int ro = Address.RowNumber;
+                int maxCo = 0;
+                foreach (object m in data)
                 {
-                    Int32 co = Address.ColumnNumber;
+                    int co = Address.ColumnNumber;
 
-                    if (m.GetType().IsPrimitive || m.GetType() == typeof (String) || m.GetType() == typeof (DateTime))
-                    {
+                    if (m.GetType().IsPrimitive || m.GetType() == typeof(String) || m.GetType() == typeof(DateTime))
                         SetValue(m, ro, co);
-                    }
                     else if (m.GetType().IsArray)
                     {
-                        //dynamic arr = m;
-                        foreach (var item in (Array) m)
+                        // dynamic arr = m;
+                        foreach (object item in (Array)m)
                         {
                             SetValue(item, ro, co);
                             co++;
@@ -586,7 +514,7 @@
                     }
                     else if ((m as DataRow) != null)
                     {
-                        foreach (var item in (m as DataRow).ItemArray)
+                        foreach (object item in (m as DataRow).ItemArray)
                         {
                             SetValue(item, ro, co);
                             co++;
@@ -595,146 +523,352 @@
                     else
                     {
                         var fieldInfo = m.GetType().GetFields();
-                        foreach (var info in fieldInfo)
+                        foreach (FieldInfo info in fieldInfo)
                         {
                             SetValue(info.GetValue(m), ro, co);
                             co++;
                         }
+
                         var propertyInfo = m.GetType().GetProperties();
-                        foreach (var info in propertyInfo)
+                        foreach (PropertyInfo info in propertyInfo)
                         {
                             if ((info as IEnumerable) == null)
-                            {
                                 SetValue(info.GetValue(m, null), ro, co);
-                            }
                             co++;
                         }
                     }
 
                     if (co > maxCo)
-                    {
                         maxCo = co;
-                    }
 
                     ro++;
                 }
+
                 ClearMerged(ro - 1, maxCo - 1);
-                return m_worksheet.Range(
-                        Address.RowNumber,
-                        Address.ColumnNumber,
-                        Address.RowNumber + ro - 1,
-                        Address.ColumnNumber + maxCo - 1);
+                return _worksheet.Range(
+                    Address.RowNumber, 
+                    Address.ColumnNumber, 
+                    Address.RowNumber + ro - 1, 
+                    Address.ColumnNumber + maxCo - 1);
             }
+
             return null;
         }
 
-        private void ClearMerged(Int32 rowCount, Int32 columnCount)
-        {
-            //TODO: For MDLeon: Need review why parameters is never used(see compare with revision 67871 before VF changes)
-            var intersectingRanges = m_worksheet.Internals.MergedRanges.GetIntersectingMergedRanges(Address.GetSheetPoint());
-            intersectingRanges.ForEach(m => m_worksheet.Internals.MergedRanges.Remove(m));
-        }
-
-        private void SetValue(object objWithValue, int ro, int co)
-        {
-            String str = String.Empty;
-            if (objWithValue != null)
-            {
-                str = objWithValue.ToString();
-            }
-
-            m_worksheet.Cell(ro, co).Value = str;
-        }
-
-        private void SetValue(Object value)
-        {
-            FormulaA1 = String.Empty;
-            String val = value.ToString();
-            m_richText = null;
-            if (val.Length > 0)
-            {
-                Double dTest;
-                DateTime dtTest;
-                Boolean bTest;
-                TimeSpan tsTest;
-                if (m_style.NumberFormat.Format == "@")
-                {
-                    m_dataType = XLCellValues.Text;
-                    if (val.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
-                    {
-                        Style.Alignment.WrapText = true;
-                    }
-                }
-                else if (val[0] == '\'')
-                {
-                    val = val.Substring(1, val.Length - 1);
-                    m_dataType = XLCellValues.Text;
-                    if (val.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
-                    {
-                        Style.Alignment.WrapText = true;
-                    }
-                }
-                else if (value is TimeSpan || (TimeSpan.TryParse(val, out tsTest) && !Double.TryParse(val, out dTest)))
-                {
-                    m_dataType = XLCellValues.TimeSpan;
-                    if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
-                    {
-                        Style.NumberFormat.NumberFormatId = 46;
-                    }
-                }
-                else if (Double.TryParse(val, out dTest))
-                {
-                    m_dataType = XLCellValues.Number;
-                }
-                else if (DateTime.TryParse(val, out dtTest))
-                {
-                    m_dataType = XLCellValues.DateTime;
-
-                    if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
-                    {
-                        if (dtTest.Date == dtTest)
-                        {
-                            Style.NumberFormat.NumberFormatId = 14;
-                        }
-                        else
-                        {
-                            Style.NumberFormat.NumberFormatId = 22;
-                        }
-                    }
-
-                    val = dtTest.ToOADate().ToString();
-                }
-                else if (Boolean.TryParse(val, out bTest))
-                {
-                    m_dataType = XLCellValues.Boolean;
-                    val = bTest ? "1" : "0";
-                }
-                else
-                {
-                    m_dataType = XLCellValues.Text;
-                    if (val.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
-                    {
-                        Style.Alignment.WrapText = true;
-                    }
-                }
-            }
-            m_cellValue = val;
-        }
-        #region IXLStylized Members
-
-        private IXLStyle m_style;
         public IXLStyle Style
         {
             get
             {
-                    m_style = new XLStyle(this, m_style);
+                m_style = new XLStyle(this, m_style);
                 return m_style;
             }
-            set { 
-                m_style = new XLStyle(this, value);
+
+            set { m_style = new XLStyle(this, value); }
+        }
+
+        public IXLCell SetDataType(XLCellValues dataType)
+        {
+            DataType = dataType;
+            return this;
+        }
+
+
+        public XLCellValues DataType
+        {
+            get { return _dataType; }
+            set
+            {
+                if (_dataType != value)
+                {
+                    if (_richText != null)
+                    {
+                        _cellValue = _richText.ToString();
+                        _richText = null;
+                    }
+
+                    if (_cellValue.Length > 0)
+                    {
+                        if (value == XLCellValues.Boolean)
+                        {
+                            bool bTest;
+                            if (Boolean.TryParse(_cellValue, out bTest))
+                                _cellValue = bTest ? "1" : "0";
+                            else
+                                _cellValue = _cellValue == "0" || String.IsNullOrEmpty(_cellValue) ? "0" : "1";
+                        }
+                        else if (value == XLCellValues.DateTime)
+                        {
+                            DateTime dtTest;
+                            double dblTest;
+                            if (DateTime.TryParse(_cellValue, out dtTest))
+                                _cellValue = dtTest.ToOADate().ToString();
+                            else if (Double.TryParse(_cellValue, out dblTest))
+                                _cellValue = dblTest.ToString();
+                            else
+                            {
+                                throw new ArgumentException(
+                                    string.Format(
+                                        "Cannot set data type to DateTime because '{0}' is not recognized as a date.", 
+                                        _cellValue));
+                            }
+
+                            if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
+                            {
+                                if (_cellValue.Contains('.'))
+                                    Style.NumberFormat.NumberFormatId = 22;
+                                else
+                                    Style.NumberFormat.NumberFormatId = 14;
+                            }
+                        }
+                        else if (value == XLCellValues.TimeSpan)
+                        {
+                            TimeSpan tsTest;
+                            if (TimeSpan.TryParse(_cellValue, out tsTest))
+                            {
+                                _cellValue = tsTest.ToString();
+                                if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
+                                    Style.NumberFormat.NumberFormatId = 46;
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    _cellValue = (DateTime.FromOADate(Double.Parse(_cellValue)) - BaseDate).ToString();
+                                }
+                                catch
+                                {
+                                    throw new ArgumentException(
+                                        string.Format(
+                                            "Cannot set data type to TimeSpan because '{0}' is not recognized as a TimeSpan.", 
+                                            _cellValue));
+                                }
+                            }
+                        }
+                        else if (value == XLCellValues.Number)
+                        {
+                            double dTest;
+                            if (Double.TryParse(_cellValue, out dTest))
+                                _cellValue = Double.Parse(_cellValue).ToString();
+                            else
+                            {
+                                throw new ArgumentException(
+                                    string.Format(
+                                        "Cannot set data type to Number because '{0}' is not recognized as a number.", 
+                                        _cellValue));
+                            }
+                        }
+                        else
+                        {
+                            var formatCodes = GetFormatCodes();
+                            if (_dataType == XLCellValues.Boolean)
+                                _cellValue = (_cellValue != "0").ToString();
+                            else if (_dataType == XLCellValues.TimeSpan)
+                                _cellValue = TimeSpan.Parse(_cellValue).ToString();
+                            else if (_dataType == XLCellValues.Number)
+                            {
+                                string format;
+                                if (Style.NumberFormat.NumberFormatId > 0)
+                                    format = formatCodes[Style.NumberFormat.NumberFormatId];
+                                else
+                                    format = Style.NumberFormat.Format;
+
+                                if (!StringExtensions.IsNullOrWhiteSpace(format) && format != "@")
+                                    _cellValue = Double.Parse(_cellValue).ToString(format);
+                            }
+                            else if (_dataType == XLCellValues.DateTime)
+                            {
+                                string format;
+                                if (Style.NumberFormat.NumberFormatId > 0)
+                                    format = formatCodes[Style.NumberFormat.NumberFormatId];
+                                else
+                                    format = Style.NumberFormat.Format;
+                                _cellValue = DateTime.FromOADate(Double.Parse(_cellValue)).ToString(format);
+                            }
+                        }
+                    }
+
+                    _dataType = value;
+                }
             }
         }
 
+        public void Clear()
+        {
+            _worksheet.Range(Address, Address).Clear();
+        }
+
+        public void ClearStyles()
+        {
+            var newStyle = new XLStyle(this, _worksheet.Style);
+            newStyle.NumberFormat = Style.NumberFormat;
+            Style = newStyle;
+        }
+
+        public void Delete(XLShiftDeletedCells shiftDeleteCells)
+        {
+            _worksheet.Range(Address, Address).Delete(shiftDeleteCells);
+        }
+
+        public string FormulaA1
+        {
+            get
+            {
+                if (StringExtensions.IsNullOrWhiteSpace(m_formulaA1))
+                {
+                    if (!StringExtensions.IsNullOrWhiteSpace(m_formulaR1C1))
+                    {
+                        m_formulaA1 = GetFormulaA1(m_formulaR1C1);
+                        return FormulaA1;
+                    }
+                    else
+                        return String.Empty;
+                }
+                else if (m_formulaA1.Trim()[0] == '=')
+                    return m_formulaA1.Substring(1);
+                else if (m_formulaA1.Trim().StartsWith("{="))
+                    return "{" + m_formulaA1.Substring(2);
+                else
+                    return m_formulaA1;
+            }
+
+            set
+            {
+                m_formulaA1 = value;
+                m_formulaR1C1 = String.Empty;
+            }
+        }
+
+        public string FormulaR1C1
+        {
+            get
+            {
+                if (StringExtensions.IsNullOrWhiteSpace(m_formulaR1C1))
+                    m_formulaR1C1 = GetFormulaR1C1(FormulaA1);
+
+                return m_formulaR1C1;
+            }
+
+            set
+            {
+                m_formulaR1C1 = value;
+
+// FormulaA1 = GetFormulaA1(value);
+            }
+        }
+
+        public bool ShareString { get; set; }
+
+        public XLHyperlink Hyperlink
+        {
+            get
+            {
+                if (_hyperlink == null)
+                    Hyperlink = new XLHyperlink();
+
+                return _hyperlink;
+            }
+
+            set
+            {
+                _hyperlink = value;
+                _hyperlink.Worksheet = _worksheet;
+                _hyperlink.Cell = this;
+                if (_worksheet.Hyperlinks.Any(hl => Address.Equals(hl.Cell.Address)))
+                    _worksheet.Hyperlinks.Delete(Address);
+
+                _worksheet.Hyperlinks.Add(_hyperlink);
+
+                if (!SettingHyperlink)
+                {
+                    if (Style.Font.FontColor.Equals(_worksheet.Style.Font.FontColor))
+                        Style.Font.FontColor = XLColor.FromTheme(XLThemeColor.Hyperlink);
+
+                    if (Style.Font.Underline == _worksheet.Style.Font.Underline)
+                        Style.Font.Underline = XLFontUnderlineValues.Single;
+                }
+            }
+        }
+
+        public IXLDataValidation DataValidation
+        {
+            get { return AsRange().DataValidation; }
+        }
+
+        public IXLCells InsertCellsAbove(int numberOfRows)
+        {
+            return AsRange().InsertRowsAbove(numberOfRows).Cells();
+        }
+
+        public IXLCells InsertCellsBelow(int numberOfRows)
+        {
+            return AsRange().InsertRowsBelow(numberOfRows).Cells();
+        }
+
+        public IXLCells InsertCellsAfter(int numberOfColumns)
+        {
+            return AsRange().InsertColumnsAfter(numberOfColumns).Cells();
+        }
+
+        public IXLCells InsertCellsBefore(int numberOfColumns)
+        {
+            return AsRange().InsertColumnsBefore(numberOfColumns).Cells();
+        }
+
+        public IXLCell AddToNamed(string rangeName)
+        {
+            AsRange().AddToNamed(rangeName);
+            return this;
+        }
+
+        public IXLCell AddToNamed(string rangeName, XLScope scope)
+        {
+            AsRange().AddToNamed(rangeName, scope);
+            return this;
+        }
+
+        public IXLCell AddToNamed(string rangeName, XLScope scope, string comment)
+        {
+            AsRange().AddToNamed(rangeName, scope, comment);
+            return this;
+        }
+
+        public IXLCell CopyTo(IXLCell target)
+        {
+            target.Value = this;
+            return target;
+        }
+
+        public string ValueCached { get; internal set; }
+
+        public IXLRichText RichText
+        {
+            get
+            {
+                if (_richText == null)
+                {
+                    if (StringExtensions.IsNullOrWhiteSpace(_cellValue))
+                        _richText = new XLRichText(m_style.Font);
+                    else
+                        _richText = new XLRichText(GetFormattedString(), m_style.Font);
+
+                    _dataType = XLCellValues.Text;
+                    if (!Style.Alignment.WrapText)
+                        Style.Alignment.WrapText = true;
+                }
+
+                return _richText;
+            }
+        }
+
+        public bool HasRichText
+        {
+            get { return _richText != null; }
+        }
+
+        #endregion
+
+        #region IXLStylized Members
+
         public IEnumerable<IXLStyle> Styles
         {
             get
@@ -745,184 +879,222 @@
             }
         }
 
-        public Boolean UpdatingStyle { get; set; }
+        public bool UpdatingStyle { get; set; }
 
         public IXLStyle InnerStyle
         {
             get { return Style; }
             set { Style = value; }
         }
-        #endregion
-        public IXLCell SetDataType(XLCellValues dataType)
+
+        public IXLRanges RangesUsed
         {
-            DataType = dataType;
-            return this;
+            get
+            {
+                var retVal = new XLRanges();
+                retVal.Add(AsRange());
+                return retVal;
+            }
         }
 
-        
-        public XLCellValues DataType
+        #endregion
+
+        private bool IsDateFormat()
         {
-            get { 
-                return m_dataType; 
-            }
-            set
+            return _dataType == XLCellValues.Number
+                    && StringExtensions.IsNullOrWhiteSpace(Style.NumberFormat.Format)
+                    && ((Style.NumberFormat.NumberFormatId >= 14
+                         && Style.NumberFormat.NumberFormatId <= 22)
+                        || (Style.NumberFormat.NumberFormatId >= 45
+                            && Style.NumberFormat.NumberFormatId <= 47));
+        }
+
+        private string GetFormat()
+        {
+            string format;
+            if (StringExtensions.IsNullOrWhiteSpace(Style.NumberFormat.Format))
             {
-                if (m_dataType != value)
+                var formatCodes = GetFormatCodes();
+                format = formatCodes[Style.NumberFormat.NumberFormatId];
+            }
+            else
+                format = Style.NumberFormat.Format;
+            return format;
+        }
+
+        private bool SetRichText(object value)
+        {
+            var asRichString = value as XLRichText;
+
+            if (asRichString == null)
+                return false;
+
+            _richText = asRichString;
+            _dataType = XLCellValues.Text;
+            return true;
+        }
+
+        private bool SetRange(object rangeObject)
+        {
+            var asRange = rangeObject as XLRangeBase;
+            if (asRange == null)
+            {
+                var tmp = rangeObject as XLCell;
+                if (tmp != null)
+                    asRange = tmp.AsRange() as XLRangeBase;
+            }
+
+            if (asRange != null)
+            {
+                int maxRows;
+                int maxColumns;
+                if (asRange is XLRow || asRange is XLColumn)
                 {
-                    if (m_richText != null)
+                    var lastCellUsed = asRange.LastCellUsed(true);
+                    maxRows = lastCellUsed.Address.RowNumber;
+                    maxColumns = lastCellUsed.Address.ColumnNumber;
+
+// if (asRange is XLRow)
+                    // {
+                    // worksheet.Range(Address.RowNumber, Address.ColumnNumber,  , maxColumns).Clear();
+                    // }
+                }
+                else
+                {
+                    maxRows = asRange.RowCount();
+                    maxColumns = asRange.ColumnCount();
+                    _worksheet.Range(Address.RowNumber, Address.ColumnNumber, maxRows, maxColumns).Clear();
+                }
+
+                for (int ro = 1; ro <= maxRows; ro++)
+                {
+                    for (int co = 1; co <= maxColumns; co++)
                     {
-                        m_cellValue = m_richText.ToString();
-                        m_richText = null;
+                        var sourceCell = asRange.Cell(ro, co);
+                        var targetCell = _worksheet.Cell(Address.RowNumber + ro - 1, Address.ColumnNumber + co - 1);
+                        targetCell.CopyFrom(sourceCell);
+
+// targetCell.Style = sourceCell.style;
                     }
+                }
 
-                    if (m_cellValue.Length > 0)
+                var rangesToMerge = new List<IXLRange>();
+                foreach (SheetRange mergedRange in asRange.Worksheet.Internals.MergedRanges)
+                {
+                    if (asRange.Contains(mergedRange))
                     {
-                        if (value == XLCellValues.Boolean)
-                        {
-                            Boolean bTest;
-                            if (Boolean.TryParse(m_cellValue, out bTest))
-                            {
-                                m_cellValue = bTest ? "1" : "0";
-                            }
-                            else
-                            {
-                                m_cellValue = m_cellValue == "0" || String.IsNullOrEmpty(m_cellValue) ? "0" : "1";
-                            }
-                        }
-                        else if (value == XLCellValues.DateTime)
-                        {
-                            DateTime dtTest;
-                            Double dblTest;
-                            if (DateTime.TryParse(m_cellValue, out dtTest))
-                            {
-                                m_cellValue = dtTest.ToOADate().ToString();
-                            }
-                            else if (Double.TryParse(m_cellValue, out dblTest))
-                            {
-                                m_cellValue = dblTest.ToString();
-                            }
-                            else
-                            {
-                                throw new ArgumentException(string.Format("Cannot set data type to DateTime because '{0}' is not recognized as a date.", m_cellValue));
-                            }
+                        int initialRo = Address.RowNumber +
+                                        (mergedRange.FirstAddress.RowNumber -
+                                         asRange.RangeAddress.FirstAddress.RowNumber);
+                        int initialCo = Address.ColumnNumber +
+                                        (mergedRange.FirstAddress.ColumnNumber -
+                                         asRange.RangeAddress.FirstAddress.ColumnNumber);
+                        rangesToMerge.Add(_worksheet.Range(initialRo, 
+                                                           initialCo, 
+                                                           initialRo + mergedRange.RowCount - 1, 
+                                                           initialCo + mergedRange.ColumnCount - 1));
+                    }
+                }
 
-                            if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
-                            {
-                                if (m_cellValue.Contains('.'))
-                                {
-                                    Style.NumberFormat.NumberFormatId = 22;
-                                }
-                                else
-                                {
-                                    Style.NumberFormat.NumberFormatId = 14;
-                                }
-                            }
-                        }
-                        else if (value == XLCellValues.TimeSpan)
-                        {
-                            TimeSpan tsTest;
-                            if (TimeSpan.TryParse(m_cellValue, out tsTest))
-                            {
-                                m_cellValue = tsTest.ToString();
-                                if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
-                                {
-                                    Style.NumberFormat.NumberFormatId = 46;
-                                }
-                            }
-                            else
-                            {
-                                try
-                                {
-                                    m_cellValue = (DateTime.FromOADate(Double.Parse(m_cellValue)) - BaseDate).ToString();
-                                }
-                                catch
-                                {
-                                    throw new ArgumentException(string.Format("Cannot set data type to TimeSpan because '{0}' is not recognized as a TimeSpan.", m_cellValue));
-                                }
-                            }
-                        }
-                        else if (value == XLCellValues.Number)
-                        {
-                            Double dTest;
-                            if (Double.TryParse(m_cellValue, out dTest))
-                            {
-                                m_cellValue = Double.Parse(m_cellValue).ToString();
-                            }
-                            else
-                            {
-                                throw new ArgumentException(string.Format("Cannot set data type to Number because '{0}' is not recognized as a number.", m_cellValue));
-                            }
-                        }
+                rangesToMerge.ForEach(r => r.Merge());
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool SetEnumerable(object collectionObject)
+        {
+            var asEnumerable = collectionObject as IEnumerable;
+            return InsertData(asEnumerable) != null;
+        }
+
+        private void ClearMerged(int rowCount, int columnCount)
+        {
+            // TODO: For MDLeon: Need review why parameters is never used(see compare with revision 67871 before VF changes)
+            var intersectingRanges =
+                _worksheet.Internals.MergedRanges.GetIntersectingMergedRanges(Address.GetSheetPoint());
+            intersectingRanges.ForEach(m => _worksheet.Internals.MergedRanges.Remove(m));
+        }
+
+        private void SetValue(object objWithValue, int ro, int co)
+        {
+            string str = String.Empty;
+            if (objWithValue != null)
+                str = objWithValue.ToString();
+
+            _worksheet.Cell(ro, co).Value = str;
+        }
+
+        private void SetValue(object value)
+        {
+            FormulaA1 = String.Empty;
+            string val = value.ToString();
+            _richText = null;
+            if (val.Length > 0)
+            {
+                double dTest;
+                DateTime dtTest;
+                bool bTest;
+                TimeSpan tsTest;
+                if (m_style.NumberFormat.Format == "@")
+                {
+                    _dataType = XLCellValues.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;
+                    if (val.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
+                        Style.Alignment.WrapText = true;
+                }
+                else if (value is TimeSpan || (TimeSpan.TryParse(val, out tsTest) && !Double.TryParse(val, out dTest)))
+                {
+                    _dataType = XLCellValues.TimeSpan;
+                    if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
+                        Style.NumberFormat.NumberFormatId = 46;
+                }
+                else if (Double.TryParse(val, out dTest))
+                    _dataType = XLCellValues.Number;
+                else if (DateTime.TryParse(val, out dtTest))
+                {
+                    _dataType = XLCellValues.DateTime;
+
+                    if (Style.NumberFormat.Format == String.Empty && Style.NumberFormat.NumberFormatId == 0)
+                    {
+                        if (dtTest.Date == dtTest)
+                            Style.NumberFormat.NumberFormatId = 14;
                         else
-                        {
-                            var formatCodes = GetFormatCodes();
-                            if (m_dataType == XLCellValues.Boolean)
-                            {
-                                m_cellValue = (m_cellValue != "0").ToString();
-                            }
-                            else if (m_dataType == XLCellValues.TimeSpan)
-                            {
-                                m_cellValue = TimeSpan.Parse(m_cellValue).ToString();
-                            }
-                            else if (m_dataType == XLCellValues.Number)
-                            {
-                                String format;
-                                if (Style.NumberFormat.NumberFormatId > 0)
-                                {
-                                    format = formatCodes[Style.NumberFormat.NumberFormatId];
-                                }
-                                else
-                                {
-                                    format = Style.NumberFormat.Format;
-                                }
-
-                                if (!StringExtensions.IsNullOrWhiteSpace(format) && format != "@")
-                                {
-                                    m_cellValue = Double.Parse(m_cellValue).ToString(format);
-                                }
-                            }
-                            else if (m_dataType == XLCellValues.DateTime)
-                            {
-                                String format;
-                                if (Style.NumberFormat.NumberFormatId > 0)
-                                {
-                                    format = formatCodes[Style.NumberFormat.NumberFormatId];
-                                }
-                                else
-                                {
-                                    format = Style.NumberFormat.Format;
-                                }
-                                m_cellValue = DateTime.FromOADate(Double.Parse(m_cellValue)).ToString(format);
-                            }
-                        }
+                            Style.NumberFormat.NumberFormatId = 22;
                     }
-                    m_dataType = value;
+
+                    val = dtTest.ToOADate().ToString();
+                }
+                else if (Boolean.TryParse(val, out bTest))
+                {
+                    _dataType = XLCellValues.Boolean;
+                    val = bTest ? "1" : "0";
+                }
+                else
+                {
+                    _dataType = XLCellValues.Text;
+                    if (val.Contains(Environment.NewLine) && !Style.Alignment.WrapText)
+                        Style.Alignment.WrapText = true;
                 }
             }
+
+            _cellValue = val;
         }
 
-        public void Clear()
+        private static Dictionary<int, string> GetFormatCodes()
         {
-            m_worksheet.Range(Address, Address).Clear();
-        }
-        public void ClearStyles()
-        {
-            var newStyle = new XLStyle(this, m_worksheet.Style);
-            newStyle.NumberFormat = Style.NumberFormat;
-            Style = newStyle;
-        }
-        public void Delete(XLShiftDeletedCells shiftDeleteCells)
-        {
-            m_worksheet.Range(Address, Address).Delete(shiftDeleteCells);
-        }
-
-        private static Dictionary<Int32, String> ms_formatCodes;
-        private static Dictionary<Int32, String> GetFormatCodes()
-        {
-            if (ms_formatCodes == null)
+            if (_formatCodes == null)
             {
-                var fCodes = new Dictionary<Int32, String>();
-                fCodes.Add(0, "");
+                var fCodes = new Dictionary<int, string>();
+                fCodes.Add(0, string.Empty);
                 fCodes.Add(1, "0");
                 fCodes.Add(2, "0.00");
                 fCodes.Add(3, "#,##0");
@@ -950,171 +1122,71 @@
                 fCodes.Add(47, "mmss.0");
                 fCodes.Add(48, "##0.0E+0");
                 fCodes.Add(49, "@");
-                ms_formatCodes = fCodes;
+                _formatCodes = fCodes;
             }
-            return ms_formatCodes;
+
+            return _formatCodes;
         }
 
-        private String m_formulaA1;
-        public String FormulaA1
-        {
-            get
-            {
-                if (StringExtensions.IsNullOrWhiteSpace(m_formulaA1))
-                {
-                    if (!StringExtensions.IsNullOrWhiteSpace(m_formulaR1C1))
-                    {
-                        m_formulaA1 = GetFormulaA1(m_formulaR1C1);
-                        return FormulaA1;
-                    }
-                    else
-                    {
-                        return String.Empty;
-                    }
-                }
-                else if (m_formulaA1.Trim()[0] == '=')
-                {
-                    return m_formulaA1.Substring(1);
-                }
-                else if (m_formulaA1.Trim().StartsWith("{="))
-                {
-                    return "{" + m_formulaA1.Substring(2);
-                }
-                else
-                {
-                    return m_formulaA1;
-                }
-            }
-            set
-            {
-                m_formulaA1 = value;
-                m_formulaR1C1 = String.Empty;
-            }
-        }
-
-        private String m_formulaR1C1;
-        public String FormulaR1C1
-        {
-            get
-            {
-                if (StringExtensions.IsNullOrWhiteSpace(m_formulaR1C1))
-                {
-                    m_formulaR1C1 = GetFormulaR1C1(FormulaA1);
-                }
-
-                return m_formulaR1C1;
-            }
-            set
-            {
-                m_formulaR1C1 = value;
-                //FormulaA1 = GetFormulaA1(value);
-            }
-        }
-
-        private String GetFormulaR1C1(String value)
+        private string GetFormulaR1C1(string value)
         {
             return GetFormula(value, FormulaConversionType.A1toR1C1, 0, 0);
         }
 
-        private String GetFormulaA1(String value)
+        private string GetFormulaA1(string value)
         {
             return GetFormula(value, FormulaConversionType.R1C1toA1, 0, 0);
         }
 
-        private static readonly Regex a1Regex = new Regex(
-                @"(?<=\W)(\$?[a-zA-Z]{1,3}\$?\d{1,7})(?=\W)" // A1
-                + @"|(?<=\W)(\d{1,7}:\d{1,7})(?=\W)" // 1:1
-                + @"|(?<=\W)([a-zA-Z]{1,3}:[a-zA-Z]{1,3})(?=\W)"); // A:A
-
-        private static readonly Regex a1SimpleRegex = new Regex(
-                @"(?<=\W)" // Start with non word
-                + @"(" // Start Group to pick
-                + @"(" // Start Sheet Name, optional
-                + @"("
-                + @"\'[^\[\]\*/\\\?:]+\'" // Sheet name with special characters, surrounding apostrophes are required
-                + @"|"
-                + @"\'?\w+\'?" // Sheet name with letters and numbers, surrounding apostrophes are optional
-                + @")"
-                + @"!)?" // End Sheet Name, optional
-                + @"(" // Start range
-                + @"\$?[a-zA-Z]{1,3}\$?\d{1,7}" // A1 Address 1
-                + @"(:\$?[a-zA-Z]{1,3}\$?\d{1,7})?" // A1 Address 2, optional
-                + @"|"
-                + @"(\d{1,7}:\d{1,7})" // 1:1
-                + @"|"
-                + @"([a-zA-Z]{1,3}:[a-zA-Z]{1,3})" // A:A
-                + @")" // End Range
-                + @")" // End Group to pick
-                + @"(?=\W)" // End with non word
-                );
-
-        private static readonly Regex a1RowRegex = new Regex(
-                @"(\d{1,7}:\d{1,7})" // 1:1
-                );
-        private static readonly Regex a1ColumnRegex = new Regex(
-                @"([a-zA-Z]{1,3}:[a-zA-Z]{1,3})" // A:A
-                );
-
-        private static readonly Regex r1c1Regex = new Regex(
-                @"(?<=\W)([Rr]\[?-?\d{0,7}\]?[Cc]\[?-?\d{0,7}\]?)(?=\W)" // R1C1
-                + @"|(?<=\W)([Rr]\[?-?\d{0,7}\]?:[Rr]\[?-?\d{0,7}\]?)(?=\W)" // R:R
-                + @"|(?<=\W)([Cc]\[?-?\d{0,5}\]?:[Cc]\[?-?\d{0,5}\]?)(?=\W)"); // C:C
-        private String GetFormula(String strValue, FormulaConversionType conversionType, Int32 rowsToShift, Int32 columnsToShift)
+        private string GetFormula(string strValue, FormulaConversionType conversionType, int rowsToShift, 
+                                  int columnsToShift)
         {
             if (StringExtensions.IsNullOrWhiteSpace(strValue))
-            {
                 return String.Empty;
-            }
 
-            var value = ">" + strValue + "<";
+            string value = ">" + strValue + "<";
 
-            Regex regex = conversionType == FormulaConversionType.A1toR1C1 ? a1Regex : r1c1Regex;
+            var regex = conversionType == FormulaConversionType.A1toR1C1 ? _a1Regex : r1c1Regex;
 
             var sb = new StringBuilder();
-            var lastIndex = 0;
+            int lastIndex = 0;
 
-            foreach (var match in regex.Matches(value).Cast<Match>())
+            foreach (Match match in regex.Matches(value).Cast<Match>())
             {
-                var matchString = match.Value;
-                var matchIndex = match.Index;
-                if (value.Substring(0, matchIndex).CharCount('"')%2 == 0) // Check if the match is in between quotes
+                string matchString = match.Value;
+                int matchIndex = match.Index;
+                if (value.Substring(0, matchIndex).CharCount('"') % 2 == 0)
                 {
+// Check if the match is in between quotes
                     sb.Append(value.Substring(lastIndex, matchIndex - lastIndex));
                     if (conversionType == FormulaConversionType.A1toR1C1)
-                    {
                         sb.Append(GetR1C1Address(matchString, rowsToShift, columnsToShift));
-                    }
                     else
-                    {
                         sb.Append(GetA1Address(matchString, rowsToShift, columnsToShift));
-                    }
                 }
                 else
-                {
                     sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length));
-                }
                 lastIndex = matchIndex + matchString.Length;
             }
-            if (lastIndex < value.Length)
-            {
-                sb.Append(value.Substring(lastIndex));
-            }
 
-            var retVal = sb.ToString();
+            if (lastIndex < value.Length)
+                sb.Append(value.Substring(lastIndex));
+
+            string retVal = sb.ToString();
             return retVal.Substring(1, retVal.Length - 2);
         }
 
-        private String GetA1Address(String r1c1Address, Int32 rowsToShift, Int32 columnsToShift)
+        private string GetA1Address(string r1c1Address, int rowsToShift, int columnsToShift)
         {
-            var addressToUse = r1c1Address.ToUpper();
+            string addressToUse = r1c1Address.ToUpper();
 
             if (addressToUse.Contains(':'))
             {
                 var parts = addressToUse.Split(':');
-                var p1 = parts[0];
-                var p2 = parts[1];
-                String leftPart;
-                String rightPart;
+                string p1 = parts[0];
+                string p2 = parts[1];
+                string leftPart;
+                string rightPart;
                 if (p1.StartsWith("R"))
                 {
                     leftPart = GetA1Row(p1, rowsToShift);
@@ -1125,173 +1197,161 @@
                     leftPart = GetA1Column(p1, columnsToShift);
                     rightPart = GetA1Column(p2, columnsToShift);
                 }
+
                 return leftPart + ":" + rightPart;
             }
             else
             {
-                var rowPart = addressToUse.Substring(0, addressToUse.IndexOf("C"));
-                String rowToReturn = GetA1Row(rowPart, rowsToShift);
+                string rowPart = addressToUse.Substring(0, addressToUse.IndexOf("C"));
+                string rowToReturn = GetA1Row(rowPart, rowsToShift);
 
-                var columnPart = addressToUse.Substring(addressToUse.IndexOf("C"));
-                String columnToReturn = GetA1Column(columnPart, columnsToShift);
+                string columnPart = addressToUse.Substring(addressToUse.IndexOf("C"));
+                string columnToReturn = GetA1Column(columnPart, columnsToShift);
 
-                var retAddress = columnToReturn + rowToReturn;
+                string retAddress = columnToReturn + rowToReturn;
                 return retAddress;
             }
         }
 
-        private String GetA1Column(String columnPart, Int32 columnsToShift)
+        private string GetA1Column(string columnPart, int columnsToShift)
         {
-            String columnToReturn;
+            string columnToReturn;
             if (columnPart == "C")
-            {
                 columnToReturn = ExcelHelper.GetColumnLetterFromNumber(Address.ColumnNumber + columnsToShift);
-            }
             else
             {
-                var bIndex = columnPart.IndexOf("[");
-                var mIndex = columnPart.IndexOf("-");
+                int bIndex = columnPart.IndexOf("[");
+                int mIndex = columnPart.IndexOf("-");
                 if (bIndex >= 0)
                 {
                     columnToReturn = ExcelHelper.GetColumnLetterFromNumber(
-                            Address.ColumnNumber + Int32.Parse(columnPart.Substring(bIndex + 1, columnPart.Length - bIndex - 2)) + columnsToShift
-                            );
+                        Address.ColumnNumber +
+                        Int32.Parse(columnPart.Substring(bIndex + 1, columnPart.Length - bIndex - 2)) + columnsToShift
+                        );
                 }
                 else if (mIndex >= 0)
                 {
                     columnToReturn = ExcelHelper.GetColumnLetterFromNumber(
-                            Address.ColumnNumber + Int32.Parse(columnPart.Substring(mIndex)) + columnsToShift
-                            );
+                        Address.ColumnNumber + Int32.Parse(columnPart.Substring(mIndex)) + columnsToShift
+                        );
                 }
                 else
-                {
-                    columnToReturn = "$" + ExcelHelper.GetColumnLetterFromNumber(Int32.Parse(columnPart.Substring(1)) + columnsToShift);
-                }
+                    columnToReturn = "$" +
+                                     ExcelHelper.GetColumnLetterFromNumber(Int32.Parse(columnPart.Substring(1)) +
+                                                                           columnsToShift);
             }
+
             return columnToReturn;
         }
 
-        private String GetA1Row(String rowPart, Int32 rowsToShift)
+        private string GetA1Row(string rowPart, int rowsToShift)
         {
-            String rowToReturn;
+            string rowToReturn;
             if (rowPart == "R")
-            {
                 rowToReturn = (Address.RowNumber + rowsToShift).ToString();
-            }
             else
             {
-                var bIndex = rowPart.IndexOf("[");
+                int bIndex = rowPart.IndexOf("[");
                 if (bIndex >= 0)
                 {
                     rowToReturn =
-                            (Address.RowNumber + Int32.Parse(rowPart.Substring(bIndex + 1, rowPart.Length - bIndex - 2)) + rowsToShift).ToString();
+                        (Address.RowNumber + Int32.Parse(rowPart.Substring(bIndex + 1, rowPart.Length - bIndex - 2)) +
+                         rowsToShift).ToString();
                 }
                 else
-                {
-                    rowToReturn = "$" + (Int32.Parse(rowPart.Substring(1)) + rowsToShift).ToString();
-                }
+                    rowToReturn = "$" + (Int32.Parse(rowPart.Substring(1)) + rowsToShift);
             }
+
             return rowToReturn;
         }
 
-        private String GetR1C1Address(String a1Address, Int32 rowsToShift, Int32 columnsToShift)
+        private string GetR1C1Address(string a1Address, int rowsToShift, int columnsToShift)
         {
             if (a1Address.Contains(':'))
             {
                 var parts = a1Address.Split(':');
-                var p1 = parts[0];
-                var p2 = parts[1];
-                Int32 row1;
-                if (Int32.TryParse(p1.Replace("$", ""), out row1))
+                string p1 = parts[0];
+                string p2 = parts[1];
+                int row1;
+                if (Int32.TryParse(p1.Replace("$", string.Empty), out row1))
                 {
-                    var row2 = Int32.Parse(p2.Replace("$", ""));
-                    var leftPart = GetR1C1Row(row1, p1.Contains('$'), rowsToShift);
-                    var rightPart = GetR1C1Row(row2, p2.Contains('$'), rowsToShift);
+                    int row2 = Int32.Parse(p2.Replace("$", string.Empty));
+                    string leftPart = GetR1C1Row(row1, p1.Contains('$'), rowsToShift);
+                    string rightPart = GetR1C1Row(row2, p2.Contains('$'), rowsToShift);
                     return leftPart + ":" + rightPart;
                 }
                 else
                 {
-                    var column1 = ExcelHelper.GetColumnNumberFromLetter(p1.Replace("$", ""));
-                    var column2 = ExcelHelper.GetColumnNumberFromLetter(p2.Replace("$", ""));
-                    var leftPart = GetR1C1Column(column1, p1.Contains('$'), columnsToShift);
-                    var rightPart = GetR1C1Column(column2, p2.Contains('$'), columnsToShift);
+                    int column1 = ExcelHelper.GetColumnNumberFromLetter(p1.Replace("$", string.Empty));
+                    int column2 = ExcelHelper.GetColumnNumberFromLetter(p2.Replace("$", string.Empty));
+                    string leftPart = GetR1C1Column(column1, p1.Contains('$'), columnsToShift);
+                    string rightPart = GetR1C1Column(column2, p2.Contains('$'), columnsToShift);
                     return leftPart + ":" + rightPart;
                 }
             }
-            var address = XLAddress.Create(m_worksheet, a1Address);
 
-            String rowPart = GetR1C1Row(address.RowNumber, address.FixedRow, rowsToShift);
-            String columnPart = GetR1C1Column(address.ColumnNumber, address.FixedRow, columnsToShift);
+            var address = XLAddress.Create(_worksheet, a1Address);
+
+            string rowPart = GetR1C1Row(address.RowNumber, address.FixedRow, rowsToShift);
+            string columnPart = GetR1C1Column(address.ColumnNumber, address.FixedRow, columnsToShift);
 
             return rowPart + columnPart;
         }
 
-        private String GetR1C1Row(Int32 rowNumber, Boolean fixedRow, Int32 rowsToShift)
+        private string GetR1C1Row(int rowNumber, bool fixedRow, int rowsToShift)
         {
-            String rowPart;
+            string rowPart;
             rowNumber += rowsToShift;
-            var rowDiff = rowNumber - Address.RowNumber;
+            int rowDiff = rowNumber - Address.RowNumber;
             if (rowDiff != 0 || fixedRow)
             {
                 if (fixedRow)
-                {
                     rowPart = String.Format("R{0}", rowNumber);
-                }
                 else
-                {
                     rowPart = String.Format("R[{0}]", rowDiff);
-                }
             }
             else
-            {
                 rowPart = "R";
-            }
 
             return rowPart;
         }
 
-        private String GetR1C1Column(Int32 columnNumber, Boolean fixedColumn, Int32 columnsToShift)
+        private string GetR1C1Column(int columnNumber, bool fixedColumn, int columnsToShift)
         {
-            String columnPart;
+            string columnPart;
             columnNumber += columnsToShift;
-            var columnDiff = columnNumber - Address.ColumnNumber;
+            int columnDiff = columnNumber - Address.ColumnNumber;
             if (columnDiff != 0 || fixedColumn)
             {
                 if (fixedColumn)
-                {
                     columnPart = String.Format("C{0}", columnNumber);
-                }
                 else
-                {
                     columnPart = String.Format("C[{0}]", columnDiff);
-                }
             }
             else
-            {
                 columnPart = "C";
-            }
 
             return columnPart;
         }
 
         internal void CopyValues(XLCell source)
         {
-            m_cellValue = source.m_cellValue;
-            m_dataType = source.m_dataType;
+            _cellValue = source._cellValue;
+            _dataType = source._dataType;
             FormulaR1C1 = source.FormulaR1C1;
-            m_richText = source.m_richText;
+            _richText = new XLRichText(source._richText, source.Style.Font);
         }
 
         public IXLCell CopyFrom(XLCell otherCell)
         {
             var source = otherCell;
-            m_cellValue = source.m_cellValue;
-            m_richText = source.m_richText;
-            m_dataType = source.m_dataType;
+            _cellValue = source._cellValue;
+            _richText = new XLRichText(source._richText, source.Style.Font);
+            _dataType = source._dataType;
             FormulaR1C1 = source.FormulaR1C1;
             m_style = new XLStyle(this, source.m_style);
 
-            if (source.m_hyperlink != null)
+            if (source._hyperlink != null)
             {
                 SettingHyperlink = true;
                 Hyperlink = new XLHyperlink(source.Hyperlink);
@@ -1300,154 +1360,178 @@
 
             var asRange = source.AsRange();
             if (source.Worksheet.DataValidations.Any(dv => dv.Ranges.Contains(asRange)))
-            {
                 (DataValidation as XLDataValidation).CopyFrom(source.DataValidation);
-            }
 
             return this;
         }
 
-        //internal void ShiftFormula(Int32 rowsToShift, Int32 columnsToShift)
-        //{
-        //    if (!StringExtensions.IsNullOrWhiteSpace(formulaA1))
-        //        FormulaR1C1 = GetFormula(formulaA1, FormulaConversionType.A1toR1C1, rowsToShift, columnsToShift);
-        //    else if (!StringExtensions.IsNullOrWhiteSpace(formulaR1C1))
-        //        FormulaA1 = GetFormula(formulaR1C1, FormulaConversionType.R1C1toA1, rowsToShift, columnsToShift);
-        //}
+        // internal void ShiftFormula(Int32 rowsToShift, Int32 columnsToShift)
+        // {
+        // if (!StringExtensions.IsNullOrWhiteSpace(formulaA1))
+        // FormulaR1C1 = GetFormula(formulaA1, FormulaConversionType.A1toR1C1, rowsToShift, columnsToShift);
+        // else if (!StringExtensions.IsNullOrWhiteSpace(formulaR1C1))
+        // FormulaA1 = GetFormula(formulaR1C1, FormulaConversionType.R1C1toA1, rowsToShift, columnsToShift);
+        // }
 
         internal void ShiftFormulaRows(XLRange shiftedRange, int rowsShifted)
         {
             if (!StringExtensions.IsNullOrWhiteSpace(FormulaA1))
             {
-                var value = ">" + m_formulaA1 + "<";
+                string value = ">" + m_formulaA1 + "<";
 
-                Regex regex = a1SimpleRegex;
+                var regex = _a1SimpleRegex;
 
                 var sb = new StringBuilder();
-                var lastIndex = 0;
+                int lastIndex = 0;
 
-                foreach (var match in regex.Matches(value).Cast<Match>())
+                foreach (Match match in regex.Matches(value).Cast<Match>())
                 {
-                    var matchString = match.Value;
-                    var matchIndex = match.Index;
-                    if (value.Substring(0, matchIndex).CharCount('"')%2 == 0) // Check that the match is not between quotes
+                    string matchString = match.Value;
+                    int matchIndex = match.Index;
+                    if (value.Substring(0, matchIndex).CharCount('"') % 2 == 0)
                     {
+// Check that the match is not between quotes
                         sb.Append(value.Substring(lastIndex, matchIndex - lastIndex));
-                        String sheetName;
-                        Boolean useSheetName = false;
+                        string sheetName;
+                        bool useSheetName = false;
                         if (matchString.Contains('!'))
                         {
                             sheetName = matchString.Substring(0, matchString.IndexOf('!'));
                             if (sheetName[0] == '\'')
-                            {
                                 sheetName = sheetName.Substring(1, sheetName.Length - 2);
-                            }
                             useSheetName = true;
                         }
                         else
-                        {
-                            sheetName = m_worksheet.Name;
-                        }
+                            sheetName = _worksheet.Name;
 
                         if (sheetName.ToLower().Equals(shiftedRange.Worksheet.Name.ToLower()))
                         {
-                            String rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1);
+                            string rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1);
                             if (!a1ColumnRegex.IsMatch(rangeAddress))
                             {
-                                IXLRange matchRange = m_worksheet.Internals.Workbook.Worksheet(sheetName).Range(rangeAddress);
-                                if (shiftedRange.RangeAddress.FirstAddress.RowNumber <= matchRange.RangeAddress.LastAddress.RowNumber
-                                    && shiftedRange.RangeAddress.FirstAddress.ColumnNumber <= matchRange.RangeAddress.FirstAddress.ColumnNumber
-                                    && shiftedRange.RangeAddress.LastAddress.ColumnNumber >= matchRange.RangeAddress.LastAddress.ColumnNumber)
+                                var matchRange = _worksheet.Internals.Workbook.Worksheet(sheetName).Range(rangeAddress);
+                                if (shiftedRange.RangeAddress.FirstAddress.RowNumber <=
+                                    matchRange.RangeAddress.LastAddress.RowNumber
+                                    &&
+                                    shiftedRange.RangeAddress.FirstAddress.ColumnNumber <=
+                                    matchRange.RangeAddress.FirstAddress.ColumnNumber
+                                    &&
+                                    shiftedRange.RangeAddress.LastAddress.ColumnNumber >=
+                                    matchRange.RangeAddress.LastAddress.ColumnNumber)
                                 {
-                                    #region change
                                     if (a1RowRegex.IsMatch(rangeAddress))
                                     {
                                         var rows = rangeAddress.Split(':');
-                                        String row1String = rows[0];
-                                        String row2String = rows[1];
-                                        String row1;
+                                        string row1String = rows[0];
+                                        string row2String = rows[1];
+                                        string row1;
                                         if (row1String[0] == '$')
                                         {
-                                            row1 = "$" + (Int32.Parse(row1String.Substring(1)) + rowsShifted).ToStringLookup();
+                                            row1 = "$" +
+                                                   (Int32.Parse(row1String.Substring(1)) + rowsShifted).ToStringLookup();
                                         }
                                         else
-                                        {
                                             row1 = (Int32.Parse(row1String) + rowsShifted).ToStringLookup();
-                                        }
 
-                                        String row2;
+                                        string row2;
                                         if (row2String[0] == '$')
                                         {
-                                            row2 = "$" + (Int32.Parse(row2String.Substring(1)) + rowsShifted).ToStringLookup();
+                                            row2 = "$" +
+                                                   (Int32.Parse(row2String.Substring(1)) + rowsShifted).ToStringLookup();
                                         }
                                         else
-                                        {
                                             row2 = (Int32.Parse(row2String) + rowsShifted).ToStringLookup();
-                                        }
 
                                         if (useSheetName)
-                                        {
                                             sb.Append(String.Format("'{0}'!{1}:{2}", sheetName, row1, row2));
-                                        }
                                         else
-                                        {
                                             sb.Append(String.Format("{0}:{1}", row1, row2));
-                                        }
                                     }
-                                    else if (shiftedRange.RangeAddress.FirstAddress.RowNumber <= matchRange.RangeAddress.FirstAddress.RowNumber)
+                                    else if (shiftedRange.RangeAddress.FirstAddress.RowNumber <=
+                                             matchRange.RangeAddress.FirstAddress.RowNumber)
                                     {
                                         if (rangeAddress.Contains(':'))
                                         {
                                             if (useSheetName)
                                             {
-                                                sb.Append(String.Format("'{0}'!{1}:{2}",
-                                                                        sheetName,
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn),
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.LastAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.LastAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                                sb.Append(String.Format("'{0}'!{1}:{2}", 
+                                                                        sheetName, 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn), 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedColumn)));
                                             }
                                             else
                                             {
-                                                sb.Append(String.Format("{0}:{1}",
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn),
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.LastAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.LastAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                                sb.Append(String.Format("{0}:{1}", 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn), 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedColumn)));
                                             }
                                         }
                                         else
                                         {
                                             if (useSheetName)
                                             {
-                                                sb.Append(String.Format("'{0}'!{1}",
-                                                                        sheetName,
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn)));
+                                                sb.Append(String.Format("'{0}'!{1}", 
+                                                                        sheetName, 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn)));
                                             }
                                             else
                                             {
-                                                sb.Append(String.Format("{0}",
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber + rowsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnLetter,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn)));
+                                                sb.Append(String.Format("{0}", 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber +
+                                                                                      rowsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnLetter, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn)));
                                             }
                                         }
                                     }
@@ -1455,56 +1539,55 @@
                                     {
                                         if (useSheetName)
                                         {
-                                            sb.Append(String.Format("'{0}'!{1}:{2}",
-                                                                    sheetName,
-                                                                    matchRange.RangeAddress.FirstAddress,
-                                                                    new XLAddress(m_worksheet,
-                                                                                  matchRange.RangeAddress.LastAddress.RowNumber + rowsShifted,
-                                                                                  matchRange.RangeAddress.LastAddress.ColumnLetter,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                            sb.Append(String.Format("'{0}'!{1}:{2}", 
+                                                                    sheetName, 
+                                                                    matchRange.RangeAddress.FirstAddress, 
+                                                                    new XLAddress(_worksheet, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.RowNumber +
+                                                                                  rowsShifted, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.ColumnLetter, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedRow, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedColumn)));
                                         }
                                         else
                                         {
-                                            sb.Append(String.Format("{0}:{1}",
-                                                                    matchRange.RangeAddress.FirstAddress,
-                                                                    new XLAddress(m_worksheet,
-                                                                                  matchRange.RangeAddress.LastAddress.RowNumber + rowsShifted,
-                                                                                  matchRange.RangeAddress.LastAddress.ColumnLetter,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                            sb.Append(String.Format("{0}:{1}", 
+                                                                    matchRange.RangeAddress.FirstAddress, 
+                                                                    new XLAddress(_worksheet, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.RowNumber +
+                                                                                  rowsShifted, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.ColumnLetter, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedRow, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedColumn)));
                                         }
                                     }
-                                    #endregion
                                 }
                                 else
-                                {
                                     sb.Append(matchString);
-                                }
                             }
                             else
-                            {
                                 sb.Append(matchString);
-                            }
                         }
                         else
-                        {
                             sb.Append(matchString);
-                        }
                     }
                     else
-                    {
                         sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length));
-                    }
                     lastIndex = matchIndex + matchString.Length;
                 }
+
                 if (lastIndex < value.Length)
-                {
                     sb.Append(value.Substring(lastIndex));
-                }
 
-                var retVal = sb.ToString();
-
+                string retVal = sb.ToString();
                 m_formulaA1 = retVal.Substring(1, retVal.Length - 2);
             }
         }
@@ -1513,149 +1596,175 @@
         {
             if (!StringExtensions.IsNullOrWhiteSpace(FormulaA1))
             {
-                var value = ">" + m_formulaA1 + "<";
+                string value = ">" + m_formulaA1 + "<";
 
-                Regex regex = a1SimpleRegex;
+                var regex = _a1SimpleRegex;
 
                 var sb = new StringBuilder();
-                var lastIndex = 0;
+                int lastIndex = 0;
 
-                foreach (var match in regex.Matches(value).Cast<Match>())
+                foreach (Match match in regex.Matches(value).Cast<Match>())
                 {
-                    var matchString = match.Value;
-                    var matchIndex = match.Index;
-                    if (value.Substring(0, matchIndex).CharCount('"')%2 == 0) // Check that the match is not between quotes
+                    string matchString = match.Value;
+                    int matchIndex = match.Index;
+                    if (value.Substring(0, matchIndex).CharCount('"') % 2 == 0)
                     {
+// Check that the match is not between quotes
                         sb.Append(value.Substring(lastIndex, matchIndex - lastIndex));
-                        String sheetName;
-                        Boolean useSheetName = false;
+                        string sheetName;
+                        bool useSheetName = false;
                         if (matchString.Contains('!'))
                         {
                             sheetName = matchString.Substring(0, matchString.IndexOf('!'));
                             if (sheetName[0] == '\'')
-                            {
                                 sheetName = sheetName.Substring(1, sheetName.Length - 2);
-                            }
                             useSheetName = true;
                         }
                         else
-                        {
-                            sheetName = m_worksheet.Name;
-                        }
+                            sheetName = _worksheet.Name;
 
                         if (sheetName.ToLower().Equals(shiftedRange.Worksheet.Name.ToLower()))
                         {
-                            String rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1);
+                            string rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1);
                             if (!a1RowRegex.IsMatch(rangeAddress))
                             {
-                                IXLRange matchRange = m_worksheet.Internals.Workbook.Worksheet(sheetName).Range(rangeAddress);
-                                if (shiftedRange.RangeAddress.FirstAddress.ColumnNumber <= matchRange.RangeAddress.LastAddress.ColumnNumber
-                                    && shiftedRange.RangeAddress.FirstAddress.RowNumber <= matchRange.RangeAddress.FirstAddress.RowNumber
-                                    && shiftedRange.RangeAddress.LastAddress.RowNumber >= matchRange.RangeAddress.LastAddress.RowNumber)
+                                var matchRange = _worksheet.Internals.Workbook.Worksheet(sheetName).Range(rangeAddress);
+                                if (shiftedRange.RangeAddress.FirstAddress.ColumnNumber <=
+                                    matchRange.RangeAddress.LastAddress.ColumnNumber
+                                    &&
+                                    shiftedRange.RangeAddress.FirstAddress.RowNumber <=
+                                    matchRange.RangeAddress.FirstAddress.RowNumber
+                                    &&
+                                    shiftedRange.RangeAddress.LastAddress.RowNumber >=
+                                    matchRange.RangeAddress.LastAddress.RowNumber)
                                 {
-                                    #region change
                                     if (a1ColumnRegex.IsMatch(rangeAddress))
                                     {
                                         var columns = rangeAddress.Split(':');
-                                        String column1String = columns[0];
-                                        String column2String = columns[1];
-                                        String column1;
+                                        string column1String = columns[0];
+                                        string column2String = columns[1];
+                                        string column1;
                                         if (column1String[0] == '$')
                                         {
                                             column1 = "$" +
                                                       ExcelHelper.GetColumnLetterFromNumber(
-                                                              ExcelHelper.GetColumnNumberFromLetter(column1String.Substring(1)) + columnsShifted);
+                                                          ExcelHelper.GetColumnNumberFromLetter(
+                                                              column1String.Substring(1)) + columnsShifted);
                                         }
                                         else
                                         {
                                             column1 =
-                                                    ExcelHelper.GetColumnLetterFromNumber(ExcelHelper.GetColumnNumberFromLetter(column1String) +
-                                                                                        columnsShifted);
+                                                ExcelHelper.GetColumnLetterFromNumber(
+                                                    ExcelHelper.GetColumnNumberFromLetter(column1String) +
+                                                    columnsShifted);
                                         }
 
-                                        String column2;
+                                        string column2;
                                         if (column2String[0] == '$')
                                         {
                                             column2 = "$" +
                                                       ExcelHelper.GetColumnLetterFromNumber(
-                                                              ExcelHelper.GetColumnNumberFromLetter(column2String.Substring(1)) + columnsShifted);
+                                                          ExcelHelper.GetColumnNumberFromLetter(
+                                                              column2String.Substring(1)) + columnsShifted);
                                         }
                                         else
                                         {
                                             column2 =
-                                                    ExcelHelper.GetColumnLetterFromNumber(ExcelHelper.GetColumnNumberFromLetter(column2String) +
-                                                                                        columnsShifted);
+                                                ExcelHelper.GetColumnLetterFromNumber(
+                                                    ExcelHelper.GetColumnNumberFromLetter(column2String) +
+                                                    columnsShifted);
                                         }
 
                                         if (useSheetName)
-                                        {
                                             sb.Append(String.Format("'{0}'!{1}:{2}", sheetName, column1, column2));
-                                        }
                                         else
-                                        {
                                             sb.Append(String.Format("{0}:{1}", column1, column2));
-                                        }
                                     }
-                                    else if (shiftedRange.RangeAddress.FirstAddress.ColumnNumber <= matchRange.RangeAddress.FirstAddress.ColumnNumber)
+                                    else if (shiftedRange.RangeAddress.FirstAddress.ColumnNumber <=
+                                             matchRange.RangeAddress.FirstAddress.ColumnNumber)
                                     {
                                         if (rangeAddress.Contains(':'))
                                         {
                                             if (useSheetName)
                                             {
-                                                sb.Append(String.Format("'{0}'!{1}:{2}",
-                                                                        sheetName,
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn),
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.LastAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.LastAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                                sb.Append(String.Format("'{0}'!{1}:{2}", 
+                                                                        sheetName, 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn), 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedColumn)));
                                             }
                                             else
                                             {
-                                                sb.Append(String.Format("{0}:{1}",
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn),
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.LastAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.LastAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                                sb.Append(String.Format("{0}:{1}", 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn), 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          LastAddress.FixedColumn)));
                                             }
                                         }
                                         else
                                         {
                                             if (useSheetName)
                                             {
-                                                sb.Append(String.Format("'{0}'!{1}",
-                                                                        sheetName,
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn)));
+                                                sb.Append(String.Format("'{0}'!{1}", 
+                                                                        sheetName, 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn)));
                                             }
                                             else
                                             {
-                                                sb.Append(String.Format("{0}",
-                                                                        new XLAddress(m_worksheet,
-                                                                                      matchRange.RangeAddress.FirstAddress.RowNumber,
-                                                                                      matchRange.RangeAddress.FirstAddress.ColumnNumber +
-                                                                                      columnsShifted,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedRow,
-                                                                                      matchRange.RangeAddress.FirstAddress.FixedColumn)));
+                                                sb.Append(String.Format("{0}", 
+                                                                        new XLAddress(_worksheet, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.RowNumber, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.ColumnNumber +
+                                                                                      columnsShifted, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedRow, 
+                                                                                      matchRange.RangeAddress.
+                                                                                          FirstAddress.FixedColumn)));
                                             }
                                         }
                                     }
@@ -1663,192 +1772,69 @@
                                     {
                                         if (useSheetName)
                                         {
-                                            sb.Append(String.Format("'{0}'!{1}:{2}",
-                                                                    sheetName,
-                                                                    matchRange.RangeAddress.FirstAddress,
-                                                                    new XLAddress(m_worksheet,
-                                                                                  matchRange.RangeAddress.LastAddress.RowNumber,
-                                                                                  matchRange.RangeAddress.LastAddress.ColumnNumber + columnsShifted,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                            sb.Append(String.Format("'{0}'!{1}:{2}", 
+                                                                    sheetName, 
+                                                                    matchRange.RangeAddress.FirstAddress, 
+                                                                    new XLAddress(_worksheet, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.RowNumber, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.ColumnNumber +
+                                                                                  columnsShifted, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedRow, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedColumn)));
                                         }
                                         else
                                         {
-                                            sb.Append(String.Format("{0}:{1}",
-                                                                    matchRange.RangeAddress.FirstAddress,
-                                                                    new XLAddress(m_worksheet,
-                                                                                  matchRange.RangeAddress.LastAddress.RowNumber,
-                                                                                  matchRange.RangeAddress.LastAddress.ColumnNumber + columnsShifted,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedRow,
-                                                                                  matchRange.RangeAddress.LastAddress.FixedColumn)));
+                                            sb.Append(String.Format("{0}:{1}", 
+                                                                    matchRange.RangeAddress.FirstAddress, 
+                                                                    new XLAddress(_worksheet, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.RowNumber, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.ColumnNumber +
+                                                                                  columnsShifted, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedRow, 
+                                                                                  matchRange.RangeAddress.
+                                                                                      LastAddress.FixedColumn)));
                                         }
                                     }
-                                    #endregion
                                 }
                                 else
-                                {
                                     sb.Append(matchString);
-                                }
                             }
                             else
-                            {
                                 sb.Append(matchString);
-                            }
                         }
                         else
-                        {
                             sb.Append(matchString);
-                        }
                     }
                     else
-                    {
                         sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length));
-                    }
                     lastIndex = matchIndex + matchString.Length;
                 }
-                if (lastIndex < value.Length)
-                {
-                    sb.Append(value.Substring(lastIndex));
-                }
 
-                var retVal = sb.ToString();
+                if (lastIndex < value.Length)
+                    sb.Append(value.Substring(lastIndex));
+
+                string retVal = sb.ToString();
 
                 m_formulaA1 = retVal.Substring(1, retVal.Length - 2);
             }
         }
 
-        public Boolean ShareString { get; set; }
-
-        public Boolean SettingHyperlink;
-
-        public XLHyperlink Hyperlink
-        {
-            get
-            {
-                if (m_hyperlink == null)
-                {
-                    Hyperlink = new XLHyperlink();
-                }
-
-                return m_hyperlink;
-            }
-            set
-            {
-                m_hyperlink = value;
-                m_hyperlink.Worksheet = m_worksheet;
-                m_hyperlink.Cell = this;
-                if (m_worksheet.Hyperlinks.Any(hl => Address.Equals(hl.Cell.Address)))
-                {
-                    m_worksheet.Hyperlinks.Delete(Address);
-                }
-
-                m_worksheet.Hyperlinks.Add(m_hyperlink);
-
-                if (!SettingHyperlink)
-                {
-                    if (Style.Font.FontColor.Equals(m_worksheet.Style.Font.FontColor))
-                    {
-                        Style.Font.FontColor = XLColor.FromTheme(XLThemeColor.Hyperlink);
-                    }
-
-                    if (Style.Font.Underline == m_worksheet.Style.Font.Underline)
-                    {
-                        Style.Font.Underline = XLFontUnderlineValues.Single;
-                    }
-                }
-            }
-        }
-
-        public IXLDataValidation DataValidation
-        {
-            get { return AsRange().DataValidation; }
-        }
-
-        public IXLCells InsertCellsAbove(int numberOfRows)
-        {
-            return AsRange().InsertRowsAbove(numberOfRows).Cells();
-        }
-        public IXLCells InsertCellsBelow(int numberOfRows)
-        {
-            return AsRange().InsertRowsBelow(numberOfRows).Cells();
-        }
-        public IXLCells InsertCellsAfter(int numberOfColumns)
-        {
-            return AsRange().InsertColumnsAfter(numberOfColumns).Cells();
-        }
-        public IXLCells InsertCellsBefore(int numberOfColumns)
-        {
-            return AsRange().InsertColumnsBefore(numberOfColumns).Cells();
-        }
-
-        public IXLCell AddToNamed(String rangeName)
-        {
-            AsRange().AddToNamed(rangeName);
-            return this;
-        }
-        public IXLCell AddToNamed(String rangeName, XLScope scope)
-        {
-            AsRange().AddToNamed(rangeName, scope);
-            return this;
-        }
-        public IXLCell AddToNamed(String rangeName, XLScope scope, String comment)
-        {
-            AsRange().AddToNamed(rangeName, scope, comment);
-            return this;
-        }
-
-        public IXLRanges RangesUsed
-        {
-            get
-            {
-                var retVal = new XLRanges();
-                retVal.Add(AsRange());
-                return retVal;
-            }
-        }
-
-        public IXLCell CopyTo(IXLCell target)
-        {
-            target.Value = this;
-            return target;
-        }
-
-        public String ValueCached { get; internal set; }
-
-        public IXLRichText RichText
-        {
-            get
-            {
-                if (m_richText == null)
-                {
-                    if (StringExtensions.IsNullOrWhiteSpace(m_cellValue))
-                    {
-                        m_richText = new XLRichText(m_style.Font);
-                    }
-                    else
-                        m_richText = new XLRichText(GetFormattedString(), m_style.Font);
-
-                    m_dataType = XLCellValues.Text;
-                    if (!Style.Alignment.WrapText)
-                        Style.Alignment.WrapText = true;
-                }
-                return m_richText;
-            }
-        }
-
-        public Int32 SharedStringId;
-        public Boolean HasRichText
-        {
-            get { return m_richText != null; }
-        }
-
-        //--
+        // --
         #region Nested type: FormulaConversionType
+
         private enum FormulaConversionType
         {
-            A1toR1C1,
+            A1toR1C1, 
             R1C1toA1
         };
+
         #endregion
     }
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRange.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRange.cs
index 2c6036d..d852a94 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRange.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRange.cs
@@ -185,7 +185,7 @@
                                                 false,
                                                 false);
             return new XLRangeRow(
-                    new XLRangeParameters(new XLRangeAddress(firstCellAddress, lastCellAddress), Worksheet.Style));
+                    new XLRangeParameters(new XLRangeAddress(firstCellAddress, lastCellAddress), Worksheet.Style), false);
         }
         public XLRangeRow RowQuick(Int32 row)
         {
@@ -215,7 +215,7 @@
                                                 false,
                                                 false);
             return new XLRangeColumn(
-                    new XLRangeParameters(new XLRangeAddress(firstCellAddress, lastCellAddress), Worksheet.Style));
+                    new XLRangeParameters(new XLRangeAddress(firstCellAddress, lastCellAddress), Worksheet.Style), false);
         }
         public IXLRangeColumn Column(String column)
         {
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeColumn.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeColumn.cs
index 9fe151b..5094f84 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeColumn.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeColumn.cs
@@ -1,91 +1,57 @@
-using System;
-using System.Linq;
-
-namespace ClosedXML.Excel
+namespace ClosedXML.Excel
 {
+    using System;
+    using System.Linq;
+
     internal class XLRangeColumn : XLRangeBase, IXLRangeColumn
     {
         #region Constructor
-        public XLRangeColumn(XLRangeParameters xlRangeParameters)
-            : base(xlRangeParameters.RangeAddress)
+
+        public XLRangeColumn(XLRangeParameters rangeParameters, bool quickLoad)
+            : base(rangeParameters.RangeAddress)
         {
-            (Worksheet).RangeShiftedRows += Worksheet_RangeShiftedRows;
-            (Worksheet).RangeShiftedColumns += Worksheet_RangeShiftedColumns;
-            m_defaultStyle = new XLStyle(this, xlRangeParameters.DefaultStyle);
+            if (!quickLoad)
+            {
+                Worksheet.RangeShiftedRows += WorksheetRangeShiftedRows;
+                Worksheet.RangeShiftedColumns += WorksheetRangeShiftedColumns;
+                m_defaultStyle = new XLStyle(this, rangeParameters.DefaultStyle);
+            }
         }
-        public XLRangeColumn(XLRangeParameters xlRangeParameters, Boolean quick)
-            : base(xlRangeParameters.RangeAddress)
-        {
-        }
+
         #endregion
 
-        private void Worksheet_RangeShiftedColumns(XLRange range, int columnsShifted)
-        {
-            ShiftColumns(RangeAddress, range, columnsShifted);
-        }
-        private void Worksheet_RangeShiftedRows(XLRange range, int rowsShifted)
-        {
-            ShiftRows(RangeAddress, range, rowsShifted);
-        }
+        #region IXLRangeColumn Members
 
         public IXLCell Cell(int row)
         {
             return Cell(row, 1);
         }
 
-        public new IXLCells Cells(String cellsInColumn)
+        public new IXLCells Cells(string cellsInColumn)
         {
             var retVal = new XLCells(false, false, false);
             var rangePairs = cellsInColumn.Split(',');
-            foreach (var pair in rangePairs)
-            {
+            foreach (string pair in rangePairs)
                 retVal.Add(Range(pair.Trim()).RangeAddress);
-            }
             return retVal;
         }
 
-        public IXLCells Cells(Int32 firstRow, Int32 lastRow)
+        public IXLCells Cells(int firstRow, int lastRow)
         {
             return Cells(firstRow + ":" + lastRow);
         }
 
-        public XLRange Range(int firstRow, int lastRow)
-        {
-            return Range(firstRow, 1, lastRow, 1);
-        }
-        public override XLRange Range(String rangeAddressStr)
-        {
-            String rangeAddressToUse;
-            if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-'))
-            {
-                if (rangeAddressStr.Contains('-'))
-                {
-                    rangeAddressStr = rangeAddressStr.Replace('-', ':');
-                }
-
-                String[] arrRange = rangeAddressStr.Split(':');
-                var firstPart = arrRange[0];
-                var secondPart = arrRange[1];
-                rangeAddressToUse = FixColumnAddress(firstPart) + ":" + FixColumnAddress(secondPart);
-            }
-            else
-            {
-                rangeAddressToUse = FixColumnAddress(rangeAddressStr);
-            }
-
-            var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse);
-            return Range(rangeAddress);
-        }
-
         public void Delete()
         {
             Delete(XLShiftDeletedCells.ShiftCellsLeft);
         }
+
         public IXLCells InsertCellsAbove(int numberOfRows)
         {
             return InsertCellsAbove(numberOfRows, false);
         }
-        public IXLCells InsertCellsAbove(int numberOfRows, Boolean expandRange)
+
+        public IXLCells InsertCellsAbove(int numberOfRows, bool expandRange)
         {
             return InsertRowsAbove(numberOfRows, expandRange).Cells();
         }
@@ -94,100 +60,36 @@
         {
             return InsertCellsBelow(numberOfRows, true);
         }
-        public IXLCells InsertCellsBelow(int numberOfRows, Boolean expandRange)
+
+        public IXLCells InsertCellsBelow(int numberOfRows, bool expandRange)
         {
             return InsertRowsBelow(numberOfRows, expandRange).Cells();
         }
 
-        public Int32 CellCount()
+        public int CellCount()
         {
             return RangeAddress.LastAddress.ColumnNumber - RangeAddress.FirstAddress.ColumnNumber + 1;
         }
 
-        public Int32 CompareTo(XLRangeColumn otherColumn, IXLSortElements rowsToSort)
-        {
-            foreach (var e in rowsToSort)
-            {
-                var thisCell = (XLCell) Cell(e.ElementNumber);
-                var otherCell = (XLCell) otherColumn.Cell(e.ElementNumber);
-                Int32 comparison;
-                Boolean thisCellIsBlank = StringExtensions.IsNullOrWhiteSpace(thisCell.InnerText);
-                Boolean otherCellIsBlank = StringExtensions.IsNullOrWhiteSpace(otherCell.InnerText);
-                if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank))
-                {
-                    if (thisCellIsBlank && otherCellIsBlank)
-                    {
-                        comparison = 0;
-                    }
-                    else
-                    {
-                        if (thisCellIsBlank)
-                        {
-                            comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1;
-                        }
-                        else
-                        {
-                            comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1;
-                        }
-                    }
-                }
-                else
-                {
-                    if (thisCell.DataType == otherCell.DataType)
-                    {
-                        if (thisCell.DataType == XLCellValues.Text)
-                        {
-                            if (e.MatchCase)
-                            {
-                                comparison = thisCell.InnerText.CompareTo(otherCell.InnerText);
-                            }
-                            else
-                            {
-                                comparison = thisCell.InnerText.ToLower().CompareTo(otherCell.InnerText.ToLower());
-                            }
-                        }
-                        else if (thisCell.DataType == XLCellValues.TimeSpan)
-                        {
-                            comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
-                        }
-                        else
-                        {
-                            comparison = Double.Parse(thisCell.InnerText).CompareTo(Double.Parse(otherCell.InnerText));
-                        }
-                    }
-                    else if (e.MatchCase)
-                    {
-                        comparison = thisCell.GetString().ToLower().CompareTo(otherCell.GetString().ToLower());
-                    }
-                    else
-                    {
-                        comparison = thisCell.GetString().CompareTo(otherCell.GetString());
-                    }
-                }
-                if (comparison != 0)
-                {
-                    return e.SortOrder == XLSortOrder.Ascending ? comparison : comparison*-1;
-                }
-            }
-            return 0;
-        }
-
         public IXLRangeColumn Sort()
         {
             AsRange().Sort();
             return this;
         }
+
         public IXLRangeColumn Sort(XLSortOrder sortOrder)
         {
             AsRange().Sort(sortOrder);
             return this;
         }
-        public IXLRangeColumn Sort(Boolean matchCase)
+
+        public IXLRangeColumn Sort(bool matchCase)
         {
             AsRange().Sort(matchCase);
             return this;
         }
-        public IXLRangeColumn Sort(XLSortOrder sortOrder, Boolean matchCase)
+
+        public IXLRangeColumn Sort(XLSortOrder sortOrder, bool matchCase)
         {
             AsRange().Sort(sortOrder, matchCase);
             return this;
@@ -197,76 +99,72 @@
         {
             base.CopyTo(target);
 
-            Int32 lastRowNumber = target.Address.RowNumber + RowCount() - 1;
+            int lastRowNumber = target.Address.RowNumber + RowCount() - 1;
             if (lastRowNumber > ExcelHelper.MaxRowNumber)
-            {
                 lastRowNumber = ExcelHelper.MaxRowNumber;
-            }
-            Int32 lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1;
+            int lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1;
             if (lastColumnNumber > ExcelHelper.MaxColumnNumber)
-            {
                 lastColumnNumber = ExcelHelper.MaxColumnNumber;
-            }
 
-            return target.Worksheet.Range(target.Address.RowNumber,
-                                          target.Address.ColumnNumber,
-                                          lastRowNumber,
-                                          lastColumnNumber)
-                    .Column(1);
+            return target.Worksheet.Range(
+                target.Address.RowNumber, 
+                target.Address.ColumnNumber, 
+                lastRowNumber, 
+                lastColumnNumber)
+                .Column(1);
         }
+
         public new IXLRangeColumn CopyTo(IXLRangeBase target)
         {
             base.CopyTo(target);
 
-            var lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1;
+            int lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1;
             if (lastRowNumber > ExcelHelper.MaxRowNumber)
-            {
                 lastRowNumber = ExcelHelper.MaxRowNumber;
-            }
-            Int32 lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1;
+            int lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1;
             if (lastColumnNumber > ExcelHelper.MaxColumnNumber)
-            {
                 lastColumnNumber = ExcelHelper.MaxColumnNumber;
-            }
 
-            return target.Worksheet.Range(target.RangeAddress.FirstAddress.RowNumber,
-                                          target.RangeAddress.FirstAddress.ColumnNumber,
-                                          lastRowNumber,
-                                          lastColumnNumber)
-                    .Column(1);
+            return target.Worksheet.Range(
+                target.RangeAddress.FirstAddress.RowNumber, 
+                target.RangeAddress.FirstAddress.ColumnNumber, 
+                lastRowNumber, 
+                lastColumnNumber)
+                .Column(1);
         }
 
-        public IXLRangeColumn Column(Int32 start, Int32 end)
+        public IXLRangeColumn Column(int start, int end)
         {
             return Range(start, end).FirstColumn();
         }
-        public IXLRangeColumns Columns(String columns)
+
+        public IXLRangeColumns Columns(string columns)
         {
             var retVal = new XLRangeColumns();
             var rowPairs = columns.Split(',');
-            foreach (var pair in rowPairs)
+            foreach (string pair in rowPairs)
             {
-                var tPair = pair.Trim();
-                String firstRow;
-                String lastRow;
-                if (tPair.Contains(':') || tPair.Contains('-'))
+                string trimmedPair = pair.Trim();
+                string firstRow;
+                string lastRow;
+                if (trimmedPair.Contains(':') || trimmedPair.Contains('-'))
                 {
-                    if (tPair.Contains('-'))
-                    {
-                        tPair = tPair.Replace('-', ':');
-                    }
+                    if (trimmedPair.Contains('-'))
+                        trimmedPair = trimmedPair.Replace('-', ':');
 
-                    var rowRange = tPair.Split(':');
+                    var rowRange = trimmedPair.Split(':');
                     firstRow = rowRange[0];
                     lastRow = rowRange[1];
                 }
                 else
                 {
-                    firstRow = tPair;
-                    lastRow = tPair;
+                    firstRow = trimmedPair;
+                    lastRow = trimmedPair;
                 }
+
                 retVal.Add(Range(firstRow, lastRow).FirstColumn());
             }
+
             return retVal;
         }
 
@@ -275,5 +173,92 @@
             DataType = dataType;
             return this;
         }
+
+        #endregion
+
+        private void WorksheetRangeShiftedColumns(XLRange range, int columnsShifted)
+        {
+            ShiftColumns(RangeAddress, range, columnsShifted);
+        }
+
+        private void WorksheetRangeShiftedRows(XLRange range, int rowsShifted)
+        {
+            ShiftRows(RangeAddress, range, rowsShifted);
+        }
+
+        public XLRange Range(int firstRow, int lastRow)
+        {
+            return Range(firstRow, 1, lastRow, 1);
+        }
+
+        public override XLRange Range(string rangeAddressStr)
+        {
+            string rangeAddressToUse;
+            if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-'))
+            {
+                if (rangeAddressStr.Contains('-'))
+                    rangeAddressStr = rangeAddressStr.Replace('-', ':');
+
+                var arrRange = rangeAddressStr.Split(':');
+                string firstPart = arrRange[0];
+                string secondPart = arrRange[1];
+                rangeAddressToUse = FixColumnAddress(firstPart) + ":" + FixColumnAddress(secondPart);
+            }
+            else
+                rangeAddressToUse = FixColumnAddress(rangeAddressStr);
+
+            var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse);
+            return Range(rangeAddress);
+        }
+
+        public int CompareTo(XLRangeColumn otherColumn, IXLSortElements rowsToSort)
+        {
+            foreach (IXLSortElement e in rowsToSort)
+            {
+                var thisCell = (XLCell)Cell(e.ElementNumber);
+                var otherCell = (XLCell)otherColumn.Cell(e.ElementNumber);
+                int comparison;
+                bool thisCellIsBlank = StringExtensions.IsNullOrWhiteSpace(thisCell.InnerText);
+                bool otherCellIsBlank = StringExtensions.IsNullOrWhiteSpace(otherCell.InnerText);
+                if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank))
+                {
+                    if (thisCellIsBlank && otherCellIsBlank)
+                        comparison = 0;
+                    else
+                    {
+                        if (thisCellIsBlank)
+                            comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1;
+                        else
+                            comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1;
+                    }
+                }
+                else
+                {
+                    if (thisCell.DataType == otherCell.DataType)
+                    {
+                        if (thisCell.DataType == XLCellValues.Text)
+                        {
+                            if (e.MatchCase)
+                                comparison = thisCell.InnerText.CompareTo(otherCell.InnerText);
+                            else
+                                comparison = thisCell.InnerText.ToLower().CompareTo(otherCell.InnerText.ToLower());
+                        }
+                        else if (thisCell.DataType == XLCellValues.TimeSpan)
+                            comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
+                        else
+                            comparison = Double.Parse(thisCell.InnerText).CompareTo(Double.Parse(otherCell.InnerText));
+                    }
+                    else if (e.MatchCase)
+                        comparison = thisCell.GetString().ToLower().CompareTo(otherCell.GetString().ToLower());
+                    else
+                        comparison = thisCell.GetString().CompareTo(otherCell.GetString());
+                }
+
+                if (comparison != 0)
+                    return e.SortOrder == XLSortOrder.Ascending ? comparison : comparison * -1;
+            }
+
+            return 0;
+        }
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeRow.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeRow.cs
index 9f8daf6..0b683c1 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeRow.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeRow.cs
@@ -1,51 +1,40 @@
-using System;
-using System.Linq;
-
-namespace ClosedXML.Excel
+namespace ClosedXML.Excel
 {
+    using System;
+    using System.Linq;
+
     internal class XLRangeRow : XLRangeBase, IXLRangeRow
     {
         #region Constructor
-        public XLRangeRow(XLRangeParameters xlRangeParameters)
-                : base(xlRangeParameters.RangeAddress)
-        {
-            RangeParameters = xlRangeParameters;
 
-            (Worksheet).RangeShiftedRows += Worksheet_RangeShiftedRows;
-            (Worksheet).RangeShiftedColumns += Worksheet_RangeShiftedColumns;
-            m_defaultStyle = new XLStyle(this, xlRangeParameters.DefaultStyle);
-        }
-        public XLRangeRow(XLRangeParameters xlRangeParameters, Boolean quick)
-                : base(xlRangeParameters.RangeAddress)
+        public XLRangeRow(XLRangeParameters rangeParameters, bool quickLoad)
+            : base(rangeParameters.RangeAddress)
         {
-            RangeParameters = xlRangeParameters;
+            RangeParameters = rangeParameters;
+            if (!quickLoad)
+            {
+                Worksheet.RangeShiftedRows += WorksheetRangeShiftedRows;
+                Worksheet.RangeShiftedColumns += WorksheetRangeShiftedColumns;
+                m_defaultStyle = new XLStyle(this, rangeParameters.DefaultStyle);
+            }
         }
+
         #endregion
+
         public XLRangeParameters RangeParameters { get; private set; }
 
-        private void Worksheet_RangeShiftedColumns(XLRange range, int columnsShifted)
-        {
-            ShiftColumns(RangeAddress, range, columnsShifted);
-        }
-        private void Worksheet_RangeShiftedRows(XLRange range, int rowsShifted)
-        {
-            ShiftRows(RangeAddress, range, rowsShifted);
-        }
+        #region IXLRangeRow Members
 
         public IXLCell Cell(int column)
         {
             return Cell(1, column);
         }
+
         public new IXLCell Cell(string column)
         {
             return Cell(1, column);
         }
 
-        public IXLRange Range(int firstColumn, int lastColumn)
-        {
-            return Range(1, firstColumn, 1, lastColumn);
-        }
-
         public void Delete()
         {
             Delete(XLShiftDeletedCells.ShiftCellsUp);
@@ -55,7 +44,8 @@
         {
             return InsertCellsAfter(numberOfColumns, true);
         }
-        public IXLCells InsertCellsAfter(int numberOfColumns, Boolean expandRange)
+
+        public IXLCells InsertCellsAfter(int numberOfColumns, bool expandRange)
         {
             return InsertColumnsAfter(numberOfColumns, expandRange).Cells();
         }
@@ -64,146 +54,56 @@
         {
             return InsertCellsBefore(numberOfColumns, false);
         }
-        public IXLCells InsertCellsBefore(int numberOfColumns, Boolean expandRange)
+
+        public IXLCells InsertCellsBefore(int numberOfColumns, bool expandRange)
         {
             return InsertColumnsBefore(numberOfColumns, expandRange).Cells();
         }
 
-        public new IXLCells Cells(String cellsInRow)
+        public new IXLCells Cells(string cellsInRow)
         {
             var retVal = new XLCells(false, false, false);
             var rangePairs = cellsInRow.Split(',');
-            foreach (var pair in rangePairs)
-            {
+            foreach (string pair in rangePairs)
                 retVal.Add(Range(pair.Trim()).RangeAddress);
-            }
             return retVal;
         }
 
-        public override XLRange Range(String rangeAddressStr)
-        {
-            String rangeAddressToUse;
-            if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-'))
-            {
-                if (rangeAddressStr.Contains('-'))
-                {
-                    rangeAddressStr = rangeAddressStr.Replace('-', ':');
-                }
-
-                String[] arrRange = rangeAddressStr.Split(':');
-                var firstPart = arrRange[0];
-                var secondPart = arrRange[1];
-                rangeAddressToUse = FixRowAddress(firstPart) + ":" + FixRowAddress(secondPart);
-            }
-            else
-            {
-                rangeAddressToUse = FixRowAddress(rangeAddressStr);
-            }
-
-            var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse);
-            return Range(rangeAddress);
-        }
-
-        public IXLCells Cells(Int32 firstColumn, Int32 lastColumn)
+        public IXLCells Cells(int firstColumn, int lastColumn)
         {
             return Cells(firstColumn + ":" + lastColumn);
         }
 
-        public IXLCells Cells(String firstColumn, String lastColumn)
+        public IXLCells Cells(string firstColumn, string lastColumn)
         {
             return Cells(ExcelHelper.GetColumnNumberFromLetter(firstColumn) + ":"
                          + ExcelHelper.GetColumnNumberFromLetter(lastColumn));
         }
 
-        public Int32 CellCount()
+        public int CellCount()
         {
             return RangeAddress.LastAddress.ColumnNumber - RangeAddress.FirstAddress.ColumnNumber + 1;
         }
 
-        public Int32 CompareTo(XLRangeRow otherRow, IXLSortElements columnsToSort)
-        {
-            foreach (var e in columnsToSort)
-            {
-                var thisCell = (XLCell) Cell(e.ElementNumber);
-                var otherCell = (XLCell) otherRow.Cell(e.ElementNumber);
-                Int32 comparison;
-                Boolean thisCellIsBlank = StringExtensions.IsNullOrWhiteSpace(thisCell.InnerText);
-                Boolean otherCellIsBlank = StringExtensions.IsNullOrWhiteSpace(otherCell.InnerText);
-                if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank))
-                {
-                    if (thisCellIsBlank && otherCellIsBlank)
-                    {
-                        comparison = 0;
-                    }
-                    else
-                    {
-                        if (thisCellIsBlank)
-                        {
-                            comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1;
-                        }
-                        else
-                        {
-                            comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1;
-                        }
-                    }
-                }
-                else
-                {
-                    if (thisCell.DataType == otherCell.DataType)
-                    {
-                        if (thisCell.DataType == XLCellValues.Text)
-                        {
-                            if (e.MatchCase)
-                            {
-                                comparison = thisCell.InnerText.CompareTo(otherCell.InnerText);
-                            }
-                            else
-                            {
-                                comparison = thisCell.InnerText.ToLower().CompareTo(otherCell.InnerText.ToLower());
-                            }
-                        }
-                        else if (thisCell.DataType == XLCellValues.TimeSpan)
-                        {
-                            comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
-                        }
-                        else
-                        {
-                            comparison = Double.Parse(thisCell.InnerText).CompareTo(Double.Parse(otherCell.InnerText));
-                        }
-                    }
-                    else if (e.MatchCase)
-                    {
-                        comparison = thisCell.GetString().ToLower().CompareTo(otherCell.GetString().ToLower());
-                    }
-                    else
-                    {
-                        comparison = thisCell.GetString().CompareTo(otherCell.GetString());
-                    }
-                }
-                if (comparison != 0)
-                {
-                    return e.SortOrder == XLSortOrder.Ascending ? comparison : comparison*-1;
-                }
-            }
-            return 0;
-        }
-
         public IXLRangeRow Sort()
         {
             AsRange().Sort(XLSortOrientation.LeftToRight);
             return this;
         }
+
         public IXLRangeRow Sort(XLSortOrder sortOrder)
         {
             AsRange().Sort(XLSortOrientation.LeftToRight, sortOrder);
             return this;
         }
-        public IXLRangeRow Sort(Boolean matchCase)
+
+        public IXLRangeRow Sort(bool matchCase)
         {
             AsRange().Sort(XLSortOrientation.LeftToRight, matchCase);
             return this;
         }
-        public IXLRangeRow Sort(XLSortOrder sortOrder, Boolean matchCase)
+
+        public IXLRangeRow Sort(XLSortOrder sortOrder, bool matchCase)
         {
             AsRange().Sort(XLSortOrientation.LeftToRight, sortOrder, matchCase);
             return this;
@@ -213,76 +113,71 @@
         {
             base.CopyTo(target);
 
-            Int32 lastRowNumber = target.Address.RowNumber + RowCount() - 1;
+            int lastRowNumber = target.Address.RowNumber + RowCount() - 1;
             if (lastRowNumber > ExcelHelper.MaxRowNumber)
-            {
                 lastRowNumber = ExcelHelper.MaxRowNumber;
-            }
-            Int32 lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1;
+            int lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1;
             if (lastColumnNumber > ExcelHelper.MaxColumnNumber)
-            {
                 lastColumnNumber = ExcelHelper.MaxColumnNumber;
-            }
 
-            return target.Worksheet.Range(target.Address.RowNumber,
-                                          target.Address.ColumnNumber,
-                                          lastRowNumber,
-                                          lastColumnNumber)
-                    .Row(1);
+            return target.Worksheet.Range(
+                target.Address.RowNumber, 
+                target.Address.ColumnNumber, 
+                lastRowNumber, 
+                lastColumnNumber)
+                .Row(1);
         }
+
         public new IXLRangeRow CopyTo(IXLRangeBase target)
         {
             base.CopyTo(target);
-            Int32 lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1;
+            int lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1;
             if (lastRowNumber > ExcelHelper.MaxRowNumber)
-            {
                 lastRowNumber = ExcelHelper.MaxRowNumber;
-            }
-            Int32 lastColumnNumber = target.RangeAddress.LastAddress.ColumnNumber + ColumnCount() - 1;
+            int lastColumnNumber = target.RangeAddress.LastAddress.ColumnNumber + ColumnCount() - 1;
             if (lastColumnNumber > ExcelHelper.MaxColumnNumber)
-            {
                 lastColumnNumber = ExcelHelper.MaxColumnNumber;
-            }
 
-            return target.Worksheet.Range(target.RangeAddress.FirstAddress.RowNumber,
-                                          target.RangeAddress.LastAddress.ColumnNumber,
-                                          lastRowNumber,
-                                          lastColumnNumber)
-                    .Row(1);
+            return target.Worksheet.Range(
+                target.RangeAddress.FirstAddress.RowNumber, 
+                target.RangeAddress.LastAddress.ColumnNumber, 
+                lastRowNumber, 
+                lastColumnNumber)
+                .Row(1);
         }
 
-        public IXLRangeRow Row(Int32 start, Int32 end)
+        public IXLRangeRow Row(int start, int end)
         {
             return Range(1, start, 1, end).Row(1);
         }
-        public IXLRangeRows Rows(String rows)
+
+        public IXLRangeRows Rows(string rows)
         {
             var retVal = new XLRangeRows();
             var columnPairs = rows.Split(',');
-            foreach (var pair in columnPairs)
+            foreach (string pair in columnPairs)
             {
-                var tPair = pair.Trim();
-                String firstColumn;
-                String lastColumn;
-                if (tPair.Contains(':') || tPair.Contains('-'))
+                string trimmedPair = pair.Trim();
+                string firstColumn;
+                string lastColumn;
+                if (trimmedPair.Contains(':') || trimmedPair.Contains('-'))
                 {
-                    if (tPair.Contains('-'))
-                    {
-                        tPair = tPair.Replace('-', ':');
-                    }
+                    if (trimmedPair.Contains('-'))
+                        trimmedPair = trimmedPair.Replace('-', ':');
 
-                    var columnRange = tPair.Split(':');
+                    var columnRange = trimmedPair.Split(':');
                     firstColumn = columnRange[0];
                     lastColumn = columnRange[1];
                 }
                 else
                 {
-                    firstColumn = tPair;
-                    lastColumn = tPair;
+                    firstColumn = trimmedPair;
+                    lastColumn = trimmedPair;
                 }
 
                 retVal.Add(Range(firstColumn, lastColumn).FirstRow());
             }
+
             return retVal;
         }
 
@@ -291,5 +186,92 @@
             DataType = dataType;
             return this;
         }
+
+        #endregion
+
+        private void WorksheetRangeShiftedColumns(XLRange range, int columnsShifted)
+        {
+            ShiftColumns(RangeAddress, range, columnsShifted);
+        }
+
+        private void WorksheetRangeShiftedRows(XLRange range, int rowsShifted)
+        {
+            ShiftRows(RangeAddress, range, rowsShifted);
+        }
+
+        public IXLRange Range(int firstColumn, int lastColumn)
+        {
+            return Range(1, firstColumn, 1, lastColumn);
+        }
+
+        public override XLRange Range(string rangeAddressStr)
+        {
+            string rangeAddressToUse;
+            if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-'))
+            {
+                if (rangeAddressStr.Contains('-'))
+                    rangeAddressStr = rangeAddressStr.Replace('-', ':');
+
+                var arrRange = rangeAddressStr.Split(':');
+                string firstPart = arrRange[0];
+                string secondPart = arrRange[1];
+                rangeAddressToUse = FixRowAddress(firstPart) + ":" + FixRowAddress(secondPart);
+            }
+            else
+                rangeAddressToUse = FixRowAddress(rangeAddressStr);
+
+            var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse);
+            return Range(rangeAddress);
+        }
+
+        public int CompareTo(XLRangeRow otherRow, IXLSortElements columnsToSort)
+        {
+            foreach (IXLSortElement e in columnsToSort)
+            {
+                var thisCell = (XLCell)Cell(e.ElementNumber);
+                var otherCell = (XLCell)otherRow.Cell(e.ElementNumber);
+                int comparison;
+                bool thisCellIsBlank = StringExtensions.IsNullOrWhiteSpace(thisCell.InnerText);
+                bool otherCellIsBlank = StringExtensions.IsNullOrWhiteSpace(otherCell.InnerText);
+                if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank))
+                {
+                    if (thisCellIsBlank && otherCellIsBlank)
+                        comparison = 0;
+                    else
+                    {
+                        if (thisCellIsBlank)
+                            comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1;
+                        else
+                            comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1;
+                    }
+                }
+                else
+                {
+                    if (thisCell.DataType == otherCell.DataType)
+                    {
+                        if (thisCell.DataType == XLCellValues.Text)
+                        {
+                            if (e.MatchCase)
+                                comparison = thisCell.InnerText.CompareTo(otherCell.InnerText);
+                            else
+                                comparison = thisCell.InnerText.ToLower().CompareTo(otherCell.InnerText.ToLower());
+                        }
+                        else if (thisCell.DataType == XLCellValues.TimeSpan)
+                            comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan());
+                        else
+                            comparison = Double.Parse(thisCell.InnerText).CompareTo(Double.Parse(otherCell.InnerText));
+                    }
+                    else if (e.MatchCase)
+                        comparison = thisCell.GetString().ToLower().CompareTo(otherCell.GetString().ToLower());
+                    else
+                        comparison = thisCell.GetString().CompareTo(otherCell.GetString());
+                }
+
+                if (comparison != 0)
+                    return e.SortOrder == XLSortOrder.Ascending ? comparison : comparison * -1;
+            }
+
+            return 0;
+        }
     }
 }
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Tables/XLTableRow.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Tables/XLTableRow.cs
index d809dae..a095dd9 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Tables/XLTableRow.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Tables/XLTableRow.cs
@@ -6,7 +6,7 @@
     {
         private XLTable table;
         public XLTableRow(XLTable table, XLRangeRow rangeRow)
-            : base(rangeRow.RangeParameters)
+            : base(rangeRow.RangeParameters, false)
         {
             this.table = table;
         }
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Load.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Load.cs
index c4d58c5..1667983 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Load.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Load.cs
@@ -344,8 +344,8 @@
             {
                 if (cell.DataType == CellValues.InlineString)
                 {
-                    xlCell.m_cellValue = cell.InlineString.Text.Text;
-                    xlCell.m_dataType = XLCellValues.Text;
+                    xlCell._cellValue = cell.InlineString.Text.Text;
+                    xlCell._dataType = XLCellValues.Text;
                     xlCell.ShareString = false;
                 }
                 else if (cell.DataType == CellValues.SharedString)
@@ -380,7 +380,7 @@
                                 #endregion
                             }
                             else
-                                xlCell.m_cellValue = sharedString.Text.InnerText;
+                                xlCell._cellValue = sharedString.Text.InnerText;
 
                             #region Load PhoneticProperties
 
@@ -408,37 +408,37 @@
                             #endregion
                         }
                         else
-                            xlCell.m_cellValue = cell.CellValue.Text;
+                            xlCell._cellValue = cell.CellValue.Text;
                     }
                     else
-                        xlCell.m_cellValue = String.Empty;
-                    xlCell.m_dataType = XLCellValues.Text;
+                        xlCell._cellValue = String.Empty;
+                    xlCell._dataType = XLCellValues.Text;
                 }
                 else if (cell.DataType == CellValues.Date)
                 {
                     //xlCell.cellValue = DateTime.FromOADate(Double.Parse(dCell.CellValue.Text, CultureInfo.InvariantCulture));
-                    xlCell.m_cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
-                    xlCell.m_dataType = XLCellValues.DateTime;
+                    xlCell._cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
+                    xlCell._dataType = XLCellValues.DateTime;
                 }
                 else if (cell.DataType == CellValues.Boolean)
                 {
-                    xlCell.m_cellValue = cell.CellValue.Text;
-                    xlCell.m_dataType = XLCellValues.Boolean;
+                    xlCell._cellValue = cell.CellValue.Text;
+                    xlCell._dataType = XLCellValues.Boolean;
                 }
                 else if (cell.DataType == CellValues.Number)
                 {
-                    xlCell.m_cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
+                    xlCell._cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
                     var numberFormatId = ((CellFormat) (s.CellFormats).ElementAt(styleIndex)).NumberFormatId;
                     if (numberFormatId == 46U)
                         xlCell.DataType = XLCellValues.TimeSpan;
                     else
-                        xlCell.m_dataType = XLCellValues.Number;
+                        xlCell._dataType = XLCellValues.Number;
                 }
             }
             else if (cell.CellValue != null)
             {
                 var numberFormatId = ((CellFormat) (s.CellFormats).ElementAt(styleIndex)).NumberFormatId;
-                xlCell.m_cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
+                xlCell._cellValue = Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToString();
                 if (s.NumberingFormats != null &&
                     s.NumberingFormats.Any(nf => ((NumberingFormat) nf).NumberFormatId.Value == numberFormatId))
                 {
@@ -452,13 +452,13 @@
 
 
                 if (!StringExtensions.IsNullOrWhiteSpace(xlCell.Style.NumberFormat.Format))
-                    xlCell.m_dataType = GetDataTypeFromFormat(xlCell.Style.NumberFormat.Format);
+                    xlCell._dataType = GetDataTypeFromFormat(xlCell.Style.NumberFormat.Format);
                 else if ((numberFormatId >= 14 && numberFormatId <= 22) || (numberFormatId >= 45 && numberFormatId <= 47))
-                    xlCell.m_dataType = XLCellValues.DateTime;
+                    xlCell._dataType = XLCellValues.DateTime;
                 else if (numberFormatId == 49)
-                    xlCell.m_dataType = XLCellValues.Text;
+                    xlCell._dataType = XLCellValues.Text;
                 else
-                    xlCell.m_dataType = XLCellValues.Number;
+                    xlCell._dataType = XLCellValues.Number;
             }
         }