
 (, , =1) 
 (, =1, __=0) 


 ()  ;  


//_____________________________________________________________________________
 ()
	 1;

//_____________________________________________________________________________
 ()
	 (().(""));

//_____________________________________________________________________________
 () 
	 ;
	 = ();
	 () = "" 
		().("", );
	;


//_____________________________________________________________________________
//    
 () 
	 ().("");

 ()
	 ().("");


//_____________________________________________________________________________
 () 
	 = ();
	.("", );


//_____________________________________________________________________________
 () 
	 ;
	
	 = ().("");
	
	 () = "" 
		.();
	
		
			.(.());
		
			("    '" + () + "'");
		;
	;
	
	
		.(.);
		.(.);
	
	;



//_____________________________________________________________________________
 () 
	
		().("").();
	
		 0;
	;
	 1;



//_____________________________________________________________________________
 ( ) 
	 ;
	
	 = ().("");

	 () = 1 
		
			 .();
		
			 "";
		;
	;
	
	 () = 1 
		 .();
	
		 = .(());
		 .();
	;


 () 
	 ();


//_____________________________________________________________________________
 ( ) 
	 ;
	
	 = ().("");

	 () = 1 
		
			 = .();
		
			 "";
		;
	;
	
	 () = 1 
		 = .();
	 () = 2 
	
		 = ();
	;

	
		 .(.());
	
		 0;
	;


//_____________________________________________________________________________
 ( ) 
	 , ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		 "";
	;
	
	.(, );
	 ;


 () 
	 , ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		 0;
	;
	
	.(,, );
	 ;


 () 
	 , ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		 0;
	;
	
	.(,,, );
	 ;


 (, ) 
	 , ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		 "";
	;
	
	.(,,,, );
	 () = 2 
		.(,,,, );
	;
	 ;


 (, ) 
	 , ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		 0;
	;
	
	.(,,,,, );
	
	  > 0 
		.(,,,,, );
	;
	
	 ;



//_____________________________________________________________________________
 () 
	 , ;
	 , , , , , ;
	
	 = ().("");

	 = ("");
	.("", "");
	.("", "");
	.("", "", 3, 0);
	.("", "", 3, 0);
	.("", "");
	.("", "", 4, 0);
	
	 =1  .() 
		.();
		 = .(, , , , , );
		. = ;
		. = ;
		. = ;
		. = ;
		. = ;
		. = ;
	;
	
	 ;


//_____________________________________________________________________________
 (,  ,  ) 
	 ;
	 , , , , , , , , ;
	 ;
	
	 = ();
	  = 0 
		//#error   
		 0;
	;
	
	 = ().("");
	 = .(, , , , , , , );
	
	
	  =  
		 = ;
	 () = 1 
		 = ;
	
		 () = 1 
			 0;
		;
	;

	  =  
		 = ;
	  = 0 
		 = ;
	
		  > .() 
			 0;
		;
	;
	
	 = ("");
	.(,,, );
	.();
	.(, , , , , , , , );
	.(,,, );
	
	 1;



//_____________________________________________________________________________
 ( ) 
	 , , ;
	
	 () = 2 
		 = ("");
		 = (, " ", "");
		 = .(, ",");
	;
	
	 = ();
	  = 1  .() 
		 = .();
		
			.();
		
		;
	;


//_____________________________________________________________________________
 (  = "", ) 
	 ;
	
	 = ().("");
	
		 () = 1   = .(); ;
	
		;
	;
	
	.(., , );


//_____________________________________________________________________________
 (  = "") 
	 ;

	 = ().("");
	
		 () = 1   = .(); ;
	
		 ();
	;
	
	 .(., );



//_____________________________________________________________________________
 () 
	 ;
	
	 = ().("");
	
	 = (".");
	.(.(),,, );
	
	 ;


//_____________________________________________________________________________
//       ,  <>
 () 
	 ;
	 , ;
	 , , , , , , __, ;
	
	 = ().("");
	 = (".");
	 =1  .() 
		 = .(, , , , , , __, );
		.(, , , , , , __, );
	;
	
	 ;


//_____________________________________________________________________________
 (, ) 
	 , , ;
	 , , , , , __, ;
	
	 = ();
	 = .("");
	
	  = 0 
		 = .();
		  > 0 
			.();
			 =  - 1;
		;
	;
	
	 =1  .() 
		 = .(, , , , , , __, );
		 .() = 1 
			.(, , , , , , __, );
		
			.(, , , , , , __, );
		;
	;


