/Classes/PHPExcel/Reader/Excel5.php

<?php

/**

 * PHPExcel

 *

 * Copyright (c) 2006 - 2012 PHPExcel

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * @category   PHPExcel

 * @package    PHPExcel_Reader_Excel5

 * @copyright  Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)

 * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL

 * @version    1.7.8, 2012-10-12

 */



// Original file header of ParseXL (used as the base for this class):

// --------------------------------------------------------------------------------

// Adapted from Excel_Spreadsheet_Reader developed by users bizon153,

// trex005, and mmp11 (SourceForge.net)

// http://sourceforge.net/projects/phpexcelreader/

// Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ...

//	 Modelled moreso after Perl Excel Parse/Write modules

//	 Added Parse_Excel_Spreadsheet object

//		 Reads a whole worksheet or tab as row,column array or as

//		 associated hash of indexed rows and named column fields

//	 Added variables for worksheet (tab) indexes and names

//	 Added an object call for loading individual woorksheets

//	 Changed default indexing defaults to 0 based arrays

//	 Fixed date/time and percent formats

//	 Includes patches found at SourceForge...

//		 unicode patch by nobody

//		 unpack("d") machine depedency patch by matchy

//		 boundsheet utf16 patch by bjaenichen

//	 Renamed functions for shorter names

//	 General code cleanup and rigor, including <80 column width

//	 Included a testcase Excel file and PHP example calls

//	 Code works for PHP 5.x



// Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ...

// http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334

//	 Decoding of formula conditions, results, and tokens.

//	 Support for user-defined named cells added as an array "namedcells"

//		 Patch code for user-defined named cells supports single cells only.

//		 NOTE: this patch only works for BIFF8 as BIFF5-7 use a different

//		 external sheet reference structure





/** PHPExcel root directory */

if (!defined('PHPEXCEL_ROOT')) {

	/**

	 * @ignore

	 */

	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');

	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');

}



/**

 * PHPExcel_Reader_Excel5

 *

 * This class uses {@link http://sourceforge.net/projects/phpexcelreader/parseXL}

 *

 * @category	PHPExcel

 * @package		PHPExcel_Reader_Excel5

 * @copyright	Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)

 */

class PHPExcel_Reader_Excel5 implements PHPExcel_Reader_IReader

{

	// ParseXL definitions

	const XLS_BIFF8						= 0x0600;

	const XLS_BIFF7						= 0x0500;

	const XLS_WorkbookGlobals			= 0x0005;

	const XLS_Worksheet					= 0x0010;



	// record identifiers

	const XLS_Type_FORMULA				= 0x0006;

	const XLS_Type_EOF					= 0x000a;

	const XLS_Type_PROTECT				= 0x0012;

	const XLS_Type_OBJECTPROTECT		= 0x0063;

	const XLS_Type_SCENPROTECT			= 0x00dd;

	const XLS_Type_PASSWORD				= 0x0013;

	const XLS_Type_HEADER				= 0x0014;

	const XLS_Type_FOOTER				= 0x0015;

	const XLS_Type_EXTERNSHEET			= 0x0017;

	const XLS_Type_DEFINEDNAME			= 0x0018;

	const XLS_Type_VERTICALPAGEBREAKS	= 0x001a;

	const XLS_Type_HORIZONTALPAGEBREAKS	= 0x001b;

	const XLS_Type_NOTE					= 0x001c;

	const XLS_Type_SELECTION			= 0x001d;

	const XLS_Type_DATEMODE				= 0x0022;

	const XLS_Type_EXTERNNAME			= 0x0023;

	const XLS_Type_LEFTMARGIN			= 0x0026;

	const XLS_Type_RIGHTMARGIN			= 0x0027;

	const XLS_Type_TOPMARGIN			= 0x0028;

	const XLS_Type_BOTTOMMARGIN			= 0x0029;

	const XLS_Type_PRINTGRIDLINES		= 0x002b;

	const XLS_Type_FILEPASS				= 0x002f;

	const XLS_Type_FONT					= 0x0031;

	const XLS_Type_CONTINUE				= 0x003c;

	const XLS_Type_PANE					= 0x0041;

	const XLS_Type_CODEPAGE				= 0x0042;

	const XLS_Type_DEFCOLWIDTH 			= 0x0055;

	const XLS_Type_OBJ					= 0x005d;

	const XLS_Type_COLINFO				= 0x007d;

	const XLS_Type_IMDATA				= 0x007f;

	const XLS_Type_SHEETPR				= 0x0081;

	const XLS_Type_HCENTER				= 0x0083;

	const XLS_Type_VCENTER				= 0x0084;

	const XLS_Type_SHEET				= 0x0085;

	const XLS_Type_PALETTE				= 0x0092;

	const XLS_Type_SCL					= 0x00a0;

	const XLS_Type_PAGESETUP			= 0x00a1;

	const XLS_Type_MULRK				= 0x00bd;

	const XLS_Type_MULBLANK				= 0x00be;

	const XLS_Type_DBCELL				= 0x00d7;

	const XLS_Type_XF					= 0x00e0;

	const XLS_Type_MERGEDCELLS			= 0x00e5;

	const XLS_Type_MSODRAWINGGROUP		= 0x00eb;

	const XLS_Type_MSODRAWING			= 0x00ec;

	const XLS_Type_SST					= 0x00fc;

	const XLS_Type_LABELSST				= 0x00fd;

	const XLS_Type_EXTSST				= 0x00ff;

	const XLS_Type_EXTERNALBOOK			= 0x01ae;

	const XLS_Type_DATAVALIDATIONS		= 0x01b2;

	const XLS_Type_TXO					= 0x01b6;

	const XLS_Type_HYPERLINK			= 0x01b8;

	const XLS_Type_DATAVALIDATION		= 0x01be;

	const XLS_Type_DIMENSION			= 0x0200;

	const XLS_Type_BLANK				= 0x0201;

	const XLS_Type_NUMBER				= 0x0203;

	const XLS_Type_LABEL				= 0x0204;

	const XLS_Type_BOOLERR				= 0x0205;

	const XLS_Type_STRING				= 0x0207;

	const XLS_Type_ROW					= 0x0208;

	const XLS_Type_INDEX				= 0x020b;

	const XLS_Type_ARRAY				= 0x0221;

	const XLS_Type_DEFAULTROWHEIGHT 	= 0x0225;

	const XLS_Type_WINDOW2				= 0x023e;

	const XLS_Type_RK					= 0x027e;

	const XLS_Type_STYLE				= 0x0293;

	const XLS_Type_FORMAT				= 0x041e;

	const XLS_Type_SHAREDFMLA			= 0x04bc;

	const XLS_Type_BOF					= 0x0809;

	const XLS_Type_SHEETPROTECTION		= 0x0867;

	const XLS_Type_RANGEPROTECTION		= 0x0868;

	const XLS_Type_SHEETLAYOUT			= 0x0862;

	const XLS_Type_XFEXT				= 0x087d;

	const XLS_Type_UNKNOWN				= 0xffff;





	/**

	 * Read data only?

	 * Identifies whether the Reader should only read data values for cells, and ignore any formatting information;

	 *		or whether it should read both data and formatting

	 *

	 * @var	boolean

	 */

	private $_readDataOnly = false;



	/**

	 * Restrict which sheets should be loaded?

	 * This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded.

	 *

	 * @var	array of string

	 */

	private $_loadSheetsOnly = null;



	/**

	 * PHPExcel_Reader_IReadFilter instance

	 *

	 * @var PHPExcel_Reader_IReadFilter

	 */

	private $_readFilter = null;



	/**

	 * Summary Information stream data.

	 *

	 * @var string

	 */

	private $_summaryInformation;



	/**

	 * Extended Summary Information stream data.

	 *

	 * @var string

	 */

	private $_documentSummaryInformation;



	/**

	 * User-Defined Properties stream data.

	 *

	 * @var string

	 */

	private $_userDefinedProperties;



	/**

	 * Workbook stream data. (Includes workbook globals substream as well as sheet substreams)

	 *

	 * @var string

	 */

	private $_data;



	/**

	 * Size in bytes of $this->_data

	 *

	 * @var int

	 */

	private $_dataSize;



	/**

	 * Current position in stream

	 *

	 * @var integer

	 */

	private $_pos;



	/**

	 * Workbook to be returned by the reader.

	 *

	 * @var PHPExcel

	 */

	private $_phpExcel;



	/**

	 * Worksheet that is currently being built by the reader.

	 *

	 * @var PHPExcel_Worksheet

	 */

	private $_phpSheet;



	/**

	 * BIFF version

	 *

	 * @var int

	 */

	private $_version;



	/**

	 * Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95)

	 * For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE'

	 *

	 * @var string

	 */

	private $_codepage;



	/**

	 * Shared formats

	 *

	 * @var array

	 */

	private $_formats;



	/**

	 * Shared fonts

	 *

	 * @var array

	 */

	private $_objFonts;



	/**

	 * Color palette

	 *

	 * @var array

	 */

	private $_palette;



	/**

	 * Worksheets

	 *

	 * @var array

	 */

	private $_sheets;



	/**

	 * External books

	 *

	 * @var array

	 */

	private $_externalBooks;



	/**

	 * REF structures. Only applies to BIFF8.

	 *

	 * @var array

	 */

	private $_ref;



	/**

	 * External names

	 *

	 * @var array

	 */

	private $_externalNames;



	/**

	 * Defined names

	 *

	 * @var array

	 */

	private $_definedname;



	/**

	 * Shared strings. Only applies to BIFF8.

	 *

	 * @var array

	 */

	private $_sst;



	/**

	 * Panes are frozen? (in sheet currently being read). See WINDOW2 record.

	 *

	 * @var boolean

	 */

	private $_frozen;



	/**

	 * Fit printout to number of pages? (in sheet currently being read). See SHEETPR record.

	 *

	 * @var boolean

	 */

	private $_isFitToPages;



	/**

	 * Objects. One OBJ record contributes with one entry.

	 *

	 * @var array

	 */

	private $_objs;



	/**

	 * Text Objects. One TXO record corresponds with one entry.

	 *

	 * @var array

	 */

	private $_textObjects;



	/**

	 * Cell Annotations (BIFF8)

	 *

	 * @var array

	 */

	private $_cellNotes;



	/**

	 * The combined MSODRAWINGGROUP data

	 *

	 * @var string

	 */

	private $_drawingGroupData;



	/**

	 * The combined MSODRAWING data (per sheet)

	 *

	 * @var string

	 */

	private $_drawingData;



	/**

	 * Keep track of XF index

	 *

	 * @var int

	 */

	private $_xfIndex;



	/**

	 * Mapping of XF index (that is a cell XF) to final index in cellXf collection

	 *

	 * @var array

	 */

	private $_mapCellXfIndex;



	/**

	 * Mapping of XF index (that is a style XF) to final index in cellStyleXf collection

	 *

	 * @var array

	 */

	private $_mapCellStyleXfIndex;



	/**

	 * The shared formulas in a sheet. One SHAREDFMLA record contributes with one value.

	 *

	 * @var array

	 */

	private $_sharedFormulas;



	/**

	 * The shared formula parts in a sheet. One FORMULA record contributes with one value if it

	 * refers to a shared formula.

	 *

	 * @var array

	 */

	private $_sharedFormulaParts;





	/**

	 * Create a new PHPExcel_Reader_Excel5 instance

	 */

	public function __construct() {

		$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter();

	}





	/**

	 * Read data only?

	 *		If this is true, then the Reader will only read data values for cells, it will not read any formatting information.

	 *		If false (the default) it will read data and formatting.

	 *

	 * @return	boolean

	 */

	public function getReadDataOnly()

	{

		return $this->_readDataOnly;

	}





	/**

	 * Set read data only

	 *		Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information.

	 *		Set to false (the default) to advise the Reader to read both data and formatting for cells.

	 *

	 * @param	boolean	$pValue

	 *

	 * @return	PHPExcel_Reader_Excel5

	 */

	public function setReadDataOnly($pValue = false)

	{

		$this->_readDataOnly = $pValue;

		return $this;

	}





	/**

	 * Get which sheets to load

	 *		Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null

	 *			indicating that all worksheets in the workbook should be loaded.

	 *

	 * @return mixed

	 */

	public function getLoadSheetsOnly()

	{

		return $this->_loadSheetsOnly;

	}





	/**

	 * Set which sheets to load

	 *

	 * @param mixed $value

	 *		This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name.

	 *		If NULL, then it tells the Reader to read all worksheets in the workbook

	 *

	 * @return PHPExcel_Reader_Excel5

	 */

	public function setLoadSheetsOnly($value = null)

	{

		$this->_loadSheetsOnly = is_array($value) ?

			$value : array($value);

		return $this;

	}





	/**

	 * Set all sheets to load

	 *		Tells the Reader to load all worksheets from the workbook.

	 *

	 * @return	PHPExcel_Reader_Excel5

	 */

	public function setLoadAllSheets()

	{

		$this->_loadSheetsOnly = null;

		return $this;

	}





	/**

	 * Read filter

	 *

	 * @return PHPExcel_Reader_IReadFilter

	 */

	public function getReadFilter() {

		return $this->_readFilter;

	}





	/**

	 * Set read filter

	 *

	 * @param PHPExcel_Reader_IReadFilter $pValue

	 * @return PHPExcel_Reader_Excel5

	 */

	public function setReadFilter(PHPExcel_Reader_IReadFilter $pValue) {

		$this->_readFilter = $pValue;

		return $this;

	}





	/**

	 * Can the current PHPExcel_Reader_IReader read the file?

	 *

	 * @param 	string 		$pFileName

	 * @return 	boolean

	 * @throws Exception

	 */

	public function canRead($pFilename)

	{

		// Check if file exists

		if (!file_exists($pFilename)) {

			throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");

		}



		try {

			// Use ParseXL for the hard work.

			$ole = new PHPExcel_Shared_OLERead();



			// get excel data

			$res = $ole->read($pFilename);

			return true;



		} catch (Exception $e) {

			return false;

		}

	}





	/**

	 * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object

	 *

	 * @param 	string 		$pFilename

	 * @throws 	Exception

	 */

	public function listWorksheetNames($pFilename)

	{

		// Check if file exists

		if (!file_exists($pFilename)) {

			throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");

		}



		$worksheetNames = array();



		// Read the OLE file

		$this->_loadOLE($pFilename);



		// total byte size of Excel data (workbook global substream + sheet substreams)

		$this->_dataSize = strlen($this->_data);



		$this->_pos		= 0;

		$this->_sheets	= array();



		// Parse Workbook Global Substream

		while ($this->_pos < $this->_dataSize) {

			$code = self::_GetInt2d($this->_data, $this->_pos);



			switch ($code) {

				case self::XLS_Type_BOF:	$this->_readBof();		break;

				case self::XLS_Type_SHEET:	$this->_readSheet();	break;

				case self::XLS_Type_EOF:	$this->_readDefault();	break 2;

				default:					$this->_readDefault();	break;

			}

		}



		foreach ($this->_sheets as $sheet) {

			if ($sheet['sheetType'] != 0x00) {

				// 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module

				continue;

			}



			$worksheetNames[] = $sheet['name'];

		}



		return $worksheetNames;

	}





	/**

	 * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)

	 *

	 * @param   string     $pFilename

	 * @throws   Exception

	 */

	public function listWorksheetInfo($pFilename)

	{

		// Check if file exists

		if (!file_exists($pFilename)) {

			throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");

		}



		$worksheetInfo = array();



		// Read the OLE file

		$this->_loadOLE($pFilename);



		// total byte size of Excel data (workbook global substream + sheet substreams)

		$this->_dataSize = strlen($this->_data);



		// initialize

		$this->_pos    = 0;

		$this->_sheets = array();



		// Parse Workbook Global Substream

		while ($this->_pos < $this->_dataSize) {

			$code = self::_GetInt2d($this->_data, $this->_pos);



			switch ($code) {

				case self::XLS_Type_BOF:        $this->_readBof();        break;

				case self::XLS_Type_SHEET:      $this->_readSheet();      break;

				case self::XLS_Type_EOF:        $this->_readDefault();    break 2;

				default:                        $this->_readDefault();    break;

			}

		}



		// Parse the individual sheets

		foreach ($this->_sheets as $sheet) {



			if ($sheet['sheetType'] != 0x00) {

				// 0x00: Worksheet

				// 0x02: Chart

				// 0x06: Visual Basic module

				continue;

			}



			$tmpInfo = array();

			$tmpInfo['worksheetName'] = $sheet['name'];

			$tmpInfo['lastColumnLetter'] = 'A';

			$tmpInfo['lastColumnIndex'] = 0;

			$tmpInfo['totalRows'] = 0;

			$tmpInfo['totalColumns'] = 0;



			$this->_pos = $sheet['offset'];



			while ($this->_pos <= $this->_dataSize - 4) {

				$code = self::_GetInt2d($this->_data, $this->_pos);



				switch ($code) {

					case self::XLS_Type_RK:

					case self::XLS_Type_LABELSST:

					case self::XLS_Type_NUMBER:

					case self::XLS_Type_FORMULA:

					case self::XLS_Type_BOOLERR:

					case self::XLS_Type_LABEL:

						$length = self::_GetInt2d($this->_data, $this->_pos + 2);

						$recordData = substr($this->_data, $this->_pos + 4, $length);



						// move stream pointer to next record

						$this->_pos += 4 + $length;



						$rowIndex = self::_GetInt2d($recordData, 0) + 1;

						$columnIndex = self::_GetInt2d($recordData, 2);



						$tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex);

						$tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex);

						break;

					case self::XLS_Type_BOF:      $this->_readBof();          break;

					case self::XLS_Type_EOF:      $this->_readDefault();      break 2;

					default:                      $this->_readDefault();      break;

				}

			}



