TUint32 aIsDebug,

                                 const TDesC8& aAtoolVersion,

                                 const TDesC8& aApiVersion )

    // PCS <Process name> <Process ID> <Time stamp> <Udeb> <Version>

    //Buffer to trace

    TBuf8<KProcessStartBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // PCS

    buffer.Append( KProcessStart );

    // process name

    buffer.Append( aProcessName );

    buffer.Append( KSpace );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // time stamp

    buffer.Append( KSpace );

    // urel/udeb

    buffer.Append( KSpace );

    // version

    buffer.Append( KSpace );    

    // atool version

    buffer.Append( aAtoolVersion );

    buffer.Append( KSpace );

    // ATAPI version

    buffer.Append( aApiVersion );

    RDebug::RawPrint( buffer );

    // PCE

    	{

        // HDL <Handle count>

        TBuf8<KHandleLeakBufLength> buffer2;

        // AT indentifier

        buffer2.Append( KATIdentifier );

        // process id

        buffer2.AppendNum( aProcessId, EHex );

        buffer2.Append( KSpace );

        // HDL

        buffer2.Append( KHandleLeak );

        // leak count

        buffer2.AppendNum( aHandleLeakCount );

        RDebug::RawPrint( buffer2 );

    	}

    // Buffer to trace.

    TBuf8<KProcessEndBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex );

    buffer.Append( KSpace );

    // PCE

    buffer.Append( KProcessEnd );

    RDebug::RawPrint( buffer );

    // DLL <DLL name> <Memory start address> <Memory end address>

    TBuf8<KDllLoadBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // DLL

    buffer.Append( KDllLoad );

    // dll name

    buffer.Append( aDllName );

    buffer.Append( KSpace );

    // start adress

    buffer.AppendNum( aStartAddress, EHex );

    buffer.Append( KSpace );   

    //end adress

    buffer.AppendNum( aEndAddress, EHex );

    RDebug::RawPrint( buffer );

    // DLU <DLL name> <Memory start address> <Memory end address>

    TBuf8<KDllUnloadBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // DLU

    buffer.Append( KDllUnload );

    // dll name

    buffer.Append( aDllName );

    buffer.Append( KSpace );

    // start adress

    buffer.AppendNum( aStartAddress, EHex );

    buffer.Append( KSpace );   

    //end adress

    buffer.AppendNum( aEndAddress, EHex );

    RDebug::RawPrint( buffer );

                                  TInt aSize, TUint aThreadId )

    // ALH <Memory address> <Allocation size> <Thread ID> 

    // <Call stack address count> <Call stack address> <Call stack address> ...

    // Buffer to trace.

    TBuf8<KMemAllocBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // ALH

    buffer.Append( KMemoryAllocHeader );

    // memory adress

    buffer.AppendNum( aMemAddress, EHex );

    buffer.Append( KSpace );

    // allocation size

    buffer.AppendNum( aSize, EHex );

    buffer.Append( KSpace ); 

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    buffer.Append( KSpace );

	TInt addrCount(0);

	for ( TInt j = 0; j < aCallstack.Count() ; j++ )

		{

		if ( aCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

    // address count

    buffer.AppendNum( addrCount, EHex );

        // ALF <Memory address> <Packet number> <Call stack address> <Call stack address> ...

        if ( buffer.Length() <= 0 )

            {

            // AT indentifier

            buffer.Append( KATIdentifier );

            // process id

            buffer.AppendNum( aProcessId, EHex  );

            buffer.Append( KSpace ); 

            buffer.Append( KMemoryAllocFragment );

            buffer.AppendNum( aMemAddress, EHex );

            buffer.Append( KSpace );     

            buffer.AppendNum( packetNumber, EHex );

        buffer.Append( KSpace );

        buffer.AppendNum( aCallstack.At( addrPos ), EHex );

        if ( KLastItemLength + buffer.Length() >= KMemAllocBufLength )

            RDebug::RawPrint( buffer );

            buffer.Delete( 0, buffer.MaxLength() );

    if ( buffer.Length() > 0 )

        RDebug::RawPrint( buffer );

                              TFixedArray<TUint32, KATMaxFreeCallstackLength>& aFreeCallstack,

                              TUint aThreadId )

	// FRH <Memory address> <Thread ID> <Call stack address count> 

	// <Call stack address> <Call stack address> ...

	// Buffer to trace.

	TBuf8<KMemFreedBufLength> buffer;

	// AT indentifier

	buffer.Append( KATIdentifier );

	// process id

	buffer.AppendNum( aProcessId, EHex  );

	buffer.Append( KSpace );

	// FRH

	buffer.Append( KMemoryFreedHeader );

	// Append the start address of this allocation in the 32-bit (max 8 characters)

	// hexadecimal text format.

	buffer.AppendNum( aMemAddress, EHex );

	buffer.Append( KSpace );

	// thread ID

	buffer.AppendNum( aThreadId, EHex );

	buffer.Append( KSpace );

	// Search call stack for address count.

	TInt addrCount(0);

	for ( TInt j = 0; j < aFreeCallstack.Count() ; j++ )

		{

		if ( aFreeCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

	// address count.

	buffer.AppendNum( addrCount, EHex );

	TUint packetNumber( 1 );

	// Go through all call stack's memory addresses associated with

	// this memory allocation 

	for ( TInt j = 0; j < addrCount; j++ )

		{

		// FRF <Memory address> <Packet number> 

		// <Call stack address> <Call stack address> ...

		if ( buffer.Length() <= 0 )

			{               

			// Create alloc fragment message header

			buffer.Append( KMemoryFreedFragment );

			buffer.AppendNum( aMemAddress, EHex );

			buffer.Append( KSpace );

			buffer.AppendNum( packetNumber, EHex );

			// Increase packet number

			packetNumber++;

			}

		// Append call stack address.

		buffer.Append( KSpace );

		buffer.AppendNum( aFreeCallstack.At( addrPos ), EHex );

		// Move the call stack position.

		addrPos++;

		// Check if buffer max length exceed

		if ( KLastItemLength + buffer.Length() >= KMemFreedBufLength )

			{

			// Log through debug channel 

			RDebug::RawPrint( buffer );

			// Empty trace buffer

			buffer.Delete( 0, buffer.MaxLength() );

			}

		}

	// Send last message if exists.

	if ( buffer.Length() > 0 )

		{

		RDebug::RawPrint( buffer );

		}

    return KErrNone;   

    }

TInt ATFastLogMemoryReallocated( TUint aProcessId, TUint32 aMemAddressFree,  TUint32 aMemAddressAlloc,

                                  TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,

                                  TInt aSize, TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogMemoryReallocated()" );    

    // RAH <Freed memory address> <Allocated memory address> <Allocation size> <Thread ID>

    // <Call stack address count> <Call stack address> <Call stack address> ...

    // Buffer to trace.

    TBuf8<KMemReallocBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // RAH

    buffer.Append( KMemoryReallocHeader );

    // memory adress freed

    buffer.AppendNum( aMemAddressFree, EHex );

    buffer.Append( KSpace );

    // memory adress allocated

    buffer.AppendNum( aMemAddressAlloc, EHex );

    buffer.Append( KSpace );

    // allocation size

    buffer.AppendNum( aSize, EHex );

    buffer.Append( KSpace ); 

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    buffer.Append( KSpace );

	TInt addrCount(0);

	for ( TInt j = 0; j < aCallstack.Count() ; j++ )

		{

		if ( aCallstack.At(j) == 0 )

			break;

		addrCount++;

		}

	// Current position in call stack.

	TInt addrPos( 0 );

    // address count

    buffer.AppendNum( addrCount, EHex );

        // RAF <Freed memory address> <Allocated memory address> <Packet number>

        if ( buffer.Length() <= 0 )

            {

            // AT indentifier

            buffer.Append( KATIdentifier );

            // process id

            buffer.AppendNum( aProcessId, EHex  );

            buffer.Append( KSpace ); 

            buffer.Append( KMemoryReallocFragment );

            // memory adress freed

            buffer.AppendNum( aMemAddressFree, EHex );

            buffer.Append( KSpace );

            // memory adress allocated

            buffer.AppendNum( aMemAddressAlloc, EHex );

            buffer.Append( KSpace );

            // packet number

            buffer.AppendNum( packetNumber, EHex );

        buffer.Append( KSpace );

        buffer.AppendNum( aCallstack.At( addrPos ), EHex );

        if ( KLastItemLength + buffer.Length() >= KMemAllocBufLength )

            RDebug::RawPrint( buffer );

            buffer.Delete( 0, buffer.MaxLength() );

    if ( buffer.Length() > 0 )

        RDebug::RawPrint( buffer);

    return KErrNone;

    }

TInt ATFastLogThreadStarted( TUint aProcessId, TUint aThreadId )

    {

    LOGSTR1( "ATFL ATFastLogThreadStarted()" );

    // TDS <Thread ID>

    //Buffer to trace

    TBuf8<KThreadStartBufLength> buffer;

    // AT indentifier

    buffer.Append( KATIdentifier );

    // process id

    buffer.AppendNum( aProcessId, EHex  );

    buffer.Append( KSpace );

    // TDS

    buffer.Append( KThreadStart );

    // thread ID

    buffer.AppendNum( aThreadId, EHex );

    RDebug::RawPrint( buffer );