//_____________________________________________________________________________
//     <>    .
//      <>
 (__,   = 0,  = 0) 
	 , ;
	 , ;
	 ;
	
	 = ().("");
	 (__) = 1 
		 = ; //     
	
		 = __;
	;
	
	  = 0 
		 = .;
	;
	
	 .() = 0 
		.();
	;
	
	  = 1 
		 = .();
	
		 = (.(), .());
	;
	 =1   
		 = .(, );
		 =1 
			 = .();
			
				.(., , );
			
			;
		
			.(., , );
		;
	;


//_____________________________________________________________________________
//      <>
 (,  1=0,  2=0, =0) 
	 ;
	 ;
	
	 = ().("");
	
	 (1 = 0)  (2 = 0)  ( = 0)  (() = 0) 
		 .() = 0  ; ;
		
		1 = .() + 1;
		.(.() + .());
		2 = .();
		.(, 1, 2);
	;

	 1 = 0  1 = 1; ;
	 2 = 0  2 = .(); ;
	
	  = 1  2 
		.();
		(, , );
	;


//_____________________________________________________________________________
//    ,     
 () 
	 ;
	 , , ;
	
	 = ().("");
	 = ().("");
	
	.();
	 = (.(), .());
	 =1   
		.(., , .());
	;
	
	 .;


//_____________________________________________________________________________
 (, , , 1="", 2="", 3="", 4="")
	  > .() 
		 0;
	;
	
	 =1   
		
			 = .(+-1);
		
			 = ();
		;
		//#if DEBUG
		(" = "++";  - '"++"'  - "+());
		//#endif
		 =1 
			1 = ;
		 =2 
			2 = ;
		 =3 
			3 = ;
		 =4 
			4 = ;
		;
	;
	
	 =  + ;
	
	 1;


//_____________________________________________________________________________
//   ,     .
//   .    : <>, <1>, <2>.    .
//   <1> <= <> <= <2>
 () 
	 , , ;
	 , _, , 1, 2;

	 = ();
	 = .("");
	 = .("");
	 = ("");
	
	 = .();
	 >0 
		_ = 1;
		 (, _, 3, , 1, 2) = 1 
			//#if DEBUG
			(""++"  "+1+"  "+2);
			//#endif
			 = .(, );
			 .(, 1, 2) = 0 
				.();
				; //   
			;
		;
		
	     =  - 1;
	;


//_____________________________________________________________________________
//        
//:
//	 - .      .
//          : .(, );
//                  : .(, );
//	        ..   .
//	 - .  ,      
//	 - .  1,       
// :
//    1)  = 1:     - 1;   - 0
//    2)  = 0:     -  ;   - 0
 (, =0, =1) 
     ;
	 , ;
	 , , , ;

	 = ().("");
	 .() = 0 
		 0;
	;

	 = .(1, );
	 (() = "")  (() = "") 
		 = 0;
	
		 .(, , )=0 
			 0;
		;
	;
	
	 <   = ; ;
	
	 <=.() 
		 = 1;
		  = 1  .() 
			 = .(, );
			 = .(, );
			 (() = "")  (() = "") 
				//  
				 .() = 0 
					 = 0;
					;
				;
			
				 //    -   
					  <>  
						 = 0;
						;
					;
				
					 = 0;
					;
				;
			;
		;

		 =1 
			  = 1 
				.();
				 1;
			
				 ;
			;
		;
		 =  + 1;
	;
	
	 0;


//_____________________________________________________________________________
 (, )
	  = 1 
		 ();
	
		 () = 12 
			 .();
		;
		 ();
	;


//_____________________________________________________________________________
// :
// 0 -  = 
// 1 -  > 
// -1 -  < 
 (, , ,  = 0)
	 , , , ;
	
	  = 1  .() 
		 = .(, );
		    = .(, );
		 () > 3 
			 = (, );
			    = (,    );
		;
		  >  
			 1;
		  <  
			 -1;
		;
	;
	
	 0;


