diff --git a/src/LLC_EncDec.cc b/src/LLC_EncDec.cc
new file mode 100644
index 0000000..b96b961
--- /dev/null
+++ b/src/LLC_EncDec.cc
@@ -0,0 +1,317 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2017 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v1.0
+// which accompanies this distribution, and is available at
+// http://www.eclipse.org/legal/epl-v10.html
+///////////////////////////////////////////////////////////////////////////////
+//
+//  File:               LLC_EncDec.cc
+//  Rev:                R2A
+//  Prodnr:             CNL 113 577
+//  Updated:            2008-01-22
+//  Contact:            http://ttcn.ericsson.se
+//  Reference:          3GPP TS 44.064 7.1.0
+ 
+#include "LLC_Types.hh"
+#include <string.h>
+
+// GIVEN IN CODE RECEIVED FROM ERV
+#define CRC_POLY_LLC2  0xad85dd
+
+// GIVEN IN SPECIFICATION
+//#define CRC_POLY_LLC2  0xbba1b5
+
+#define TABLE_LENGTH  256
+
+// For UI frames if PM bit is 0 (unprotected) then CRC will be calculated over Header + N202 octets
+#define N202 4
+
+unsigned int mCRCTable[TABLE_LENGTH];
+
+
+static void BuildCrc24Table()
+{
+ unsigned int i,j;
+ unsigned int reg;
+
+  //TRACE_FUNC( "BuildCrc24Table" );
+
+  for( i = 0; i < TABLE_LENGTH; i++ )
+  {
+    reg = i;
+    for( j = 8; j > 0; j-- )
+    {
+      if( reg & 1 )
+      {
+        
+	reg = (reg>>1) ^ (unsigned int) CRC_POLY_LLC2;
+      }
+      else
+      {
+        reg >>= 1;
+      }
+    }
+    reg &= 0x00ffffffL;
+   
+      mCRCTable[i] = (unsigned int)reg;
+      //TTCN_Logger::begin_event(TTCN_DEBUG);
+     
+      //TTCN_Logger::log_event("mCRCTable[%d]= %d",i,mCRCTable[i]);
+  
+     // TTCN_Logger::end_event();
+
+  }
+}
+
+//---------------------------------------------------------------------------------------
+
+unsigned int  Calculate_CRC(TTCN_Buffer& pdu)
+{
+
+const unsigned char* loc_pdu = pdu.get_data();
+
+ //TTCN_Logger::begin_event(TTCN_DEBUG);
+     
+     //for (size_t i =0; i< pdu.get_len();i++)
+    // {
+     // TTCN_Logger::log_event("%02x ",loc_pdu[i]);
+    // }
+     
+//TTCN_Logger::log_event("\n");      
+     
+//TTCN_Logger::end_event();
+
+BuildCrc24Table();
+
+//TTCN_Logger::begin_event(TTCN_DEBUG);
+//TTCN_Logger::log_event("mCRCTable[%d]= %d\n",255,mCRCTable[255]);
+//TTCN_Logger::log_event("mCRCTable[%d]= 0x%08x (%u)",255,mCRCTable[255]);
+//TTCN_Logger::log_event("\n");      
+//TTCN_Logger::end_event();
+
+unsigned int reg = 0xFFFFFF;
+
+unsigned int length = pdu.get_len();
+
+
+      
+if (  ((loc_pdu[1] >>5) & 0x07) == 0x06 )      //UI frame
+{ 
+ if ((loc_pdu[2] & 0x01) == 0x00)              // PM bit is 0 (unprotected)         
+  { 
+     if(length  > 3 + N202)                     // pdu length is longer than header + N202    
+     {
+     length = 3 + N202;                         // length = header length + N202    
+          
+     }	
+   }              
+}
+
+   
+
+while ( length--)
+  {
+    reg =
+      ((reg>>8) & 0x00ffff)^mCRCTable[(reg^*((unsigned char*)loc_pdu++)) & 0xffL];
+  }
+   //TTCN_Logger::log(TTCN_DEBUG, "reg:%08x\n",reg);	
+   // 1's complement of FCS 
+  reg ^= 0xffffffL;
+  
+  reg = ((reg >> 16) & 0x000000ff)+ ((reg)  & 0x0000ff00) + ((reg <<16 )& 0x00ff0000);
+ //unsigned int tempint = *(unsigned int*)loc_crcBuffer;
+ //reg =  (unsigned int*)loc_crcBuffer ;
+ //TTCN_Logger::log(TTCN_DEBUG, "reg:%08x\n",reg);	
+	
+return  reg & 0x00ffffffL;	
+}
+//---------------------------------------------------------------------------------------
+
+namespace LLC__Types {
+
+OCTETSTRING enc__PDU__LLC(const PDU__LLC& pdu)
+{
+	TTCN_Buffer bb;
+	PDU__LLC pdu2(pdu);
+	
+	if (pdu2.get_selection() == PDU__LLC::ALT_pDU__LLC__U)
+	{
+
+          if (pdu2.pDU__LLC__U().information__field__U().get_selection() ==  Information__field__U::ALT_uA)
+           {int record_of_size = pdu2.pDU__LLC__U().information__field__U().uA().size_of();
+       
+            for (int  i = 0; i < (record_of_size) ; i++)
+	      { 
+	      // AUTOMATICALLY CALCULATE WHICH LENGTH FORMAT SHOULD BE USED AND CHANGE SHORT LENGTH FORM 
+	      // TO LONG LENGTH FORM IF NECESSARY WHEN L3 PDU IS INCLUDED
+	         if ( pdu2.pDU__LLC__U().information__field__U().uA()[i].typefield() == int2bit(11,5) )
+	          {  
+		   if( pdu2.pDU__LLC__U().information__field__U().uA()[i].xID__Data().l3param().lengthof() > 3)
+		   {		  
+		   pdu2.pDU__LLC__U().information__field__U().uA()[i].xID__length().long__len() = 
+		   pdu2.pDU__LLC__U().information__field__U().uA()[i].xID__Data().l3param().lengthof();		   
+		   }		 		 		  
+		  }
+	      } 
+           }
+
+           if (pdu2.pDU__LLC__U().information__field__U().get_selection() ==  Information__field__U::ALT_sABM)
+        {int record_of_size = pdu2.pDU__LLC__U().information__field__U().sABM().size_of();
+       
+            for (int  i = 0; i < (record_of_size) ; i++)
+	      { 
+	      // AUTOMATICALLY CALCULATE WHICH LENGTH FORMAT SHOULD BE USED AND CHANGE SHORT LENGTH FORM 
+	      // TO LONG LENGTH FORM IF NECESSARY WHEN L3 PDU IS INCLUDED
+	         if ( pdu2.pDU__LLC__U().information__field__U().sABM()[i].typefield() == int2bit(11,5) )
+	          {  
+		   if( pdu2.pDU__LLC__U().information__field__U().sABM()[i].xID__Data().l3param().lengthof() > 3)
+		   {		  
+		   pdu2.pDU__LLC__U().information__field__U().sABM()[i].xID__length().long__len() = 
+		   pdu2.pDU__LLC__U().information__field__U().sABM()[i].xID__Data().l3param().lengthof();		   
+		   }		 		 		  
+		  }
+	      } 
+           }
+		
+            if (pdu2.pDU__LLC__U().information__field__U().get_selection() ==  Information__field__U::ALT_xID)
+       {int record_of_size = pdu2.pDU__LLC__U().information__field__U().xID().size_of();
+       
+            for (int  i = 0; i < (record_of_size) ; i++)
+	      { 
+	      // AUTOMATICALLY CALCULATE WHICH LENGTH FORMAT SHOULD BE USED AND CHANGE SHORT LENGTH FORM 
+	      // TO LONG LENGTH FORM IF NECESSARY WHEN L3 PDU IS INCLUDED
+	         if ( pdu2.pDU__LLC__U().information__field__U().xID()[i].typefield() == int2bit(11,5) )
+	          {  
+		   if( pdu2.pDU__LLC__U().information__field__U().xID()[i].xID__Data().l3param().lengthof() > 3)
+		   {		  
+		   pdu2.pDU__LLC__U().information__field__U().xID()[i].xID__length().long__len() = 
+		   pdu2.pDU__LLC__U().information__field__U().xID()[i].xID__Data().l3param().lengthof();		   
+		   }		 		 		  
+		  }
+	      } 
+           }			
+	}
+	
+	
+	if (pdu2.get_selection() == PDU__LLC::ALT_pDU__LLC__U)
+	 {
+	    if ( pdu2.pDU__LLC__U().fCS().ispresent())
+	    {
+	        if ( pdu2.pDU__LLC__U().fCS() == int2oct(0,3) )  // IF ENCODER NEEDS TO GENERATE CRC
+	          {      
+                    pdu2.pDU__LLC__U().fCS() = OMIT_VALUE;
+	            pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);
+	            unsigned int crcBuffer = Calculate_CRC(bb);
+		    bb.put_os(int2oct(crcBuffer,3));		
+	            return OCTETSTRING (bb.get_len(), bb.get_data());
+	
+		  }
+	    
+	     else {	// IF ENCODER SENDS OUT NONZERO CRC GIVEN IN TTCN TEMPLATE
+	         pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);	
+	         return OCTETSTRING (bb.get_len(), bb.get_data());
+	          }    	    
+	    }	
+	    else {	//FCS OMIT
+	            pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);
+	            unsigned int crcBuffer = Calculate_CRC(bb);
+		    bb.put_os(int2oct(crcBuffer,3));		
+	            return OCTETSTRING (bb.get_len(), bb.get_data());
+		    
+	         }
+	 }
+	
+	
+	
+	else if (pdu2.get_selection() == PDU__LLC::ALT_pDU__LLC__UI)
+	    {
+	      if ( pdu2.pDU__LLC__UI().fCS().ispresent())
+	       {
+	          if ( pdu2.pDU__LLC__UI().fCS() == int2oct(0,3) )   // IF ENCODER NEEDS TO GENERATE CRC 
+	          {      
+		    pdu2.pDU__LLC__UI().fCS() = OMIT_VALUE;
+	            pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);
+	            unsigned int crcBuffer = Calculate_CRC(bb);
+		    bb.put_os(int2oct(crcBuffer,3));		
+	            return OCTETSTRING (bb.get_len(), bb.get_data()); 
+		  
+		  }
+		  
+	     else {	// IF ENCODER SENDS OUT NONZERO CRC GIVEN IN TTCN TEMPLATE
+	          pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW); 	
+	          return OCTETSTRING (bb.get_len(), bb.get_data());	    
+	          }
+	       }
+	     else {	//FCS OMIT
+	            pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);
+	            unsigned int crcBuffer = Calculate_CRC(bb);
+		    bb.put_os(int2oct(crcBuffer,3));		
+	            return OCTETSTRING (bb.get_len(), bb.get_data()); 
+	          }		
+	    }
+	else {TTCN_error("Can not encode LLC PDU");  //Neither UI NOR U
+	
+	      return  OCTETSTRING (bb.get_len(), bb.get_data()); // this is dummy to avoid warning during compilation
+	    }
+	//pdu2.encode(PDU__LLC_descr_ ,bb, TTCN_EncDec::CT_RAW);	
+	//unsigned int crcBuffer = Calculate_CRC(bb);
+		
+	//bb.put_os( int2oct(crcBuffer,3));
+	
+	
+	//return OCTETSTRING (bb.get_len(), bb.get_data());
+		
+}
+
+
+OCTETSTRING enc__PDU__LLC(const PDU__LLC_template& pdu)
+{
+  return enc__PDU__LLC(pdu.valueof());
+}
+
+
+PDU__LLC dec__PDU__LLC(const OCTETSTRING& stream)
+{
+	PDU__LLC retv;
+	TTCN_Buffer bb;
+        OCTETSTRING crc = int2oct(0,3);
+	
+	size_t datalength = stream.lengthof()-3;
+	const unsigned char * CRC_AS_RECEIVED = (const unsigned char *)stream+datalength;
+	bb.put_s(datalength,(const unsigned char *)stream);
+	
+	unsigned int CRC_CALCULATED = Calculate_CRC(bb);
+     
+      // COMPARE CRC RECEIVED IN LLC PDU WITH CRC CALCULATED FROM LLC PDU	
+	if(
+	  (CRC_AS_RECEIVED[ 0 ] != (CRC_CALCULATED & 0xff0000  ) >> 16) ||
+          (CRC_AS_RECEIVED[ 1 ] != (CRC_CALCULATED & 0xff00    ) >> 8) ||
+          (CRC_AS_RECEIVED[ 2 ] != (CRC_CALCULATED & 0xff      )     )
+	  ) 
+	{
+	     TTCN_warning("CRC ERROR IN LLC PDU");  // CRC IS NOT AS EXPECTED
+	     crc=OCTETSTRING(3,CRC_AS_RECEIVED);
+	}
+	 // CRC IS 
+         // FILL CRC octets with zeroes if CRC is OK
+	
+	retv.decode(PDU__LLC_descr_, bb, TTCN_EncDec::CT_RAW);
+	 
+	if (retv.get_selection() == PDU__LLC::ALT_pDU__LLC__UI){
+	   retv.pDU__LLC__UI().fCS() = crc;
+	} 
+	    
+	if (retv.get_selection() == PDU__LLC::ALT_pDU__LLC__U){
+	retv.pDU__LLC__U().fCS() = crc;
+	} 
+	
+	
+	return retv;
+	   
+
+}
+
+}//namespace
diff --git a/src/LLC_Types.ttcn b/src/LLC_Types.ttcn
new file mode 100644
index 0000000..d07a77f
--- /dev/null
+++ b/src/LLC_Types.ttcn
@@ -0,0 +1,328 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2017 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v1.0
+// which accompanies this distribution, and is available at
+// http://www.eclipse.org/legal/epl-v10.html
+///////////////////////////////////////////////////////////////////////////////
+//
+//  File:               LLC_Types.ttcn
+//  Description:        This module contains the Logical Link Control protocol (LLC)
+//                      44.064 v7.1.0 with attributes for RAW encoding/decoding.
+//  Rev:                R2A
+//  Prodnr:             CNL 113 577
+//  Updated:            2008-01-22
+//  Contact:            http://ttcn.ericsson.se
+//  Reference:          3GPP TS 44.064 7.1.0
+ 
+module LLC_Types
+{    
+
+import from General_Types all;
+
+external function enc_PDU_LLC(in PDU_LLC pdu) return octetstring;
+external function dec_PDU_LLC(in octetstring stream) return PDU_LLC;
+
+type record Version
+{
+  integer 	version_value (0..15),
+  BIT4		spare
+
+} with {
+  variant (version_value) "FIELDLENGTH(4)";
+}
+
+type octetstring IOV_UI length(4) 
+
+
+type octetstring IOV_I length(4)
+
+
+type record T200
+{
+  BIT4		spare,
+  integer 	t200Value
+} with {
+  variant (t200Value) "FIELDLENGTH(12)";
+  variant (t200Value) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+
+type record N200
+{
+  integer 	retransmissions (0..15),
+  BIT4		spare
+} with {
+  variant (retransmissions) "FIELDLENGTH(4)";
+}     
+
+
+type record N201_U
+{
+  BIT5		spare,
+  integer 	n201UValue
+} with {
+  variant (n201UValue) "FIELDLENGTH(11)";
+  variant (n201UValue) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+
+type record N201_I
+{
+  BIT5		spare,
+  integer 	n201IValue
+}
+with {
+  variant (n201IValue) "FIELDLENGTH(11)";
+  variant (n201IValue) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+type record MD
+{
+  BIT1		spare,
+  integer 	mDValue
+} with {
+  variant (mDValue) "FIELDLENGTH(15)";
+  variant (mDValue) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+
+type record MU
+{
+  BIT1		spare,
+  integer 	mUValue
+} with {
+  variant (mUValue) "FIELDLENGTH(15)";
+  variant (mUValue) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+type integer KD with {variant  "FIELDLENGTH(8)";};	
+
+type integer KU with {variant  "FIELDLENGTH(8)";};	
+
+type octetstring L3param;
+
+type octetstring Reset_LLC length(0);
+
+type union XID_Data
+{
+  Version		version,
+  IOV_UI		iOV_UI,
+  IOV_I		iOV_I,
+  T200		t200,
+  N200		n200,
+  N201_U		n201_U,
+  N201_I		n201_I,
+  MD		mD,	
+  MU		mU,
+  KD		kD,
+  KU		kU,
+  L3param		l3param,
+  Reset_LLC		reset    	
+}
+
+
+type union  XID_length
+{
+  integer short_len,
+  integer long_len
+}with {
+  variant (short_len) "FIELDLENGTH(2)";
+  variant (long_len)  "FIELDLENGTH(8)";
+  variant (long_len)  "BYTEORDER(last)";
+  variant (short_len) "FIELDORDER(msb)";
+  variant (long_len)  "FIELDORDER(msb)";
+
+}
+
+
+type record XID
+{
+  BIT1	  xl,
+  BIT5     typefield,
+  XID_length  xID_length,
+  //Header_XID      header_XID,
+  XID_Data	xID_Data      
+} with { 
+  variant (xID_Data) "CROSSTAG( version, 	typefield = '00000'B;
+				     iOV_UI, 	typefield = '00001'B;
+				     iOV_I, 	typefield = '00010'B;
+				     t200, 	typefield = '00011'B;
+				     n200, 	typefield = '00100'B;
+				     n201_U, 	typefield = '00101'B;
+				     n201_I, 	typefield = '00110'B;
+				     mD, 	typefield = '00111'B;
+				     mU, 	typefield = '01000'B;
+				     kD, 	typefield = '01001'B;
+				     kU, 	typefield = '01010'B;
+				     l3param, 	typefield = '01011'B;
+				     reset, 	typefield = '01100'B;
+				     
+					 )";
+  variant  "FIELDORDER(msb)";
+  variant (xID_length) "CROSSTAG( short_len, 	xl = '0'B;
+				                long_len, 	xl = '1'B;)";
+  variant (xID_length) "LENGTHTO (xID_Data)"
+
+  variant (xID_length) "PADDING(yes)" 
+};
+
+
+type record RejectedFrameControlField_UI
+{
+  Control_field_UI	control_field,
+  OCT4			spare
+}
+
+
+type record RejectedFrameControlField_U
+{
+  Control_field_U		control_field,
+  OCT5			spare
+}		
+
+
+type union RejectedFrameControlField 
+{
+  RejectedFrameControlField_UI 	rejectedFrameControlField_UI,
+  RejectedFrameControlField_U	rejectedFrameControlField_U
+} with {
+  variant "TAG(rejectedFrameControlField_UI,  control_field.format = '110'B;
+		     rejectedFrameControlField_U,   control_field.format = '111'B;
+ 			)";
+};
+
+
+type record of XID UA_Information;
+
+type record of XID SABM_Information;
+
+type record of XID XID_Information;
+
+
+type octetstring DM_Information length(0);
+
+
+type record FRMR_Information
+{
+  RejectedFrameControlField   rejectedFrameControlField,
+  BIT4 			    spare1,
+  BIT9 			    vS,
+  BIT1			    spare2,
+  BIT9			    vR,
+  BIT1			    cR,
+  BIT4			    spare3,
+  BIT1			    w4,
+  BIT1			    w3,
+  BIT1			    w2,
+  BIT1			    w1
+} with {
+  variant (vS) "BYTEORDER(last)";
+  variant (vR) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+};
+
+
+type record Address_field
+{
+  BIT4		sAPI,
+  BIT2		spare,    // '00'B
+  BIT1		cR,      
+  BIT1		pD	  //'0' for LLC
+}
+
+type record Control_field_U
+{
+  BIT4		mBits,	
+  BIT1		pF,
+  BIT3 		format   // '111'B
+}
+
+
+
+type record Control_field_UI
+
+{
+  BIT3 		format,        // '110'B
+  BIT2 		spare, 
+  integer		nU,     //BIT9
+  BIT1		e,
+  BIT1		pM
+} with {
+
+  variant (nU) "FIELDLENGTH(9)";
+  variant (nU) "BYTEORDER(last)";
+  variant  "FIELDORDER(msb)";
+}
+
+
+type union Information_field_U
+{
+  UA_Information		uA,
+  SABM_Information	sABM,
+  FRMR_Information	fRMR,
+  DM_Information		dM,
+  XID_Information		xID  
+};
+
+
+type record PDU_LLC_UI
+{
+  Address_field 		address_field,
+  Control_field_UI 	control_field,
+  octetstring 		information_field_UI, 
+  OCT3			fCS    optional 
+  // fCS ENCODING:
+  //'000000'O in send template -> generate CRC, 
+  // omit in send template -> generate CRC, 
+  // otherwise send out fCS in send template
+  // 
+  // DECODING:
+  // decoder generates '000000'O if CRC OK
+}
+
+
+
+type record PDU_LLC_U
+{
+  Address_field 		address_field,
+  Control_field_U 	control_field,
+  Information_field_U	information_field_U,	
+  OCT3			fCS    optional  
+  // ENCODING:
+  //'000000'O in send template -> generate CRC, 
+  // omit in send template -> generate CRC, 
+  // otherwise send out fCS in send template
+  // 
+  // DECODING:
+  // decoder generates '000000'O if CRC OK
+} with { 
+  variant (information_field_U) "CROSSTAG( uA, 	control_field.mBits = '0110'B;
+				  	      	sABM, 	control_field.mBits = '0111'B;
+				   		fRMR, 	control_field.mBits = '1000'B;
+						dM, 	control_field.mBits = '0001'B;
+						xID, 	control_field.mBits = '1011'B;	
+					 )";
+};
+
+
+type union PDU_LLC
+{
+  PDU_LLC_UI pDU_LLC_UI,
+  PDU_LLC_U  pDU_LLC_U
+} with   { variant "TAG (              
+		pDU_LLC_UI,       		control_field.format ='110'B;	
+		pDU_LLC_U,       		control_field.format ='111'B;
+                         )"
+};
+
+
+
+}with{ encode "RAW"}// end of module