			$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);

			$tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;



			$worksheetInfo[] = $tmpInfo;

		}



		return $worksheetInfo;

	}





	/**

	 * Loads PHPExcel from file

	 *

	 * @param 	string 		$pFilename

	 * @return 	PHPExcel

	 * @throws 	Exception

	 */

	public function load($pFilename)

	{

		// Read the OLE file

		$this->_loadOLE($pFilename);



		// Initialisations

		$this->_phpExcel = new PHPExcel;

		$this->_phpExcel->removeSheetByIndex(0); // remove 1st sheet

		if (!$this->_readDataOnly) {

			$this->_phpExcel->removeCellStyleXfByIndex(0); // remove the default style

			$this->_phpExcel->removeCellXfByIndex(0); // remove the default style

		}



		// Read the summary information stream (containing meta data)

		$this->_readSummaryInformation();



		// Read the Additional document summary information stream (containing application-specific meta data)

		$this->_readDocumentSummaryInformation();



		// total byte size of Excel data (workbook global substream + sheet substreams)

		$this->_dataSize = strlen($this->_data);



		// initialize

		$this->_pos					= 0;

		$this->_codepage			= 'CP1252';

		$this->_formats				= array();

		$this->_objFonts			= array();

		$this->_palette				= array();

		$this->_sheets				= array();

		$this->_externalBooks		= array();

		$this->_ref					= array();

		$this->_definedname			= array();

		$this->_sst					= array();

		$this->_drawingGroupData	= '';

		$this->_xfIndex				= '';

		$this->_mapCellXfIndex		= array();

		$this->_mapCellStyleXfIndex	= array();



		// Parse Workbook Global Substream

		while ($this->_pos < $this->_dataSize) {

			$code = self::_GetInt2d($this->_data, $this->_pos);



			switch ($code) {

				case self::XLS_Type_BOF:			$this->_readBof();				break;

				case self::XLS_Type_FILEPASS:		$this->_readFilepass();			break;

				case self::XLS_Type_CODEPAGE:		$this->_readCodepage();			break;

				case self::XLS_Type_DATEMODE:		$this->_readDateMode();			break;

				case self::XLS_Type_FONT:			$this->_readFont();				break;

				case self::XLS_Type_FORMAT:			$this->_readFormat();			break;

				case self::XLS_Type_XF:				$this->_readXf();				break;

				case self::XLS_Type_XFEXT:			$this->_readXfExt();			break;

				case self::XLS_Type_STYLE:			$this->_readStyle();			break;

				case self::XLS_Type_PALETTE:		$this->_readPalette();			break;

				case self::XLS_Type_SHEET:			$this->_readSheet();			break;

				case self::XLS_Type_EXTERNALBOOK:	$this->_readExternalBook();		break;

				case self::XLS_Type_EXTERNNAME:		$this->_readExternName();		break;

				case self::XLS_Type_EXTERNSHEET:	$this->_readExternSheet();		break;

				case self::XLS_Type_DEFINEDNAME:	$this->_readDefinedName();		break;

				case self::XLS_Type_MSODRAWINGGROUP:	$this->_readMsoDrawingGroup();	break;

				case self::XLS_Type_SST:			$this->_readSst();				break;

				case self::XLS_Type_EOF:			$this->_readDefault();			break 2;

				default:							$this->_readDefault();			break;

			}

		}



		// Resolve indexed colors for font, fill, and border colors

		// Cannot be resolved already in XF record, because PALETTE record comes afterwards

		if (!$this->_readDataOnly) {

			foreach ($this->_objFonts as $objFont) {

				if (isset($objFont->colorIndex)) {

					$color = self::_readColor($objFont->colorIndex,$this->_palette,$this->_version);

					$objFont->getColor()->setRGB($color['rgb']);

				}

			}



			foreach ($this->_phpExcel->getCellXfCollection() as $objStyle) {

				// fill start and end color

				$fill = $objStyle->getFill();



				if (isset($fill->startcolorIndex)) {

					$startColor = self::_readColor($fill->startcolorIndex,$this->_palette,$this->_version);

					$fill->getStartColor()->setRGB($startColor['rgb']);

				}



				if (isset($fill->endcolorIndex)) {

					$endColor = self::_readColor($fill->endcolorIndex,$this->_palette,$this->_version);

					$fill->getEndColor()->setRGB($endColor['rgb']);

				}



				// border colors

				$top      = $objStyle->getBorders()->getTop();

				$right    = $objStyle->getBorders()->getRight();

				$bottom   = $objStyle->getBorders()->getBottom();

				$left     = $objStyle->getBorders()->getLeft();

				$diagonal = $objStyle->getBorders()->getDiagonal();



				if (isset($top->colorIndex)) {

					$borderTopColor = self::_readColor($top->colorIndex,$this->_palette,$this->_version);

					$top->getColor()->setRGB($borderTopColor['rgb']);

				}



				if (isset($right->colorIndex)) {

					$borderRightColor = self::_readColor($right->colorIndex,$this->_palette,$this->_version);

					$right->getColor()->setRGB($borderRightColor['rgb']);

				}



				if (isset($bottom->colorIndex)) {

					$borderBottomColor = self::_readColor($bottom->colorIndex,$this->_palette,$this->_version);

					$bottom->getColor()->setRGB($borderBottomColor['rgb']);

				}



				if (isset($left->colorIndex)) {

					$borderLeftColor = self::_readColor($left->colorIndex,$this->_palette,$this->_version);

					$left->getColor()->setRGB($borderLeftColor['rgb']);

				}



				if (isset($diagonal->colorIndex)) {

					$borderDiagonalColor = self::_readColor($diagonal->colorIndex,$this->_palette,$this->_version);

					$diagonal->getColor()->setRGB($borderDiagonalColor['rgb']);

				}

			}

		}



		// treat MSODRAWINGGROUP records, workbook-level Escher

		if (!$this->_readDataOnly && $this->_drawingGroupData) {

			$escherWorkbook = new PHPExcel_Shared_Escher();

			$reader = new PHPExcel_Reader_Excel5_Escher($escherWorkbook);

			$escherWorkbook = $reader->load($this->_drawingGroupData);



			// debug Escher stream

			//$debug = new Debug_Escher(new PHPExcel_Shared_Escher());

			//$debug->load($this->_drawingGroupData);

		}



		// Parse the individual sheets

		foreach ($this->_sheets as $sheet) {



			if ($sheet['sheetType'] != 0x00) {

				// 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module

				continue;

			}



			// check if sheet should be skipped

			if (isset($this->_loadSheetsOnly) && !in_array($sheet['name'], $this->_loadSheetsOnly)) {

				continue;

			}



			// add sheet to PHPExcel object

			$this->_phpSheet = $this->_phpExcel->createSheet();

			//	Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula

			//		cells... during the load, all formulae should be correct, and we're simply bringing the worksheet

			//		name in line with the formula, not the reverse

			$this->_phpSheet->setTitle($sheet['name'],false);

			$this->_phpSheet->setSheetState($sheet['sheetState']);



			$this->_pos = $sheet['offset'];



			// Initialize isFitToPages. May change after reading SHEETPR record.

			$this->_isFitToPages = false;



			// Initialize drawingData

			$this->_drawingData = '';



			// Initialize objs

			$this->_objs = array();



			// Initialize shared formula parts

			$this->_sharedFormulaParts = array();



			// Initialize shared formulas

			$this->_sharedFormulas = array();



			// Initialize text objs

			$this->_textObjects = array();



			// Initialize cell annotations

			$this->_cellNotes = array();

			$this->textObjRef = -1;



			while ($this->_pos <= $this->_dataSize - 4) {

				$code = self::_GetInt2d($this->_data, $this->_pos);



				switch ($code) {

					case self::XLS_Type_BOF:					$this->_readBof();						break;

					case self::XLS_Type_PRINTGRIDLINES:			$this->_readPrintGridlines();			break;

					case self::XLS_Type_DEFAULTROWHEIGHT:		$this->_readDefaultRowHeight();			break;

					case self::XLS_Type_SHEETPR:				$this->_readSheetPr();					break;

					case self::XLS_Type_HORIZONTALPAGEBREAKS:	$this->_readHorizontalPageBreaks();		break;

					case self::XLS_Type_VERTICALPAGEBREAKS:		$this->_readVerticalPageBreaks();		break;

					case self::XLS_Type_HEADER:					$this->_readHeader();					break;

					case self::XLS_Type_FOOTER:					$this->_readFooter();					break;

					case self::XLS_Type_HCENTER:				$this->_readHcenter();					break;

					case self::XLS_Type_VCENTER:				$this->_readVcenter();					break;

					case self::XLS_Type_LEFTMARGIN:				$this->_readLeftMargin();				break;

					case self::XLS_Type_RIGHTMARGIN:			$this->_readRightMargin();				break;

					case self::XLS_Type_TOPMARGIN:				$this->_readTopMargin();				break;

					case self::XLS_Type_BOTTOMMARGIN:			$this->_readBottomMargin();				break;

					case self::XLS_Type_PAGESETUP:				$this->_readPageSetup();				break;

					case self::XLS_Type_PROTECT:				$this->_readProtect();					break;

					case self::XLS_Type_SCENPROTECT:			$this->_readScenProtect();				break;

					case self::XLS_Type_OBJECTPROTECT:			$this->_readObjectProtect();			break;

					case self::XLS_Type_PASSWORD:				$this->_readPassword();					break;

					case self::XLS_Type_DEFCOLWIDTH:			$this->_readDefColWidth();				break;

					case self::XLS_Type_COLINFO:				$this->_readColInfo();					break;

					case self::XLS_Type_DIMENSION:				$this->_readDefault();					break;

					case self::XLS_Type_ROW:					$this->_readRow();						break;

					case self::XLS_Type_DBCELL:					$this->_readDefault();					break;

					case self::XLS_Type_RK:						$this->_readRk();						break;

					case self::XLS_Type_LABELSST:				$this->_readLabelSst();					break;

					case self::XLS_Type_MULRK:					$this->_readMulRk();					break;

					case self::XLS_Type_NUMBER:					$this->_readNumber();					break;

					case self::XLS_Type_FORMULA:				$this->_readFormula();					break;

					case self::XLS_Type_SHAREDFMLA:				$this->_readSharedFmla();				break;

					case self::XLS_Type_BOOLERR:				$this->_readBoolErr();					break;

					case self::XLS_Type_MULBLANK:				$this->_readMulBlank();					break;

					case self::XLS_Type_LABEL:					$this->_readLabel();					break;

					case self::XLS_Type_BLANK:					$this->_readBlank();					break;

					case self::XLS_Type_MSODRAWING:				$this->_readMsoDrawing();				break;

					case self::XLS_Type_OBJ:					$this->_readObj();						break;

					case self::XLS_Type_WINDOW2:				$this->_readWindow2();					break;

					case self::XLS_Type_SCL:					$this->_readScl();						break;

					case self::XLS_Type_PANE:					$this->_readPane();						break;

					case self::XLS_Type_SELECTION:				$this->_readSelection();				break;

					case self::XLS_Type_MERGEDCELLS:			$this->_readMergedCells();				break;

					case self::XLS_Type_HYPERLINK:				$this->_readHyperLink();				break;

					case self::XLS_Type_DATAVALIDATIONS:		$this->_readDataValidations();			break;

					case self::XLS_Type_DATAVALIDATION:			$this->_readDataValidation();			break;

					case self::XLS_Type_SHEETLAYOUT:			$this->_readSheetLayout();				break;

					case self::XLS_Type_SHEETPROTECTION:		$this->_readSheetProtection();			break;

					case self::XLS_Type_RANGEPROTECTION:		$this->_readRangeProtection();			break;

					case self::XLS_Type_NOTE:					$this->_readNote();						break;

					//case self::XLS_Type_IMDATA:				$this->_readImData();					break;

					case self::XLS_Type_TXO:					$this->_readTextObject();				break;

					case self::XLS_Type_CONTINUE:				$this->_readContinue();					break;

					case self::XLS_Type_EOF:					$this->_readDefault();					break 2;

					default:									$this->_readDefault();					break;

				}



			}



			// treat MSODRAWING records, sheet-level Escher

			if (!$this->_readDataOnly && $this->_drawingData) {

				$escherWorksheet = new PHPExcel_Shared_Escher();

				$reader = new PHPExcel_Reader_Excel5_Escher($escherWorksheet);

				$escherWorksheet = $reader->load($this->_drawingData);



				// debug Escher stream

				//$debug = new Debug_Escher(new PHPExcel_Shared_Escher());

				//$debug->load($this->_drawingData);



				// get all spContainers in one long array, so they can be mapped to OBJ records

				$allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers();

			}



			// treat OBJ records

			foreach ($this->_objs as $n => $obj) {

//				echo '<hr /><b>Object</b> reference is ',$n,'<br />';

//				var_dump($obj);

//				echo '<br />';



				// the first shape container never has a corresponding OBJ record, hence $n + 1

				if (isset($allSpContainers[$n + 1]) && is_object($allSpContainers[$n + 1])) {

					$spContainer = $allSpContainers[$n + 1];



					// we skip all spContainers that are a part of a group shape since we cannot yet handle those

					if ($spContainer->getNestingLevel() > 1) {

						continue;

					}



					// calculate the width and height of the shape

					list($startColumn, $startRow) = PHPExcel_Cell::coordinateFromString($spContainer->getStartCoordinates());

					list($endColumn, $endRow) = PHPExcel_Cell::coordinateFromString($spContainer->getEndCoordinates());



					$startOffsetX = $spContainer->getStartOffsetX();

					$startOffsetY = $spContainer->getStartOffsetY();

					$endOffsetX = $spContainer->getEndOffsetX();

					$endOffsetY = $spContainer->getEndOffsetY();



					$width = PHPExcel_Shared_Excel5::getDistanceX($this->_phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX);

					$height = PHPExcel_Shared_Excel5::getDistanceY($this->_phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY);



					// calculate offsetX and offsetY of the shape

					$offsetX = $startOffsetX * PHPExcel_Shared_Excel5::sizeCol($this->_phpSheet, $startColumn) / 1024;

					$offsetY = $startOffsetY * PHPExcel_Shared_Excel5::sizeRow($this->_phpSheet, $startRow) / 256;



					switch ($obj['otObjType']) {

						case 0x19:

							// Note

//							echo 'Cell Annotation Object<br />';

//							echo 'Object ID is ',$obj['idObjID'],'<br />';

//

							if (isset($this->_cellNotes[$obj['idObjID']])) {

								$cellNote = $this->_cellNotes[$obj['idObjID']];



								if (isset($this->_textObjects[$obj['idObjID']])) {

									$textObject = $this->_textObjects[$obj['idObjID']];

									$this->_cellNotes[$obj['idObjID']]['objTextData'] = $textObject;

								}

							}

							break;



						case 0x08:

//							echo 'Picture Object<br />';

							// picture



							// get index to BSE entry (1-based)

							$BSEindex = $spContainer->getOPT(0x0104);

							$BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection();

							$BSE = $BSECollection[$BSEindex - 1];

							$blipType = $BSE->getBlipType();



							// need check because some blip types are not supported by Escher reader such as EMF

							if ($blip = $BSE->getBlip()) {

								$ih = imagecreatefromstring($blip->getData());

								$drawing = new PHPExcel_Worksheet_MemoryDrawing();

								$drawing->setImageResource($ih);



								// width, height, offsetX, offsetY

								$drawing->setResizeProportional(false);

								$drawing->setWidth($width);

								$drawing->setHeight($height);

								$drawing->setOffsetX($offsetX);

								$drawing->setOffsetY($offsetY);



								switch ($blipType) {

									case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG:

										$drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_JPEG);

										$drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_JPEG);

										break;



									case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG:

										$drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_PNG);

										$drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_PNG);

										break;

								}



								$drawing->setWorksheet($this->_phpSheet);

								$drawing->setCoordinates($spContainer->getStartCoordinates());

							}



							break;



						default:

							// other object type

							break;



					}

				}

			}



			// treat SHAREDFMLA records

			if ($this->_version == self::XLS_BIFF8) {

				foreach ($this->_sharedFormulaParts as $cell => $baseCell) {

					list($column, $row) = PHPExcel_Cell::coordinateFromString($cell);

					if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()) ) {

						$formula = $this->_getFormulaFromStructure($this->_sharedFormulas[$baseCell], $cell);

						$this->_phpSheet->getCell($cell)->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);

					}

				}

			}



			if (!empty($this->_cellNotes)) {

				foreach($this->_cellNotes as $note => $noteDetails) {

					if (!isset($noteDetails['objTextData'])) {

						if (isset($this->_textObjects[$note])) {

							$textObject = $this->_textObjects[$note];

							$noteDetails['objTextData'] = $textObject;

						} else {

							$noteDetails['objTextData']['text'] = '';

						}

					}

//					echo '<b>Cell annotation ',$note,'</b><br />';

//					var_dump($noteDetails);

//					echo '<br />';

					$cellAddress = str_replace('$','',$noteDetails['cellRef']);

					$this->_phpSheet->getComment( $cellAddress )

													->setAuthor( $noteDetails['author'] )

													->setText($this->_parseRichText($noteDetails['objTextData']['text']) );

				}

			}

		}



		// add the named ranges (defined names)

		foreach ($this->_definedname as $definedName) {

			if ($definedName['isBuiltInName']) {

				switch ($definedName['name']) {



				case pack('C', 0x06):

					// print area

					//	in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2



					$ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?



					$extractedRanges = array();

					foreach ($ranges as $range) {

						// $range should look like one of these

						//		Foo!$C$7:$J$66

						//		Bar!$A$1:$IV$2



						$explodes = explode('!', $range);	// FIXME: what if sheetname contains exclamation mark?

						$sheetName = $explodes[0];



						if (count($explodes) == 2) {

							$extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66

						}

					}

					if ($docSheet = $this->_phpExcel->getSheetByName($sheetName)) {

						$docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2

					}

					break;



				case pack('C', 0x07):

					// print titles (repeating rows)

					// Assuming BIFF8, there are 3 cases

					// 1. repeating rows

					//		formula looks like this: Sheet!$A$1:$IV$2

					//		rows 1-2 repeat

					// 2. repeating columns

					//		formula looks like this: Sheet!$A$1:$B$65536

					//		columns A-B repeat

					// 3. both repeating rows and repeating columns

					//		formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2



					$ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?



					foreach ($ranges as $range) {

						// $range should look like this one of these

						//		Sheet!$A$1:$B$65536

						//		Sheet!$A$1:$IV$2



						$explodes = explode('!', $range);



						if (count($explodes) == 2) {

							if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) {



								$extractedRange = $explodes[1];

								$extractedRange = str_replace('$', '', $extractedRange);



								$coordinateStrings = explode(':', $extractedRange);

								if (count($coordinateStrings) == 2) {

									list($firstColumn, $firstRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[0]);

									list($lastColumn, $lastRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[1]);



									if ($firstColumn == 'A' and $lastColumn == 'IV') {

										// then we have repeating rows

										$docSheet->getPageSetup()->setRowsToRepeatAtTop(array($firstRow, $lastRow));

									} elseif ($firstRow == 1 and $lastRow == 65536) {

										// then we have repeating columns

										$docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array($firstColumn, $lastColumn));

									}

								}

							}

						}

					}

					break;



				}

			} else {

				// Extract range

				$explodes = explode('!', $definedName['formula']);



				if (count($explodes) == 2) {

					if (($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) ||

						($docSheet = $this->_phpExcel->getSheetByName(trim($explodes[0],"'")))) {

						$extractedRange = $explodes[1];

						$extractedRange = str_replace('$', '', $extractedRange);



						$localOnly = ($definedName['scope'] == 0) ? false : true;



						$scope = ($definedName['scope'] == 0) ?

							null : $this->_phpExcel->getSheetByName($this->_sheets[$definedName['scope'] - 1]['name']);



						$this->_phpExcel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $docSheet, $extractedRange, $localOnly, $scope) );

					}

				} else {

					//	Named Value

					//	TODO Provide support for named values

				}

			}

		}



		return $this->_phpExcel;

	}





	/**

	 * Use OLE reader to extract the relevant data streams from the OLE file

	 *

	 * @param string $pFilename

	 */

	private function _loadOLE($pFilename)

	{

		// OLE reader

		$ole = new PHPExcel_Shared_OLERead();



		// get excel data,

		$res = $ole->read($pFilename);

		// Get workbook data: workbook stream + sheet streams

		$this->_data = $ole->getStream($ole->wrkbook);



		// Get summary information data

		$this->_summaryInformation = $ole->getStream($ole->summaryInformation);



		// Get additional document summary information data

		$this->_documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation);



		// Get user-defined property data

//		$this->_userDefinedProperties = $ole->getUserDefinedProperties();

	}





	/**

	 * Read summary information

	 */

	private function _readSummaryInformation()

	{

		if (!isset($this->_summaryInformation)) {

			return;

		}



		// offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)

		// offset: 2; size: 2;

		// offset: 4; size: 2; OS version

		// offset: 6; size: 2; OS indicator

		// offset: 8; size: 16

		// offset: 24; size: 4; section count

		$secCount = self::_GetInt4d($this->_summaryInformation, 24);



		// offset: 28; size: 16; first section's class id: e0 85 9f f2 f9 4f 68 10 ab 91 08 00 2b 27 b3 d9

		// offset: 44; size: 4

		$secOffset = self::_GetInt4d($this->_summaryInformation, 44);



		// section header

		// offset: $secOffset; size: 4; section length

		$secLength = self::_GetInt4d($this->_summaryInformation, $secOffset);



		// offset: $secOffset+4; size: 4; property count

		$countProperties = self::_GetInt4d($this->_summaryInformation, $secOffset+4);



		// initialize code page (used to resolve string values)

		$codePage = 'CP1252';



		// offset: ($secOffset+8); size: var

		// loop through property decarations and properties

		for ($i = 0; $i < $countProperties; ++$i) {



			// offset: ($secOffset+8) + (8 * $i); size: 4; property ID

			$id = self::_GetInt4d($this->_summaryInformation, ($secOffset+8) + (8 * $i));



			// Use value of property id as appropriate

			// offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48)

			$offset = self::_GetInt4d($this->_summaryInformation, ($secOffset+12) + (8 * $i));



			$type = self::_GetInt4d($this->_summaryInformation, $secOffset + $offset);



			// initialize property value

			$value = null;



			// extract property value based on property type

			switch ($type) {

				case 0x02: // 2 byte signed integer

					$value = self::_GetInt2d($this->_summaryInformation, $secOffset + 4 + $offset);

					break;



				case 0x03: // 4 byte signed integer

					$value = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);

					break;



				case 0x13: // 4 byte unsigned integer

					// not needed yet, fix later if necessary

					break;



				case 0x1E: // null-terminated string prepended by dword string length

					$byteLength = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);

					$value = substr($this->_summaryInformation, $secOffset + 8 + $offset, $byteLength);

					$value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);

					$value = rtrim($value);

					break;



				case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)

					// PHP-time

					$value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_summaryInformation, $secOffset + 4 + $offset, 8));

					break;



				case 0x47: // Clipboard format

					// not needed yet, fix later if necessary

					break;

			}



			switch ($id) {

				case 0x01:	//	Code Page

					$codePage = PHPExcel_Shared_CodePage::NumberToName($value);

					break;



				case 0x02:	//	Title

					$this->_phpExcel->getProperties()->setTitle($value);

					break;



				case 0x03:	//	Subject

					$this->_phpExcel->getProperties()->setSubject($value);

					break;



				case 0x04:	//	Author (Creator)

					$this->_phpExcel->getProperties()->setCreator($value);

					break;



				case 0x05:	//	Keywords

					$this->_phpExcel->getProperties()->setKeywords($value);

					break;



				case 0x06:	//	Comments (Description)

					$this->_phpExcel->getProperties()->setDescription($value);

					break;



				case 0x07:	//	Template

					//	Not supported by PHPExcel

					break;



				case 0x08:	//	Last Saved By (LastModifiedBy)

					$this->_phpExcel->getProperties()->setLastModifiedBy($value);

					break;



				case 0x09:	//	Revision

					//	Not supported by PHPExcel

					break;



				case 0x0A:	//	Total Editing Time

					//	Not supported by PHPExcel

					break;



				case 0x0B:	//	Last Printed

					//	Not supported by PHPExcel

					break;



				case 0x0C:	//	Created Date/Time

					$this->_phpExcel->getProperties()->setCreated($value);

					break;



				case 0x0D:	//	Modified Date/Time

					$this->_phpExcel->getProperties()->setModified($value);

					break;



				case 0x0E:	//	Number of Pages

					//	Not supported by PHPExcel

					break;



				case 0x0F:	//	Number of Words

					//	Not supported by PHPExcel

					break;



				case 0x10:	//	Number of Characters

					//	Not supported by PHPExcel

					break;



				case 0x11:	//	Thumbnail

					//	Not supported by PHPExcel

					break;



				case 0x12:	//	Name of creating application

					//	Not supported by PHPExcel

					break;



				case 0x13:	//	Security

					//	Not supported by PHPExcel

					break;



			}

		}

	}





	/**

	 * Read additional document summary information

	 */

	private function _readDocumentSummaryInformation()

	{

		if (!isset($this->_documentSummaryInformation)) {

			return;

		}



		//	offset: 0;	size: 2;	must be 0xFE 0xFF (UTF-16 LE byte order mark)

		//	offset: 2;	size: 2;

		//	offset: 4;	size: 2;	OS version

		//	offset: 6;	size: 2;	OS indicator

		//	offset: 8;	size: 16

		//	offset: 24;	size: 4;	section count

		$secCount = self::_GetInt4d($this->_documentSummaryInformation, 24);

//		echo '$secCount = ',$secCount,'<br />';



		// offset: 28;	size: 16;	first section's class id: 02 d5 cd d5 9c 2e 1b 10 93 97 08 00 2b 2c f9 ae

		// offset: 44;	size: 4;	first section offset

		$secOffset = self::_GetInt4d($this->_documentSummaryInformation, 44);

//		echo '$secOffset = ',$secOffset,'<br />';



		//	section header

		//	offset: $secOffset;	size: 4;	section length

		$secLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset);

//		echo '$secLength = ',$secLength,'<br />';



		//	offset: $secOffset+4;	size: 4;	property count

		$countProperties = self::_GetInt4d($this->_documentSummaryInformation, $secOffset+4);

//		echo '$countProperties = ',$countProperties,'<br />';



		// initialize code page (used to resolve string values)

		$codePage = 'CP1252';



		//	offset: ($secOffset+8);	size: var

		//	loop through property decarations and properties

		for ($i = 0; $i < $countProperties; ++$i) {

//			echo 'Property ',$i,'<br />';

			//	offset: ($secOffset+8) + (8 * $i);	size: 4;	property ID

			$id = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+8) + (8 * $i));

//			echo 'ID is ',$id,'<br />';



			// Use value of property id as appropriate

			// offset: 60 + 8 * $i;	size: 4;	offset from beginning of section (48)

			$offset = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+12) + (8 * $i));



			$type = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + $offset);

//			echo 'Type is ',$type,', ';



			// initialize property value

			$value = null;



			// extract property value based on property type

			switch ($type) {

				case 0x02:	//	2 byte signed integer

					$value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

					break;



				case 0x03:	//	4 byte signed integer

					$value = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

					break;



				case 0x0B:  // Boolean

					$value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

					$value = ($value == 0 ? false : true);

					break;



				case 0x13:	//	4 byte unsigned integer

					// not needed yet, fix later if necessary

					break;



				case 0x1E:	//	null-terminated string prepended by dword string length

					$byteLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);

					$value = substr($this->_documentSummaryInformation, $secOffset + 8 + $offset, $byteLength);

					$value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);

					$value = rtrim($value);

					break;



				case 0x40:	//	Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)

					// PHP-Time

					$value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_documentSummaryInformation, $secOffset + 4 + $offset, 8));

					break;



				case 0x47:	//	Clipboard format

					// not needed yet, fix later if necessary

					break;

			}



			switch ($id) {

				case 0x01:	//	Code Page

					$codePage = PHPExcel_Shared_CodePage::NumberToName($value);

					break;



				case 0x02:	//	Category

					$this->_phpExcel->getProperties()->setCategory($value);

					break;



				case 0x03:	//	Presentation Target

					//	Not supported by PHPExcel

					break;



				case 0x04:	//	Bytes

					//	Not supported by PHPExcel

					break;



				case 0x05:	//	Lines

					//	Not supported by PHPExcel

					break;



				case 0x06:	//	Paragraphs

					//	Not supported by PHPExcel

					break;



				case 0x07:	//	Slides

					//	Not supported by PHPExcel

					break;



				case 0x08:	//	Notes

					//	Not supported by PHPExcel

					break;



				case 0x09:	//	Hidden Slides

					//	Not supported by PHPExcel

					break;



				case 0x0A:	//	MM Clips

					//	Not supported by PHPExcel

					break;



				case 0x0B:	//	Scale Crop

					//	Not supported by PHPExcel

					break;



				case 0x0C:	//	Heading Pairs

					//	Not supported by PHPExcel

					break;



				case 0x0D:	//	Titles of Parts

					//	Not supported by PHPExcel

					break;



				case 0x0E:	//	Manager

					$this->_phpExcel->getProperties()->setManager($value);

					break;



				case 0x0F:	//	Company

					$this->_phpExcel->getProperties()->setCompany($value);

					break;



				case 0x10:	//	Links up-to-date

					//	Not supported by PHPExcel

					break;



			}

		}

	}





	/**

	 * Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record.

	 */

	private function _readDefault()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

//		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;

	}





	/**

	 *	The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions,

	 *		this record stores a note (cell note). This feature was significantly enhanced in Excel 97.

	 */

	private function _readNote()

	{

//		echo '<b>Read Cell Annotation</b><br />';

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		$cellAddress = $this->_readBIFF8CellAddress(substr($recordData, 0, 4));

		if ($this->_version == self::XLS_BIFF8) {

			$noteObjID = self::_GetInt2d($recordData, 6);

			$noteAuthor = self::_readUnicodeStringLong(substr($recordData, 8));

			$noteAuthor = $noteAuthor['value'];

//			echo 'Note Address=',$cellAddress,'<br />';

//			echo 'Note Object ID=',$noteObjID,'<br />';

//			echo 'Note Author=',$noteAuthor,'<hr />';

//

			$this->_cellNotes[$noteObjID] = array('cellRef'		=> $cellAddress,

												  'objectID'	=> $noteObjID,

												  'author'		=> $noteAuthor

												 );

		} else {

			$extension = false;

			if ($cellAddress == '$B$65536') {

				//	If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation

				//		note from the previous cell annotation. We're not yet handling this, so annotations longer than the

				//		max 2048 bytes will probably throw a wobbly.

				$row = self::_GetInt2d($recordData, 0);

				$extension = true;

				$cellAddress = array_pop(array_keys($this->_phpSheet->getComments()));

			}

//			echo 'Note Address=',$cellAddress,'<br />';



			$cellAddress = str_replace('$','',$cellAddress);

			$noteLength = self::_GetInt2d($recordData, 4);

			$noteText = trim(substr($recordData, 6));

//			echo 'Note Length=',$noteLength,'<br />';

//			echo 'Note Text=',$noteText,'<br />';



			if ($extension) {

				//	Concatenate this extension with the currently set comment for the cell

				$comment = $this->_phpSheet->getComment( $cellAddress );

				$commentText = $comment->getText()->getPlainText();

				$comment->setText($this->_parseRichText($commentText.$noteText) );

			} else {

				//	Set comment for the cell

				$this->_phpSheet->getComment( $cellAddress )

//													->setAuthor( $author )

													->setText($this->_parseRichText($noteText) );

			}

		}



	}





	/**

	 *	The TEXT Object record contains the text associated with a cell annotation.

	 */

	private function _readTextObject()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// recordData consists of an array of subrecords looking like this:

		//	grbit: 2 bytes; Option Flags

		//	rot: 2 bytes; rotation

		//	cchText: 2 bytes; length of the text (in the first continue record)

		//	cbRuns: 2 bytes; length of the formatting (in the second continue record)

		// followed by the continuation records containing the actual text and formatting

		$grbitOpts	= self::_GetInt2d($recordData, 0);

		$rot		= self::_GetInt2d($recordData, 2);

		$cchText	= self::_GetInt2d($recordData, 10);

		$cbRuns		= self::_GetInt2d($recordData, 12);

		$text		= $this->_getSplicedRecordData();



		$this->_textObjects[$this->textObjRef] = array(

				'text'		=> substr($text["recordData"],$text["spliceOffsets"][0]+1,$cchText),

				'format'	=> substr($text["recordData"],$text["spliceOffsets"][1],$cbRuns),

				'alignment'	=> $grbitOpts,

				'rotation'	=> $rot

			 );