//   .        
//   ,        , 
//     
 2(, , , , , ) 
	 ;
     1, , 2;
	 , ;
    
	 = ().("");
	 .() = 0 
		 0;
	;

	  = 0 
		1 = 1;
	
		1 = ;
	;
	  = 0 
		2 = .();
	
		2 = ;
	;
	 = 0;
	
	 1 < 2 
		 = ((1+2) / 2);
		  = 1 
			 = ( + 1, 2);
		;
		
		 = (, , , );
		  = 0 
			  = 0 
				2 = ;
			
				1 = 
			;
			 = 1;
		  < 0 
			2 =  - 1;
			 = 2;
		
			1 =  + 1;
			 = 1;
		;
	;
	
	  = 0 
		 (, , 1, ) = 0 
			 = 1;
		;
	;
	
	  = 1 
		   = 1 
			.(1);
			 1;
		;
		 1;
	
		 0;
	;


//_____________________________________________________________________________
 () 
	 , ;
	 , , ;
	
	 = ().("");
	 = ("");
	 = 1;
	 (, , 2, , ) = 1 
		.(, );
	;
	
	 ;


//_____________________________________________________________________________
 (,  = 0) 
	 , , , ;
    
	 = "";  = "";
	  = 1  .() 
		.(, );
		 =  +  + ;
		 = ",";
	;
	
	  = 1 
		 = "*" + (, ",", ",*");
	;
	
	().(, 1);


//_____________________________________________________________________________
//   
Procedure swap(self, val i1, val i2) Export
	If i1 > i2 Then
		i = i1;
		i1 = i2;
		i2 = i;
	EndIf;
	shift = i2 - i1;
	If shift > 1 Then
		self.MoveLine(shift-1, i1);
	EndIf;
	self.MoveLine(-shift, i2);
EndProcedure

//_____________________________________________________________________________
Procedure ShortSort(self, lo, hi, CompMod)
    Var p, _max_;

    ///* Note: in assertions below, i and j are alway inside original bound of
    //   array to sort. */

    While hi > lo Do
        //* A[i] <= A[j] for i <= j, j > hi */
        _max_ = lo;
		p = lo + 1;
		While p <= hi Do
            //* A[i] <= A[max] for lo <= i < p */
            If CompMod.Compare(self, p, _max_) > 0 Then
                _max_ = p;
            EndIf;
            ///* A[i] <= A[max] for lo <= i <= p */
			
			p = p + 1;
		EndDo;

        //* A[i] <= A[max] for lo <= i <= hi */

        swap(self, _max_, hi);
		//("swap("+_max_+", "+hi+")");

        //* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */

        hi = hi - 1;

        //* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
    EndDo;
    ///* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
    //   so array is sorted */
EndProcedure

//_____________________________________________________________________________
//        qsort  Standard C Library
//CompMod -   ,        . 
//-   Compare,   3 :
//   -  -  ,   
//   - 1, 2 - ,   
//-   0,   ; -1   1   2; 1   1   2
 qsort(CompMod) 
	Var lo, hi; //ends of sub-array currently sorting
	Var m;    //points to middle of subarray
	Var loguy, higuy; //traveling pointers for partition step
	Var size; //size of the sub-array
	Var lostk[30], histk[30];
	Var stkptr;  //* stack for saving sub-array to be processed */
	
	//* Note: the number of stack entries required is no more than
	//   1 + log2(size), so 30 is sufficient for any array */
	
	//if (num < 2 || width == 0)
	//    return;                 /* nothing to do */
	
	self = ();
	stkptr = 1;                 //* initialize stack */
	lo = 1;
	hi = self.LinesCnt();        ///* initialize limits */
	
	//* this entry point is for pseudo-recursion calling: setting
	//   lo and hi and jumping to here is like recursion, but stkptr is
	//   prserved, locals aren't, so we preserve stuff on the stack */
