diff --git a/Classes/PHPExcel/Calculation/Functions.php b/Classes/PHPExcel/Calculation/Functions.php
index 9e7a5db10..ecb3a67c8 100644
--- a/Classes/PHPExcel/Calculation/Functions.php
+++ b/Classes/PHPExcel/Calculation/Functions.php
@@ -48,6 +48,620 @@
  * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  * @version        ##VERSION##, ##DATE##
  */
+<<<<<<< HEAD
+class PHPExcel_Calculation_Functions {
+
+	/** constants */
+	const COMPATIBILITY_EXCEL		= 'Excel';
+	const COMPATIBILITY_GNUMERIC	= 'Gnumeric';
+	const COMPATIBILITY_OPENOFFICE	= 'OpenOfficeCalc';
+
+	const RETURNDATE_PHP_NUMERIC	= 'P';
+	const RETURNDATE_PHP_OBJECT		= 'O';
+	const RETURNDATE_EXCEL			= 'E';
+
+
+	/**
+	 * Compatibility mode to use for error checking and responses
+	 *
+	 * @access	private
+	 * @var string
+	 */
+	protected static $compatibilityMode	= self::COMPATIBILITY_EXCEL;
+
+	/**
+	 * Data Type to use when returning date values
+	 *
+	 * @access	private
+	 * @var string
+	 */
+	protected static $ReturnDateType	= self::RETURNDATE_EXCEL;
+
+	/**
+	 * List of error codes
+	 *
+	 * @access	private
+	 * @var array
+	 */
+	protected static $_errorCodes	= array( 'null'				=> '#NULL!',
+											 'divisionbyzero'	=> '#DIV/0!',
+											 'value'			=> '#VALUE!',
+											 'reference'		=> '#REF!',
+											 'name'				=> '#NAME?',
+											 'num'				=> '#NUM!',
+											 'na'				=> '#N/A',
+											 'gettingdata'		=> '#GETTING_DATA'
+										   );
+
+
+	/**
+	 * Set the Compatibility Mode
+	 *
+	 * @access	public
+	 * @category Function Configuration
+	 * @param	 string		$compatibilityMode		Compatibility Mode
+	 *												Permitted values are:
+	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
+	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
+	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
+	 * @return	 boolean	(Success or Failure)
+	 */
+	public static function setCompatibilityMode($compatibilityMode) {
+		if (($compatibilityMode == self::COMPATIBILITY_EXCEL) ||
+			($compatibilityMode == self::COMPATIBILITY_GNUMERIC) ||
+			($compatibilityMode == self::COMPATIBILITY_OPENOFFICE)) {
+			self::$compatibilityMode = $compatibilityMode;
+			return True;
+		}
+		return False;
+	}	//	function setCompatibilityMode()
+
+
+	/**
+	 * Return the current Compatibility Mode
+	 *
+	 * @access	public
+	 * @category Function Configuration
+	 * @return	 string		Compatibility Mode
+	 *							Possible Return values are:
+	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
+	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
+	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
+	 */
+	public static function getCompatibilityMode() {
+		return self::$compatibilityMode;
+	}	//	function getCompatibilityMode()
+
+
+	/**
+	 * Set the Return Date Format used by functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
+	 *
+	 * @access	public
+	 * @category Function Configuration
+	 * @param	 string	$returnDateType			Return Date Format
+	 *												Permitted values are:
+	 *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
+	 *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
+	 *													PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
+	 * @return	 boolean							Success or failure
+	 */
+	public static function setReturnDateType($returnDateType) {
+		if (($returnDateType == self::RETURNDATE_PHP_NUMERIC) ||
+			($returnDateType == self::RETURNDATE_PHP_OBJECT) ||
+			($returnDateType == self::RETURNDATE_EXCEL)) {
+			self::$ReturnDateType = $returnDateType;
+			return True;
+		}
+		return False;
+	}	//	function setReturnDateType()
+
+
+	/**
+	 * Return the current Return Date Format for functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
+	 *
+	 * @access	public
+	 * @category Function Configuration
+	 * @return	 string		Return Date Format
+	 *							Possible Return values are:
+	 *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
+	 *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
+	 *								PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
+	 */
+	public static function getReturnDateType() {
+		return self::$ReturnDateType;
+	}	//	function getReturnDateType()
+
+
+	/**
+	 * DUMMY
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#Not Yet Implemented
+	 */
+	public static function DUMMY() {
+		return '#Not Yet Implemented';
+	}	//	function DUMMY()
+
+
+	/**
+	 * DIV0
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#Not Yet Implemented
+	 */
+	public static function DIV0() {
+		return self::$_errorCodes['divisionbyzero'];
+	}	//	function DIV0()
+
+
+	/**
+	 * NA
+	 *
+	 * Excel Function:
+	 *		=NA()
+	 *
+	 * Returns the error value #N/A
+	 *		#N/A is the error value that means "no value is available."
+	 *
+	 * @access	public
+	 * @category Logical Functions
+	 * @return	string	#N/A!
+	 */
+	public static function NA() {
+		return self::$_errorCodes['na'];
+	}	//	function NA()
+
+
+	/**
+	 * NaN
+	 *
+	 * Returns the error value #NUM!
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#NUM!
+	 */
+	public static function NaN() {
+		return self::$_errorCodes['num'];
+	}	//	function NaN()
+
+
+	/**
+	 * NAME
+	 *
+	 * Returns the error value #NAME?
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#NAME?
+	 */
+	public static function NAME() {
+		return self::$_errorCodes['name'];
+	}	//	function NAME()
+
+
+	/**
+	 * REF
+	 *
+	 * Returns the error value #REF!
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#REF!
+	 */
+	public static function REF() {
+		return self::$_errorCodes['reference'];
+	}	//	function REF()
+
+
+	/**
+	 * NULL
+	 *
+	 * Returns the error value #NULL!
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#NULL!
+	 */
+	public static function NULL() {
+		return self::$_errorCodes['null'];
+	}	//	function NULL()
+
+
+	/**
+	 * VALUE
+	 *
+	 * Returns the error value #VALUE!
+	 *
+	 * @access	public
+	 * @category Error Returns
+	 * @return	string	#VALUE!
+	 */
+	public static function VALUE() {
+		return self::$_errorCodes['value'];
+	}	//	function VALUE()
+
+
+	public static function isMatrixValue($idx) {
+		return ((substr_count($idx,'.') <= 1) || (preg_match('/\.[A-Z]/',$idx) > 0));
+	}
+
+
+	public static function isValue($idx) {
+		return (substr_count($idx,'.') == 0);
+	}
+
+
+	public static function isCellValue($idx) {
+		return (substr_count($idx,'.') > 1);
+	}
+
+
+	public static function _ifCondition($condition) {
+		$condition	= PHPExcel_Calculation_Functions::flattenSingleValue($condition);
+		if (!isset($condition{0}))
+			$condition = '=""';
+		if (!in_array($condition{0},array('>', '<', '='))) {
+			if (!is_numeric($condition)) { $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition)); }
+			return '='.$condition;
+		} else {
+			preg_match('/([<>=]+)(.*)/',$condition,$matches);
+			list(,$operator,$operand) = $matches;
+
+			if (!is_numeric($operand)) {
+				$operand = str_replace('"', '""', $operand);
+				$operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand));
+			}
+
+			return $operator.$operand;
+		}
+	}	//	function _ifCondition()
+
+
+	/**
+	 * ERROR_TYPE
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function ERROR_TYPE($value = '') {
+		$value	= self::flattenSingleValue($value);
+
+		$i = 1;
+		foreach(self::$_errorCodes as $errorCode) {
+			if ($value === $errorCode) {
+				return $i;
+			}
+			++$i;
+		}
+		return self::NA();
+	}	//	function ERROR_TYPE()
+
+
+	/**
+	 * IS_BLANK
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_BLANK($value = NULL) {
+		if (!is_null($value)) {
+			$value	= self::flattenSingleValue($value);
+		}
+
+		return is_null($value);
+	}	//	function IS_BLANK()
+
+
+	/**
+	 * IS_ERR
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_ERR($value = '') {
+		$value		= self::flattenSingleValue($value);
+
+		return self::IS_ERROR($value) && (!self::IS_NA($value));
+	}	//	function IS_ERR()
+
+
+	/**
+	 * IS_ERROR
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_ERROR($value = '') {
+		$value		= self::flattenSingleValue($value);
+
+		if (!is_string($value))
+			return false;
+		return in_array($value, array_values(self::$_errorCodes));
+	}	//	function IS_ERROR()
+
+
+	/**
+	 * IS_NA
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_NA($value = '') {
+		$value		= self::flattenSingleValue($value);
+
+		return ($value === self::NA());
+	}	//	function IS_NA()
+
+
+	/**
+	 * IS_EVEN
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_EVEN($value = NULL) {
+		$value = self::flattenSingleValue($value);
+
+		if ($value === NULL)
+			return self::NAME();
+		if ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value))))
+			return self::VALUE();
+		return ($value % 2 == 0);
+	}	//	function IS_EVEN()
+
+
+	/**
+	 * IS_ODD
+	 *
+	 * @param	mixed	$value	Value to check
+	 * @return	boolean
+	 */
+	public static function IS_ODD($value = NULL) {
+		$value = self::flattenSingleValue($value);
+
+		if ($value === NULL)
+			return self::NAME();
+		if ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value))))
+			return self::VALUE();
+		return (abs($value) % 2 == 1);
+	}	//	function IS_ODD()
+
+
+	/**
+	 * IS_NUMBER
+	 *
+	 * @param	mixed	$value		Value to check
+	 * @return	boolean
+	 */
+	public static function IS_NUMBER($value = NULL) {
+		$value		= self::flattenSingleValue($value);
+
+		if (is_string($value)) {
+			return False;
+		}
+		return is_numeric($value);
+	}	//	function IS_NUMBER()
+
+
+	/**
+	 * IS_LOGICAL
+	 *
+	 * @param	mixed	$value		Value to check
+	 * @return	boolean
+	 */
+	public static function IS_LOGICAL($value = NULL) {
+		$value		= self::flattenSingleValue($value);
+
+		return is_bool($value);
+	}	//	function IS_LOGICAL()
+
+
+	/**
+	 * IS_TEXT
+	 *
+	 * @param	mixed	$value		Value to check
+	 * @return	boolean
+	 */
+	public static function IS_TEXT($value = NULL) {
+		$value		= self::flattenSingleValue($value);
+
+		return (is_string($value) && !self::IS_ERROR($value));
+	}	//	function IS_TEXT()
+
+
+	/**
+	 * IS_NONTEXT
+	 *
+	 * @param	mixed	$value		Value to check
+	 * @return	boolean
+	 */
+	public static function IS_NONTEXT($value = NULL) {
+		return !self::IS_TEXT($value);
+	}	//	function IS_NONTEXT()
+
+
+	/**
+	 * VERSION
+	 *
+	 * @return	string	Version information
+	 */
+	public static function VERSION() {
+		return 'PHPExcel 1.8.1, 2015-04-30';
+	}	//	function VERSION()
+
+
+	/**
+	 * N
+	 *
+	 * Returns a value converted to a number
+	 *
+	 * @param	value		The value you want converted
+	 * @return	number		N converts values listed in the following table
+	 *		If value is or refers to N returns
+	 *		A number			That number
+	 *		A date				The serial number of that date
+	 *		TRUE				1
+	 *		FALSE				0
+	 *		An error value		The error value
+	 *		Anything else		0
+	 */
+	public static function N($value = NULL) {
+		while (is_array($value)) {
+			$value = array_shift($value);
+		}
+
+		switch (gettype($value)) {
+			case 'double'	:
+			case 'float'	:
+			case 'integer'	:
+				return $value;
+				break;
+			case 'boolean'	:
+				return (integer) $value;
+				break;
+			case 'string'	:
+				//	Errors
+				if ((strlen($value) > 0) && ($value{0} == '#')) {
+					return $value;
+				}
+				break;
+		}
+		return 0;
+	}	//	function N()
+
+
+	/**
+	 * TYPE
+	 *
+	 * Returns a number that identifies the type of a value
+	 *
+	 * @param	value		The value you want tested
+	 * @return	number		N converts values listed in the following table
+	 *		If value is or refers to N returns
+	 *		A number			1
+	 *		Text				2
+	 *		Logical Value		4
+	 *		An error value		16
+	 *		Array or Matrix		64
+	 */
+	public static function TYPE($value = NULL) {
+		$value	= self::flattenArrayIndexed($value);
+		if (is_array($value) && (count($value) > 1)) {
+			$a = array_keys($value);
+			$a = array_pop($a);
+			//	Range of cells is an error
+			if (self::isCellValue($a)) {
+				return 16;
+			//	Test for Matrix
+			} elseif (self::isMatrixValue($a)) {
+				return 64;
+			}
+		} elseif(empty($value)) {
+			//	Empty Cell
+			return 1;
+		}
+		$value	= self::flattenSingleValue($value);
+
+		if (($value === NULL) || (is_float($value)) || (is_int($value))) {
+				return 1;
+		} elseif(is_bool($value)) {
+				return 4;
+		} elseif(is_array($value)) {
+				return 64;
+		} elseif(is_string($value)) {
+			//	Errors
+			if ((strlen($value) > 0) && ($value{0} == '#')) {
+				return 16;
+			}
+			return 2;
+		}
+		return 0;
+	}	//	function TYPE()
+
+
+	/**
+	 * Convert a multi-dimensional array to a simple 1-dimensional array
+	 *
+	 * @param	array	$array	Array to be flattened
+	 * @return	array	Flattened array
+	 */
+	public static function flattenArray($array) {
+		if (!is_array($array)) {
+			return (array) $array;
+		}
+
+		$arrayValues = array();
+		foreach ($array as $value) {
+			if (is_array($value)) {
+				foreach ($value as $val) {
+					if (is_array($val)) {
+						foreach ($val as $v) {
+							$arrayValues[] = $v;
+						}
+					} else {
+						$arrayValues[] = $val;
+					}
+				}
+			} else {
+				$arrayValues[] = $value;
+			}
+		}
+
+		return $arrayValues;
+	}	//	function flattenArray()
+
+
+	/**
+	 * Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing
+	 *
+	 * @param	array	$array	Array to be flattened
+	 * @return	array	Flattened array
+	 */
+	public static function flattenArrayIndexed($array) {
+		if (!is_array($array)) {
+			return (array) $array;
+		}
+
+		$arrayValues = array();
+		foreach ($array as $k1 => $value) {
+			if (is_array($value)) {
+				foreach ($value as $k2 => $val) {
+					if (is_array($val)) {
+						foreach ($val as $k3 => $v) {
+							$arrayValues[$k1.'.'.$k2.'.'.$k3] = $v;
+						}
+					} else {
+						$arrayValues[$k1.'.'.$k2] = $val;
+					}
+				}
+			} else {
+				$arrayValues[$k1] = $value;
+			}
+		}
+
+		return $arrayValues;
+	}	//	function flattenArrayIndexed()
+
+
+	/**
+	 * Convert an array to a single scalar value by extracting the first element
+	 *
+	 * @param	mixed		$value		Array or scalar value
+	 * @return	mixed
+	 */
+	public static function flattenSingleValue($value = '') {
+		while (is_array($value)) {
+			$value = array_pop($value);
+		}
+
+		return $value;
+	}	//	function flattenSingleValue()
+
+}	//	class PHPExcel_Calculation_Functions
+=======
 class PHPExcel_Calculation_Functions
 {
 
@@ -701,6 +1315,7 @@ public static function flattenSingleValue($value = '')
         return $value;
     }
 }