//		echo '<b>_readTextObject()</b><br />';

//		var_dump($this->_textObjects[$this->textObjRef]);

//		echo '<br />';

	}





	/**

	 * Read BOF

	 */

	private function _readBof()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 2; size: 2; type of the following data

		$substreamType = self::_GetInt2d($recordData, 2);



		switch ($substreamType) {

			case self::XLS_WorkbookGlobals:

				$version = self::_GetInt2d($recordData, 0);

				if (($version != self::XLS_BIFF8) && ($version != self::XLS_BIFF7)) {

					throw new Exception('Cannot read this Excel file. Version is too old.');

				}

				$this->_version = $version;

				break;



			case self::XLS_Worksheet:

				// do not use this version information for anything

				// it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream

				break;



			default:

				// substream, e.g. chart

				// just skip the entire substream

				do {

					$code = self::_GetInt2d($this->_data, $this->_pos);

					$this->_readDefault();

				} while ($code != self::XLS_Type_EOF && $this->_pos < $this->_dataSize);

				break;

		}

	}





	/**

	 * FILEPASS

	 *

	 * This record is part of the File Protection Block. It

	 * contains information about the read/write password of the

	 * file. All record contents following this record will be

	 * encrypted.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readFilepass()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

//		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		throw new Exception('Cannot read encrypted file');

	}





	/**

	 * CODEPAGE

	 *

	 * This record stores the text encoding used to write byte

	 * strings, stored as MS Windows code page identifier.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readCodepage()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; code page identifier

		$codepage = self::_GetInt2d($recordData, 0);



		$this->_codepage = PHPExcel_Shared_CodePage::NumberToName($codepage);

	}





	/**

	 * DATEMODE

	 *

	 * This record specifies the base date for displaying date

	 * values. All dates are stored as count of days past this

	 * base date. In BIFF2-BIFF4 this record is part of the

	 * Calculation Settings Block. In BIFF5-BIFF8 it is

	 * stored in the Workbook Globals Substream.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readDateMode()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; 0 = base 1900, 1 = base 1904

		PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900);

		if (ord($recordData{0}) == 1) {

			PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904);

		}

	}





	/**

	 * Read a FONT record

	 */

	private function _readFont()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			$objFont = new PHPExcel_Style_Font();



			// offset: 0; size: 2; height of the font (in twips = 1/20 of a point)

			$size = self::_GetInt2d($recordData, 0);

			$objFont->setSize($size / 20);



			// offset: 2; size: 2; option flags

				// bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8)

				// bit: 1; mask 0x0002; italic

				$isItalic = (0x0002 & self::_GetInt2d($recordData, 2)) >> 1;

				if ($isItalic) $objFont->setItalic(true);



				// bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8)

				// bit: 3; mask 0x0008; strike

				$isStrike = (0x0008 & self::_GetInt2d($recordData, 2)) >> 3;

				if ($isStrike) $objFont->setStrikethrough(true);



			// offset: 4; size: 2; colour index

			$colorIndex = self::_GetInt2d($recordData, 4);

			$objFont->colorIndex = $colorIndex;



			// offset: 6; size: 2; font weight

			$weight = self::_GetInt2d($recordData, 6);

			switch ($weight) {

				case 0x02BC:

					$objFont->setBold(true);

					break;

			}



			// offset: 8; size: 2; escapement type

			$escapement = self::_GetInt2d($recordData, 8);

			switch ($escapement) {

				case 0x0001:

					$objFont->setSuperScript(true);

					break;

				case 0x0002:

					$objFont->setSubScript(true);

					break;

			}



			// offset: 10; size: 1; underline type

			$underlineType = ord($recordData{10});

			switch ($underlineType) {

				case 0x00:

					break; // no underline

				case 0x01:

					$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE);

					break;

				case 0x02:

					$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE);

					break;

				case 0x21:

					$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING);

					break;

				case 0x22:

					$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING);

					break;

			}



			// offset: 11; size: 1; font family

			// offset: 12; size: 1; character set

			// offset: 13; size: 1; not used

			// offset: 14; size: var; font name

			if ($this->_version == self::XLS_BIFF8) {

				$string = self::_readUnicodeStringShort(substr($recordData, 14));

			} else {

				$string = $this->_readByteStringShort(substr($recordData, 14));

			}

			$objFont->setName($string['value']);



			$this->_objFonts[] = $objFont;

		}

	}





	/**

	 * FORMAT

	 *

	 * This record contains information about a number format.

	 * All FORMAT records occur together in a sequential list.

	 *

	 * In BIFF2-BIFF4 other records referencing a FORMAT record

	 * contain a zero-based index into this list. From BIFF5 on

	 * the FORMAT record contains the index itself that will be

	 * used by other records.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readFormat()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			$indexCode = self::_GetInt2d($recordData, 0);



			if ($this->_version == self::XLS_BIFF8) {

				$string = self::_readUnicodeStringLong(substr($recordData, 2));

			} else {

				// BIFF7

				$string = $this->_readByteStringShort(substr($recordData, 2));

			}



			$formatString = $string['value'];

			$this->_formats[$indexCode] = $formatString;

		}

	}





	/**

	 * XF - Extended Format

	 *

	 * This record contains formatting information for cells, rows, columns or styles.

	 * According to http://support.microsoft.com/kb/147732 there are always at least 15 cell style XF

	 * and 1 cell XF.

	 * Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF

	 * and XF record 15 is a cell XF

	 * We only read the first cell style XF and skip the remaining cell style XF records

	 * We read all cell XF records.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readXf()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		$objStyle = new PHPExcel_Style();



		if (!$this->_readDataOnly) {

			// offset:  0; size: 2; Index to FONT record

			if (self::_GetInt2d($recordData, 0) < 4) {

				$fontIndex = self::_GetInt2d($recordData, 0);

			} else {

				// this has to do with that index 4 is omitted in all BIFF versions for some strange reason

				// check the OpenOffice documentation of the FONT record

				$fontIndex = self::_GetInt2d($recordData, 0) - 1;

			}

			$objStyle->setFont($this->_objFonts[$fontIndex]);



			// offset:  2; size: 2; Index to FORMAT record

			$numberFormatIndex = self::_GetInt2d($recordData, 2);

			if (isset($this->_formats[$numberFormatIndex])) {

				// then we have user-defined format code

				$numberformat = array('code' => $this->_formats[$numberFormatIndex]);

			} elseif (($code = PHPExcel_Style_NumberFormat::builtInFormatCode($numberFormatIndex)) !== '') {

				// then we have built-in format code

				$numberformat = array('code' => $code);

			} else {

				// we set the general format code

				$numberformat = array('code' => 'General');

			}

			$objStyle->getNumberFormat()->setFormatCode($numberformat['code']);



			// offset:  4; size: 2; XF type, cell protection, and parent style XF

			// bit 2-0; mask 0x0007; XF_TYPE_PROT

			$xfTypeProt = self::_GetInt2d($recordData, 4);

			// bit 0; mask 0x01; 1 = cell is locked

			$isLocked = (0x01 & $xfTypeProt) >> 0;

			$objStyle->getProtection()->setLocked($isLocked ?

				PHPExcel_Style_Protection::PROTECTION_INHERIT : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);



			// bit 1; mask 0x02; 1 = Formula is hidden

			$isHidden = (0x02 & $xfTypeProt) >> 1;

			$objStyle->getProtection()->setHidden($isHidden ?

				PHPExcel_Style_Protection::PROTECTION_PROTECTED : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);



			// bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF

			$isCellStyleXf = (0x04 & $xfTypeProt) >> 2;



			// offset:  6; size: 1; Alignment and text break

			// bit 2-0, mask 0x07; horizontal alignment

			$horAlign = (0x07 & ord($recordData{6})) >> 0;

			switch ($horAlign) {

				case 0:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_GENERAL);

					break;

				case 1:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_LEFT);

					break;

				case 2:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER);

					break;

				case 3:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_RIGHT);

					break;

				case 5:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY);

					break;

				case 6:

					$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS);

					break;

			}

			// bit 3, mask 0x08; wrap text

			$wrapText = (0x08 & ord($recordData{6})) >> 3;

			switch ($wrapText) {

				case 0:

					$objStyle->getAlignment()->setWrapText(false);

					break;

				case 1:

					$objStyle->getAlignment()->setWrapText(true);

					break;

			}

			// bit 6-4, mask 0x70; vertical alignment

			$vertAlign = (0x70 & ord($recordData{6})) >> 4;

			switch ($vertAlign) {

				case 0:

					$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_TOP);

					break;

				case 1:

					$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_CENTER);

					break;

				case 2:

					$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_BOTTOM);

					break;

				case 3:

					$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_JUSTIFY);

					break;

			}



			if ($this->_version == self::XLS_BIFF8) {

				// offset:  7; size: 1; XF_ROTATION: Text rotation angle

					$angle = ord($recordData{7});

					$rotation = 0;

					if ($angle <= 90) {

						$rotation = $angle;

					} else if ($angle <= 180) {

						$rotation = 90 - $angle;

					} else if ($angle == 255) {

						$rotation = -165;

					}

					$objStyle->getAlignment()->setTextRotation($rotation);



				// offset:  8; size: 1; Indentation, shrink to cell size, and text direction

					// bit: 3-0; mask: 0x0F; indent level

					$indent = (0x0F & ord($recordData{8})) >> 0;

					$objStyle->getAlignment()->setIndent($indent);



					// bit: 4; mask: 0x10; 1 = shrink content to fit into cell

					$shrinkToFit = (0x10 & ord($recordData{8})) >> 4;

					switch ($shrinkToFit) {

						case 0:

							$objStyle->getAlignment()->setShrinkToFit(false);

							break;

						case 1:

							$objStyle->getAlignment()->setShrinkToFit(true);

							break;

					}



				// offset:  9; size: 1; Flags used for attribute groups



				// offset: 10; size: 4; Cell border lines and background area

					// bit: 3-0; mask: 0x0000000F; left style

					if ($bordersLeftStyle = self::_mapBorderStyle((0x0000000F & self::_GetInt4d($recordData, 10)) >> 0)) {

						$objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle);

					}

					// bit: 7-4; mask: 0x000000F0; right style

					if ($bordersRightStyle = self::_mapBorderStyle((0x000000F0 & self::_GetInt4d($recordData, 10)) >> 4)) {

						$objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle);

					}

					// bit: 11-8; mask: 0x00000F00; top style

					if ($bordersTopStyle = self::_mapBorderStyle((0x00000F00 & self::_GetInt4d($recordData, 10)) >> 8)) {

						$objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle);

					}

					// bit: 15-12; mask: 0x0000F000; bottom style

					if ($bordersBottomStyle = self::_mapBorderStyle((0x0000F000 & self::_GetInt4d($recordData, 10)) >> 12)) {

						$objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle);

					}

					// bit: 22-16; mask: 0x007F0000; left color

					$objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self::_GetInt4d($recordData, 10)) >> 16;



					// bit: 29-23; mask: 0x3F800000; right color

					$objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self::_GetInt4d($recordData, 10)) >> 23;



					// bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom

					$diagonalDown = (0x40000000 & self::_GetInt4d($recordData, 10)) >> 30 ?

						true : false;



					// bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right

					$diagonalUp = (0x80000000 & self::_GetInt4d($recordData, 10)) >> 31 ?

						true : false;



					if ($diagonalUp == false && $diagonalDown == false) {

						$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_NONE);

					} elseif ($diagonalUp == true && $diagonalDown == false) {

						$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_UP);

					} elseif ($diagonalUp == false && $diagonalDown == true) {

						$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_DOWN);

					} elseif ($diagonalUp == true && $diagonalDown == true) {

						$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_BOTH);

					}



				// offset: 14; size: 4;

					// bit: 6-0; mask: 0x0000007F; top color

					$objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self::_GetInt4d($recordData, 14)) >> 0;



					// bit: 13-7; mask: 0x00003F80; bottom color

					$objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self::_GetInt4d($recordData, 14)) >> 7;



					// bit: 20-14; mask: 0x001FC000; diagonal color

					$objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self::_GetInt4d($recordData, 14)) >> 14;



					// bit: 24-21; mask: 0x01E00000; diagonal style

					if ($bordersDiagonalStyle = self::_mapBorderStyle((0x01E00000 & self::_GetInt4d($recordData, 14)) >> 21)) {

						$objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle);

					}



					// bit: 31-26; mask: 0xFC000000 fill pattern

					if ($fillType = self::_mapFillPattern((0xFC000000 & self::_GetInt4d($recordData, 14)) >> 26)) {

						$objStyle->getFill()->setFillType($fillType);

					}

				// offset: 18; size: 2; pattern and background colour

					// bit: 6-0; mask: 0x007F; color index for pattern color

					$objStyle->getFill()->startcolorIndex = (0x007F & self::_GetInt2d($recordData, 18)) >> 0;



					// bit: 13-7; mask: 0x3F80; color index for pattern background

					$objStyle->getFill()->endcolorIndex = (0x3F80 & self::_GetInt2d($recordData, 18)) >> 7;

			} else {

				// BIFF5



				// offset: 7; size: 1; Text orientation and flags

				$orientationAndFlags = ord($recordData{7});



				// bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation

				$xfOrientation = (0x03 & $orientationAndFlags) >> 0;

				switch ($xfOrientation) {

					case 0:

						$objStyle->getAlignment()->setTextRotation(0);

						break;

					case 1:

						$objStyle->getAlignment()->setTextRotation(-165);

						break;

					case 2:

						$objStyle->getAlignment()->setTextRotation(90);

						break;

					case 3:

						$objStyle->getAlignment()->setTextRotation(-90);

						break;

				}



				// offset: 8; size: 4; cell border lines and background area

				$borderAndBackground = self::_GetInt4d($recordData, 8);



				// bit: 6-0; mask: 0x0000007F; color index for pattern color

				$objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0;



				// bit: 13-7; mask: 0x00003F80; color index for pattern background

				$objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7;



				// bit: 21-16; mask: 0x003F0000; fill pattern

				$objStyle->getFill()->setFillType(self::_mapFillPattern((0x003F0000 & $borderAndBackground) >> 16));



				// bit: 24-22; mask: 0x01C00000; bottom line style

				$objStyle->getBorders()->getBottom()->setBorderStyle(self::_mapBorderStyle((0x01C00000 & $borderAndBackground) >> 22));



				// bit: 31-25; mask: 0xFE000000; bottom line color

				$objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25;



				// offset: 12; size: 4; cell border lines

				$borderLines = self::_GetInt4d($recordData, 12);



				// bit: 2-0; mask: 0x00000007; top line style

				$objStyle->getBorders()->getTop()->setBorderStyle(self::_mapBorderStyle((0x00000007 & $borderLines) >> 0));



				// bit: 5-3; mask: 0x00000038; left line style

				$objStyle->getBorders()->getLeft()->setBorderStyle(self::_mapBorderStyle((0x00000038 & $borderLines) >> 3));



				// bit: 8-6; mask: 0x000001C0; right line style

				$objStyle->getBorders()->getRight()->setBorderStyle(self::_mapBorderStyle((0x000001C0 & $borderLines) >> 6));



				// bit: 15-9; mask: 0x0000FE00; top line color index

				$objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9;



				// bit: 22-16; mask: 0x007F0000; left line color index

				$objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16;



				// bit: 29-23; mask: 0x3F800000; right line color index

				$objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23;

			}



			// add cellStyleXf or cellXf and update mapping

			if ($isCellStyleXf) {

				// we only read one style XF record which is always the first

				if ($this->_xfIndex == 0) {

					$this->_phpExcel->addCellStyleXf($objStyle);

					$this->_mapCellStyleXfIndex[$this->_xfIndex] = 0;

				}

			} else {

				// we read all cell XF records

				$this->_phpExcel->addCellXf($objStyle);

				$this->_mapCellXfIndex[$this->_xfIndex] = count($this->_phpExcel->getCellXfCollection()) - 1;

			}



			// update XF index for when we read next record

			++$this->_xfIndex;

		}

	}





	/**

	 *

	 */

	private function _readXfExt()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; 0x087D = repeated header



			// offset: 2; size: 2



			// offset: 4; size: 8; not used



			// offset: 12; size: 2; record version



			// offset: 14; size: 2; index to XF record which this record modifies

			$ixfe = self::_GetInt2d($recordData, 14);



			// offset: 16; size: 2; not used



			// offset: 18; size: 2; number of extension properties that follow

			$cexts = self::_GetInt2d($recordData, 18);



			// start reading the actual extension data

			$offset = 20;

			while ($offset < $length) {

				// extension type

				$extType = self::_GetInt2d($recordData, $offset);



				// extension length

				$cb = self::_GetInt2d($recordData, $offset + 2);



				// extension data

				$extData = substr($recordData, $offset + 4, $cb);



				switch ($extType) {

					case 4:		// fill start color

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();

								$fill->getStartColor()->setRGB($rgb);

								unset($fill->startcolorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 5:		// fill end color

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();

								$fill->getEndColor()->setRGB($rgb);

								unset($fill->endcolorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 7:		// border color top

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$top = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getTop();

								$top->getColor()->setRGB($rgb);

								unset($top->colorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 8:		// border color bottom

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$bottom = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getBottom();

								$bottom->getColor()->setRGB($rgb);

								unset($bottom->colorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 9:		// border color left

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$left = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getLeft();

								$left->getColor()->setRGB($rgb);

								unset($left->colorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 10:		// border color right

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$right = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getRight();

								$right->getColor()->setRGB($rgb);

								unset($right->colorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 11:		// border color diagonal

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$diagonal = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getDiagonal();

								$diagonal->getColor()->setRGB($rgb);

								unset($diagonal->colorIndex); // normal color index does not apply, discard

							}

						}

						break;



					case 13:	// font color

						$xclfType  = self::_GetInt2d($extData, 0); // color type

						$xclrValue = substr($extData, 4, 4); // color value (value based on color type)



						if ($xclfType == 2) {

							$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));



							// modify the relevant style property

							if ( isset($this->_mapCellXfIndex[$ixfe]) ) {

								$font = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFont();

								$font->getColor()->setRGB($rgb);

								unset($font->colorIndex); // normal color index does not apply, discard

							}

						}

						break;

				}



				$offset += $cb;

			}

		}



	}





	/**

	 * Read STYLE record

	 */

	private function _readStyle()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; index to XF record and flag for built-in style

			$ixfe = self::_GetInt2d($recordData, 0);



			// bit: 11-0; mask 0x0FFF; index to XF record

			$xfIndex = (0x0FFF & $ixfe) >> 0;



			// bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style

			$isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15);



			if ($isBuiltIn) {

				// offset: 2; size: 1; identifier for built-in style

				$builtInId = ord($recordData{2});



				switch ($builtInId) {

				case 0x00:

					// currently, we are not using this for anything

					break;



				default:

					break;

				}



			} else {

				// user-defined; not supported by PHPExcel

			}

		}

	}





	/**

	 * Read PALETTE record

	 */

	private function _readPalette()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; number of following colors

			$nm = self::_GetInt2d($recordData, 0);



			// list of RGB colors

			for ($i = 0; $i < $nm; ++$i) {

				$rgb = substr($recordData, 2 + 4 * $i, 4);

				$this->_palette[] = self::_readRGB($rgb);

			}

		}

	}





	/**

	 * SHEET

	 *

	 * This record is  located in the  Workbook Globals

	 * Substream  and represents a sheet inside the workbook.

	 * One SHEET record is written for each sheet. It stores the

	 * sheet name and a stream offset to the BOF record of the

	 * respective Sheet Substream within the Workbook Stream.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readSheet()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 4; absolute stream position of the BOF record of the sheet

		$rec_offset = self::_GetInt4d($recordData, 0);



		// offset: 4; size: 1; sheet state

		switch (ord($recordData{4})) {

			case 0x00: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;    break;

			case 0x01: $sheetState = PHPExcel_Worksheet::SHEETSTATE_HIDDEN;     break;

			case 0x02: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VERYHIDDEN; break;

			default: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;      break;

		}



		// offset: 5; size: 1; sheet type

		$sheetType = ord($recordData{5});



		// offset: 6; size: var; sheet name

		if ($this->_version == self::XLS_BIFF8) {

			$string = self::_readUnicodeStringShort(substr($recordData, 6));

			$rec_name = $string['value'];

		} elseif ($this->_version == self::XLS_BIFF7) {

			$string = $this->_readByteStringShort(substr($recordData, 6));

			$rec_name = $string['value'];

		}



		$this->_sheets[] = array(

			'name' => $rec_name,

			'offset' => $rec_offset,

			'sheetState' => $sheetState,

			'sheetType' => $sheetType,

		);

	}





	/**

	 * Read EXTERNALBOOK record

	 */

	private function _readExternalBook()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset within record data

		$offset = 0;



		// there are 4 types of records

		if (strlen($recordData) > 4) {

			// external reference

			// offset: 0; size: 2; number of sheet names ($nm)

			$nm = self::_GetInt2d($recordData, 0);

			$offset += 2;



			// offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length)

			$encodedUrlString = self::_readUnicodeStringLong(substr($recordData, 2));

			$offset += $encodedUrlString['size'];



			// offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length)

			$externalSheetNames = array();

			for ($i = 0; $i < $nm; ++$i) {

				$externalSheetNameString = self::_readUnicodeStringLong(substr($recordData, $offset));

				$externalSheetNames[] = $externalSheetNameString['value'];

				$offset += $externalSheetNameString['size'];

			}



			// store the record data

			$this->_externalBooks[] = array(

				'type' => 'external',

				'encodedUrl' => $encodedUrlString['value'],

				'externalSheetNames' => $externalSheetNames,

			);



		} elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04)) {

			// internal reference

			// offset: 0; size: 2; number of sheet in this document

			// offset: 2; size: 2; 0x01 0x04

			$this->_externalBooks[] = array(

				'type' => 'internal',

			);

		} elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A)) {

			// add-in function

			// offset: 0; size: 2; 0x0001

			$this->_externalBooks[] = array(

				'type' => 'addInFunction',

			);

		} elseif (substr($recordData, 0, 2) == pack('v', 0x0000)) {

			// DDE links, OLE links

			// offset: 0; size: 2; 0x0000

			// offset: 2; size: var; encoded source document name

			$this->_externalBooks[] = array(

				'type' => 'DDEorOLE',

			);

		}

	}





	/**

	 * Read EXTERNNAME record.

	 */

	private function _readExternName()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// external sheet references provided for named cells

		if ($this->_version == self::XLS_BIFF8) {

			// offset: 0; size: 2; options

			$options = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 2;



			// offset: 4; size: 2; not used



			// offset: 6; size: var

			$nameString = self::_readUnicodeStringShort(substr($recordData, 6));



			// offset: var; size: var; formula data

			$offset = 6 + $nameString['size'];

			$formula = $this->_getFormulaFromStructure(substr($recordData, $offset));



			$this->_externalNames[] = array(

				'name' => $nameString['value'],

				'formula' => $formula,

			);

		}

	}





	/**

	 * Read EXTERNSHEET record

	 */

	private function _readExternSheet()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// external sheet references provided for named cells

		if ($this->_version == self::XLS_BIFF8) {

			// offset: 0; size: 2; number of following ref structures

			$nm = self::_GetInt2d($recordData, 0);

			for ($i = 0; $i < $nm; ++$i) {

				$this->_ref[] = array(

					// offset: 2 + 6 * $i; index to EXTERNALBOOK record

					'externalBookIndex' => self::_GetInt2d($recordData, 2 + 6 * $i),

					// offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record

					'firstSheetIndex' => self::_GetInt2d($recordData, 4 + 6 * $i),

					// offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record

					'lastSheetIndex' => self::_GetInt2d($recordData, 6 + 6 * $i),

				);

			}

		}

	}





	/**

	 * DEFINEDNAME

	 *

	 * This record is part of a Link Table. It contains the name

	 * and the token array of an internal defined name. Token

	 * arrays of defined names contain tokens with aberrant

	 * token classes.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readDefinedName()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8) {

			// retrieves named cells



			// offset: 0; size: 2; option flags

			$opts = self::_GetInt2d($recordData, 0);



				// bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name

				$isBuiltInName = (0x0020 & $opts) >> 5;



			// offset: 2; size: 1; keyboard shortcut



			// offset: 3; size: 1; length of the name (character count)

			$nlen = ord($recordData{3});



			// offset: 4; size: 2; size of the formula data (it can happen that this is zero)

			// note: there can also be additional data, this is not included in $flen

			$flen = self::_GetInt2d($recordData, 4);



			// offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based)

			$scope = self::_GetInt2d($recordData, 8);



			// offset: 14; size: var; Name (Unicode string without length field)

			$string = self::_readUnicodeString(substr($recordData, 14), $nlen);



			// offset: var; size: $flen; formula data

			$offset = 14 + $string['size'];

			$formulaStructure = pack('v', $flen) . substr($recordData, $offset);



			try {

				$formula = $this->_getFormulaFromStructure($formulaStructure);

			} catch (Exception $e) {

				$formula = '';

			}



			$this->_definedname[] = array(

				'isBuiltInName' => $isBuiltInName,

				'name' => $string['value'],

				'formula' => $formula,

				'scope' => $scope,

			);

		}

	}





	/**

	 * Read MSODRAWINGGROUP record

	 */

	private function _readMsoDrawingGroup()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);



		// get spliced record data

		$splicedRecordData = $this->_getSplicedRecordData();

		$recordData = $splicedRecordData['recordData'];



		$this->_drawingGroupData .= $recordData;

	}





	/**

	 * SST - Shared String Table

	 *

	 * This record contains a list of all strings used anywhere

	 * in the workbook. Each string occurs only once. The

	 * workbook uses indexes into the list to reference the

	 * strings.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 **/

	private function _readSst()

	{

		// offset within (spliced) record data

		$pos = 0;



		// get spliced record data

		$splicedRecordData = $this->_getSplicedRecordData();



		$recordData = $splicedRecordData['recordData'];

		$spliceOffsets = $splicedRecordData['spliceOffsets'];



		// offset: 0; size: 4; total number of strings in the workbook

		$pos += 4;



		// offset: 4; size: 4; number of following strings ($nm)

		$nm = self::_GetInt4d($recordData, 4);

		$pos += 4;



		// loop through the Unicode strings (16-bit length)

		for ($i = 0; $i < $nm; ++$i) {



			// number of characters in the Unicode string

			$numChars = self::_GetInt2d($recordData, $pos);

			$pos += 2;



			// option flags

			$optionFlags = ord($recordData{$pos});

			++$pos;



			// bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed

			$isCompressed = (($optionFlags & 0x01) == 0) ;



			// bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic

			$hasAsian = (($optionFlags & 0x04) != 0);



			// bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text

			$hasRichText = (($optionFlags & 0x08) != 0);



			if ($hasRichText) {

				// number of Rich-Text formatting runs

				$formattingRuns = self::_GetInt2d($recordData, $pos);

				$pos += 2;

			}



			if ($hasAsian) {

				// size of Asian phonetic setting

				$extendedRunLength = self::_GetInt4d($recordData, $pos);

				$pos += 4;

			}



			// expected byte length of character array if not split

			$len = ($isCompressed) ? $numChars : $numChars * 2;



			// look up limit position

			foreach ($spliceOffsets as $spliceOffset) {

				// it can happen that the string is empty, therefore we need

				// <= and not just <

				if ($pos <= $spliceOffset) {

					$limitpos = $spliceOffset;

					break;

				}

			}



			if ($pos + $len <= $limitpos) {

				// character array is not split between records



				$retstr = substr($recordData, $pos, $len);

				$pos += $len;



			} else {

				// character array is split between records



				// first part of character array

				$retstr = substr($recordData, $pos, $limitpos - $pos);



				$bytesRead = $limitpos - $pos;



				// remaining characters in Unicode string

				$charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2));



				$pos = $limitpos;



				// keep reading the characters

				while ($charsLeft > 0) {



					// look up next limit position, in case the string span more than one continue record

					foreach ($spliceOffsets as $spliceOffset) {

						if ($pos < $spliceOffset) {

							$limitpos = $spliceOffset;

							break;

						}

					}



					// repeated option flags

					// OpenOffice.org documentation 5.21

					$option = ord($recordData{$pos});

					++$pos;



					if ($isCompressed && ($option == 0)) {

						// 1st fragment compressed

						// this fragment compressed

						$len = min($charsLeft, $limitpos - $pos);

						$retstr .= substr($recordData, $pos, $len);

						$charsLeft -= $len;

						$isCompressed = true;



					} elseif (!$isCompressed && ($option != 0)) {

						// 1st fragment uncompressed

						// this fragment uncompressed

						$len = min($charsLeft * 2, $limitpos - $pos);

						$retstr .= substr($recordData, $pos, $len);

						$charsLeft -= $len / 2;

						$isCompressed = false;



					} elseif (!$isCompressed && ($option == 0)) {

						// 1st fragment uncompressed

						// this fragment compressed

						$len = min($charsLeft, $limitpos - $pos);

						for ($j = 0; $j < $len; ++$j) {

							$retstr .= $recordData{$pos + $j} . chr(0);

						}

						$charsLeft -= $len;

						$isCompressed = false;



					} else {

						// 1st fragment compressed

						// this fragment uncompressed

						$newstr = '';

						for ($j = 0; $j < strlen($retstr); ++$j) {

							$newstr .= $retstr[$j] . chr(0);

						}

						$retstr = $newstr;

						$len = min($charsLeft * 2, $limitpos - $pos);

						$retstr .= substr($recordData, $pos, $len);

						$charsLeft -= $len / 2;

						$isCompressed = false;

					}



					$pos += $len;

				}

			}



			// convert to UTF-8

			$retstr = self::_encodeUTF16($retstr, $isCompressed);



			// read additional Rich-Text information, if any

			$fmtRuns = array();

			if ($hasRichText) {

				// list of formatting runs

				for ($j = 0; $j < $formattingRuns; ++$j) {

					// first formatted character; zero-based

					$charPos = self::_GetInt2d($recordData, $pos + $j * 4);



					// index to font record

					$fontIndex = self::_GetInt2d($recordData, $pos + 2 + $j * 4);



					$fmtRuns[] = array(

						'charPos' => $charPos,

						'fontIndex' => $fontIndex,

					);

				}

				$pos += 4 * $formattingRuns;

			}



			// read additional Asian phonetics information, if any

			if ($hasAsian) {

				// For Asian phonetic settings, we skip the extended string data

				$pos += $extendedRunLength;

			}



			// store the shared sting

			$this->_sst[] = array(

				'value' => $retstr,

				'fmtRuns' => $fmtRuns,

			);

		}



		// _getSplicedRecordData() takes care of moving current position in data stream

	}





	/**

	 * Read PRINTGRIDLINES record

	 */

	private function _readPrintGridlines()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {

			// offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines

			$printGridlines = (bool) self::_GetInt2d($recordData, 0);

			$this->_phpSheet->setPrintGridlines($printGridlines);

		}

	}





	/**

	 * Read DEFAULTROWHEIGHT record

	 */

	private function _readDefaultRowHeight()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; option flags

		// offset: 2; size: 2; default height for unused rows, (twips 1/20 point)

		$height = self::_GetInt2d($recordData, 2);

		$this->_phpSheet->getDefaultRowDimension()->setRowHeight($height / 20);

	}





	/**

	 * Read SHEETPR record

	 */

	private function _readSheetPr()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2



		// bit: 6; mask: 0x0040; 0 = outline buttons above outline group

		$isSummaryBelow = (0x0040 & self::_GetInt2d($recordData, 0)) >> 6;

		$this->_phpSheet->setShowSummaryBelow($isSummaryBelow);



		// bit: 7; mask: 0x0080; 0 = outline buttons left of outline group

		$isSummaryRight = (0x0080 & self::_GetInt2d($recordData, 0)) >> 7;

		$this->_phpSheet->setShowSummaryRight($isSummaryRight);



		// bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages

		// this corresponds to radio button setting in page setup dialog in Excel

		$this->_isFitToPages = (bool) ((0x0100 & self::_GetInt2d($recordData, 0)) >> 8);

	}





	/**

	 * Read HORIZONTALPAGEBREAKS record

	 */

	private function _readHorizontalPageBreaks()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {



			// offset: 0; size: 2; number of the following row index structures

			$nm = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 6 * $nm; list of $nm row index structures

			for ($i = 0; $i < $nm; ++$i) {

				$r = self::_GetInt2d($recordData, 2 + 6 * $i);

				$cf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);

				$cl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);



				// not sure why two column indexes are necessary?

				$this->_phpSheet->setBreakByColumnAndRow($cf, $r, PHPExcel_Worksheet::BREAK_ROW);

			}

		}

	}





	/**

	 * Read VERTICALPAGEBREAKS record

	 */

	private function _readVerticalPageBreaks()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {

			// offset: 0; size: 2; number of the following column index structures

			$nm = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 6 * $nm; list of $nm row index structures

			for ($i = 0; $i < $nm; ++$i) {

				$c = self::_GetInt2d($recordData, 2 + 6 * $i);

				$rf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);

				$rl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);



				// not sure why two row indexes are necessary?

				$this->_phpSheet->setBreakByColumnAndRow($c, $rf, PHPExcel_Worksheet::BREAK_COLUMN);

			}

		}

	}





	/**

	 * Read HEADER record

	 */

	private function _readHeader()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: var

			// realized that $recordData can be empty even when record exists

			if ($recordData) {

				if ($this->_version == self::XLS_BIFF8) {

					$string = self::_readUnicodeStringLong($recordData);

				} else {

					$string = $this->_readByteStringShort($recordData);

				}



				$this->_phpSheet->getHeaderFooter()->setOddHeader($string['value']);

				$this->_phpSheet->getHeaderFooter()->setEvenHeader($string['value']);

			}

		}

	}





	/**

	 * Read FOOTER record

	 */

	private function _readFooter()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: var

			// realized that $recordData can be empty even when record exists

			if ($recordData) {

				if ($this->_version == self::XLS_BIFF8) {

					$string = self::_readUnicodeStringLong($recordData);

				} else {

					$string = $this->_readByteStringShort($recordData);

				}

				$this->_phpSheet->getHeaderFooter()->setOddFooter($string['value']);

				$this->_phpSheet->getHeaderFooter()->setEvenFooter($string['value']);

			}

		}

	}





	/**

	 * Read HCENTER record

	 */

	private function _readHcenter()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally

			$isHorizontalCentered = (bool) self::_GetInt2d($recordData, 0);



			$this->_phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered);

		}

	}





	/**

	 * Read VCENTER record

	 */

	private function _readVcenter()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered

			$isVerticalCentered = (bool) self::_GetInt2d($recordData, 0);



			$this->_phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered);

		}

	}





	/**

	 * Read LEFTMARGIN record

	 */

	private function _readLeftMargin()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 8

			$this->_phpSheet->getPageMargins()->setLeft(self::_extractNumber($recordData));

		}

	}





	/**

	 * Read RIGHTMARGIN record

	 */

	private function _readRightMargin()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 8

			$this->_phpSheet->getPageMargins()->setRight(self::_extractNumber($recordData));

		}

	}





	/**

	 * Read TOPMARGIN record

	 */

	private function _readTopMargin()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 8

			$this->_phpSheet->getPageMargins()->setTop(self::_extractNumber($recordData));

		}

	}





	/**

	 * Read BOTTOMMARGIN record

	 */

	private function _readBottomMargin()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 8

			$this->_phpSheet->getPageMargins()->setBottom(self::_extractNumber($recordData));

		}

	}





	/**

	 * Read PAGESETUP record

	 */

	private function _readPageSetup()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; paper size

			$paperSize = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 2; scaling factor

			$scale = self::_GetInt2d($recordData, 2);



			// offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed

			$fitToWidth = self::_GetInt2d($recordData, 6);



			// offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed

			$fitToHeight = self::_GetInt2d($recordData, 8);



			// offset: 10; size: 2; option flags



				// bit: 1; mask: 0x0002; 0=landscape, 1=portrait

				$isPortrait = (0x0002 & self::_GetInt2d($recordData, 10)) >> 1;



				// bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init

				// when this bit is set, do not use flags for those properties

				$isNotInit = (0x0004 & self::_GetInt2d($recordData, 10)) >> 2;



			if (!$isNotInit) {

				$this->_phpSheet->getPageSetup()->setPaperSize($paperSize);

				switch ($isPortrait) {

				case 0: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_LANDSCAPE); break;

				case 1: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_PORTRAIT); break;

				}



				$this->_phpSheet->getPageSetup()->setScale($scale, false);

				$this->_phpSheet->getPageSetup()->setFitToPage((bool) $this->_isFitToPages);

				$this->_phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false);

				$this->_phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false);

			}



			// offset: 16; size: 8; header margin (IEEE 754 floating-point value)

			$marginHeader = self::_extractNumber(substr($recordData, 16, 8));

			$this->_phpSheet->getPageMargins()->setHeader($marginHeader);



			// offset: 24; size: 8; footer margin (IEEE 754 floating-point value)

			$marginFooter = self::_extractNumber(substr($recordData, 24, 8));

			$this->_phpSheet->getPageMargins()->setFooter($marginFooter);

		}

	}





	/**

	 * PROTECT - Sheet protection (BIFF2 through BIFF8)

	 *   if this record is omitted, then it also means no sheet protection

	 */

	private function _readProtect()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// offset: 0; size: 2;



		// bit 0, mask 0x01; 1 = sheet is protected

		$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;

		$this->_phpSheet->getProtection()->setSheet((bool)$bool);

	}





	/**

	 * SCENPROTECT

	 */

	private function _readScenProtect()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// offset: 0; size: 2;



		// bit: 0, mask 0x01; 1 = scenarios are protected

		$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;



		$this->_phpSheet->getProtection()->setScenarios((bool)$bool);

	}





	/**

	 * OBJECTPROTECT

	 */

	private function _readObjectProtect()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// offset: 0; size: 2;



		// bit: 0, mask 0x01; 1 = objects are protected

		$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;



		$this->_phpSheet->getProtection()->setObjects((bool)$bool);

	}





	/**

	 * PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8)

	 */

	private function _readPassword()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; 16-bit hash value of password

			$password = strtoupper(dechex(self::_GetInt2d($recordData, 0))); // the hashed password

			$this->_phpSheet->getProtection()->setPassword($password, true);

		}

	}





	/**

	 * Read DEFCOLWIDTH record

	 */

	private function _readDefColWidth()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; default column width

		$width = self::_GetInt2d($recordData, 0);

		if ($width != 8) {

			$this->_phpSheet->getDefaultColumnDimension()->setWidth($width);

		}

	}





	/**

	 * Read COLINFO record

	 */

	private function _readColInfo()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; index to first column in range

			$fc = self::_GetInt2d($recordData, 0); // first column index



			// offset: 2; size: 2; index to last column in range

			$lc = self::_GetInt2d($recordData, 2); // first column index



			// offset: 4; size: 2; width of the column in 1/256 of the width of the zero character

			$width = self::_GetInt2d($recordData, 4);



			// offset: 6; size: 2; index to XF record for default column formatting

			$xfIndex = self::_GetInt2d($recordData, 6);



			// offset: 8; size: 2; option flags



				// bit: 0; mask: 0x0001; 1= columns are hidden

				$isHidden = (0x0001 & self::_GetInt2d($recordData, 8)) >> 0;



				// bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline)

				$level = (0x0700 & self::_GetInt2d($recordData, 8)) >> 8;



				// bit: 12; mask: 0x1000; 1 = collapsed

				$isCollapsed = (0x1000 & self::_GetInt2d($recordData, 8)) >> 12;



			// offset: 10; size: 2; not used



			for ($i = $fc; $i <= $lc; ++$i) {

				if ($lc == 255 || $lc == 256) {

					$this->_phpSheet->getDefaultColumnDimension()->setWidth($width / 256);

					break;

				}

				$this->_phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256);

				$this->_phpSheet->getColumnDimensionByColumn($i)->setVisible(!$isHidden);

				$this->_phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level);

				$this->_phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed);

				$this->_phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}

	}





	/**

	 * ROW

	 *

	 * This record contains the properties of a single row in a

	 * sheet. Rows and cells in a sheet are divided into blocks

	 * of 32 rows.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readRow()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; index of this row

			$r = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 2; index to column of the first cell which is described by a cell record



			// offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1



			// offset: 6; size: 2;



			// bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point

			$height = (0x7FFF & self::_GetInt2d($recordData, 6)) >> 0;



			// bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height

			$useDefaultHeight = (0x8000 & self::_GetInt2d($recordData, 6)) >> 15;



			if (!$useDefaultHeight) {

				$this->_phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20);

			}



			// offset: 8; size: 2; not used



			// offset: 10; size: 2; not used in BIFF5-BIFF8



			// offset: 12; size: 4; option flags and default row formatting



			// bit: 2-0: mask: 0x00000007; outline level of the row

			$level = (0x00000007 & self::_GetInt4d($recordData, 12)) >> 0;

			$this->_phpSheet->getRowDimension($r + 1)->setOutlineLevel($level);



			// bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed

			$isCollapsed = (0x00000010 & self::_GetInt4d($recordData, 12)) >> 4;

			$this->_phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed);



			// bit: 5; mask: 0x00000020; 1 = row is hidden

			$isHidden = (0x00000020 & self::_GetInt4d($recordData, 12)) >> 5;

			$this->_phpSheet->getRowDimension($r + 1)->setVisible(!$isHidden);



			// bit: 7; mask: 0x00000080; 1 = row has explicit format

			$hasExplicitFormat = (0x00000080 & self::_GetInt4d($recordData, 12)) >> 7;



			// bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record

			$xfIndex = (0x0FFF0000 & self::_GetInt4d($recordData, 12)) >> 16;



			if ($hasExplicitFormat) {

				$this->_phpSheet->getRowDimension($r + 1)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}

	}





	/**

	 * Read RK record

	 * This record represents a cell that contains an RK value

	 * (encoded integer or floating-point value). If a

	 * floating-point value cannot be encoded to an RK value,

	 * a NUMBER record will be written. This record replaces the

	 * record INTEGER written in BIFF2.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readRk()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; index to column

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset: 4; size: 2; index to XF record

			$xfIndex = self::_GetInt2d($recordData, 4);



			// offset: 6; size: 4; RK value

			$rknum = self::_GetInt4d($recordData, 6);

			$numValue = self::_GetIEEE754($rknum);



			$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

			if (!$this->_readDataOnly) {

				// add style information

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}



			// add cell

			$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);

		}

	}





	/**

	 * Read LABELSST record

	 * This record represents a cell that contains a string. It

	 * replaces the LABEL record and RSTRING record used in

	 * BIFF2-BIFF5.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readLabelSst()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; index to column

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset: 4; size: 2; index to XF record

			$xfIndex = self::_GetInt2d($recordData, 4);



			// offset: 6; size: 4; index to SST record

			$index = self::_GetInt4d($recordData, 6);



			// add cell

			if (($fmtRuns = $this->_sst[$index]['fmtRuns']) && !$this->_readDataOnly) {

				// then we should treat as rich text

				$richText = new PHPExcel_RichText();

				$charPos = 0;

				$sstCount = count($this->_sst[$index]['fmtRuns']);

				for ($i = 0; $i <= $sstCount; ++$i) {

					if (isset($fmtRuns[$i])) {

						$text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos);

						$charPos = $fmtRuns[$i]['charPos'];

					} else {

						$text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, PHPExcel_Shared_String::CountCharacters($this->_sst[$index]['value']));

					}



					if (PHPExcel_Shared_String::CountCharacters($text) > 0) {

						if ($i == 0) { // first text run, no style

							$richText->createText($text);

						} else {

							$textRun = $richText->createTextRun($text);

							if (isset($fmtRuns[$i - 1])) {

								if ($fmtRuns[$i - 1]['fontIndex'] < 4) {

									$fontIndex = $fmtRuns[$i - 1]['fontIndex'];

								} else {

									// this has to do with that index 4 is omitted in all BIFF versions for some strange reason

									// check the OpenOffice documentation of the FONT record

									$fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1;

								}

								$textRun->setFont(clone $this->_objFonts[$fontIndex]);

							}

						}

					}

				}

				$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

				$cell->setValueExplicit($richText, PHPExcel_Cell_DataType::TYPE_STRING);

			} else {

				$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

				$cell->setValueExplicit($this->_sst[$index]['value'], PHPExcel_Cell_DataType::TYPE_STRING);

			}



			if (!$this->_readDataOnly) {

				// add style information

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}

	}





	/**

	 * Read MULRK record

	 * This record represents a cell range containing RK value

	 * cells. All cells are located in the same row.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readMulRk()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; index to first column

		$colFirst = self::_GetInt2d($recordData, 2);



		// offset: var; size: 2; index to last column

		$colLast = self::_GetInt2d($recordData, $length - 2);

		$columns = $colLast - $colFirst + 1;



		// offset within record data

		$offset = 4;



		for ($i = 0; $i < $columns; ++$i) {

			$columnString = PHPExcel_Cell::stringFromColumnIndex($colFirst + $i);



			// Read cell?

			if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {



				// offset: var; size: 2; index to XF record

				$xfIndex = self::_GetInt2d($recordData, $offset);



				// offset: var; size: 4; RK value

				$numValue = self::_GetIEEE754(self::_GetInt4d($recordData, $offset + 2));

				$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

				if (!$this->_readDataOnly) {

					// add style

					$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

				}



				// add cell value

				$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);

			}



			$offset += 6;

		}

	}





	/**

	 * Read NUMBER record

	 * This record represents a cell that contains a

	 * floating-point value.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readNumber()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size 2; index to column

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset 4; size: 2; index to XF record

			$xfIndex = self::_GetInt2d($recordData, 4);



			$numValue = self::_extractNumber(substr($recordData, 6, 8));



			$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

			if (!$this->_readDataOnly) {

				// add cell style

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}



			// add cell value

			$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);

		}

	}





	/**

	 * Read FORMULA record + perhaps a following STRING record if formula result is a string

	 * This record contains the token array and the result of a

	 * formula cell.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readFormula()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; row index

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; col index

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// offset: 20: size: variable; formula structure

		$formulaStructure = substr($recordData, 20);



		// offset: 14: size: 2; option flags, recalculate always, recalculate on open etc.

		$options = self::_GetInt2d($recordData, 14);



		// bit: 0; mask: 0x0001; 1 = recalculate always

		// bit: 1; mask: 0x0002; 1 = calculate on open

		// bit: 2; mask: 0x0008; 1 = part of a shared formula

		$isPartOfSharedFormula = (bool) (0x0008 & $options);



		// WARNING:

		// We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true

		// the formula data may be ordinary formula data, therefore we need to check

		// explicitly for the tExp token (0x01)

		$isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure{2}) == 0x01;



		if ($isPartOfSharedFormula) {

			// part of shared formula which means there will be a formula with a tExp token and nothing else

			// get the base cell, grab tExp token

			$baseRow = self::_GetInt2d($formulaStructure, 3);

			$baseCol = self::_GetInt2d($formulaStructure, 5);

			$this->_baseCell = PHPExcel_Cell::stringFromColumnIndex($baseCol). ($baseRow + 1);

		}



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {



			if ($isPartOfSharedFormula) {

				// formula is added to this cell after the sheet has been read

				$this->_sharedFormulaParts[$columnString . ($row + 1)] = $this->_baseCell;

			}



			// offset: 16: size: 4; not used



			// offset: 4; size: 2; XF index

			$xfIndex = self::_GetInt2d($recordData, 4);



			// offset: 6; size: 8; result of the formula

			if ( (ord($recordData{6}) == 0)

				&& (ord($recordData{12}) == 255)

				&& (ord($recordData{13}) == 255) ) {



				// String formula. Result follows in appended STRING record

				$dataType = PHPExcel_Cell_DataType::TYPE_STRING;



				// read possible SHAREDFMLA record

				$code = self::_GetInt2d($this->_data, $this->_pos);

				if ($code == self::XLS_Type_SHAREDFMLA) {

					$this->_readSharedFmla();

				}



				// read STRING record

				$value = $this->_readString();



			} elseif ((ord($recordData{6}) == 1)

				&& (ord($recordData{12}) == 255)

				&& (ord($recordData{13}) == 255)) {



				// Boolean formula. Result is in +2; 0=false, 1=true

				$dataType = PHPExcel_Cell_DataType::TYPE_BOOL;

				$value = (bool) ord($recordData{8});



			} elseif ((ord($recordData{6}) == 2)

				&& (ord($recordData{12}) == 255)

				&& (ord($recordData{13}) == 255)) {



				// Error formula. Error code is in +2

				$dataType = PHPExcel_Cell_DataType::TYPE_ERROR;

				$value = self::_mapErrorCode(ord($recordData{8}));



			} elseif ((ord($recordData{6}) == 3)

				&& (ord($recordData{12}) == 255)

				&& (ord($recordData{13}) == 255)) {



				// Formula result is a null string

				$dataType = PHPExcel_Cell_DataType::TYPE_NULL;

				$value = '';



			} else {



				// forumla result is a number, first 14 bytes like _NUMBER record

				$dataType = PHPExcel_Cell_DataType::TYPE_NUMERIC;

				$value = self::_extractNumber(substr($recordData, 6, 8));



			}



			$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

			if (!$this->_readDataOnly) {

				// add cell style

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}



			// store the formula

			if (!$isPartOfSharedFormula) {

				// not part of shared formula

				// add cell value. If we can read formula, populate with formula, otherwise just used cached value

				try {

					if ($this->_version != self::XLS_BIFF8) {

						throw new Exception('Not BIFF8. Can only read BIFF8 formulas');

					}

					$formula = $this->_getFormulaFromStructure($formulaStructure); // get formula in human language

					$cell->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);



				} catch (Exception $e) {

					$cell->setValueExplicit($value, $dataType);

				}

			} else {

				if ($this->_version == self::XLS_BIFF8) {

					// do nothing at this point, formula id added later in the code

				} else {

					$cell->setValueExplicit($value, $dataType);

				}

			}



			// store the cached calculated value

			$cell->setCalculatedValue($value);

		}

	}





	/**

	 * Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader,

	 * which usually contains relative references.

	 * These will be used to construct the formula in each shared formula part after the sheet is read.

	 */

	private function _readSharedFmla()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything

		$cellRange = substr($recordData, 0, 6);

		$cellRange = $this->_readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax



		// offset: 6, size: 1; not used



		// offset: 7, size: 1; number of existing FORMULA records for this shared formula

		$no = ord($recordData{7});



		// offset: 8, size: var; Binary token array of the shared formula

		$formula = substr($recordData, 8);



		// at this point we only store the shared formula for later use

		$this->_sharedFormulas[$this->_baseCell] = $formula;



	}





	/**

	 * Read a STRING record from current stream position and advance the stream pointer to next record

	 * This record is used for storing result from FORMULA record when it is a string, and

	 * it occurs directly after the FORMULA record

	 *

	 * @return string The string contents as UTF-8

	 */

	private function _readString()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8) {

			$string = self::_readUnicodeStringLong($recordData);

			$value = $string['value'];

		} else {

			$string = $this->_readByteStringLong($recordData);

			$value = $string['value'];

		}



		return $value;

	}





	/**

	 * Read BOOLERR record

	 * This record represents a Boolean value or error value

	 * cell.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readBoolErr()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; row index

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; column index

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset: 4; size: 2; index to XF record

			$xfIndex = self::_GetInt2d($recordData, 4);



			// offset: 6; size: 1; the boolean value or error value

			$boolErr = ord($recordData{6});



			// offset: 7; size: 1; 0=boolean; 1=error

			$isError = ord($recordData{7});



			$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

			switch ($isError) {

				case 0: // boolean

					$value = (bool) $boolErr;



					// add cell value

					$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_BOOL);

					break;



				case 1: // error type

					$value = self::_mapErrorCode($boolErr);



					// add cell value

					$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_ERROR);

					break;

			}



			if (!$this->_readDataOnly) {

				// add cell style

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}

	}





	/**

	 * Read MULBLANK record

	 * This record represents a cell range of empty cells. All

	 * cells are located in the same row

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readMulBlank()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; index to first column

		$fc = self::_GetInt2d($recordData, 2);



		// offset: 4; size: 2 x nc; list of indexes to XF records

		// add style information

		if (!$this->_readDataOnly) {

			for ($i = 0; $i < $length / 2 - 3; ++$i) {

				$columnString = PHPExcel_Cell::stringFromColumnIndex($fc + $i);



				// Read cell?

				if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

					$xfIndex = self::_GetInt2d($recordData, 4 + 2 * $i);

					$this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

				}

			}

		}



		// offset: 6; size 2; index to last column (not needed)

	}





	/**

	 * Read LABEL record

	 * This record represents a cell that contains a string. In

	 * BIFF8 it is usually replaced by the LABELSST record.

	 * Excel still uses this record, if it copies unformatted

	 * text cells to the clipboard.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readLabel()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; index to row

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; index to column

		$column = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($column);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset: 4; size: 2; XF index

			$xfIndex = self::_GetInt2d($recordData, 4);



			// add cell value

			// todo: what if string is very long? continue record

			if ($this->_version == self::XLS_BIFF8) {

				$string = self::_readUnicodeStringLong(substr($recordData, 6));

				$value = $string['value'];

			} else {

				$string = $this->_readByteStringLong(substr($recordData, 6));

				$value = $string['value'];

			}

			$cell = $this->_phpSheet->getCell($columnString . ($row + 1));

			$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_STRING);



			if (!$this->_readDataOnly) {

				// add cell style

				$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}

	}





	/**

	 * Read BLANK record

	 */

	private function _readBlank()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; row index

		$row = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; col index

		$col = self::_GetInt2d($recordData, 2);

		$columnString = PHPExcel_Cell::stringFromColumnIndex($col);



		// Read cell?

		if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {

			// offset: 4; size: 2; XF index

			$xfIndex = self::_GetInt2d($recordData, 4);



			// add style information

			if (!$this->_readDataOnly) {

				$this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);

			}

		}



	}





	/**

	 * Read MSODRAWING record

	 */

	private function _readMsoDrawing()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);



		// get spliced record data

		$splicedRecordData = $this->_getSplicedRecordData();

		$recordData = $splicedRecordData['recordData'];



		$this->_drawingData .= $recordData;

	}





	/**

	 * Read OBJ record

	 */

	private function _readObj()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly || $this->_version != self::XLS_BIFF8) {

			return;

		}



		// recordData consists of an array of subrecords looking like this:

		//	ft: 2 bytes; ftCmo type (0x15)

		//	cb: 2 bytes; size in bytes of ftCmo data

		//	ot: 2 bytes; Object Type

		//	id: 2 bytes; Object id number

		//	grbit: 2 bytes; Option Flags

		//	data: var; subrecord data



		// for now, we are just interested in the second subrecord containing the object type

		$ftCmoType	= self::_GetInt2d($recordData, 0);

		$cbCmoSize	= self::_GetInt2d($recordData, 2);

		$otObjType	= self::_GetInt2d($recordData, 4);

		$idObjID	= self::_GetInt2d($recordData, 6);

		$grbitOpts	= self::_GetInt2d($recordData, 6);



		$this->_objs[] = array(

			'ftCmoType'	=> $ftCmoType,

			'cbCmoSize'	=> $cbCmoSize,

			'otObjType'	=> $otObjType,

			'idObjID'	=> $idObjID,

			'grbitOpts'	=> $grbitOpts

		);

		$this->textObjRef = $idObjID;