~recurse:
	
	size = hi - lo + 1;        //* number of el's to sort */
	
	//* below a certain size, it is faster to use a O(n^2) sorting method */
	If size <= 8 Then
		//("ShortSort("+lo+", "+hi+")");
		ShortSort(self, lo, hi, CompMod);
	Else
		//First we pick a partititioning element.  The efficiency of the
		//algorithm demands that we find one that is approximately the
		//median of the values, but also that we select one fast.  Using
		//the first one produces bad performace if the array is already
		//sorted, so we use the middle one, which would require a very
		//wierdly arranged array for worst case performance.  Testing shows
		//that a median-of-three algorithm does not, in general, increase
		//performance. */
		
		m = int(lo + (size / 2));      //* find middle element */
		swap(self, m, lo);               //* swap it to beginning of array */
		
		///* We now wish to partition the array into three pieces, one
		//   consisiting of elements <= partition element, one of elements
		//   equal to the parition element, and one of element >= to it.  This
		//   is done below; comments indicate conditions established at every
		//   step. */
		
		loguy = lo;
		higuy = hi + 1;
		
		///* Note that higuy decreases and loguy increases on every iteration,
		//   so loop must terminate. */
		While 1 = 1 Do
			///* lo <= loguy < hi, lo < higuy <= hi + 1,
			//   A[i] <= A[lo] for lo <= i <= loguy,
			//   A[i] >= A[lo] for higuy <= i <= hi */
			
			While 1 = 1 Do
				loguy = loguy + 1;
				If loguy > hi Then
					break;
				EndIf;
				comp = CompMod.Compare(self, loguy, lo);
				If comp > 0 Then
					break;
				EndIf;
			EndDo;
			
			///* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
			//   either loguy > hi or A[loguy] > A[lo] */
			
			While 1 = 1 Do
				higuy = higuy - 1;
				If higuy <= lo Then
					break;
				ElsIf CompMod.Compare(self, higuy, lo) < 0 Then
					break;
				EndIf;
				//If  } while (higuy > lo && comp(higuy, lo) >= 0);
			EndDo;
			
			///* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
			//   either higuy <= lo or A[higuy] < A[lo] */
			
			If higuy < loguy Then break; EndIf;
			
			///* if loguy > hi or higuy <= lo, then we would have exited, so
			//   A[loguy] > A[lo], A[higuy] < A[lo],
			//   loguy < hi, highy > lo */
			
			swap(self, loguy, higuy);
			
			///* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
			//   of loop is re-established */
		EndDo;
		
		///*     A[i] >= A[lo] for higuy < i <= hi,
		//       A[i] <= A[lo] for lo <= i < loguy,
		//       higuy < loguy, lo <= higuy <= hi
		//   implying:
		//       A[i] >= A[lo] for loguy <= i <= hi,
		//       A[i] <= A[lo] for lo <= i <= higuy,
		//       A[i] = A[lo] for higuy < i < loguy */
		
		swap(self, lo, higuy);     //* put partition element in place */
		
		///* OK, now we have the following:
		//      A[i] >= A[higuy] for loguy <= i <= hi,
		//      A[i] <= A[higuy] for lo <= i < higuy
		//      A[i] = A[lo] for higuy <= i < loguy    */
		
		///* We've finished the partition, now we want to sort the subarrays
		//   [lo, higuy-1] and [loguy, hi].
		//   We do the smaller one first to minimize stack usage.
		//   We only sort arrays of length 2 or more.*/
		
		If (higuy - 1 - lo) >= (hi - loguy) Then
			If (lo + 1) < higuy Then
				lostk[stkptr] = lo;
				histk[stkptr] = higuy - 1;
				stkptr = stkptr + 1;
			EndIf;                           //* save big recursion for later */
			
			If loguy < hi Then
				lo = loguy;
				goto ~recurse;           //* do small recursion */
			EndIf;
		Else
			If loguy < hi Then
				lostk[stkptr] = loguy;
				histk[stkptr] = hi;
				stkptr = stkptr + 1;               //* save big recursion for later */
			EndIf;
			
			If (lo + 1) < higuy Then
				hi = higuy - 1;
				goto ~recurse;           //* do small recursion */
			EndIf;
		EndIf;
	EndIf;
	
	///* We have sorted the array, except for any pending sorts on the stack.
	//   Check if there are any, and do them. */
	
	stkptr = stkptr - 1;
	If stkptr > 0 Then
		lo = lostk[stkptr];
		hi = histk[stkptr];
		goto ~recurse;           //* pop subarray from stack */
	Else
		return;                 //* all subarrays done */
	EndIf;


//_____________________________________________________________________________
//        
// 1   ,  0   
 (, , =1) 
	 , ;
	
	 = ().("");
	
	 .(, , ) = 0   0; ;
	  = 1 
		.();
		 1;
	
		 ;
	;



//_____________________________________________________________________________
//    <> = <>,     <>
//<>     -       ( <> )
//   ,       ,  
// <>
 (, , ) 
     , ;
	 , , ;
	
	 = ();
	 = .("");
	
	 ()="" 
		 = .(0, );
	
		 = .(, , );
		  = 1   = ; ;
	;

	  > 0 
		 .(, );
	
		.(, );
		 ();
	;