+>>>>>>> problema_lookup
 
 
 //
diff --git a/Classes/PHPExcel/Calculation/LookupRef.php b/Classes/PHPExcel/Calculation/LookupRef.php
index d86055121..52cad33cd 100644
--- a/Classes/PHPExcel/Calculation/LookupRef.php
+++ b/Classes/PHPExcel/Calculation/LookupRef.php
@@ -598,6 +598,16 @@ public static function MATCH($lookup_value, $lookup_array, $match_type = 1)
      */
     public static function INDEX($arrayValues, $rowNum = 0, $columnNum = 0)
     {
+        
+        if(is_array($rowNum)){
+			foreach($rowNum as $k=>$v){
+				foreach($v as $k2=>$v2){
+					$rowNum = $v2;
+					break 2;
+				}
+			}
+		}
+		        
         if (($rowNum < 0) || ($columnNum < 0)) {
             return PHPExcel_Calculation_Functions::VALUE();
         }
@@ -770,7 +780,7 @@ public static function HLOOKUP($lookup_value, $lookup_array, $index_number, $not
         } else {
             $f = array_keys($lookup_array);
             $firstRow = array_pop($f);
-            if ((!is_array($lookup_array[$firstRow])) || ($index_number > count($lookup_array[$firstRow]))) {
+            if ((!is_array($lookup_array[$firstRow]))) {
                 return PHPExcel_Calculation_Functions::REF();
             } else {
                 $columnKeys = array_keys($lookup_array[$firstRow]);
diff --git a/Classes/PHPExcel/Worksheet.php b/Classes/PHPExcel/Worksheet.php
index 0f44c7744..5a2834247 100644
--- a/Classes/PHPExcel/Worksheet.php
+++ b/Classes/PHPExcel/Worksheet.php
@@ -1150,7 +1150,11 @@ public function getCell($pCoordinate = 'A1')
         // Worksheet reference?
         if (strpos($pCoordinate, '!') !== false) {
             $worksheetReference = PHPExcel_Worksheet::extractSheetTitle($pCoordinate, true);
+<<<<<<< HEAD
+			return $this->_parent->getSheetByName($worksheetReference[0])->getCell(strtoupper($worksheetReference[1]));
+=======
             return $this->parent->getSheetByName($worksheetReference[0])->getCell(strtoupper($worksheetReference[1]));
+>>>>>>> problema_lookup
         }
 
         // Named range?
diff --git a/Classes/PHPExcel/Worksheet/CellIterator.php b/Classes/PHPExcel/Worksheet/CellIterator.php
index 151c17f53..6e1a64bb7 100644
--- a/Classes/PHPExcel/Worksheet/CellIterator.php
+++ b/Classes/PHPExcel/Worksheet/CellIterator.php
@@ -70,7 +70,11 @@ public function getIterateOnlyExistingCells()
      * Validate start/end values for "IterateOnlyExistingCells" mode, and adjust if necessary
      *
      * @throws PHPExcel_Exception
+<<<<<<< HEAD
+	 */
+=======
      */
+>>>>>>> problema_lookup
     abstract protected function adjustForExistingOnlyRange();
 
     /**