//		echo '<b>_readObj()</b><br />';

//		var_dump(end($this->_objs));

//		echo '<br />';

	}





	/**

	 * Read WINDOW2 record

	 */

	private function _readWindow2()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; option flags

		$options = self::_GetInt2d($recordData, 0);



		// bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines

		$showGridlines = (bool) ((0x0002 & $options) >> 1);

		$this->_phpSheet->setShowGridlines($showGridlines);



		// bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers

		$showRowColHeaders = (bool) ((0x0004 & $options) >> 2);

		$this->_phpSheet->setShowRowColHeaders($showRowColHeaders);



		// bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen

		$this->_frozen = (bool) ((0x0008 & $options) >> 3);



		// bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left

		$this->_phpSheet->setRightToLeft((bool)((0x0040 & $options) >> 6));



		// bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active

		$isActive = (bool) ((0x0400 & $options) >> 10);

		if ($isActive) {

			$this->_phpExcel->setActiveSheetIndex($this->_phpExcel->getIndex($this->_phpSheet));

		}

	}





	/**

	 * Read SCL record

	 */

	private function _readScl()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// offset: 0; size: 2; numerator of the view magnification

		$numerator = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; numerator of the view magnification

		$denumerator = self::_GetInt2d($recordData, 2);



		// set the zoom scale (in percent)

		$this->_phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator);

	}





	/**

	 * Read PANE record

	 */

	private function _readPane()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; position of vertical split

			$px = self::_GetInt2d($recordData, 0);



			// offset: 2; size: 2; position of horizontal split

			$py = self::_GetInt2d($recordData, 2);



			if ($this->_frozen) {

				// frozen panes

				$this->_phpSheet->freezePane(PHPExcel_Cell::stringFromColumnIndex($px) . ($py + 1));

			} else {

				// unfrozen panes; split windows; not supported by PHPExcel core

			}

		}

	}





	/**

	 * Read SELECTION record. There is one such record for each pane in the sheet.

	 */

	private function _readSelection()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 1; pane identifier

			$paneId = ord($recordData{0});



			// offset: 1; size: 2; index to row of the active cell

			$r = self::_GetInt2d($recordData, 1);



			// offset: 3; size: 2; index to column of the active cell

			$c = self::_GetInt2d($recordData, 3);



			// offset: 5; size: 2; index into the following cell range list to the

			//  entry that contains the active cell

			$index = self::_GetInt2d($recordData, 5);



			// offset: 7; size: var; cell range address list containing all selected cell ranges

			$data = substr($recordData, 7);

			$cellRangeAddressList = $this->_readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax



			$selectedCells = $cellRangeAddressList['cellRangeAddresses'][0];



			// first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!)

			if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells)) {

				$selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells);

			}



			// first row '1' + last row '65536' indicates that full column is selected

			if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells)) {

				$selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells);

			}



			// first column 'A' + last column 'IV' indicates that full row is selected

			if (preg_match('/^(A[0-9]+\:)IV([0-9]+)$/', $selectedCells)) {

				$selectedCells = preg_replace('/^(A[0-9]+\:)IV([0-9]+)$/', '${1}XFD${2}', $selectedCells);

			}



			$this->_phpSheet->setSelectedCells($selectedCells);

		}

	}





	private function _includeCellRangeFiltered($cellRangeAddress)

	{

		$includeCellRange = true;

		if ($this->getReadFilter() !== NULL) {

			$includeCellRange = false;

			$rangeBoundaries = PHPExcel_Cell::getRangeBoundaries($cellRangeAddress);

			$rangeBoundaries[1][0]++;

			for ($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; $row++) {

				for ($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; $column++) {

					if ($this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle())) {

						$includeCellRange = true;

						break 2;

					}

				}

			}

		}

		return $includeCellRange;

	}





	/**

	 * MERGEDCELLS

	 *

	 * This record contains the addresses of merged cell ranges

	 * in the current sheet.

	 *

	 * --	"OpenOffice.org's Documentation of the Microsoft

	 * 		Excel File Format"

	 */

	private function _readMergedCells()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {

			$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($recordData);

			foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress) {

				if ((strpos($cellRangeAddress,':') !== FALSE) &&

					($this->_includeCellRangeFiltered($cellRangeAddress))) {

					$this->_phpSheet->mergeCells($cellRangeAddress);

				}

			}

		}

	}





	/**

	 * Read HYPERLINK record

	 */

	private function _readHyperLink()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer forward to next record

		$this->_pos += 4 + $length;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 8; cell range address of all cells containing this hyperlink

			try {

				$cellRange = $this->_readBIFF8CellRangeAddressFixed($recordData, 0, 8);

			} catch (Exception $e) {

				return;

			}



			// offset: 8, size: 16; GUID of StdLink



			// offset: 24, size: 4; unknown value



			// offset: 28, size: 4; option flags



				// bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL

				$isFileLinkOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 0;



				// bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL

				$isAbsPathOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 1;



				// bit: 2 (and 4); mask: 0x00000014; 0 = no description

				$hasDesc = (0x00000014 & self::_GetInt2d($recordData, 28)) >> 2;



				// bit: 3; mask: 0x00000008; 0 = no text, 1 = has text

				$hasText = (0x00000008 & self::_GetInt2d($recordData, 28)) >> 3;



				// bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame

				$hasFrame = (0x00000080 & self::_GetInt2d($recordData, 28)) >> 7;



				// bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name)

				$isUNC = (0x00000100 & self::_GetInt2d($recordData, 28)) >> 8;



			// offset within record data

			$offset = 32;



			if ($hasDesc) {

				// offset: 32; size: var; character count of description text

				$dl = self::_GetInt4d($recordData, 32);

				// offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated

				$desc = self::_encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false);

				$offset += 4 + 2 * $dl;

			}

			if ($hasFrame) {

				$fl = self::_GetInt4d($recordData, $offset);

				$offset += 4 + 2 * $fl;

			}



			// detect type of hyperlink (there are 4 types)

			$hyperlinkType = null;



			if ($isUNC) {

				$hyperlinkType = 'UNC';

			} else if (!$isFileLinkOrUrl) {

				$hyperlinkType = 'workbook';

			} else if (ord($recordData{$offset}) == 0x03) {

				$hyperlinkType = 'local';

			} else if (ord($recordData{$offset}) == 0xE0) {

				$hyperlinkType = 'URL';

			}



			switch ($hyperlinkType) {

			case 'URL':

				// section 5.58.2: Hyperlink containing a URL

				// e.g. http://example.org/index.php



				// offset: var; size: 16; GUID of URL Moniker

				$offset += 16;

				// offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word

				$us = self::_GetInt4d($recordData, $offset);

				$offset += 4;

				// offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated

				$url = self::_encodeUTF16(substr($recordData, $offset, $us - 2), false);

				$url .= $hasText ? '#' : '';

				$offset += $us;

				break;



			case 'local':

				// section 5.58.3: Hyperlink to local file

				// examples:

				//   mydoc.txt

				//   ../../somedoc.xls#Sheet!A1



				// offset: var; size: 16; GUI of File Moniker

				$offset += 16;



				// offset: var; size: 2; directory up-level count.

				$upLevelCount = self::_GetInt2d($recordData, $offset);

				$offset += 2;



				// offset: var; size: 4; character count of the shortened file path and name, including trailing zero word

				$sl = self::_GetInt4d($recordData, $offset);

				$offset += 4;



				// offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string)

				$shortenedFilePath = substr($recordData, $offset, $sl);

				$shortenedFilePath = self::_encodeUTF16($shortenedFilePath, true);

				$shortenedFilePath = substr($shortenedFilePath, 0, -1); // remove trailing zero



				$offset += $sl;



				// offset: var; size: 24; unknown sequence

				$offset += 24;



				// extended file path

				// offset: var; size: 4; size of the following file link field including string lenth mark

				$sz = self::_GetInt4d($recordData, $offset);

				$offset += 4;



				// only present if $sz > 0

				if ($sz > 0) {

					// offset: var; size: 4; size of the character array of the extended file path and name

					$xl = self::_GetInt4d($recordData, $offset);

					$offset += 4;



					// offset: var; size 2; unknown

					$offset += 2;



					// offset: var; size $xl; character array of the extended file path and name.

					$extendedFilePath = substr($recordData, $offset, $xl);

					$extendedFilePath = self::_encodeUTF16($extendedFilePath, false);

					$offset += $xl;

				}



				// construct the path

				$url = str_repeat('..\\', $upLevelCount);

				$url .= ($sz > 0) ?

					$extendedFilePath : $shortenedFilePath; // use extended path if available

				$url .= $hasText ? '#' : '';



				break;





			case 'UNC':

				// section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path

				// todo: implement

				return;



			case 'workbook':

				// section 5.58.5: Hyperlink to the Current Workbook

				// e.g. Sheet2!B1:C2, stored in text mark field

				$url = 'sheet://';

				break;



			default:

				return;



			}



			if ($hasText) {

				// offset: var; size: 4; character count of text mark including trailing zero word

				$tl = self::_GetInt4d($recordData, $offset);

				$offset += 4;

				// offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated

				$text = self::_encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false);

				$url .= $text;

			}



			// apply the hyperlink to all the relevant cells

			foreach (PHPExcel_Cell::extractAllCellReferencesInRange($cellRange) as $coordinate) {

				$this->_phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url);

			}

		}

	}





	/**

	 * Read DATAVALIDATIONS record

	 */

	private function _readDataValidations()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer forward to next record

		$this->_pos += 4 + $length;

	}





	/**

	 * Read DATAVALIDATION record

	 */

	private function _readDataValidation()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer forward to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// offset: 0; size: 4; Options

		$options = self::_GetInt4d($recordData, 0);



		// bit: 0-3; mask: 0x0000000F; type

		$type = (0x0000000F & $options) >> 0;

		switch ($type) {

			case 0x00:	$type = PHPExcel_Cell_DataValidation::TYPE_NONE;		break;

			case 0x01:	$type = PHPExcel_Cell_DataValidation::TYPE_WHOLE;		break;

			case 0x02:	$type = PHPExcel_Cell_DataValidation::TYPE_DECIMAL;		break;

			case 0x03:	$type = PHPExcel_Cell_DataValidation::TYPE_LIST;		break;

			case 0x04:	$type = PHPExcel_Cell_DataValidation::TYPE_DATE;		break;

			case 0x05:	$type = PHPExcel_Cell_DataValidation::TYPE_TIME;		break;

			case 0x06:	$type = PHPExcel_Cell_DataValidation::TYPE_TEXTLENGTH;	break;

			case 0x07:	$type = PHPExcel_Cell_DataValidation::TYPE_CUSTOM;		break;

		}



		// bit: 4-6; mask: 0x00000070; error type

		$errorStyle = (0x00000070 & $options) >> 4;

		switch ($errorStyle) {

			case 0x00:	$errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP;			break;

			case 0x01:	$errorStyle = PHPExcel_Cell_DataValidation::STYLE_WARNING;		break;

			case 0x02:	$errorStyle = PHPExcel_Cell_DataValidation::STYLE_INFORMATION;	break;

		}



		// bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list)

		// I have only seen cases where this is 1

		$explicitFormula = (0x00000080 & $options) >> 7;



		// bit: 8; mask: 0x00000100; 1= empty cells allowed

		$allowBlank = (0x00000100 & $options) >> 8;



		// bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity

		$suppressDropDown = (0x00000200 & $options) >> 9;



		// bit: 18; mask: 0x00040000; 1= show prompt box if cell selected

		$showInputMessage = (0x00040000 & $options) >> 18;



		// bit: 19; mask: 0x00080000; 1= show error box if invalid values entered

		$showErrorMessage = (0x00080000 & $options) >> 19;



		// bit: 20-23; mask: 0x00F00000; condition operator

		$operator = (0x00F00000 & $options) >> 20;

		switch ($operator) {

			case 0x00: $operator = PHPExcel_Cell_DataValidation::OPERATOR_BETWEEN			;	break;

			case 0x01: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTBETWEEN		;	break;

			case 0x02: $operator = PHPExcel_Cell_DataValidation::OPERATOR_EQUAL				;	break;

			case 0x03: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTEQUAL			;	break;

			case 0x04: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHAN		;	break;

			case 0x05: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHAN			;	break;

			case 0x06: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHANOREQUAL;	break;

			case 0x07: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHANOREQUAL	;	break;

		}



		// offset: 4; size: var; title of the prompt box

		$offset = 4;

		$string = self::_readUnicodeStringLong(substr($recordData, $offset));

		$promptTitle = $string['value'] !== chr(0) ?

			$string['value'] : '';

		$offset += $string['size'];



		// offset: var; size: var; title of the error box

		$string = self::_readUnicodeStringLong(substr($recordData, $offset));

		$errorTitle = $string['value'] !== chr(0) ?

			$string['value'] : '';

		$offset += $string['size'];



		// offset: var; size: var; text of the prompt box

		$string = self::_readUnicodeStringLong(substr($recordData, $offset));

		$prompt = $string['value'] !== chr(0) ?

			$string['value'] : '';

		$offset += $string['size'];



		// offset: var; size: var; text of the error box

		$string = self::_readUnicodeStringLong(substr($recordData, $offset));

		$error = $string['value'] !== chr(0) ?

			$string['value'] : '';

		$offset += $string['size'];



		// offset: var; size: 2; size of the formula data for the first condition

		$sz1 = self::_GetInt2d($recordData, $offset);

		$offset += 2;



		// offset: var; size: 2; not used

		$offset += 2;



		// offset: var; size: $sz1; formula data for first condition (without size field)

		$formula1 = substr($recordData, $offset, $sz1);

		$formula1 = pack('v', $sz1) . $formula1; // prepend the length

		try {

			$formula1 = $this->_getFormulaFromStructure($formula1);



			// in list type validity, null characters are used as item separators

			if ($type == PHPExcel_Cell_DataValidation::TYPE_LIST) {

				$formula1 = str_replace(chr(0), ',', $formula1);

			}

		} catch (Exception $e) {

			return;

		}

		$offset += $sz1;



		// offset: var; size: 2; size of the formula data for the first condition

		$sz2 = self::_GetInt2d($recordData, $offset);

		$offset += 2;



		// offset: var; size: 2; not used

		$offset += 2;



		// offset: var; size: $sz2; formula data for second condition (without size field)

		$formula2 = substr($recordData, $offset, $sz2);

		$formula2 = pack('v', $sz2) . $formula2; // prepend the length

		try {

			$formula2 = $this->_getFormulaFromStructure($formula2);

		} catch (Exception $e) {

			return;

		}

		$offset += $sz2;



		// offset: var; size: var; cell range address list with

		$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList(substr($recordData, $offset));

		$cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses'];



		foreach ($cellRangeAddresses as $cellRange) {

			$stRange = $this->_phpSheet->shrinkRangeToFit($cellRange);

			$stRange = PHPExcel_Cell::extractAllCellReferencesInRange($stRange);

			foreach ($stRange as $coordinate) {

				$objValidation = $this->_phpSheet->getCell($coordinate)->getDataValidation();

				$objValidation->setType($type);

				$objValidation->setErrorStyle($errorStyle);

				$objValidation->setAllowBlank((bool)$allowBlank);

				$objValidation->setShowInputMessage((bool)$showInputMessage);

				$objValidation->setShowErrorMessage((bool)$showErrorMessage);

				$objValidation->setShowDropDown(!$suppressDropDown);

				$objValidation->setOperator($operator);

				$objValidation->setErrorTitle($errorTitle);

				$objValidation->setError($error);

				$objValidation->setPromptTitle($promptTitle);

				$objValidation->setPrompt($prompt);

				$objValidation->setFormula1($formula1);

				$objValidation->setFormula2($formula2);

			}

		}



	}





	/**

	 * Read SHEETLAYOUT record. Stores sheet tab color information.

	 */

	private function _readSheetLayout()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// local pointer in record data

		$offset = 0;



		if (!$this->_readDataOnly) {

			// offset: 0; size: 2; repeated record identifier 0x0862



			// offset: 2; size: 10; not used



			// offset: 12; size: 4; size of record data

			// Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?)

			$sz = self::_GetInt4d($recordData, 12);



			switch ($sz) {

				case 0x14:

					// offset: 16; size: 2; color index for sheet tab

					$colorIndex = self::_GetInt2d($recordData, 16);

					$color = self::_readColor($colorIndex,$this->_palette,$this->_version);

					$this->_phpSheet->getTabColor()->setRGB($color['rgb']);

					break;



				case 0x28:

					// TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007

					return;

					break;

			}

		}

	}





	/**

	 * Read SHEETPROTECTION record (FEATHEADR)

	 */

	private function _readSheetProtection()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		if ($this->_readDataOnly) {

			return;

		}



		// offset: 0; size: 2; repeated record header



		// offset: 2; size: 2; FRT cell reference flag (=0 currently)



		// offset: 4; size: 8; Currently not used and set to 0



		// offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag)

		$isf = self::_GetInt2d($recordData, 12);

		if ($isf != 2) {

			return;

		}



		// offset: 14; size: 1; =1 since this is a feat header



		// offset: 15; size: 4; size of rgbHdrSData



		// rgbHdrSData, assume "Enhanced Protection"

		// offset: 19; size: 2; option flags

		$options = self::_GetInt2d($recordData, 19);



		// bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects

		$bool = (0x0001 & $options) >> 0;

		$this->_phpSheet->getProtection()->setObjects(!$bool);



		// bit: 1; mask 0x0002; edit scenarios

		$bool = (0x0002 & $options) >> 1;

		$this->_phpSheet->getProtection()->setScenarios(!$bool);



		// bit: 2; mask 0x0004; format cells

		$bool = (0x0004 & $options) >> 2;

		$this->_phpSheet->getProtection()->setFormatCells(!$bool);



		// bit: 3; mask 0x0008; format columns

		$bool = (0x0008 & $options) >> 3;

		$this->_phpSheet->getProtection()->setFormatColumns(!$bool);



		// bit: 4; mask 0x0010; format rows

		$bool = (0x0010 & $options) >> 4;

		$this->_phpSheet->getProtection()->setFormatRows(!$bool);



		// bit: 5; mask 0x0020; insert columns

		$bool = (0x0020 & $options) >> 5;

		$this->_phpSheet->getProtection()->setInsertColumns(!$bool);



		// bit: 6; mask 0x0040; insert rows

		$bool = (0x0040 & $options) >> 6;

		$this->_phpSheet->getProtection()->setInsertRows(!$bool);



		// bit: 7; mask 0x0080; insert hyperlinks

		$bool = (0x0080 & $options) >> 7;

		$this->_phpSheet->getProtection()->setInsertHyperlinks(!$bool);



		// bit: 8; mask 0x0100; delete columns

		$bool = (0x0100 & $options) >> 8;

		$this->_phpSheet->getProtection()->setDeleteColumns(!$bool);



		// bit: 9; mask 0x0200; delete rows

		$bool = (0x0200 & $options) >> 9;

		$this->_phpSheet->getProtection()->setDeleteRows(!$bool);



		// bit: 10; mask 0x0400; select locked cells

		$bool = (0x0400 & $options) >> 10;

		$this->_phpSheet->getProtection()->setSelectLockedCells(!$bool);



		// bit: 11; mask 0x0800; sort cell range

		$bool = (0x0800 & $options) >> 11;

		$this->_phpSheet->getProtection()->setSort(!$bool);



		// bit: 12; mask 0x1000; auto filter

		$bool = (0x1000 & $options) >> 12;

		$this->_phpSheet->getProtection()->setAutoFilter(!$bool);



		// bit: 13; mask 0x2000; pivot tables

		$bool = (0x2000 & $options) >> 13;

		$this->_phpSheet->getProtection()->setPivotTables(!$bool);



		// bit: 14; mask 0x4000; select unlocked cells

		$bool = (0x4000 & $options) >> 14;

		$this->_phpSheet->getProtection()->setSelectUnlockedCells(!$bool);



		// offset: 21; size: 2; not used

	}





	/**

	 * Read RANGEPROTECTION record

	 * Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification,

	 * where it is referred to as FEAT record

	 */

	private function _readRangeProtection()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// move stream pointer to next record

		$this->_pos += 4 + $length;



		// local pointer in record data

		$offset = 0;



		if (!$this->_readDataOnly) {

			$offset += 12;



			// offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag

			$isf = self::_GetInt2d($recordData, 12);

			if ($isf != 2) {

				// we only read FEAT records of type 2

				return;

			}

			$offset += 2;



			$offset += 5;



			// offset: 19; size: 2; count of ref ranges this feature is on

			$cref = self::_GetInt2d($recordData, 19);

			$offset += 2;



			$offset += 6;



			// offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record)

			$cellRanges = array();

			for ($i = 0; $i < $cref; ++$i) {

				try {

					$cellRange = $this->_readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8));

				} catch (Exception $e) {

					return;

				}

				$cellRanges[] = $cellRange;

				$offset += 8;

			}



			// offset: var; size: var; variable length of feature specific data

			$rgbFeat = substr($recordData, $offset);

			$offset += 4;



			// offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit)

			$wPassword = self::_GetInt4d($recordData, $offset);

			$offset += 4;



			// Apply range protection to sheet

			if ($cellRanges) {

				$this->_phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true);

			}

		}

	}





	/**

	 * Read IMDATA record

	 */

	private function _readImData()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);



		// get spliced record data

		$splicedRecordData = $this->_getSplicedRecordData();

		$recordData = $splicedRecordData['recordData'];



		// UNDER CONSTRUCTION



		// offset: 0; size: 2; image format

		$cf = self::_GetInt2d($recordData, 0);



		// offset: 2; size: 2; environment from which the file was written

		$env = self::_GetInt2d($recordData, 2);



		// offset: 4; size: 4; length of the image data

		$lcb = self::_GetInt4d($recordData, 4);



		// offset: 8; size: var; image data

		$iData = substr($recordData, 8);



		switch ($cf) {

		case 0x09: // Windows bitmap format

			// BITMAPCOREINFO

			// 1. BITMAPCOREHEADER

			// offset: 0; size: 4; bcSize, Specifies the number of bytes required by the structure

			$bcSize = self::_GetInt4d($iData, 0);

//			var_dump($bcSize);



			// offset: 4; size: 2; bcWidth, specifies the width of the bitmap, in pixels

			$bcWidth = self::_GetInt2d($iData, 4);

//			var_dump($bcWidth);



			// offset: 6; size: 2; bcHeight, specifies the height of the bitmap, in pixels.

			$bcHeight = self::_GetInt2d($iData, 6);

//			var_dump($bcHeight);

			$ih = imagecreatetruecolor($bcWidth, $bcHeight);



			// offset: 8; size: 2; bcPlanes, specifies the number of planes for the target device. This value must be 1



			// offset: 10; size: 2; bcBitCount specifies the number of bits-per-pixel. This value must be 1, 4, 8, or 24

			$bcBitCount = self::_GetInt2d($iData, 10);

//			var_dump($bcBitCount);



			$rgbString = substr($iData, 12);

			$rgbTriples = array();

			while (strlen($rgbString) > 0) {

				$rgbTriples[] = unpack('Cb/Cg/Cr', $rgbString);

				$rgbString = substr($rgbString, 3);

			}

			$x = 0;

			$y = 0;

			foreach ($rgbTriples as $i => $rgbTriple) {

				$color = imagecolorallocate($ih, $rgbTriple['r'], $rgbTriple['g'], $rgbTriple['b']);

				imagesetpixel($ih, $x, $bcHeight - 1 - $y, $color);

				$x = ($x + 1) % $bcWidth;

				$y = $y + floor(($x + 1) / $bcWidth);

			}

			//imagepng($ih, 'image.png');



			$drawing = new PHPExcel_Worksheet_Drawing();

			$drawing->setPath($filename);

			$drawing->setWorksheet($this->_phpSheet);



			break;



		case 0x02: // Windows metafile or Macintosh PICT format

		case 0x0e: // native format

		default;

			break;



		}



		// _getSplicedRecordData() takes care of moving current position in data stream

	}





	/**

	 * Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record

	 * When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented.

	 * In this case, we must treat the CONTINUE record as a MSODRAWING record

	 */

	private function _readContinue()

	{

		$length = self::_GetInt2d($this->_data, $this->_pos + 2);

		$recordData = substr($this->_data, $this->_pos + 4, $length);



		// check if we are reading drawing data

		// this is in case a free CONTINUE record occurs in other circumstances we are unaware of

		if ($this->_drawingData == '') {

			// move stream pointer to next record

			$this->_pos += 4 + $length;



			return;

		}



		// check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data

		if ($length < 4) {

			// move stream pointer to next record

			$this->_pos += 4 + $length;



			return;

		}



		// dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record

		// look inside CONTINUE record to see if it looks like a part of an Escher stream

		// we know that Escher stream may be split at least at

		//		0xF003 MsofbtSpgrContainer

		//		0xF004 MsofbtSpContainer

		//		0xF00D MsofbtClientTextbox

		$validSplitPoints = array(0xF003, 0xF004, 0xF00D); // add identifiers if we find more



		$splitPoint = self::_GetInt2d($recordData, 2);

		if (in_array($splitPoint, $validSplitPoints)) {

			// get spliced record data (and move pointer to next record)

			$splicedRecordData = $this->_getSplicedRecordData();

			$this->_drawingData .= $splicedRecordData['recordData'];



			return;

		}



		// move stream pointer to next record

		$this->_pos += 4 + $length;



	}





	/**

	 * Reads a record from current position in data stream and continues reading data as long as CONTINUE

	 * records are found. Splices the record data pieces and returns the combined string as if record data

	 * is in one piece.

	 * Moves to next current position in data stream to start of next record different from a CONtINUE record

	 *

	 * @return array

	 */

	private function _getSplicedRecordData()

	{

		$data = '';

		$spliceOffsets = array();



		$i = 0;

		$spliceOffsets[0] = 0;



		do {

			++$i;



			// offset: 0; size: 2; identifier

			$identifier = self::_GetInt2d($this->_data, $this->_pos);

			// offset: 2; size: 2; length

			$length = self::_GetInt2d($this->_data, $this->_pos + 2);

			$data .= substr($this->_data, $this->_pos + 4, $length);



			$spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length;



			$this->_pos += 4 + $length;

			$nextIdentifier = self::_GetInt2d($this->_data, $this->_pos);

		}

		while ($nextIdentifier == self::XLS_Type_CONTINUE);



		$splicedData = array(

			'recordData' => $data,

			'spliceOffsets' => $spliceOffsets,

		);



		return $splicedData;



	}





	/**

	 * Convert formula structure into human readable Excel formula like 'A3+A5*5'

	 *

	 * @param string $formulaStructure The complete binary data for the formula

	 * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

	 * @return string Human readable formula

	 */

	private function _getFormulaFromStructure($formulaStructure, $baseCell = 'A1')

	{

		// offset: 0; size: 2; size of the following formula data

		$sz = self::_GetInt2d($formulaStructure, 0);



		// offset: 2; size: sz

		$formulaData = substr($formulaStructure, 2, $sz);



		// for debug: dump the formula data

		//echo '<xmp>';

		//echo 'size: ' . $sz . "\n";

		//echo 'the entire formula data: ';

		//Debug::dump($formulaData);

		//echo "\n----\n";



		// offset: 2 + sz; size: variable (optional)

		if (strlen($formulaStructure) > 2 + $sz) {

			$additionalData = substr($formulaStructure, 2 + $sz);



			// for debug: dump the additional data

			//echo 'the entire additional data: ';

			//Debug::dump($additionalData);

			//echo "\n----\n";



		} else {

			$additionalData = '';

		}



		return $this->_getFormulaFromData($formulaData, $additionalData, $baseCell);

	}





	/**

	 * Take formula data and additional data for formula and return human readable formula

	 *

	 * @param string $formulaData The binary data for the formula itself

	 * @param string $additionalData Additional binary data going with the formula

	 * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

	 * @return string Human readable formula

	 */

	private function _getFormulaFromData($formulaData,  $additionalData = '', $baseCell = 'A1')

	{

		// start parsing the formula data

		$tokens = array();



		while (strlen($formulaData) > 0 and $token = $this->_getNextToken($formulaData, $baseCell)) {

			$tokens[] = $token;

			$formulaData = substr($formulaData, $token['size']);



			// for debug: dump the token

			//var_dump($token);

		}



		$formulaString = $this->_createFormulaFromTokens($tokens, $additionalData);



		return $formulaString;

	}





	/**

	 * Take array of tokens together with additional data for formula and return human readable formula

	 *

	 * @param array $tokens

	 * @param array $additionalData Additional binary data going with the formula

	 * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

	 * @return string Human readable formula

	 */

	private function _createFormulaFromTokens($tokens, $additionalData)

	{

		// empty formula?

		if (empty($tokens)) {

			return '';

		}



		$formulaStrings = array();

		foreach ($tokens as $token) {

			// initialize spaces

			$space0 = isset($space0) ? $space0 : ''; // spaces before next token, not tParen

			$space1 = isset($space1) ? $space1 : ''; // carriage returns before next token, not tParen

			$space2 = isset($space2) ? $space2 : ''; // spaces before opening parenthesis

			$space3 = isset($space3) ? $space3 : ''; // carriage returns before opening parenthesis

			$space4 = isset($space4) ? $space4 : ''; // spaces before closing parenthesis

			$space5 = isset($space5) ? $space5 : ''; // carriage returns before closing parenthesis



			switch ($token['name']) {

			case 'tAdd': // addition

			case 'tConcat': // addition

			case 'tDiv': // division

			case 'tEQ': // equality

			case 'tGE': // greater than or equal

			case 'tGT': // greater than

			case 'tIsect': // intersection

			case 'tLE': // less than or equal

			case 'tList': // less than or equal

			case 'tLT': // less than

			case 'tMul': // multiplication

			case 'tNE': // multiplication

			case 'tPower': // power

			case 'tRange': // range

			case 'tSub': // subtraction

				$op2 = array_pop($formulaStrings);

				$op1 = array_pop($formulaStrings);

				$formulaStrings[] = "$op1$space1$space0{$token['data']}$op2";

				unset($space0, $space1);

				break;

			case 'tUplus': // unary plus

			case 'tUminus': // unary minus

				$op = array_pop($formulaStrings);

				$formulaStrings[] = "$space1$space0{$token['data']}$op";

				unset($space0, $space1);

				break;

			case 'tPercent': // percent sign

				$op = array_pop($formulaStrings);

				$formulaStrings[] = "$op$space1$space0{$token['data']}";

				unset($space0, $space1);

				break;

			case 'tAttrVolatile': // indicates volatile function

			case 'tAttrIf':

			case 'tAttrSkip':

			case 'tAttrChoose':

				// token is only important for Excel formula evaluator

				// do nothing

				break;

			case 'tAttrSpace': // space / carriage return

				// space will be used when next token arrives, do not alter formulaString stack

				switch ($token['data']['spacetype']) {

				case 'type0':

					$space0 = str_repeat(' ', $token['data']['spacecount']);

					break;

				case 'type1':

					$space1 = str_repeat("\n", $token['data']['spacecount']);

					break;

				case 'type2':

					$space2 = str_repeat(' ', $token['data']['spacecount']);

					break;

				case 'type3':

					$space3 = str_repeat("\n", $token['data']['spacecount']);

					break;

				case 'type4':

					$space4 = str_repeat(' ', $token['data']['spacecount']);

					break;

				case 'type5':

					$space5 = str_repeat("\n", $token['data']['spacecount']);

					break;

				}

				break;

			case 'tAttrSum': // SUM function with one parameter

				$op = array_pop($formulaStrings);

				$formulaStrings[] = "{$space1}{$space0}SUM($op)";

				unset($space0, $space1);

				break;

			case 'tFunc': // function with fixed number of arguments

			case 'tFuncV': // function with variable number of arguments

				if ($token['data']['function'] != '') {

					// normal function

					$ops = array(); // array of operators

					for ($i = 0; $i < $token['data']['args']; ++$i) {

						$ops[] = array_pop($formulaStrings);

					}

					$ops = array_reverse($ops);

					$formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ")";

					unset($space0, $space1);

				} else {

					// add-in function

					$ops = array(); // array of operators

					for ($i = 0; $i < $token['data']['args'] - 1; ++$i) {

						$ops[] = array_pop($formulaStrings);

					}

					$ops = array_reverse($ops);

					$function = array_pop($formulaStrings);

					$formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ")";

					unset($space0, $space1);

				}

				break;

			case 'tParen': // parenthesis

				$expression = array_pop($formulaStrings);

				$formulaStrings[] = "$space3$space2($expression$space5$space4)";

				unset($space2, $space3, $space4, $space5);

				break;

			case 'tArray': // array constant

				$constantArray = self::_readBIFF8ConstantArray($additionalData);

				$formulaStrings[] = $space1 . $space0 . $constantArray['value'];

				$additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data

				unset($space0, $space1);

				break;

			case 'tMemArea':

				// bite off chunk of additional data

				$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($additionalData);

				$additionalData = substr($additionalData, $cellRangeAddressList['size']);

				$formulaStrings[] = "$space1$space0{$token['data']}";

				unset($space0, $space1);

				break;

			case 'tArea': // cell range address

			case 'tBool': // boolean

			case 'tErr': // error code

			case 'tInt': // integer

			case 'tMemErr':

			case 'tMemFunc':

			case 'tMissArg':

			case 'tName':

			case 'tNameX':

			case 'tNum': // number

			case 'tRef': // single cell reference

			case 'tRef3d': // 3d cell reference

			case 'tArea3d': // 3d cell range reference

			case 'tRefN':

			case 'tAreaN':

			case 'tStr': // string

				$formulaStrings[] = "$space1$space0{$token['data']}";

				unset($space0, $space1);

				break;

			}

		}

		$formulaString = $formulaStrings[0];



		// for debug: dump the human readable formula

		//echo '----' . "\n";

		//echo 'Formula: ' . $formulaString;



		return $formulaString;

	}





	/**

	 * Fetch next token from binary formula data

	 *

	 * @param string Formula data

	 * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

	 * @return array

	 * @throws Exception

	 */

	private function _getNextToken($formulaData, $baseCell = 'A1')

	{

		// offset: 0; size: 1; token id

		$id = ord($formulaData[0]); // token id

		$name = false; // initialize token name



		switch ($id) {

		case 0x03: $name = 'tAdd';		$size = 1;	$data = '+';	break;

		case 0x04: $name = 'tSub';		$size = 1;	$data = '-';	break;

		case 0x05: $name = 'tMul';		$size = 1;	$data = '*';	break;

		case 0x06: $name = 'tDiv';		$size = 1;	$data = '/';	break;

		case 0x07: $name = 'tPower';	$size = 1;	$data = '^';	break;

		case 0x08: $name = 'tConcat';	$size = 1;	$data = '&';	break;

		case 0x09: $name = 'tLT';		$size = 1;	$data = '<';	break;

		case 0x0A: $name = 'tLE';		$size = 1;	$data = '<=';	break;

		case 0x0B: $name = 'tEQ';		$size = 1;	$data = '=';	break;

		case 0x0C: $name = 'tGE';		$size = 1;	$data = '>=';	break;

		case 0x0D: $name = 'tGT';		$size = 1;	$data = '>';	break;

		case 0x0E: $name = 'tNE';		$size = 1;	$data = '<>';	break;

		case 0x0F: $name = 'tIsect';	$size = 1;	$data = ' ';	break;

		case 0x10: $name = 'tList';		$size = 1;	$data = ',';	break;

		case 0x11: $name = 'tRange';	$size = 1;	$data = ':';	break;

		case 0x12: $name = 'tUplus';	$size = 1;	$data = '+';	break;

		case 0x13: $name = 'tUminus';	$size = 1;	$data = '-';	break;

		case 0x14: $name = 'tPercent';	$size = 1;	$data = '%';	break;

		case 0x15:	//	parenthesis

			$name  = 'tParen';

			$size  = 1;

			$data = null;

			break;

		case 0x16:	//	missing argument

			$name = 'tMissArg';

			$size = 1;

			$data = '';

			break;

		case 0x17:	//	string

			$name = 'tStr';

			// offset: 1; size: var; Unicode string, 8-bit string length

			$string = self::_readUnicodeStringShort(substr($formulaData, 1));

			$size = 1 + $string['size'];

			$data = self::_UTF8toExcelDoubleQuoted($string['value']);

			break;

		case 0x19:	//	Special attribute

			// offset: 1; size: 1; attribute type flags:

			switch (ord($formulaData[1])) {

			case 0x01:

				$name = 'tAttrVolatile';

				$size = 4;

				$data = null;

				break;

			case 0x02:

				$name = 'tAttrIf';

				$size = 4;

				$data = null;

				break;

			case 0x04:

				$name = 'tAttrChoose';

				// offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1)

				$nc = self::_GetInt2d($formulaData, 2);

				// offset: 4; size: 2 * $nc

				// offset: 4 + 2 * $nc; size: 2

				$size = 2 * $nc + 6;

				$data = null;

				break;

			case 0x08:

				$name = 'tAttrSkip';

				$size = 4;

				$data = null;

				break;

			case 0x10:

				$name = 'tAttrSum';

				$size = 4;

				$data = null;

				break;

			case 0x40:

			case 0x41:

				$name = 'tAttrSpace';

				$size = 4;

				// offset: 2; size: 2; space type and position

				switch (ord($formulaData[2])) {

				case 0x00:

					$spacetype = 'type0';

					break;

				case 0x01:

					$spacetype = 'type1';

					break;

				case 0x02:

					$spacetype = 'type2';

					break;

				case 0x03:

					$spacetype = 'type3';

					break;

				case 0x04:

					$spacetype = 'type4';

					break;

				case 0x05:

					$spacetype = 'type5';

					break;

				default:

					throw new Exception('Unrecognized space type in tAttrSpace token');

					break;

				}

				// offset: 3; size: 1; number of inserted spaces/carriage returns

				$spacecount = ord($formulaData[3]);



				$data = array('spacetype' => $spacetype, 'spacecount' => $spacecount);

				break;

			default:

				throw new Exception('Unrecognized attribute flag in tAttr token');

				break;

			}

			break;

		case 0x1C:	//	error code

			// offset: 1; size: 1; error code

			$name = 'tErr';

			$size = 2;

			$data = self::_mapErrorCode(ord($formulaData[1]));

			break;

		case 0x1D:	//	boolean

			// offset: 1; size: 1; 0 = false, 1 = true;

			$name = 'tBool';

			$size = 2;

			$data = ord($formulaData[1]) ? 'TRUE' : 'FALSE';

			break;

		case 0x1E:	//	integer

			// offset: 1; size: 2; unsigned 16-bit integer

			$name = 'tInt';

			$size = 3;

			$data = self::_GetInt2d($formulaData, 1);

			break;

		case 0x1F:	//	number

			// offset: 1; size: 8;

			$name = 'tNum';

			$size = 9;

			$data = self::_extractNumber(substr($formulaData, 1));

			$data = str_replace(',', '.', (string)$data); // in case non-English locale

			break;

		case 0x20:	//	array constant

		case 0x40:

		case 0x60:

			// offset: 1; size: 7; not used

			$name = 'tArray';

			$size = 8;

			$data = null;

			break;

		case 0x21:	//	function with fixed number of arguments

		case 0x41:

		case 0x61:

			$name = 'tFunc';

			$size = 3;

			// offset: 1; size: 2; index to built-in sheet function

			switch (self::_GetInt2d($formulaData, 1)) {

			case   2: $function = 'ISNA'; 			$args = 1; 	break;

			case   3: $function = 'ISERROR'; 		$args = 1; 	break;

			case  10: $function = 'NA'; 			$args = 0; 	break;

			case  15: $function = 'SIN'; 			$args = 1; 	break;

			case  16: $function = 'COS'; 			$args = 1; 	break;

			case  17: $function = 'TAN'; 			$args = 1; 	break;

			case  18: $function = 'ATAN'; 			$args = 1; 	break;

			case  19: $function = 'PI'; 			$args = 0; 	break;

			case  20: $function = 'SQRT'; 			$args = 1; 	break;

			case  21: $function = 'EXP'; 			$args = 1; 	break;

			case  22: $function = 'LN'; 			$args = 1; 	break;

			case  23: $function = 'LOG10'; 			$args = 1; 	break;

			case  24: $function = 'ABS'; 			$args = 1; 	break;

			case  25: $function = 'INT'; 			$args = 1; 	break;

			case  26: $function = 'SIGN'; 			$args = 1; 	break;

			case  27: $function = 'ROUND'; 			$args = 2; 	break;

			case  30: $function = 'REPT'; 			$args = 2; 	break;

			case  31: $function = 'MID'; 			$args = 3; 	break;

			case  32: $function = 'LEN'; 			$args = 1; 	break;

			case  33: $function = 'VALUE'; 			$args = 1; 	break;

			case  34: $function = 'TRUE'; 			$args = 0; 	break;

			case  35: $function = 'FALSE'; 			$args = 0; 	break;

			case  38: $function = 'NOT'; 			$args = 1; 	break;

			case  39: $function = 'MOD'; 			$args = 2;	break;

			case  40: $function = 'DCOUNT'; 		$args = 3;	break;

			case  41: $function = 'DSUM'; 			$args = 3;	break;

			case  42: $function = 'DAVERAGE'; 		$args = 3;	break;

			case  43: $function = 'DMIN'; 			$args = 3;	break;

			case  44: $function = 'DMAX'; 			$args = 3;	break;

			case  45: $function = 'DSTDEV'; 		$args = 3;	break;

			case  48: $function = 'TEXT'; 			$args = 2;	break;

			case  61: $function = 'MIRR'; 			$args = 3;	break;

			case  63: $function = 'RAND'; 			$args = 0;	break;

			case  65: $function = 'DATE'; 			$args = 3;	break;

			case  66: $function = 'TIME'; 			$args = 3;	break;

			case  67: $function = 'DAY'; 			$args = 1;	break;

			case  68: $function = 'MONTH'; 			$args = 1;	break;

			case  69: $function = 'YEAR'; 			$args = 1;	break;

			case  71: $function = 'HOUR'; 			$args = 1;	break;

			case  72: $function = 'MINUTE'; 		$args = 1;	break;

			case  73: $function = 'SECOND'; 		$args = 1;	break;

			case  74: $function = 'NOW'; 			$args = 0;	break;

			case  75: $function = 'AREAS'; 			$args = 1;	break;

			case  76: $function = 'ROWS'; 			$args = 1;	break;

			case  77: $function = 'COLUMNS'; 		$args = 1;	break;

			case  83: $function = 'TRANSPOSE'; 		$args = 1;	break;

			case  86: $function = 'TYPE'; 			$args = 1;	break;

			case  97: $function = 'ATAN2'; 			$args = 2;	break;

			case  98: $function = 'ASIN'; 			$args = 1;	break;

			case  99: $function = 'ACOS'; 			$args = 1;	break;

			case 105: $function = 'ISREF'; 			$args = 1;	break;

			case 111: $function = 'CHAR'; 			$args = 1;	break;

			case 112: $function = 'LOWER'; 			$args = 1;	break;

			case 113: $function = 'UPPER'; 			$args = 1;	break;

			case 114: $function = 'PROPER'; 		$args = 1;	break;

			case 117: $function = 'EXACT'; 			$args = 2;	break;

			case 118: $function = 'TRIM'; 			$args = 1;	break;

			case 119: $function = 'REPLACE'; 		$args = 4;	break;

			case 121: $function = 'CODE'; 			$args = 1;	break;

			case 126: $function = 'ISERR'; 			$args = 1;	break;

			case 127: $function = 'ISTEXT'; 		$args = 1;	break;

			case 128: $function = 'ISNUMBER'; 		$args = 1;	break;

			case 129: $function = 'ISBLANK'; 		$args = 1;	break;

			case 130: $function = 'T'; 				$args = 1;	break;

			case 131: $function = 'N'; 				$args = 1;	break;

			case 140: $function = 'DATEVALUE'; 		$args = 1;	break;

			case 141: $function = 'TIMEVALUE'; 		$args = 1;	break;

			case 142: $function = 'SLN'; 			$args = 3;	break;

			case 143: $function = 'SYD'; 			$args = 4;	break;

			case 162: $function = 'CLEAN'; 			$args = 1;	break;

			case 163: $function = 'MDETERM'; 		$args = 1;	break;

			case 164: $function = 'MINVERSE'; 		$args = 1;	break;

			case 165: $function = 'MMULT'; 			$args = 2;	break;

			case 184: $function = 'FACT'; 			$args = 1;	break;

			case 189: $function = 'DPRODUCT'; 		$args = 3;	break;

			case 190: $function = 'ISNONTEXT'; 		$args = 1;	break;

			case 195: $function = 'DSTDEVP'; 		$args = 3;	break;

			case 196: $function = 'DVARP'; 			$args = 3;	break;

			case 198: $function = 'ISLOGICAL'; 		$args = 1;	break;

			case 199: $function = 'DCOUNTA'; 		$args = 3;	break;

			case 207: $function = 'REPLACEB'; 		$args = 4;	break;

			case 210: $function = 'MIDB'; 			$args = 3;	break;

			case 211: $function = 'LENB'; 			$args = 1;	break;

			case 212: $function = 'ROUNDUP'; 		$args = 2;	break;

			case 213: $function = 'ROUNDDOWN'; 		$args = 2;	break;

			case 214: $function = 'ASC'; 			$args = 1;	break;

			case 215: $function = 'DBCS'; 			$args = 1;	break;

			case 221: $function = 'TODAY'; 			$args = 0;	break;

			case 229: $function = 'SINH'; 			$args = 1;	break;

			case 230: $function = 'COSH'; 			$args = 1;	break;

			case 231: $function = 'TANH'; 			$args = 1;	break;

			case 232: $function = 'ASINH'; 			$args = 1;	break;

			case 233: $function = 'ACOSH'; 			$args = 1;	break;

			case 234: $function = 'ATANH'; 			$args = 1;	break;

			case 235: $function = 'DGET'; 			$args = 3;	break;

			case 244: $function = 'INFO'; 			$args = 1;	break;

			case 252: $function = 'FREQUENCY'; 		$args = 2;	break;

			case 261: $function = 'ERROR.TYPE'; 	$args = 1;	break;

			case 271: $function = 'GAMMALN'; 		$args = 1;	break;

			case 273: $function = 'BINOMDIST'; 		$args = 4;	break;

			case 274: $function = 'CHIDIST'; 		$args = 2;	break;

			case 275: $function = 'CHIINV'; 		$args = 2;	break;

			case 276: $function = 'COMBIN'; 		$args = 2;	break;

			case 277: $function = 'CONFIDENCE'; 	$args = 3;	break;

			case 278: $function = 'CRITBINOM'; 		$args = 3;	break;

			case 279: $function = 'EVEN'; 			$args = 1;	break;

			case 280: $function = 'EXPONDIST'; 		$args = 3;	break;

			case 281: $function = 'FDIST'; 			$args = 3;	break;

			case 282: $function = 'FINV'; 			$args = 3;	break;

			case 283: $function = 'FISHER'; 		$args = 1;	break;

			case 284: $function = 'FISHERINV'; 		$args = 1;	break;

			case 285: $function = 'FLOOR'; 			$args = 2;	break;

			case 286: $function = 'GAMMADIST'; 		$args = 4;	break;

			case 287: $function = 'GAMMAINV'; 		$args = 3;	break;

			case 288: $function = 'CEILING'; 		$args = 2;	break;

			case 289: $function = 'HYPGEOMDIST';	$args = 4;	break;

			case 290: $function = 'LOGNORMDIST';	$args = 3;	break;

			case 291: $function = 'LOGINV';			$args = 3;	break;

			case 292: $function = 'NEGBINOMDIST';	$args = 3;	break;

			case 293: $function = 'NORMDIST';		$args = 4;	break;

			case 294: $function = 'NORMSDIST';		$args = 1;	break;

			case 295: $function = 'NORMINV';		$args = 3;	break;

			case 296: $function = 'NORMSINV';		$args = 1;	break;

			case 297: $function = 'STANDARDIZE';	$args = 3;	break;

			case 298: $function = 'ODD';			$args = 1;	break;

			case 299: $function = 'PERMUT';			$args = 2;	break;

			case 300: $function = 'POISSON';		$args = 3;	break;

			case 301: $function = 'TDIST';			$args = 3;	break;

			case 302: $function = 'WEIBULL';		$args = 4;	break;

			case 303: $function = 'SUMXMY2';		$args = 2;	break;

			case 304: $function = 'SUMX2MY2';		$args = 2;	break;

			case 305: $function = 'SUMX2PY2';		$args = 2;	break;

			case 306: $function = 'CHITEST';		$args = 2;	break;

			case 307: $function = 'CORREL';			$args = 2;	break;

			case 308: $function = 'COVAR';			$args = 2;	break;

			case 309: $function = 'FORECAST';		$args = 3;	break;

			case 310: $function = 'FTEST';			$args = 2;	break;

			case 311: $function = 'INTERCEPT';		$args = 2;	break;

			case 312: $function = 'PEARSON';		$args = 2;	break;

			case 313: $function = 'RSQ';			$args = 2;	break;

			case 314: $function = 'STEYX';			$args = 2;	break;

			case 315: $function = 'SLOPE';			$args = 2;	break;

			case 316: $function = 'TTEST';			$args = 4;	break;

			case 325: $function = 'LARGE';			$args = 2;	break;

			case 326: $function = 'SMALL';			$args = 2;	break;

			case 327: $function = 'QUARTILE';		$args = 2;	break;

			case 328: $function = 'PERCENTILE';		$args = 2;	break;

			case 331: $function = 'TRIMMEAN';		$args = 2;	break;

			case 332: $function = 'TINV';			$args = 2;	break;

			case 337: $function = 'POWER';			$args = 2;	break;

			case 342: $function = 'RADIANS';		$args = 1;	break;

			case 343: $function = 'DEGREES';		$args = 1;	break;

			case 346: $function = 'COUNTIF';		$args = 2;	break;

			case 347: $function = 'COUNTBLANK';		$args = 1;	break;

			case 350: $function = 'ISPMT';			$args = 4;	break;

			case 351: $function = 'DATEDIF';		$args = 3;	break;

			case 352: $function = 'DATESTRING';		$args = 1;	break;

			case 353: $function = 'NUMBERSTRING';	$args = 2;	break;

			case 360: $function = 'PHONETIC';		$args = 1;	break;

			case 368: $function = 'BAHTTEXT';		$args = 1;	break;

			default:

				throw new Exception('Unrecognized function in formula');

				break;

			}

			$data = array('function' => $function, 'args' => $args);

			break;

		case 0x22:	//	function with variable number of arguments

		case 0x42:

		case 0x62:

			$name = 'tFuncV';

			$size = 4;

			// offset: 1; size: 1; number of arguments

			$args = ord($formulaData[1]);

			// offset: 2: size: 2; index to built-in sheet function

			$index = self::_GetInt2d($formulaData, 2);

			switch ($index) {

			case   0: $function = 'COUNT';			break;

			case   1: $function = 'IF';				break;

			case   4: $function = 'SUM';			break;

			case   5: $function = 'AVERAGE';		break;

			case   6: $function = 'MIN';			break;

			case   7: $function = 'MAX';			break;

			case   8: $function = 'ROW';			break;

			case   9: $function = 'COLUMN';			break;

			case  11: $function = 'NPV';			break;

			case  12: $function = 'STDEV';			break;

			case  13: $function = 'DOLLAR';			break;

			case  14: $function = 'FIXED';			break;

			case  28: $function = 'LOOKUP';			break;

			case  29: $function = 'INDEX';			break;

			case  36: $function = 'AND';			break;

			case  37: $function = 'OR';				break;

			case  46: $function = 'VAR';			break;

			case  49: $function = 'LINEST';			break;

			case  50: $function = 'TREND';			break;

			case  51: $function = 'LOGEST';			break;

			case  52: $function = 'GROWTH';			break;

			case  56: $function = 'PV';				break;

			case  57: $function = 'FV';				break;

			case  58: $function = 'NPER';			break;

			case  59: $function = 'PMT';			break;

			case  60: $function = 'RATE';			break;

			case  62: $function = 'IRR';			break;

			case  64: $function = 'MATCH';			break;

			case  70: $function = 'WEEKDAY';		break;

			case  78: $function = 'OFFSET';			break;

			case  82: $function = 'SEARCH';			break;

			case 100: $function = 'CHOOSE';			break;

			case 101: $function = 'HLOOKUP';		break;

			case 102: $function = 'VLOOKUP';		break;

			case 109: $function = 'LOG';			break;

			case 115: $function = 'LEFT';			break;

			case 116: $function = 'RIGHT';			break;

			case 120: $function = 'SUBSTITUTE';		break;

			case 124: $function = 'FIND';			break;

			case 125: $function = 'CELL';			break;

			case 144: $function = 'DDB';			break;

			case 148: $function = 'INDIRECT';		break;

			case 167: $function = 'IPMT';			break;

			case 168: $function = 'PPMT';			break;

			case 169: $function = 'COUNTA';			break;

			case 183: $function = 'PRODUCT';		break;

			case 193: $function = 'STDEVP';			break;

			case 194: $function = 'VARP';			break;

			case 197: $function = 'TRUNC';			break;

			case 204: $function = 'USDOLLAR';		break;

			case 205: $function = 'FINDB';			break;

			case 206: $function = 'SEARCHB';		break;

			case 208: $function = 'LEFTB';			break;

			case 209: $function = 'RIGHTB';			break;

			case 216: $function = 'RANK';			break;

			case 219: $function = 'ADDRESS';		break;

			case 220: $function = 'DAYS360';		break;

			case 222: $function = 'VDB';			break;

			case 227: $function = 'MEDIAN';			break;

			case 228: $function = 'SUMPRODUCT';		break;

			case 247: $function = 'DB';				break;

			case 255: $function = '';				break;

			case 269: $function = 'AVEDEV';			break;

			case 270: $function = 'BETADIST';		break;

			case 272: $function = 'BETAINV';		break;

			case 317: $function = 'PROB';			break;

			case 318: $function = 'DEVSQ';			break;

			case 319: $function = 'GEOMEAN';		break;

			case 320: $function = 'HARMEAN';		break;

			case 321: $function = 'SUMSQ';			break;

			case 322: $function = 'KURT';			break;

			case 323: $function = 'SKEW';			break;

			case 324: $function = 'ZTEST';			break;

			case 329: $function = 'PERCENTRANK';	break;

			case 330: $function = 'MODE';			break;

			case 336: $function = 'CONCATENATE';	break;

			case 344: $function = 'SUBTOTAL';		break;

			case 345: $function = 'SUMIF';			break;

			case 354: $function = 'ROMAN';			break;

			case 358: $function = 'GETPIVOTDATA';	break;

			case 359: $function = 'HYPERLINK';		break;

			case 361: $function = 'AVERAGEA';		break;

			case 362: $function = 'MAXA';			break;

			case 363: $function = 'MINA';			break;

			case 364: $function = 'STDEVPA';		break;

			case 365: $function = 'VARPA';			break;

			case 366: $function = 'STDEVA';			break;

			case 367: $function = 'VARA';			break;

			default:

				throw new Exception('Unrecognized function in formula');

				break;

			}

			$data = array('function' => $function, 'args' => $args);

			break;

		case 0x23:	//	index to defined name

		case 0x43:

		case 0x63:

			$name = 'tName';

			$size = 5;

			// offset: 1; size: 2; one-based index to definedname record

			$definedNameIndex = self::_GetInt2d($formulaData, 1) - 1;

			// offset: 2; size: 2; not used

			$data = $this->_definedname[$definedNameIndex]['name'];

			break;

		case 0x24:	//	single cell reference e.g. A5

		case 0x44:

		case 0x64:

			$name = 'tRef';

			$size = 5;

			$data = $this->_readBIFF8CellAddress(substr($formulaData, 1, 4));

			break;

		case 0x25:	//	cell range reference to cells in the same sheet (2d)

		case 0x45:

		case 0x65:

			$name = 'tArea';

			$size = 9;

			$data = $this->_readBIFF8CellRangeAddress(substr($formulaData, 1, 8));

			break;

		case 0x26:	//	Constant reference sub-expression

		case 0x46:

		case 0x66:

			$name = 'tMemArea';

			// offset: 1; size: 4; not used

			// offset: 5; size: 2; size of the following subexpression

			$subSize = self::_GetInt2d($formulaData, 5);

			$size = 7 + $subSize;

			$data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));

			break;

		case 0x27:	//	Deleted constant reference sub-expression

		case 0x47:

		case 0x67:

			$name = 'tMemErr';

			// offset: 1; size: 4; not used

			// offset: 5; size: 2; size of the following subexpression

			$subSize = self::_GetInt2d($formulaData, 5);

			$size = 7 + $subSize;

			$data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));

			break;

		case 0x29:	//	Variable reference sub-expression

		case 0x49:

		case 0x69:

			$name = 'tMemFunc';

			// offset: 1; size: 2; size of the following sub-expression

			$subSize = self::_GetInt2d($formulaData, 1);

			$size = 3 + $subSize;

			$data = $this->_getFormulaFromData(substr($formulaData, 3, $subSize));

			break;



		case 0x2C: // Relative 2d cell reference reference, used in shared formulas and some other places

		case 0x4C:

		case 0x6C:

			$name = 'tRefN';

			$size = 5;

			$data = $this->_readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell);

			break;



		case 0x2D:	//	Relative 2d range reference

		case 0x4D:

		case 0x6D:

			$name = 'tAreaN';

			$size = 9;

			$data = $this->_readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell);

			break;



		case 0x39:	//	External name

		case 0x59:

		case 0x79:

			$name = 'tNameX';

			$size = 7;

			// offset: 1; size: 2; index to REF entry in EXTERNSHEET record

			// offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record

			$index = self::_GetInt2d($formulaData, 3);

			// assume index is to EXTERNNAME record

			$data = $this->_externalNames[$index - 1]['name'];

			// offset: 5; size: 2; not used

			break;



		case 0x3A:	//	3d reference to cell

		case 0x5A:

		case 0x7A:

			$name = 'tRef3d';

			$size = 7;



			try {

				// offset: 1; size: 2; index to REF entry

				$sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));

				// offset: 3; size: 4; cell address

				$cellAddress = $this->_readBIFF8CellAddress(substr($formulaData, 3, 4));



				$data = "$sheetRange!$cellAddress";

			} catch (Exception $e) {

				// deleted sheet reference

				$data = '#REF!';

			}



			break;

		case 0x3B:	//	3d reference to cell range

		case 0x5B:

		case 0x7B:

			$name = 'tArea3d';

			$size = 11;



			try {

				// offset: 1; size: 2; index to REF entry

				$sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));

				// offset: 3; size: 8; cell address

				$cellRangeAddress = $this->_readBIFF8CellRangeAddress(substr($formulaData, 3, 8));



				$data = "$sheetRange!$cellRangeAddress";

			} catch (Exception $e) {

				// deleted sheet reference

				$data = '#REF!';

			}



			break;

		// Unknown cases	// don't know how to deal with

		default:

			throw new Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula');

			break;

		}



		return array(

			'id' => $id,

			'name' => $name,

			'size' => $size,

			'data' => $data,

		);

	}





	/**

	 * Reads a cell address in BIFF8 e.g. 'A2' or '$A$2'

	 * section 3.3.4

	 *

	 * @param string $cellAddressStructure

	 * @return string

	 */

	private function _readBIFF8CellAddress($cellAddressStructure)

	{

		// offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))

		$row = self::_GetInt2d($cellAddressStructure, 0) + 1;



		// offset: 2; size: 2; index to column or column offset + relative flags



			// bit: 7-0; mask 0x00FF; column index

			$column = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($cellAddressStructure, 2));



			// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

			if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {

				$column = '$' . $column;

			}

			// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

			if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {

				$row = '$' . $row;

			}



		return $column . $row;

	}





	/**

	 * Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column

	 * to indicate offsets from a base cell

	 * section 3.3.4

	 *

	 * @param string $cellAddressStructure

	 * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas

	 * @return string

	 */

	private function _readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1')

	{

		list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);

		$baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;



		// offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))

			$rowIndex = self::_GetInt2d($cellAddressStructure, 0);

			$row = self::_GetInt2d($cellAddressStructure, 0) + 1;



		// offset: 2; size: 2; index to column or column offset + relative flags



			// bit: 7-0; mask 0x00FF; column index

			$colIndex = 0x00FF & self::_GetInt2d($cellAddressStructure, 2);



			// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

			if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {

				$column = PHPExcel_Cell::stringFromColumnIndex($colIndex);

				$column = '$' . $column;

			} else {

				$colIndex = ($colIndex <= 127) ? $colIndex : $colIndex - 256;

				$column = PHPExcel_Cell::stringFromColumnIndex($baseCol + $colIndex);

			}



			// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

			if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {

				$row = '$' . $row;

			} else {

				$rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536;

				$row = $baseRow + $rowIndex;

			}



		return $column . $row;

	}





	/**

	 * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'

	 * always fixed range

	 * section 2.5.14

	 *

	 * @param string $subData

	 * @return string

	 * @throws Exception

	 */

	private function _readBIFF5CellRangeAddressFixed($subData)

	{

		// offset: 0; size: 2; index to first row

		$fr = self::_GetInt2d($subData, 0) + 1;



		// offset: 2; size: 2; index to last row

		$lr = self::_GetInt2d($subData, 2) + 1;



		// offset: 4; size: 1; index to first column

		$fc = ord($subData{4});



		// offset: 5; size: 1; index to last column

		$lc = ord($subData{5});



		// check values

		if ($fr > $lr || $fc > $lc) {

			throw new Exception('Not a cell range address');

		}



		// column index to letter

		$fc = PHPExcel_Cell::stringFromColumnIndex($fc);

		$lc = PHPExcel_Cell::stringFromColumnIndex($lc);



		if ($fr == $lr and $fc == $lc) {

			return "$fc$fr";

		}

		return "$fc$fr:$lc$lr";

	}





	/**

	 * Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1'

	 * always fixed range

	 * section 2.5.14

	 *

	 * @param string $subData

	 * @return string

	 * @throws Exception

	 */

	private function _readBIFF8CellRangeAddressFixed($subData)

	{

		// offset: 0; size: 2; index to first row

		$fr = self::_GetInt2d($subData, 0) + 1;



		// offset: 2; size: 2; index to last row

		$lr = self::_GetInt2d($subData, 2) + 1;



		// offset: 4; size: 2; index to first column

		$fc = self::_GetInt2d($subData, 4);



		// offset: 6; size: 2; index to last column

		$lc = self::_GetInt2d($subData, 6);



		// check values

		if ($fr > $lr || $fc > $lc) {

			throw new Exception('Not a cell range address');

		}



		// column index to letter

		$fc = PHPExcel_Cell::stringFromColumnIndex($fc);

		$lc = PHPExcel_Cell::stringFromColumnIndex($lc);



		if ($fr == $lr and $fc == $lc) {

			return "$fc$fr";

		}

		return "$fc$fr:$lc$lr";

	}





	/**

	 * Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6'

	 * there are flags indicating whether column/row index is relative

	 * section 3.3.4

	 *

	 * @param string $subData

	 * @return string

	 */

	private function _readBIFF8CellRangeAddress($subData)

	{

		// todo: if cell range is just a single cell, should this funciton

		// not just return e.g. 'A1' and not 'A1:A1' ?



		// offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767))

			$fr = self::_GetInt2d($subData, 0) + 1;



		// offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767))

			$lr = self::_GetInt2d($subData, 2) + 1;



		// offset: 4; size: 2; index to first column or column offset + relative flags



		// bit: 7-0; mask 0x00FF; column index

		$fc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 4));



		// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

		if (!(0x4000 & self::_GetInt2d($subData, 4))) {

			$fc = '$' . $fc;

		}



		// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

		if (!(0x8000 & self::_GetInt2d($subData, 4))) {

			$fr = '$' . $fr;

		}



		// offset: 6; size: 2; index to last column or column offset + relative flags



		// bit: 7-0; mask 0x00FF; column index

		$lc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 6));



		// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

		if (!(0x4000 & self::_GetInt2d($subData, 6))) {

			$lc = '$' . $lc;

		}



		// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

		if (!(0x8000 & self::_GetInt2d($subData, 6))) {

			$lr = '$' . $lr;

		}



		return "$fc$fr:$lc$lr";

	}





	/**

	 * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column

	 * to indicate offsets from a base cell

	 * section 3.3.4

	 *

	 * @param string $subData

	 * @param string $baseCell Base cell

	 * @return string Cell range address

	 */

	private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')

	{

		list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);

		$baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;



		// TODO: if cell range is just a single cell, should this funciton

		// not just return e.g. 'A1' and not 'A1:A1' ?



		// offset: 0; size: 2; first row

		$frIndex = self::_GetInt2d($subData, 0); // adjust below



		// offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)

		$lrIndex = self::_GetInt2d($subData, 2); // adjust below



		// offset: 4; size: 2; first column with relative/absolute flags



		// bit: 7-0; mask 0x00FF; column index

		$fcIndex = 0x00FF & self::_GetInt2d($subData, 4);



		// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

		if (!(0x4000 & self::_GetInt2d($subData, 4))) {

			// absolute column index

			$fc = PHPExcel_Cell::stringFromColumnIndex($fcIndex);

			$fc = '$' . $fc;

		} else {

			// column offset

			$fcIndex = ($fcIndex <= 127) ? $fcIndex : $fcIndex - 256;

			$fc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $fcIndex);

		}



		// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

		if (!(0x8000 & self::_GetInt2d($subData, 4))) {

			// absolute row index

			$fr = $frIndex + 1;

			$fr = '$' . $fr;

		} else {

			// row offset

			$frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536;

			$fr = $baseRow + $frIndex;

		}



		// offset: 6; size: 2; last column with relative/absolute flags



		// bit: 7-0; mask 0x00FF; column index

		$lcIndex = 0x00FF & self::_GetInt2d($subData, 6);

		$lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;

		$lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);



		// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)

		if (!(0x4000 & self::_GetInt2d($subData, 6))) {

			// absolute column index

			$lc = PHPExcel_Cell::stringFromColumnIndex($lcIndex);

			$lc = '$' . $lc;

		} else {

			// column offset

			$lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;

			$lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);

		}



		// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)

		if (!(0x8000 & self::_GetInt2d($subData, 6))) {

			// absolute row index

			$lr = $lrIndex + 1;

			$lr = '$' . $lr;

		} else {

			// row offset

			$lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536;

			$lr = $baseRow + $lrIndex;

		}



		return "$fc$fr:$lc$lr";

	}





	/**

	 * Read BIFF8 cell range address list

	 * section 2.5.15

	 *

	 * @param string $subData

	 * @return array

	 */

	private function _readBIFF8CellRangeAddressList($subData)

	{

		$cellRangeAddresses = array();



		// offset: 0; size: 2; number of the following cell range addresses

		$nm = self::_GetInt2d($subData, 0);



		$offset = 2;

		// offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses

		for ($i = 0; $i < $nm; ++$i) {

			$cellRangeAddresses[] = $this->_readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8));

			$offset += 8;

		}



		return array(

			'size' => 2 + 8 * $nm,

			'cellRangeAddresses' => $cellRangeAddresses,

		);

	}





	/**

	 * Read BIFF5 cell range address list

	 * section 2.5.15

	 *

	 * @param string $subData

	 * @return array

	 */

	private function _readBIFF5CellRangeAddressList($subData)

	{

		$cellRangeAddresses = array();



		// offset: 0; size: 2; number of the following cell range addresses

		$nm = self::_GetInt2d($subData, 0);



		$offset = 2;

		// offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses

		for ($i = 0; $i < $nm; ++$i) {

			$cellRangeAddresses[] = $this->_readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));

			$offset += 6;

		}



		return array(

			'size' => 2 + 6 * $nm,

			'cellRangeAddresses' => $cellRangeAddresses,

		);

	}





	/**

	 * Get a sheet range like Sheet1:Sheet3 from REF index

	 * Note: If there is only one sheet in the range, one gets e.g Sheet1

	 * It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets,

	 * in which case an exception is thrown

	 *

	 * @param int $index

	 * @return string|false

	 * @throws Exception

	 */

	private function _readSheetRangeByRefIndex($index)

	{

		if (isset($this->_ref[$index])) {



			$type = $this->_externalBooks[$this->_ref[$index]['externalBookIndex']]['type'];



			switch ($type) {

				case 'internal':

					// check if we have a deleted 3d reference

					if ($this->_ref[$index]['firstSheetIndex'] == 0xFFFF or $this->_ref[$index]['lastSheetIndex'] == 0xFFFF) {

						throw new Exception('Deleted sheet reference');

					}



					// we have normal sheet range (collapsed or uncollapsed)

					$firstSheetName = $this->_sheets[$this->_ref[$index]['firstSheetIndex']]['name'];

					$lastSheetName = $this->_sheets[$this->_ref[$index]['lastSheetIndex']]['name'];



					if ($firstSheetName == $lastSheetName) {

						// collapsed sheet range

						$sheetRange = $firstSheetName;

					} else {

						$sheetRange = "$firstSheetName:$lastSheetName";

					}



					// escape the single-quotes

					$sheetRange = str_replace("'", "''", $sheetRange);



					// if there are special characters, we need to enclose the range in single-quotes

					// todo: check if we have identified the whole set of special characters

					// it seems that the following characters are not accepted for sheet names

					// and we may assume that they are not present: []*/:\?

					if (preg_match("/[ !\"@#£$%&{()}<>=+'|^,;-]/", $sheetRange)) {

						$sheetRange = "'$sheetRange'";

					}



					return $sheetRange;

					break;



				default:

					// TODO: external sheet support

					throw new Exception('Excel5 reader only supports internal sheets in fomulas');

					break;

			}

		}

		return false;

	}





	/**

	 * read BIFF8 constant value array from array data

	 * returns e.g. array('value' => '{1,2;3,4}', 'size' => 40}

	 * section 2.5.8

	 *

	 * @param string $arrayData

	 * @return array

	 */

	private static function _readBIFF8ConstantArray($arrayData)

	{

		// offset: 0; size: 1; number of columns decreased by 1

		$nc = ord($arrayData[0]);



		// offset: 1; size: 2; number of rows decreased by 1

		$nr = self::_GetInt2d($arrayData, 1);

		$size = 3; // initialize

		$arrayData = substr($arrayData, 3);



		// offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values

		$matrixChunks = array();

		for ($r = 1; $r <= $nr + 1; ++$r) {

			$items = array();

			for ($c = 1; $c <= $nc + 1; ++$c) {

				$constant = self::_readBIFF8Constant($arrayData);

				$items[] = $constant['value'];

				$arrayData = substr($arrayData, $constant['size']);

				$size += $constant['size'];

			}

			$matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"'

		}

		$matrix = '{' . implode(';', $matrixChunks) . '}';



		return array(

			'value' => $matrix,

			'size' => $size,

		);

	}





	/**

	 * read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value'

	 * section 2.5.7

	 * returns e.g. array('value' => '5', 'size' => 9)

	 *

	 * @param string $valueData

	 * @return array

	 */

	private static function _readBIFF8Constant($valueData)

	{

		// offset: 0; size: 1; identifier for type of constant

		$identifier = ord($valueData[0]);



		switch ($identifier) {

		case 0x00: // empty constant (what is this?)

			$value = '';

			$size = 9;

			break;

		case 0x01: // number

			// offset: 1; size: 8; IEEE 754 floating-point value

			$value = self::_extractNumber(substr($valueData, 1, 8));

			$size = 9;

			break;

		case 0x02: // string value

			// offset: 1; size: var; Unicode string, 16-bit string length

			$string = self::_readUnicodeStringLong(substr($valueData, 1));

			$value = '"' . $string['value'] . '"';

			$size = 1 + $string['size'];

			break;

		case 0x04: // boolean

			// offset: 1; size: 1; 0 = FALSE, 1 = TRUE

			if (ord($valueData[1])) {

				$value = 'TRUE';

			} else {

				$value = 'FALSE';

			}

			$size = 9;

			break;

		case 0x10: // error code

			// offset: 1; size: 1; error code

			$value = self::_mapErrorCode(ord($valueData[1]));

			$size = 9;

			break;

		}

		return array(

			'value' => $value,

			'size' => $size,

		);

	}





	/**

	 * Extract RGB color

	 * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4

	 *

	 * @param string $rgb Encoded RGB value (4 bytes)

	 * @return array

	 */

	private static function _readRGB($rgb)

	{

		// offset: 0; size 1; Red component

		$r = ord($rgb{0});



		// offset: 1; size: 1; Green component

		$g = ord($rgb{1});



		// offset: 2; size: 1; Blue component

		$b = ord($rgb{2});



		// HEX notation, e.g. 'FF00FC'

		$rgb = sprintf('%02X%02X%02X', $r, $g, $b);



		return array('rgb' => $rgb);

	}





	/**

	 * Read byte string (8-bit string length)

	 * OpenOffice documentation: 2.5.2

	 *

	 * @param string $subData

	 * @return array

	 */

	private function _readByteStringShort($subData)

	{

		// offset: 0; size: 1; length of the string (character count)

		$ln = ord($subData[0]);



		// offset: 1: size: var; character array (8-bit characters)

		$value = $this->_decodeCodepage(substr($subData, 1, $ln));



		return array(

			'value' => $value,

			'size' => 1 + $ln, // size in bytes of data structure

		);

	}





	/**

	 * Read byte string (16-bit string length)

	 * OpenOffice documentation: 2.5.2

	 *

	 * @param string $subData

	 * @return array

	 */

	private function _readByteStringLong($subData)

	{

		// offset: 0; size: 2; length of the string (character count)

		$ln = self::_GetInt2d($subData, 0);



		// offset: 2: size: var; character array (8-bit characters)

		$value = $this->_decodeCodepage(substr($subData, 2));



		//return $string;

		return array(

			'value' => $value,

			'size' => 2 + $ln, // size in bytes of data structure

		);

	}





	/**

	 * Extracts an Excel Unicode short string (8-bit string length)

	 * OpenOffice documentation: 2.5.3

	 * function will automatically find out where the Unicode string ends.

	 *

	 * @param string $subData

	 * @return array

	 */

	private static function _readUnicodeStringShort($subData)

	{

		$value = '';



		// offset: 0: size: 1; length of the string (character count)

		$characterCount = ord($subData[0]);



		$string = self::_readUnicodeString(substr($subData, 1), $characterCount);



		// add 1 for the string length

		$string['size'] += 1;



		return $string;

	}





	/**

	 * Extracts an Excel Unicode long string (16-bit string length)

	 * OpenOffice documentation: 2.5.3

	 * this function is under construction, needs to support rich text, and Asian phonetic settings

	 *

	 * @param string $subData

	 * @return array

	 */

	private static function _readUnicodeStringLong($subData)

	{

		$value = '';



		// offset: 0: size: 2; length of the string (character count)

		$characterCount = self::_GetInt2d($subData, 0);



		$string = self::_readUnicodeString(substr($subData, 2), $characterCount);



		// add 2 for the string length

		$string['size'] += 2;



		return $string;

	}





	/**

	 * Read Unicode string with no string length field, but with known character count

	 * this function is under construction, needs to support rich text, and Asian phonetic settings

	 * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3

	 *

	 * @param string $subData

	 * @param int $characterCount

	 * @return array

	 */

	private static function _readUnicodeString($subData, $characterCount)

	{

		$value = '';



		// offset: 0: size: 1; option flags



			// bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit)

			$isCompressed = !((0x01 & ord($subData[0])) >> 0);



			// bit: 2; mask: 0x04; Asian phonetic settings

			$hasAsian = (0x04) & ord($subData[0]) >> 2;



			// bit: 3; mask: 0x08; Rich-Text settings

			$hasRichText = (0x08) & ord($subData[0]) >> 3;



		// offset: 1: size: var; character array

		// this offset assumes richtext and Asian phonetic settings are off which is generally wrong

		// needs to be fixed

		$value = self::_encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed);



		return array(

			'value' => $value,

			'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount, // the size in bytes including the option flags

		);

	}





	/**

	 * Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas.

	 * Example:  hello"world  -->  "hello""world"

	 *

	 * @param string $value UTF-8 encoded string

	 * @return string

	 */

	private static function _UTF8toExcelDoubleQuoted($value)

	{

		return '"' . str_replace('"', '""', $value) . '"';

	}





	/**

	 * Reads first 8 bytes of a string and return IEEE 754 float

	 *

	 * @param string $data Binary string that is at least 8 bytes long

	 * @return float

	 */

	private static function _extractNumber($data)

	{

		$rknumhigh = self::_GetInt4d($data, 4);

		$rknumlow = self::_GetInt4d($data, 0);

		$sign = ($rknumhigh & 0x80000000) >> 31;

		$exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023;

		$mantissa = (0x100000 | ($rknumhigh & 0x000fffff));

		$mantissalow1 = ($rknumlow & 0x80000000) >> 31;

		$mantissalow2 = ($rknumlow & 0x7fffffff);

		$value = $mantissa / pow( 2 , (20 - $exp));



		if ($mantissalow1 != 0) {

			$value += 1 / pow (2 , (21 - $exp));

		}



		$value += $mantissalow2 / pow (2 , (52 - $exp));

		if ($sign) {

			$value *= -1;

		}



		return $value;

	}





	private static function _GetIEEE754($rknum)

	{

		if (($rknum & 0x02) != 0) {

			$value = $rknum >> 2;

		} else {

			// changes by mmp, info on IEEE754 encoding from

			// research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html

			// The RK format calls for using only the most significant 30 bits

			// of the 64 bit floating point value. The other 34 bits are assumed

			// to be 0 so we use the upper 30 bits of $rknum as follows...

			$sign = ($rknum & 0x80000000) >> 31;

			$exp = ($rknum & 0x7ff00000) >> 20;

			$mantissa = (0x100000 | ($rknum & 0x000ffffc));

			$value = $mantissa / pow( 2 , (20- ($exp - 1023)));

			if ($sign) {

				$value = -1 * $value;

			}

			//end of changes by mmp

		}

		if (($rknum & 0x01) != 0) {

			$value /= 100;

		}

		return $value;

	}





	/**

	 * Get UTF-8 string from (compressed or uncompressed) UTF-16 string

	 *

	 * @param string $string

	 * @param bool $compressed

	 * @return string

	 */

	private static function _encodeUTF16($string, $compressed = '')

	{

		if ($compressed) {

			$string = self::_uncompressByteString($string);

 		}



		return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', 'UTF-16LE');

	}





	/**

	 * Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8.

	 *

	 * @param string $string

	 * @return string

	 */

	private static function _uncompressByteString($string)

	{

		$uncompressedString = '';

		$strLen = strlen($string);

		for ($i = 0; $i < $strLen; ++$i) {

			$uncompressedString .= $string[$i] . "\0";

		}



		return $uncompressedString;

	}





	/**

	 * Convert string to UTF-8. Only used for BIFF5.

	 *

	 * @param string $string

	 * @return string

	 */

	private function _decodeCodepage($string)

	{

		return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', $this->_codepage);

	}





	/**

	 * Read 16-bit unsigned integer

	 *

	 * @param string $data

	 * @param int $pos

	 * @return int

	 */

	public static function _GetInt2d($data, $pos)

	{

		return ord($data[$pos]) | (ord($data[$pos+1]) << 8);

	}





	/**

	 * Read 32-bit signed integer

	 *

	 * @param string $data

	 * @param int $pos

	 * @return int

	 */

	public static function _GetInt4d($data, $pos)

	{

		// FIX: represent numbers correctly on 64-bit system

		// http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334

		// Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems

		$_or_24 = ord($data[$pos + 3]);

		if ($_or_24 >= 128) {

			// negative number

			$_ord_24 = -abs((256 - $_or_24) << 24);

		} else {

			$_ord_24 = ($_or_24 & 127) << 24;

		}

		return ord($data[$pos]) | (ord($data[$pos+1]) << 8) | (ord($data[$pos+2]) << 16) | $_ord_24;

	}





	/**

	 * Read color

	 *

	 * @param int $color Indexed color

	 * @param array $palette Color palette

	 * @return array RGB color value, example: array('rgb' => 'FF0000')

	 */

	private static function _readColor($color,$palette,$version)

	{

		if ($color <= 0x07 || $color >= 0x40) {

			// special built-in color

			return self::_mapBuiltInColor($color);

		} elseif (isset($palette) && isset($palette[$color - 8])) {

			// palette color, color index 0x08 maps to pallete index 0

			return $palette[$color - 8];

		} else {

			// default color table

			if ($version == self::XLS_BIFF8) {

				return self::_mapColor($color);

			} else {

				// BIFF5

				return self::_mapColorBIFF5($color);

			}

		}



		return $color;

	}





	/**

	 * Map border style

	 * OpenOffice documentation: 2.5.11

	 *

	 * @param int $index

	 * @return string

	 */

	private static function _mapBorderStyle($index)

	{

		switch ($index) {

			case 0x00: return PHPExcel_Style_Border::BORDER_NONE;

			case 0x01: return PHPExcel_Style_Border::BORDER_THIN;

			case 0x02: return PHPExcel_Style_Border::BORDER_MEDIUM;

			case 0x03: return PHPExcel_Style_Border::BORDER_DASHED;

			case 0x04: return PHPExcel_Style_Border::BORDER_DOTTED;

			case 0x05: return PHPExcel_Style_Border::BORDER_THICK;

			case 0x06: return PHPExcel_Style_Border::BORDER_DOUBLE;

			case 0x07: return PHPExcel_Style_Border::BORDER_HAIR;

			case 0x08: return PHPExcel_Style_Border::BORDER_MEDIUMDASHED;

			case 0x09: return PHPExcel_Style_Border::BORDER_DASHDOT;

			case 0x0A: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT;

			case 0x0B: return PHPExcel_Style_Border::BORDER_DASHDOTDOT;

			case 0x0C: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT;

			case 0x0D: return PHPExcel_Style_Border::BORDER_SLANTDASHDOT;

			default:   return PHPExcel_Style_Border::BORDER_NONE;

		}

	}





	/**

	 * Get fill pattern from index

	 * OpenOffice documentation: 2.5.12

	 *

	 * @param int $index

	 * @return string

	 */

	private static function _mapFillPattern($index)

	{

		switch ($index) {

			case 0x00: return PHPExcel_Style_Fill::FILL_NONE;

			case 0x01: return PHPExcel_Style_Fill::FILL_SOLID;

			case 0x02: return PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY;

			case 0x03: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY;

			case 0x04: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY;

			case 0x05: return PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL;

			case 0x06: return PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL;

			case 0x07: return PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN;

			case 0x08: return PHPExcel_Style_Fill::FILL_PATTERN_DARKUP;

			case 0x09: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID;

			case 0x0A: return PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS;

			case 0x0B: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL;

			case 0x0C: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL;

			case 0x0D: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN;

			case 0x0E: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP;

			case 0x0F: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID;

			case 0x10: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS;

			case 0x11: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY125;

			case 0x12: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625;

			default:   return PHPExcel_Style_Fill::FILL_NONE;

		}

	}





	/**

	 * Map error code, e.g. '#N/A'

	 *

	 * @param int $subData

	 * @return string

	 */

	private static function _mapErrorCode($subData)

	{

		switch ($subData) {

			case 0x00: return '#NULL!';		break;

			case 0x07: return '#DIV/0!';	break;

			case 0x0F: return '#VALUE!';	break;

			case 0x17: return '#REF!';		break;

			case 0x1D: return '#NAME?';		break;

			case 0x24: return '#NUM!';		break;

			case 0x2A: return '#N/A';		break;

			default: return false;

		}

	}





	/**

	 * Map built-in color to RGB value

	 *

	 * @param int $color Indexed color

	 * @return array

	 */

	private static function _mapBuiltInColor($color)

	{

		switch ($color) {

			case 0x00: return array('rgb' => '000000');

			case 0x01: return array('rgb' => 'FFFFFF');

			case 0x02: return array('rgb' => 'FF0000');

			case 0x03: return array('rgb' => '00FF00');

			case 0x04: return array('rgb' => '0000FF');

			case 0x05: return array('rgb' => 'FFFF00');

			case 0x06: return array('rgb' => 'FF00FF');

			case 0x07: return array('rgb' => '00FFFF');

			case 0x40: return array('rgb' => '000000'); // system window text color

			case 0x41: return array('rgb' => 'FFFFFF'); // system window background color

			default:   return array('rgb' => '000000');

		}

	}





	/**

	 * Map color array from BIFF5 built-in color index

	 *

	 * @param int $subData

	 * @return array

	 */

	private static function _mapColorBIFF5($subData)

	{

		switch ($subData) {

			case 0x08: return array('rgb' => '000000');

			case 0x09: return array('rgb' => 'FFFFFF');

			case 0x0A: return array('rgb' => 'FF0000');

			case 0x0B: return array('rgb' => '00FF00');

			case 0x0C: return array('rgb' => '0000FF');

			case 0x0D: return array('rgb' => 'FFFF00');

			case 0x0E: return array('rgb' => 'FF00FF');

			case 0x0F: return array('rgb' => '00FFFF');

			case 0x10: return array('rgb' => '800000');

			case 0x11: return array('rgb' => '008000');

			case 0x12: return array('rgb' => '000080');

			case 0x13: return array('rgb' => '808000');

			case 0x14: return array('rgb' => '800080');

			case 0x15: return array('rgb' => '008080');

			case 0x16: return array('rgb' => 'C0C0C0');

			case 0x17: return array('rgb' => '808080');

			case 0x18: return array('rgb' => '8080FF');

			case 0x19: return array('rgb' => '802060');

			case 0x1A: return array('rgb' => 'FFFFC0');

			case 0x1B: return array('rgb' => 'A0E0F0');

			case 0x1C: return array('rgb' => '600080');

			case 0x1D: return array('rgb' => 'FF8080');

			case 0x1E: return array('rgb' => '0080C0');

			case 0x1F: return array('rgb' => 'C0C0FF');

			case 0x20: return array('rgb' => '000080');

			case 0x21: return array('rgb' => 'FF00FF');

			case 0x22: return array('rgb' => 'FFFF00');

			case 0x23: return array('rgb' => '00FFFF');

			case 0x24: return array('rgb' => '800080');

			case 0x25: return array('rgb' => '800000');

			case 0x26: return array('rgb' => '008080');

			case 0x27: return array('rgb' => '0000FF');

			case 0x28: return array('rgb' => '00CFFF');

			case 0x29: return array('rgb' => '69FFFF');

			case 0x2A: return array('rgb' => 'E0FFE0');

			case 0x2B: return array('rgb' => 'FFFF80');

			case 0x2C: return array('rgb' => 'A6CAF0');

			case 0x2D: return array('rgb' => 'DD9CB3');

			case 0x2E: return array('rgb' => 'B38FEE');

			case 0x2F: return array('rgb' => 'E3E3E3');

			case 0x30: return array('rgb' => '2A6FF9');

			case 0x31: return array('rgb' => '3FB8CD');

			case 0x32: return array('rgb' => '488436');

			case 0x33: return array('rgb' => '958C41');

			case 0x34: return array('rgb' => '8E5E42');

			case 0x35: return array('rgb' => 'A0627A');

			case 0x36: return array('rgb' => '624FAC');

			case 0x37: return array('rgb' => '969696');

			case 0x38: return array('rgb' => '1D2FBE');

			case 0x39: return array('rgb' => '286676');

			case 0x3A: return array('rgb' => '004500');

			case 0x3B: return array('rgb' => '453E01');

			case 0x3C: return array('rgb' => '6A2813');

			case 0x3D: return array('rgb' => '85396A');

			case 0x3E: return array('rgb' => '4A3285');

			case 0x3F: return array('rgb' => '424242');

			default:   return array('rgb' => '000000');

		}

	}





	/**

	 * Map color array from BIFF8 built-in color index

	 *

	 * @param int $subData

	 * @return array

	 */

	private static function _mapColor($subData)

	{

		switch ($subData) {

			case 0x08: return array('rgb' => '000000');

			case 0x09: return array('rgb' => 'FFFFFF');

			case 0x0A: return array('rgb' => 'FF0000');

			case 0x0B: return array('rgb' => '00FF00');

			case 0x0C: return array('rgb' => '0000FF');

			case 0x0D: return array('rgb' => 'FFFF00');

			case 0x0E: return array('rgb' => 'FF00FF');

			case 0x0F: return array('rgb' => '00FFFF');

			case 0x10: return array('rgb' => '800000');

			case 0x11: return array('rgb' => '008000');

			case 0x12: return array('rgb' => '000080');

			case 0x13: return array('rgb' => '808000');

			case 0x14: return array('rgb' => '800080');

			case 0x15: return array('rgb' => '008080');

			case 0x16: return array('rgb' => 'C0C0C0');

			case 0x17: return array('rgb' => '808080');

			case 0x18: return array('rgb' => '9999FF');

			case 0x19: return array('rgb' => '993366');

			case 0x1A: return array('rgb' => 'FFFFCC');

			case 0x1B: return array('rgb' => 'CCFFFF');

			case 0x1C: return array('rgb' => '660066');

			case 0x1D: return array('rgb' => 'FF8080');

			case 0x1E: return array('rgb' => '0066CC');

			case 0x1F: return array('rgb' => 'CCCCFF');

			case 0x20: return array('rgb' => '000080');

			case 0x21: return array('rgb' => 'FF00FF');

			case 0x22: return array('rgb' => 'FFFF00');

			case 0x23: return array('rgb' => '00FFFF');

			case 0x24: return array('rgb' => '800080');

			case 0x25: return array('rgb' => '800000');

			case 0x26: return array('rgb' => '008080');

			case 0x27: return array('rgb' => '0000FF');

			case 0x28: return array('rgb' => '00CCFF');

			case 0x29: return array('rgb' => 'CCFFFF');

			case 0x2A: return array('rgb' => 'CCFFCC');

			case 0x2B: return array('rgb' => 'FFFF99');

			case 0x2C: return array('rgb' => '99CCFF');

			case 0x2D: return array('rgb' => 'FF99CC');

			case 0x2E: return array('rgb' => 'CC99FF');

			case 0x2F: return array('rgb' => 'FFCC99');

			case 0x30: return array('rgb' => '3366FF');

			case 0x31: return array('rgb' => '33CCCC');

			case 0x32: return array('rgb' => '99CC00');

			case 0x33: return array('rgb' => 'FFCC00');

			case 0x34: return array('rgb' => 'FF9900');

			case 0x35: return array('rgb' => 'FF6600');

			case 0x36: return array('rgb' => '666699');

			case 0x37: return array('rgb' => '969696');

			case 0x38: return array('rgb' => '003366');

			case 0x39: return array('rgb' => '339966');

			case 0x3A: return array('rgb' => '003300');

			case 0x3B: return array('rgb' => '333300');

			case 0x3C: return array('rgb' => '993300');

			case 0x3D: return array('rgb' => '993366');

			case 0x3E: return array('rgb' => '333399');

			case 0x3F: return array('rgb' => '333333');

			default:   return array('rgb' => '000000');

		}

	}





	private function _parseRichText($is = '') {

		$value = new PHPExcel_RichText();



		$value->createText($is);



		return $value;

	}



}