//_____________________________________________________________________________
// - :  ,    
// - : 1 -   , 2 -  , 3 -  , 4 -   
// - : 1 - , -1 - 
 ( , =1, =1) 
	 ;
	 , , , ;
	
	 = ().("");

	 . = 0 
		 0;
	;
	
	 () = 1 
		
			 = .();
		
			 0;
		;
	;
	
	 = .(., );
	 = 0;
	
	 = .;
	 = 1;
	
	  = 1 
		 =  + ;
		 >0 
			 = ?( <= .(), 1, 0);
		
			 = ?( > 0, 1, 0);
		;
		 =0  ; ;

		 = .(, );
		  = 2 
			
				  <>  
					 = ;
					;
				;
			
				 = ;
				;
			;
		  = 3 
			 () = 1 
				 = ;
				;
			;
		  = 4 
			 () = 0 
				 = ;
				;
			;
		
			
				  =  
					 = ;
					;
				;
			
			;
		;
	;
	
	
	  = 0   0; ;

	.();
	
		.();
	
	;
	
	 ;



//_____________________________________________________________________________
 (, 1, , 2, )
	 , , 1, 2;
	 =1  .() 
		 = .();
		1 = .(1, );
		2 = .(2, );
		.(1, , 1 + 2);
	;


//_____________________________________________________________________________
//  :  =  + 
//   .    <>   
// <>,   .
// -  : 0 -  ; 1 -   ;
//         2 -       
// -        (  ,
//              )
 (, =0, __="") 
	 , ;
	 , , , , , , , , , __, ;
	 , 1, 2;
	
	 = ();
	 = .("");
	
	 = ("");
	 (__)=0 
		 (__)=2 
			 = ("");
			 = .(__, ",");
		 (__)="" 
			__.();
		;
	;

	 .()=0 
		//   
		 =1  .() 
			 = .(, );
			 <>""  ; ;
			.();
		;
	;
	
	//   
	 = .();
	  = 1  .() 
		 = .();
		 .() = 0 
			.(, , , , , , __, );
			.(, , , , , , __, );
		;
	;
    
	//
	  = 0 
		 =1  .() 
			  > .()  .(); ;
			(, , , , );
		;
		
	  = 1 
		(, ., , ., );
		
	 =2 
		 =1  .() 
			(, ., , , );
		;
		
	;


//_____________________________________________________________________________
 ( ="",  ="") 
	 , ;
	 , , , ;
	 ;
	
	 = ();
	 = .("");

	 () <> 1  //   ,   
		 = .;
	;
		
	 ()="" 
	 ()="" 
		 = ("");
		 = (, " ", "");
		 = .(, ",");
		// 
		  = 1  .() 
			 = .();
			 (, 1) = "-" 
				 = (, 2);
				.(, , "-");
			;
		;
	
		 = ("");
		 =1  .() 
			 = .(, );
			  <> ""  ; ;
			.();
		;
	;
	
	 .() = 0 
		 0;
	;
	
	 = 0;
	 =1  .() 
		 = .(, );
		 = ?( = "-", -1, 1);
		
		  = 0 
			//   
			 = (.() * ) + ;
		
			 = .(, );
			
				 = () * ;
			
				 = 0;
			;
			 =  + ;
		;
	;

	 ;





//==============================================================================
//----------      Excel  --------------------------------------------
//==============================================================================
Procedure ExportRowToExcel(VT, VT_Row, Sh, Row, ColList)
	Var i, ColID, Value;
	
	For i=1 To ColList.GetListSize() Do
		ColID = ColList.GetValue(i);
		Value = VT.GetValue(VT_Row, ColID);
		If ValueType(Value)>3 Then
			Value = String(Value);
		EndIf;
		If ValueType(Value)=2 Then
			Sh.Cells(Row, i).NumberFormat = "@";
		EndIf;
		Sh.Cells(Row, i).Value = Value;
	EndDo;
EndProcedure


