double *NumChanPtr;
	unsigned i,j;
	unsigned SamplesPerInterferer;
	double fee;
	int Offset;
	double OffsetDouble;
	double *RealUplinkSignalPtr,*TempRealUplinkSignalPtr;
	double *ImagUplinkSignalPtr,*TempImagUplinkSignalPtr;
	unsigned N_UplinkSignal;
	unsigned Stop;
	double *RealMpathSignalPtr,*TempRealMpathPtr;
	double *ImagMpathSignalPtr,*TempImagMpathPtr;
	mxArray *mxControlBitsPtr;
	double *InphaseUplinkChipsPtr,*QuadUplinkChipsPtr;
	mxArray *mxBetaCPtr,*mxBetaDPtr;
	double *BetaCPtr,*BetaDPtr;
//	FILE *fp;
//	float sam;

	srand( (unsigned)time( NULL ) );

	SamplesPerInterferer = PulseLength + SamplesPerChip*(CHIPS_PER_FRAME-1);

	//Find the Maximum Delay
	MaxDelay=0;
	TempDelayPtr=DelayPtr;
	for (i = 0; i <NumDelays;i++)
	{
		if (*TempDelayPtr > MaxDelay) MaxDelay = *TempDelayPtr++;
		else TempDelayPtr++;
	}

	RealUplinkSignalPtr = (double *) mxCalloc(NCurrentSignal+MaxDelay,sizeof(double));
	if (RealUplinkSignalPtr == NULL)
		mexErrMsgTxt("\n RealUplinkSignalPtr Array Not Allocated!--exiting \n");
	ImagUplinkSignalPtr = (double *) mxCalloc(NCurrentSignal+MaxDelay,sizeof(double));
	if (ImagUplinkSignalPtr == NULL)
		mexErrMsgTxt("\n ImagUplinkSignalPtr Array Not Allocated!--exiting \n");

	RealMpathSignalPtr = (double *) mxCalloc(NCurrentSignal+MaxDelay,sizeof(double));
	if (RealMpathSignalPtr == NULL)
		mexErrMsgTxt("\n RealMpathSignalPtr Array Not Allocated!--exiting \n");
	ImagMpathSignalPtr = (double *) mxCalloc(NCurrentSignal+MaxDelay,sizeof(double));
	if (ImagMpathSignalPtr == NULL)
		mexErrMsgTxt("\n ImagMpathSignalPtr Array Not Allocated!--exiting \n");

	//Generate Array for Control Bits

	mxNumChanPtr = mxCreateDoubleMatrix(1,1,mxREAL);
	if (mxNumChanPtr == NULL)
		mexErrMsgTxt("\n mxNumChanPtr Matrix Not Allocated!--exiting \n");
	NumChanPtr = mxGetPr(mxNumChanPtr);
	*NumChanPtr = (double) 1.0;

	mxControlBitsPtr = mxCreateDoubleMatrix(1,CONTROL_BITS,mxREAL);
	if (mxControlBitsPtr == NULL)
		mexErrMsgTxt("\n mxControlBitsPtr Matrix Not Allocated!--exiting \n");
	ControlBitsPtr = mxGetPr(mxControlBitsPtr);

	RealCodePtr = (short int *) mxCalloc(CHIPS_PER_FRAME,sizeof(short int));
	if (RealCodePtr == NULL)
		mexErrMsgTxt("\n RealCodePtr Array Not Allocated!--exiting \n");

	ImagCodePtr = (short int *) mxCalloc(CHIPS_PER_FRAME,sizeof(short int));
	if (ImagCodePtr == NULL)
		mexErrMsgTxt("\n ImagCodePtr Array Not Allocated!--exiting \n");

	mxScrambleCodePtr = mxCreateDoubleMatrix(1,CHIPS_PER_FRAME,mxCOMPLEX);
	if (mxScrambleCodePtr == NULL)
		mexErrMsgTxt("\n mxScrambleCodePtr Matrix Not Allocated!--exiting \n");
	RealScrambleCodePtr = mxGetPr(mxScrambleCodePtr);
	ImagScrambleCodePtr = mxGetPi(mxScrambleCodePtr);

	mxBetaCPtr = mxCreateDoubleMatrix(1,1,mxREAL);
	if (mxBetaCPtr == NULL)
		mexErrMsgTxt("\n mxBetaCPtr Matrix Not Allocated!--exiting \n");
	BetaCPtr = mxGetPr(mxBetaCPtr);
	*BetaCPtr = (double) 1.0;

	mxBetaDPtr = mxCreateDoubleMatrix(1,1,mxREAL);
	if (mxBetaDPtr == NULL)
		mexErrMsgTxt("\n mxBetaDPtr Matrix Not Allocated!--exiting \n");
	BetaDPtr = mxGetPr(mxBetaDPtr);
	*BetaDPtr = (double) 1.0;

	for (i = 0;i < NumInterferers; i++)
	{
		//Generate Control Frame
		TempControlBitsPtr=ControlBitsPtr;
		for (j = 0; j < CONTROL_BITS; j++)
		{
			fee = ((double) rand() / (double) RAND_MAX) - 0.5;
			if (fee <= 0.0)	*TempControlBitsPtr++ = (double) -1.0;
			else *TempControlBitsPtr++ = (double) 1.0;
		}
/******************************************************************
		//DEBUG CODE
		TempControlBitsPtr=ControlBitsPtr;
		fp = fopen("C:/MATLABR11/work/LGICtest/testdata.txt","r");
		for (j = 0; j < CONTROL_BITS; j++)
		{
			fscanf(fp, "%e\n", &sam);
			*TempControlBitsPtr++ = (double) sam;
		} 
		fscanf(fp, "%e\n", &sam);
		ScrambleCodeNumber = (unsigned long) sam;
		fclose (fp);


//DEBUG CODE
/***************************************************************************/

		//Generate Scramble code for each interferer


		ScrambleCodeNumber =unsigned long (((double) rand() / (double) RAND_MAX)* (pow( (double) 2.0, (double) 24.0) - (double) 1));

		scramble_long(ScrambleCodeNumber, RealCodePtr, ImagCodePtr);

		//Store Scramble Code in an mxArray
		TmpRealCodePtr = RealCodePtr;
		TmpImagCodePtr = ImagCodePtr;
		TmpRealScrambleCodePtr = RealScrambleCodePtr;
		TmpImagScrambleCodePtr = ImagScrambleCodePtr;

		for (j = 0; j < CHIPS_PER_FRAME; j++)
		{
			*TmpRealScrambleCodePtr++ = (double) *TmpRealCodePtr++;
			*TmpImagScrambleCodePtr++ = (double) *TmpImagCodePtr++;
		}

		*mxRightHandSide = mxNumChanPtr;
		*(mxRightHandSide+1) = mxScrambleCodePtr;
		*(mxRightHandSide+2) = (mxArray *) mxChanCodePtr;
		*(mxRightHandSide+3) = mxControlBitsPtr;
		*(mxRightHandSide+4) = mxBetaCPtr;
		*(mxRightHandSide+5) = mxBetaDPtr;
		N_rhs = 6;
		N_lhs = 2;

		ErrCode = mexCallMATLAB(N_lhs,mxLeftHandSide,N_rhs,mxRightHandSide,"gen_uplink_wcdma_frame");
		if(ErrCode != 0)
			mexErrMsgTxt("\nError Calling gen_uplink_wcdma_frame from MAI_Processr\n");

		//Prepare Parameters for caling GenWCDMAUplinkSignal
//		InphaseUplinkChipsPtr = mxGetPr(mxUplinkFramePtr);
//		QuadUplinkChipsPtr = mxGetPi(mxUplinkFramePtr);
		InphaseUplinkChipsPtr = mxGetPr(mxLeftHandSide[0]);
		QuadUplinkChipsPtr = mxGetPi(mxLeftHandSide[0]);

		TempRealNextPtr = RealNextSignalPtr + i*SamplesPerInterferer;
		TempImagNextPtr = ImagNextSignalPtr + i*SamplesPerInterferer;

		GenWCDMAUplinkSignal(InphaseUplinkChipsPtr,QuadUplinkChipsPtr,
							InphaseUplinkChipsPtr,QuadUplinkChipsPtr,
							InphaseUplinkChipsPtr,QuadUplinkChipsPtr,
							CHIPS_PER_FRAME,PulseShapePtr,PulseLength,SamplesPerChip,
							TempRealNextPtr,TempImagNextPtr,SamplesPerInterferer);

		//Generate Offset

		OffsetDouble = (double) rand() / (double) RAND_MAX -  0.5;
		OffsetDouble *= 2 * MaxOffset * SamplesPerChip;
		if ((OffsetDouble - floor(OffsetDouble)) < 0.5)
			Offset = (int) OffsetDouble;
		else
			Offset = (int) OffsetDouble + 1;

		//************************
		//DEBUG CODE
		//Offset = 10;
		//DEBUG CODE
		//************************

		TempRealUplinkSignalPtr = RealUplinkSignalPtr;
		TempImagUplinkSignalPtr = ImagUplinkSignalPtr;

		if (Offset > (int) MaxDelay)
		{
			TempRealLastPtr = RealLastSignalPtr + (i+1)*NLastSignal - Offset;
			TempImagLastPtr = ImagLastSignalPtr + (i+1)*NLastSignal - Offset;
			TempRealCurrentPtr = RealCurrentSignalPtr + i*NCurrentSignal;
			TempImagCurrentPtr = ImagCurrentSignalPtr + i*NCurrentSignal;

			for (j = 0; j < (unsigned) Offset; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealLastPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagLastPtr++;
			}
			
			Stop = NCurrentSignal + MaxDelay - Offset;
			for (j = 0; j < Stop; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealCurrentPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagCurrentPtr++;
			}
		}
		else if (Offset >= 1)
		{
			TempRealLastPtr = RealLastSignalPtr + (i+1)*NLastSignal - Offset;
			TempImagLastPtr = ImagLastSignalPtr + (i+1)*NLastSignal - Offset;
			TempRealCurrentPtr = RealCurrentSignalPtr + i*NCurrentSignal;
			TempImagCurrentPtr = ImagCurrentSignalPtr + i*NCurrentSignal;
			TempRealNextPtr = RealNextSignalPtr + i*NNextSignal;
			TempImagNextPtr = ImagNextSignalPtr + i*NNextSignal;

			for (j = 0; j < (unsigned) Offset; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealLastPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagLastPtr++;
			}
			
			for (j = 0; j < NCurrentSignal; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealCurrentPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagCurrentPtr++;
			}

			Stop = MaxDelay - Offset;
			for (j = 0; j < Stop; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealNextPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagNextPtr++;
			}
		}
		else if (Offset < 0)
		{
			TempRealCurrentPtr = RealCurrentSignalPtr + i*NCurrentSignal - Offset;
			TempImagCurrentPtr = ImagCurrentSignalPtr + i*NCurrentSignal - Offset;
			TempRealNextPtr = RealNextSignalPtr + i*NNextSignal;
			TempImagNextPtr = ImagNextSignalPtr + i*NNextSignal;

			Stop = NCurrentSignal + Offset;
			for (j = 0; j < Stop; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealCurrentPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagCurrentPtr++;
			}

			Stop = MaxDelay - Offset;
			for (j = 0; j < Stop; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealNextPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagNextPtr++;
			}
		}

		else  //Offset = 0
		{
			TempRealCurrentPtr = RealCurrentSignalPtr + i*NCurrentSignal;
			TempImagCurrentPtr = ImagCurrentSignalPtr + i*NCurrentSignal;
			TempRealNextPtr = RealNextSignalPtr + i*NNextSignal;
			TempImagNextPtr = RealNextSignalPtr + i*NNextSignal;

			for (j = 0; j < NCurrentSignal; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealCurrentPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagCurrentPtr++;
			}

			for (j = 0; j < MaxDelay; j++)
			{
				*TempRealUplinkSignalPtr++ = *TempRealNextPtr++;
				*TempImagUplinkSignalPtr++ = *TempImagNextPtr++;
			}
		}

		if (M_PATH_FLAG)
		{
			//ApplyMultipathChannel

			//First Initialize output vector

			TempRealMpathPtr = RealMpathSignalPtr;
			TempImagMpathPtr = ImagMpathSignalPtr;
			N_UplinkSignal = NCurrentSignal + MaxDelay;
			for (j = 0; j < N_UplinkSignal; j++)
			{
				*TempRealMpathPtr++ = (double) 0.0;
				*TempImagMpathPtr++ = (double) 0.0;
			}

			MAI_Mpath_Channel(RealUplinkSignalPtr,ImagUplinkSignalPtr,N_UplinkSignal,
							  DelayPtr,NumDelays,MPathAmpPtr,fDoppler,SamplesPerChip,
							  RealMpathSignalPtr,ImagMpathSignalPtr);
		}
		else	//Do Not apply Multipath 
		{
			TempRealMpathPtr = RealMpathSignalPtr;
			TempImagMpathPtr = ImagMpathSignalPtr;
			TempRealUplinkSignalPtr = RealUplinkSignalPtr;
			TempImagUplinkSignalPtr = ImagUplinkSignalPtr;

			N_UplinkSignal = NCurrentSignal + MaxDelay;
			for (j = 0; j < N_UplinkSignal; j++)
			{
				*TempRealMpathPtr++ = *TempRealUplinkSignalPtr++;
				*TempImagMpathPtr++ = *TempImagUplinkSignalPtr++;
			}
		}
			
		TempRealMAIPtr = RealMAISignalPtr;
		TempImagMAIPtr = ImagMAISignalPtr;
		TempRealMpathPtr = RealMpathSignalPtr;
		TempImagMpathPtr = ImagMpathSignalPtr;

		for (j = 0; j < N_UplinkSignal; j++)
		{
			*TempRealMAIPtr++ += *TempRealMpathPtr++;
			*TempImagMAIPtr++ += *TempImagMpathPtr++;
		}

	}
	mxFree(RealUplinkSignalPtr);
	mxFree(ImagUplinkSignalPtr);
	mxFree(RealMpathSignalPtr);
	mxFree(ImagMpathSignalPtr);
	mxDestroyArray(mxNumChanPtr);
	mxDestroyArray(mxControlBitsPtr);
	mxFree(RealCodePtr);
	mxFree(ImagCodePtr);
	mxDestroyArray(mxScrambleCodePtr);
	mxDestroyArray(mxBetaCPtr);
	mxDestroyArray(mxBetaDPtr);

}