Function ExportToExcel(val Excel, val ColList, val FirstRow, val LastRow, val ToFreezePanes, val AutoFilter) Export
	Var ToUnloadExcel, ColTitle;
	
	VT = ().("");
	 = ("");

	// 
	If EmptyValue(ColList) = 1 Then
		ColList = CreateObject("");
		For i=1 To VT.ColumnCount() Do
			ColList.AddValue(VT.GetColumnParameters(i));
		EndDo;
	ElsIf ValueTypeStr(ColList) = "" Then
		ColList = .(ColList, ",");
	EndIf;
	
	If ValueTypeStr(FirstRow) = "" Then
		FirstRow = .(FirstRow);
	ElsIf ValueTypeStr(FirstRow) <> "" Then
		If FirstRow = 0 Then FirstRow = 1;            EndIf;
		If LastRow = 0  Then LastRow = VT.LinesCnt(); EndIf;
	EndIf;
	
	
	// OLE- Excel, Excel.WorkBook and Excel.Worksheet
	ToUnloadExcel = 1;
	If EmptyValue(Excel) = 1 Then
		Excel = CreateObject("Excel.Application");
		ToUnloadExcel = 0;
	EndIf;

	WB = Excel.Workbooks.Add();
	Sh = WB.ActiveSheet();
	Sh.Visible = 1;
	
	
	// 
	For i=1 To ColList.GetListSize() Do
		VT.GetColumnParameters(ColList.GetValue(i),,,, ColTitle);
		Sh.Cells(1, i).Value = ColTitle;
	EndDo;
	
	//    Excel
	Row = 2;
	If ValueTypeStr(FirstRow) = "" Then
		For Row_i = 1 To FirstRow.GetListSize() Do
			Status("Writing  "+Row_i+"/"+FirstRow.GetListSize());
			
			VT_Row = Number(FirstRow.GetValue(Row_i));
			ExportRowToExcel(VT, VT_Row, Sh, Row, ColList);
			
			Row = Row + 1;
		EndDo;
	Else
		For VT_Row = FirstRow To LastRow Do
			If (VT_Row%10) = 0 Then
				Status("Writing  "+VT_Row+"/"+VT.LinesCnt());
			EndIf;
			
			ExportRowToExcel(VT, VT_Row, Sh, Row, ColList);
			
			Row = Row + 1;
		EndDo;
	EndIf;

	Sh.Cells(2,1).Select();
	// 
	For i=1 To ColList.GetListSize() Do
		Sh.Columns(i).EntireColumn.AutoFit();
	EndDo;
	
	If AutoFilter = 1 Then
		Sh.Cells(1,1).AutoFilter();
	EndIf;
	If ToFreezePanes = 1 Then
		Excel.ActiveWindow.FreezePanes = 1;
	EndIf;
	
	WB = "";
	Sh = "";
	Excel.Visible = 1;
	If ToUnloadExcel = 1 Then
		Excel = "";
	EndIf;
	

	Return 1;
EndFunction


//=============================================================================
//=====   /   /   ============================
//=============================================================================
//_____________________________________________________________________________
 (, , )
	 ;
	
	 = (, "\", "\\");
	 = (, , "\n");
	
	 ()="" 
		.();
	
		.();
	;
	 =  + 1;
	
	 (%100) = 0 
		("  "+);
	;


//_____________________________________________________________________________
 (, , )
	 , ;
	 = ();
	 = ();
	 =1 
		(, ","+, );
	 =2 
		(, ","+, );
	 =3 
		(, ","+(, ""), );
	 (>=10)  (<=15) 
		(, ","+(), );
	 ( = "")  ( = ".") 
		(, , );
	  = "" 
		(, , );
	  = "DynaValue" 
		(, , );
	
		(, ","+(), );
	;


//_____________________________________________________________________________
 (, , =1)
	 ;
	 , , , , , , , ;
	 , , ;
	
	 = ();

	//
	 ( = "")  ( = ".") 
		  = "." 
			 = "{";
		
			 = "{";
		;
		(, +","+.()+","+.(), );
		 =1  .() 
			 = .(, , , , , , , );
			(, " "++", "++","++","++","++","++", "+++, );
		;
	 ()="" 
		(, "{,"+.(), );
	  = "DynaValue" 
		(, "{DV,"+.(), );
	;

	//
	 (() = "")  (() = ".") 
		 =1  .() 
			 (%100)=0 
				("  "+);
			;
			 =1  .() 
				 = .(, );
				(, , );
			;
		;

	 ()="" 
		 =1  .() 
			 (%100)=0 
				("  "+);
			;
			 = .(, );
			(, , );
			(, , );
		;

	  = "DynaValue" 
		.();
		 .(, ) = 1 
			(, , );
			(, , );
		;
	;
	
	(, "}", );



//_____________________________________________________________________________
 (, )
	 , , , ;
	
	 ()="" 
		 = .();
	
		 = .();
		 =0 
			 = "";
		;
	;
	 =  + 1;
	
	 = (, "\");
	 = "";
	  > 0 
		 =  + (,  - 1);
		 (, +1, 1) = "\"       //      
			 =  + "\";
			 = (, +2);
		 (, +1, 1) = "n"  // \n   
			 =  + ;
			 = (, +2);
		                                     //      -    
			 =  + "\";
			 = (, );
		;
		 = (, "\");
	;
	 =  + ;
	
	 ;


//_____________________________________________________________________________
 (, , __=0)
	 , , , ;
	
	 (__)=2 
		 = __;  =  + 1;
	
		 = (, );
	;
	 (%100)=0 
		("  "+);
	;
	
	 = (, ",");
	 = (, -1);
	 = (, +1);
	
	  = "" 
		 = ();
	  = "" 
		 = ();
	//  = "" 
	//	 = ();
	  = "" 
		 = ();
	  = "{" 
		 =  - 1;
		 = (, , );
	 ="{" 
		 =  - 1;
		 = (, , );
	  = "{" 
		 =  - 1;
		 = (, , );
	 ="{DV" 
		 =  - 1;
		 = (, , );
	  = "" 
		 = ();
	;
	
	 ;


//_____________________________________________________________________________
 (, =1, __=0)
	 , ;
	 , , ;
	 , , , , , , , ;
	 , ;
	 , ;
	
	// 
	 (__)=2 
		 = __;  =  + 1;
	
		 = (, );
	;

	 = (".");
	.(, ",");
	.();
	 (="{")  (="{") 
		 (="{") 
			 = (".");
		
			 = ("");
		;
		
		.();  = ();
		.();  = ();
		
		//  
		  = 1   
			 = (, );
			.(, ",");
			.();  = ();
			.();  = ();
			.();  = ();
			.();  = ();
			.();  = ();
			.();  = ();
			.((.(), 2), ); //    ",",   - .
			.();  = ();
			.();  = ();
			.(, , , , , , , );
		;
	  = "{" 
		 = ("");
		.();  = ();
	  = "{DV" 
		 = ("DynaValue");
		.();  = ();
	
		("  :  "+, "!");
		 ;
	;
	
	 = ();
	 (="")  (=".") 
		//  
		 =1   
			.();
			 =1   
				.(, , (, ));
			;
		;
	  = "" 
		 =1   
			 = (, );
			 ()<>2 
				("  !", "!");
				 ;
			;
			 = (, );
			.(, );
		;

	 ="DynaValue" 
		 =1   
			 = (, );
			 ()<>2 
				("  !     DynaValue,  '"++"' :  "+, "!");
				 ;
			;
			 = (, );
			.(, );
		;
	;
	
	 = (, );
	  <> "}" 
		("  ", "!");
	;

	 ;



//_____________________________________________________________________________
 CreateV7TextFile(, )
	 ("v7plus.dll")=0 
		//("    v7plus.dll!"); 
		 0;
	;

	
		 = ("AddIn.V7TextFile");
	 
		("    Addin.V7TextFile!");
		 0;
	; 

	.(, );
	 ;


//_____________________________________________________________________________
 (,  = 3) 
	 ;
	
	 () = 1  
		 0;
	;
	
	 = ();
	
	  = 1 
		 (, , 1);
	  = 2 
		 (, , 2);
	
		 = CreateV7TextFile(, 1);
		 () = 1 
			 = ("");
		;
		
		(, );
		
		 () = "" 
			.();
		
			.();
		;
		 1;
	;


//_____________________________________________________________________________
 (,  = 0) 
	 , ;
	
	 ()=1  
		 0;
	;


	  = 0 
		 (, 1) = 1   1; ;
		 (, 2) = 1   1; ;
		 (, 3) = 1   1; ;
		 0;
		
	  = 1 
		
			 = (,, 1);
		
		;
	  = 2 
		
			 = (, , 2);
		
		;
	
		 = CreateV7TextFile(, 0);
		 () = 1 
			 = ("");
			.();
		;
		
		 = ();
		
		 () = "" 
			 = "";
		
			.();
		;
	;
	
	 () <> 0 
		
			();
		
			 0;
		;
	
		 0;
	;

	 1;

