text: /********************************************************************************/
  /*										*/
  /*			     				*/
  /*			     Written by Ken Goldman				*/
  /*		       IBM Thomas J. Watson Research Center			*/
  /*            $Id: CommandDispatchData.h 1047 2017-07-20 18:27:34Z kgoldman $	*/
  /*										*/
  /*  Licenses and Notices							*/
  /*										*/
  /*  1. Copyright Licenses:							*/
  /*										*/
  /*  - Trusted Computing Group (TCG) grants to the user of the source code in	*/
  /*    this specification (the "Source Code") a worldwide, irrevocable, 		*/
  /*    nonexclusive, royalty free, copyright license to reproduce, create 	*/
  /*    derivative works, distribute, display and perform the Source Code and	*/
  /*    derivative works thereof, and to grant others the rights granted herein.	*/
  /*										*/
  /*  - The TCG grants to the user of the other parts of the specification 	*/
  /*    (other than the Source Code) the rights to reproduce, distribute, 	*/
  /*    display, and perform the specification solely for the purpose of 		*/
  /*    developing products based on such documents.				*/
  /*										*/
  /*  2. Source Code Distribution Conditions:					*/
  /*										*/
  /*  - Redistributions of Source Code must retain the above copyright licenses, 	*/
  /*    this list of conditions and the following disclaimers.			*/
  /*										*/
  /*  - Redistributions in binary form must reproduce the above copyright 	*/
  /*    licenses, this list of conditions	and the following disclaimers in the 	*/
  /*    documentation and/or other materials provided with the distribution.	*/
  /*										*/
  /*  3. Disclaimers:								*/
  /*										*/
  /*  - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF	*/
  /*  LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH	*/
  /*  RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES)	*/
  /*  THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE.		*/
  /*  Contact TCG Administration (admin@trustedcomputinggroup.org) for 		*/
  /*  information on specification licensing rights available through TCG 	*/
  /*  membership agreements.							*/
  /*										*/
  /*  - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED 	*/
  /*    WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR 	*/
  /*    FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR 		*/
  /*    NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY 		*/
  /*    OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE.		*/
  /*										*/
  /*  - Without limitation, TCG and its members and licensors disclaim all 	*/
  /*    liability, including liability for infringement of any proprietary 	*/
  /*    rights, relating to use of information in this specification and to the	*/
  /*    implementation of this specification, and TCG disclaims all liability for	*/
  /*    cost of procurement of substitute goods or services, lost profits, loss 	*/
  /*    of use, loss of data or any incidental, consequential, direct, indirect, 	*/
  /*    or special damages, whether under contract, tort, warranty or otherwise, 	*/
  /*    arising in any way out of use or reliance upon this specification or any 	*/
  /*    information herein.							*/
  /*										*/
  /*  (c) Copyright IBM Corp. and others, 2016, 2017				*/
  /*										*/
  /********************************************************************************/
  
  #ifndef COMMANDDISPATCHDATA_H
  #define COMMANDDISPATCHDATA_H
  
  #define END_OF_LIST     0xff
  #define ADD_FLAG        0x80
  
  #ifdef TPM_NUVOTON
  #include "ntc2_fp.h"
  #include "ntc2lib.h"
  #endif
  
  const UNMARSHAL_t UnmarshalArray[] = {
  #define  TPMI_DH_CONTEXT_H_UNMARSHAL        0
      (UNMARSHAL_t)TPMI_DH_CONTEXT_Unmarshal,
  #if 0
  #define TPMI_RH_AC_H_UNMARSHAL          (TPMI_DH_CONTEXT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_AC_Unmarshal,
  #endif
  #define TPMI_RH_CLEAR_H_UNMARSHAL       (TPMI_DH_CONTEXT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_CLEAR_Unmarshal,
  #define TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL  (TPMI_RH_CLEAR_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_HIERARCHY_AUTH_Unmarshal,
  #define TPMI_RH_LOCKOUT_H_UNMARSHAL     (TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_LOCKOUT_Unmarshal,
  #define TPMI_RH_NV_AUTH_H_UNMARSHAL     (TPMI_RH_LOCKOUT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_NV_AUTH_Unmarshal,
  #define TPMI_RH_NV_INDEX_H_UNMARSHAL    (TPMI_RH_NV_AUTH_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_NV_INDEX_Unmarshal,
  #define TPMI_RH_PLATFORM_H_UNMARSHAL    (TPMI_RH_NV_INDEX_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_PLATFORM_Unmarshal,
  #define TPMI_RH_PROVISION_H_UNMARSHAL   (TPMI_RH_PLATFORM_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_PROVISION_Unmarshal,
  #define TPMI_SH_HMAC_H_UNMARSHAL        (TPMI_RH_PROVISION_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_SH_HMAC_Unmarshal,
  #define TPMI_SH_POLICY_H_UNMARSHAL      (TPMI_SH_HMAC_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_SH_POLICY_Unmarshal,
      // HANDLE_FIRST_FLAG_TYPE is the first handle that needs a flag when called.
  #define HANDLE_FIRST_FLAG_TYPE          (TPMI_SH_POLICY_H_UNMARSHAL + 1)
  #define TPMI_DH_ENTITY_H_UNMARSHAL      (TPMI_SH_POLICY_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_ENTITY_Unmarshal,
  #define TPMI_DH_OBJECT_H_UNMARSHAL      (TPMI_DH_ENTITY_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_OBJECT_Unmarshal,
  #define TPMI_DH_PARENT_H_UNMARSHAL      (TPMI_DH_OBJECT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_PARENT_Unmarshal,
  #define TPMI_DH_PCR_H_UNMARSHAL         (TPMI_DH_PARENT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_PCR_Unmarshal,
  #define TPMI_RH_ENDORSEMENT_H_UNMARSHAL  (TPMI_DH_PCR_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_ENDORSEMENT_Unmarshal,
  #define TPMI_RH_HIERARCHY_H_UNMARSHAL   (TPMI_RH_ENDORSEMENT_H_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_HIERARCHY_Unmarshal,
      // PARAMETER_FIRST_TYPE marks the end of the handle list.
  #define PARAMETER_FIRST_TYPE            (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1)
  #define UINT32_P_UNMARSHAL              (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1)
      (UNMARSHAL_t)UINT32_Unmarshal,
  #define TPM2B_DIGEST_P_UNMARSHAL        (UINT32_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_DIGEST_Unmarshal,
  #define TPM2B_DATA_P_UNMARSHAL          (TPM2B_DIGEST_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_DATA_Unmarshal,
  #define TPM2B_ECC_PARAMETER_P_UNMARSHAL  (TPM2B_DATA_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_ECC_PARAMETER_Unmarshal,
  #define TPM2B_ECC_POINT_P_UNMARSHAL     (TPM2B_ECC_PARAMETER_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_ECC_POINT_Unmarshal,
  #define TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL  (TPM2B_ECC_POINT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_ENCRYPTED_SECRET_Unmarshal,
  #define TPM2B_EVENT_P_UNMARSHAL         (TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_EVENT_Unmarshal,
  #define TPM2B_ID_OBJECT_P_UNMARSHAL     (TPM2B_EVENT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_ID_OBJECT_Unmarshal,
  #define TPM2B_IV_P_UNMARSHAL            (TPM2B_ID_OBJECT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_IV_Unmarshal,
  #define TPM2B_MAX_BUFFER_P_UNMARSHAL    (TPM2B_IV_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_MAX_BUFFER_Unmarshal,
  #define TPM2B_MAX_NV_BUFFER_P_UNMARSHAL  (TPM2B_MAX_BUFFER_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_MAX_NV_BUFFER_Unmarshal,
  #define TPM2B_NAME_P_UNMARSHAL          (TPM2B_MAX_NV_BUFFER_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_NAME_Unmarshal,
  #define TPM2B_NV_PUBLIC_P_UNMARSHAL     (TPM2B_NAME_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_NV_PUBLIC_Unmarshal,
  #define TPM2B_PRIVATE_P_UNMARSHAL       (TPM2B_NV_PUBLIC_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_PRIVATE_Unmarshal,
  #define TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL  (TPM2B_PRIVATE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_PUBLIC_KEY_RSA_Unmarshal,
  #define TPM2B_SENSITIVE_P_UNMARSHAL     (TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_SENSITIVE_Unmarshal,
  #define TPM2B_SENSITIVE_CREATE_P_UNMARSHAL  (TPM2B_SENSITIVE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_SENSITIVE_CREATE_Unmarshal,
  #define TPM2B_SENSITIVE_DATA_P_UNMARSHAL  (TPM2B_SENSITIVE_CREATE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_SENSITIVE_DATA_Unmarshal,
  #define TPM2B_TEMPLATE_P_UNMARSHAL      (TPM2B_SENSITIVE_DATA_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_TEMPLATE_Unmarshal,
  #define TPM2B_TIMEOUT_P_UNMARSHAL       (TPM2B_TEMPLATE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_TIMEOUT_Unmarshal,
  #define UINT8_P_UNMARSHAL               (TPM2B_TIMEOUT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)UINT8_Unmarshal,
  #define TPMI_DH_CONTEXT_P_UNMARSHAL     (UINT8_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_CONTEXT_Unmarshal,
  #define TPMI_DH_PERSISTENT_P_UNMARSHAL  (TPMI_DH_CONTEXT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_PERSISTENT_Unmarshal,
  #define TPMI_ECC_CURVE_P_UNMARSHAL      (TPMI_DH_PERSISTENT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_ECC_CURVE_Unmarshal,
  #define TPMI_YES_NO_P_UNMARSHAL         (TPMI_ECC_CURVE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_YES_NO_Unmarshal,
  #define TPML_ALG_P_UNMARSHAL            (TPMI_YES_NO_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPML_ALG_Unmarshal,
  #define TPML_CC_P_UNMARSHAL             (TPML_ALG_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPML_CC_Unmarshal,
  #define TPML_DIGEST_P_UNMARSHAL         (TPML_CC_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPML_DIGEST_Unmarshal,
  #define TPML_DIGEST_VALUES_P_UNMARSHAL  (TPML_DIGEST_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPML_DIGEST_VALUES_Unmarshal,
  #define TPML_PCR_SELECTION_P_UNMARSHAL  (TPML_DIGEST_VALUES_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPML_PCR_SELECTION_Unmarshal,
  #define TPMS_CONTEXT_P_UNMARSHAL        (TPML_PCR_SELECTION_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMS_CONTEXT_Unmarshal,
  #define TPMT_PUBLIC_PARMS_P_UNMARSHAL   (TPMS_CONTEXT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_PUBLIC_PARMS_Unmarshal,
  #define TPMT_TK_AUTH_P_UNMARSHAL        (TPMT_PUBLIC_PARMS_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_TK_AUTH_Unmarshal,
  #define TPMT_TK_CREATION_P_UNMARSHAL    (TPMT_TK_AUTH_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_TK_CREATION_Unmarshal,
  #define TPMT_TK_HASHCHECK_P_UNMARSHAL   (TPMT_TK_CREATION_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_TK_HASHCHECK_Unmarshal,
  #define TPMT_TK_VERIFIED_P_UNMARSHAL    (TPMT_TK_HASHCHECK_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_TK_VERIFIED_Unmarshal,
  #if 0
  #define TPM_AT_P_UNMARSHAL              (TPMT_TK_VERIFIED_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_AT_Unmarshal,
  #endif
  #define TPM_CAP_P_UNMARSHAL             (TPMT_TK_VERIFIED_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_CAP_Unmarshal,
  #define TPM_CLOCK_ADJUST_P_UNMARSHAL    (TPM_CAP_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_CLOCK_ADJUST_Unmarshal,
  #define TPM_EO_P_UNMARSHAL              (TPM_CLOCK_ADJUST_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_EO_Unmarshal,
  #define TPM_SE_P_UNMARSHAL              (TPM_EO_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_SE_Unmarshal,
  #define TPM_SU_P_UNMARSHAL              (TPM_SE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM_SU_Unmarshal,
  #define UINT16_P_UNMARSHAL              (TPM_SU_P_UNMARSHAL + 1)
      (UNMARSHAL_t)UINT16_Unmarshal,
  #define UINT64_P_UNMARSHAL              (UINT16_P_UNMARSHAL + 1)
      (UNMARSHAL_t)UINT64_Unmarshal,
      //PARAMETER_FIRST_FLAG_TYPE is the first parameter to need a flag.
  #define PARAMETER_FIRST_FLAG_TYPE       (UINT64_P_UNMARSHAL + 1)
  #define TPM2B_PUBLIC_P_UNMARSHAL        (UINT64_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPM2B_PUBLIC_Unmarshal,
  #define TPMI_ALG_CIPHER_MODE_P_UNMARSHAL  (TPM2B_PUBLIC_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_ALG_CIPHER_MODE_Unmarshal,
  #define TPMI_ALG_HASH_P_UNMARSHAL       (TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_ALG_HASH_Unmarshal,
  #define TPMI_ALG_MAC_SCHEME_P_UNMARSHAL  (TPMI_ALG_HASH_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_ALG_MAC_SCHEME_Unmarshal,
  #define TPMI_DH_PCR_P_UNMARSHAL         (TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_DH_PCR_Unmarshal,
  #define TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL  (TPMI_DH_PCR_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_ECC_KEY_EXCHANGE_Unmarshal,
  #define TPMI_RH_ENABLES_P_UNMARSHAL     (TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_ENABLES_Unmarshal,
  #define TPMI_RH_HIERARCHY_P_UNMARSHAL   (TPMI_RH_ENABLES_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMI_RH_HIERARCHY_Unmarshal,
  #define TPMT_RSA_DECRYPT_P_UNMARSHAL    (TPMI_RH_HIERARCHY_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_RSA_DECRYPT_Unmarshal,
  #define TPMT_SIGNATURE_P_UNMARSHAL      (TPMT_RSA_DECRYPT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_SIGNATURE_Unmarshal,
  #define TPMT_SIG_SCHEME_P_UNMARSHAL     (TPMT_SIGNATURE_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_SIG_SCHEME_Unmarshal,
  #define TPMT_SYM_DEF_P_UNMARSHAL        (TPMT_SIG_SCHEME_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_SYM_DEF_Unmarshal,
  #define TPMT_SYM_DEF_OBJECT_P_UNMARSHAL  (TPMT_SYM_DEF_P_UNMARSHAL + 1)
      (UNMARSHAL_t)TPMT_SYM_DEF_OBJECT_Unmarshal,
  
  #ifdef TPM_NUVOTON
  
  #define NTC2_CFG_STRUCT_P_UNMARSHAL	(TPMT_SYM_DEF_OBJECT_P_UNMARSHAL + 1)
      (UNMARSHAL_t)NTC2_CFG_STRUCT_Unmarshal
  #define PARAMETER_LAST_TYPE             (NTC2_CFG_STRUCT_P_UNMARSHAL)
  
  #else
      
  #define PARAMETER_LAST_TYPE             (TPMT_SYM_DEF_OBJECT_P_UNMARSHAL)
  
  #endif	/* TPM_NUVOTON */
  
  };
  
  const MARSHAL_t MarshalArray[] = {
  #define  UINT32_H_MARSHAL                   0
      (MARSHAL_t)UINT32_Marshal,
  #define RESPONSE_PARAMETER_FIRST_TYPE   (UINT32_H_MARSHAL + 1)
  #define TPM2B_ATTEST_P_MARSHAL          (UINT32_H_MARSHAL + 1)
      (MARSHAL_t)TPM2B_ATTEST_Marshal,
  #define TPM2B_CREATION_DATA_P_MARSHAL   (TPM2B_ATTEST_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_CREATION_DATA_Marshal,
  #define TPM2B_DATA_P_MARSHAL            (TPM2B_CREATION_DATA_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_DATA_Marshal,
  #define TPM2B_DIGEST_P_MARSHAL          (TPM2B_DATA_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_DIGEST_Marshal,
  #define TPM2B_ECC_POINT_P_MARSHAL       (TPM2B_DIGEST_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_ECC_POINT_Marshal,
  #define TPM2B_ENCRYPTED_SECRET_P_MARSHAL  (TPM2B_ECC_POINT_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_ENCRYPTED_SECRET_Marshal,
  #define TPM2B_ID_OBJECT_P_MARSHAL       (TPM2B_ENCRYPTED_SECRET_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_ID_OBJECT_Marshal,
  #define TPM2B_IV_P_MARSHAL              (TPM2B_ID_OBJECT_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_IV_Marshal,
  #define TPM2B_MAX_BUFFER_P_MARSHAL      (TPM2B_IV_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_MAX_BUFFER_Marshal,
  #define TPM2B_MAX_NV_BUFFER_P_MARSHAL   (TPM2B_MAX_BUFFER_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_MAX_NV_BUFFER_Marshal,
  #define TPM2B_NAME_P_MARSHAL            (TPM2B_MAX_NV_BUFFER_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_NAME_Marshal,
  #define TPM2B_NV_PUBLIC_P_MARSHAL       (TPM2B_NAME_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_NV_PUBLIC_Marshal,
  #define TPM2B_PRIVATE_P_MARSHAL         (TPM2B_NV_PUBLIC_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_PRIVATE_Marshal,
  #define TPM2B_PUBLIC_P_MARSHAL          (TPM2B_PRIVATE_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_PUBLIC_Marshal,
  #define TPM2B_PUBLIC_KEY_RSA_P_MARSHAL  (TPM2B_PUBLIC_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_PUBLIC_KEY_RSA_Marshal,
  #define TPM2B_SENSITIVE_DATA_P_MARSHAL  (TPM2B_PUBLIC_KEY_RSA_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_SENSITIVE_DATA_Marshal,
  #define TPM2B_TIMEOUT_P_MARSHAL         (TPM2B_SENSITIVE_DATA_P_MARSHAL + 1)
      (MARSHAL_t)TPM2B_TIMEOUT_Marshal,
  #define UINT8_P_MARSHAL                 (TPM2B_TIMEOUT_P_MARSHAL + 1)
      (MARSHAL_t)UINT8_Marshal,
  #if 0
  #define TPML_AC_CAPABILITIES_P_MARSHAL  (UINT8_P_MARSHAL + 1)
      (MARSHAL_t)TPML_AC_CAPABILITIES_Marshal,
  #endif
  #define TPML_ALG_P_MARSHAL              (UINT8_P_MARSHAL + 1)
      (MARSHAL_t)TPML_ALG_Marshal,
  #define TPML_DIGEST_P_MARSHAL           (TPML_ALG_P_MARSHAL + 1)
      (MARSHAL_t)TPML_DIGEST_Marshal,
  #define TPML_DIGEST_VALUES_P_MARSHAL    (TPML_DIGEST_P_MARSHAL + 1)
      (MARSHAL_t)TPML_DIGEST_VALUES_Marshal,
  #define TPML_PCR_SELECTION_P_MARSHAL    (TPML_DIGEST_VALUES_P_MARSHAL + 1)
      (MARSHAL_t)TPML_PCR_SELECTION_Marshal,
  #if 0
  #define TPMS_AC_OUTPUT_P_MARSHAL        (TPML_PCR_SELECTION_P_MARSHAL + 1)
      (MARSHAL_t)TPMS_AC_OUTPUT_Marshal,
  #endif
  #define TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL  (TPML_PCR_SELECTION_P_MARSHAL + 1)
      (MARSHAL_t)TPMS_ALGORITHM_DETAIL_ECC_Marshal,
  #define TPMS_CAPABILITY_DATA_P_MARSHAL  (TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL + 1)
      (MARSHAL_t)TPMS_CAPABILITY_DATA_Marshal,
  #define TPMS_CONTEXT_P_MARSHAL          (TPMS_CAPABILITY_DATA_P_MARSHAL + 1)
      (MARSHAL_t)TPMS_CONTEXT_Marshal,
  #define TPMS_TIME_INFO_P_MARSHAL        (TPMS_CONTEXT_P_MARSHAL + 1)
      (MARSHAL_t)TPMS_TIME_INFO_Marshal,
  #define TPMT_HA_P_MARSHAL               (TPMS_TIME_INFO_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_HA_Marshal,
  #define TPMT_SIGNATURE_P_MARSHAL        (TPMT_HA_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_SIGNATURE_Marshal,
  #define TPMT_TK_AUTH_P_MARSHAL          (TPMT_SIGNATURE_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_TK_AUTH_Marshal,
  #define TPMT_TK_CREATION_P_MARSHAL      (TPMT_TK_AUTH_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_TK_CREATION_Marshal,
  #define TPMT_TK_HASHCHECK_P_MARSHAL     (TPMT_TK_CREATION_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_TK_HASHCHECK_Marshal,
  #define TPMT_TK_VERIFIED_P_MARSHAL      (TPMT_TK_HASHCHECK_P_MARSHAL + 1)
      (MARSHAL_t)TPMT_TK_VERIFIED_Marshal,
  #define UINT32_P_MARSHAL                (TPMT_TK_VERIFIED_P_MARSHAL + 1)
      (MARSHAL_t)UINT32_Marshal,
  #define UINT16_P_MARSHAL                (UINT32_P_MARSHAL + 1)
      (MARSHAL_t)UINT16_Marshal,
  
  #ifdef TPM_NUVOTON
  
  #define NTC2_CFG_STRUCT_P_MARSHAL	(UINT16_P_MARSHAL + 1)
      (MARSHAL_t)NTC2_CFG_STRUCT_Marshal               
  #define RESPONSE_PARAMETER_LAST_TYPE    (NTC2_CFG_STRUCT_P_MARSHAL)
  
  #else     
  #define RESPONSE_PARAMETER_LAST_TYPE    (UINT16_P_MARSHAL)
  
  #endif	/* TPM_NUVOTON */
  
  };
  #if CC_Startup == YES
  #include "Startup_fp.h"
  typedef TPM_RC  (Startup_Entry)(
  				Startup_In *in
  				);
  typedef const struct {
      Startup_Entry    *entry;
      UINT16           inSize;
      UINT16           outSize;
      UINT16           offsetOfTypes;
      BYTE             types[3];
  } Startup_COMMAND_DESCRIPTOR_t;
  Startup_COMMAND_DESCRIPTOR_t _StartupData = {
      /* entry  */          &TPM2_Startup,
      /* inSize */          (UINT16)(sizeof(Startup_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(Startup_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPM_SU_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _StartupDataAddress (&_StartupData)
  #else
  #define _StartupDataAddress 0
  #endif
  #if CC_Shutdown == YES
  #include "Shutdown_fp.h"
  typedef TPM_RC  (Shutdown_Entry)(
  				 Shutdown_In *in
  				 );
  typedef const struct {
      Shutdown_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      BYTE              types[3];
  } Shutdown_COMMAND_DESCRIPTOR_t;
  Shutdown_COMMAND_DESCRIPTOR_t _ShutdownData = {
      /* entry  */          &TPM2_Shutdown,
      /* inSize */          (UINT16)(sizeof(Shutdown_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(Shutdown_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPM_SU_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ShutdownDataAddress (&_ShutdownData)
  #else
  #define _ShutdownDataAddress 0
  #endif
  #if CC_SelfTest == YES
  #include "SelfTest_fp.h"
  typedef TPM_RC  (SelfTest_Entry)(
  				 SelfTest_In *in
  				 );
  typedef const struct {
      SelfTest_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      BYTE              types[3];
  } SelfTest_COMMAND_DESCRIPTOR_t;
  SelfTest_COMMAND_DESCRIPTOR_t _SelfTestData = {
      /* entry  */          &TPM2_SelfTest,
      /* inSize */          (UINT16)(sizeof(SelfTest_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(SelfTest_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _SelfTestDataAddress (&_SelfTestData)
  #else
  #define _SelfTestDataAddress 0
  #endif
  #if CC_IncrementalSelfTest == YES
  #include "IncrementalSelfTest_fp.h"
  typedef TPM_RC  (IncrementalSelfTest_Entry)(
  					    IncrementalSelfTest_In *in,
  					    IncrementalSelfTest_Out *out
  					    );
  typedef const struct {
      IncrementalSelfTest_Entry    *entry;
      UINT16                       inSize;
      UINT16                       outSize;
      UINT16                       offsetOfTypes;
      BYTE                         types[4];
  } IncrementalSelfTest_COMMAND_DESCRIPTOR_t;
  IncrementalSelfTest_COMMAND_DESCRIPTOR_t _IncrementalSelfTestData = {
      /* entry  */          &TPM2_IncrementalSelfTest,
      /* inSize */          (UINT16)(sizeof(IncrementalSelfTest_In)),
      /* outSize */         (UINT16)(sizeof(IncrementalSelfTest_Out)),
      /* offsetOfTypes */   offsetof(IncrementalSelfTest_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPML_ALG_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPML_ALG_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _IncrementalSelfTestDataAddress (&_IncrementalSelfTestData)
  #else
  #define _IncrementalSelfTestDataAddress 0
  #endif
  #if CC_GetTestResult == YES
  #include "GetTestResult_fp.h"
  typedef TPM_RC  (GetTestResult_Entry)(
  				      GetTestResult_Out *out
  				      );
  typedef const struct {
      GetTestResult_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      UINT16                 paramOffsets[1];
      BYTE                   types[4];
  } GetTestResult_COMMAND_DESCRIPTOR_t;
  GetTestResult_COMMAND_DESCRIPTOR_t _GetTestResultData = {
      /* entry  */          &TPM2_GetTestResult,
      /* inSize */          0,
      /* outSize */         (UINT16)(sizeof(GetTestResult_Out)),
      /* offsetOfTypes */   offsetof(GetTestResult_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(GetTestResult_Out, testResult))},
      /* types */           {END_OF_LIST,
  			   TPM2B_MAX_BUFFER_P_MARSHAL,
  			   UINT32_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetTestResultDataAddress (&_GetTestResultData)
  #else
  #define _GetTestResultDataAddress 0
  #endif
  #if CC_StartAuthSession == YES
  #include "StartAuthSession_fp.h"
  typedef TPM_RC  (StartAuthSession_Entry)(
  					 StartAuthSession_In *in,
  					 StartAuthSession_Out *out
  					 );
  typedef const struct {
      StartAuthSession_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[7];
      BYTE                      types[11];
  } StartAuthSession_COMMAND_DESCRIPTOR_t;
  StartAuthSession_COMMAND_DESCRIPTOR_t _StartAuthSessionData = {
      /* entry  */          &TPM2_StartAuthSession,
      /* inSize */          (UINT16)(sizeof(StartAuthSession_In)),
      /* outSize */         (UINT16)(sizeof(StartAuthSession_Out)),
      /* offsetOfTypes */   offsetof(StartAuthSession_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(StartAuthSession_In, bind)),
  			   (UINT16)(offsetof(StartAuthSession_In, nonceCaller)),
  			   (UINT16)(offsetof(StartAuthSession_In, encryptedSalt)),
  			   (UINT16)(offsetof(StartAuthSession_In, sessionType)),
  			   (UINT16)(offsetof(StartAuthSession_In, symmetric)),
  			   (UINT16)(offsetof(StartAuthSession_In, authHash)),
  			   (UINT16)(offsetof(StartAuthSession_Out, nonceTPM))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_DH_ENTITY_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL,
  			   TPM_SE_P_UNMARSHAL,
  			   TPMT_SYM_DEF_P_UNMARSHAL + ADD_FLAG,
  			   TPMI_ALG_HASH_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _StartAuthSessionDataAddress (&_StartAuthSessionData)
  #else
  #define _StartAuthSessionDataAddress 0
  #endif
  #if CC_PolicyRestart == YES
  #include "PolicyRestart_fp.h"
  typedef TPM_RC  (PolicyRestart_Entry)(
  				      PolicyRestart_In *in
  				      );
  typedef const struct {
      PolicyRestart_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      BYTE                   types[3];
  } PolicyRestart_COMMAND_DESCRIPTOR_t;
  PolicyRestart_COMMAND_DESCRIPTOR_t _PolicyRestartData = {
      /* entry  */          &TPM2_PolicyRestart,
      /* inSize */          (UINT16)(sizeof(PolicyRestart_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyRestart_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyRestartDataAddress (&_PolicyRestartData)
  #else
  #define _PolicyRestartDataAddress 0
  #endif
  #if CC_Create == YES
  #include "Create_fp.h"
  typedef TPM_RC  (Create_Entry)(
  			       Create_In *in,
  			       Create_Out *out
  			       );
  typedef const struct {
      Create_Entry    *entry;
      UINT16          inSize;
      UINT16          outSize;
      UINT16          offsetOfTypes;
      UINT16          paramOffsets[8];
      BYTE            types[12];
  } Create_COMMAND_DESCRIPTOR_t;
  Create_COMMAND_DESCRIPTOR_t _CreateData = {
      /* entry  */          &TPM2_Create,
      /* inSize */          (UINT16)(sizeof(Create_In)),
      /* outSize */         (UINT16)(sizeof(Create_Out)),
      /* offsetOfTypes */   offsetof(Create_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Create_In, inSensitive)),
  			   (UINT16)(offsetof(Create_In, inPublic)),
  			   (UINT16)(offsetof(Create_In, outsideInfo)),
  			   (UINT16)(offsetof(Create_In, creationPCR)),
  			   (UINT16)(offsetof(Create_Out, outPublic)),
  			   (UINT16)(offsetof(Create_Out, creationData)),
  			   (UINT16)(offsetof(Create_Out, creationHash)),
  			   (UINT16)(offsetof(Create_Out, creationTicket))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_SENSITIVE_CREATE_P_UNMARSHAL,
  			   TPM2B_PUBLIC_P_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   TPM2B_PUBLIC_P_MARSHAL,
  			   TPM2B_CREATION_DATA_P_MARSHAL,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   TPMT_TK_CREATION_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CreateDataAddress (&_CreateData)
  #else
  #define _CreateDataAddress 0
  #endif
  #if CC_Load == YES
  #include "Load_fp.h"
  typedef TPM_RC  (Load_Entry)(
  			     Load_In *in,
  			     Load_Out *out
  			     );
  typedef const struct {
      Load_Entry    *entry;
      UINT16        inSize;
      UINT16        outSize;
      UINT16        offsetOfTypes;
      UINT16        paramOffsets[3];
      BYTE          types[7];
  } Load_COMMAND_DESCRIPTOR_t;
  Load_COMMAND_DESCRIPTOR_t _LoadData = {
      /* entry  */          &TPM2_Load,
      /* inSize */          (UINT16)(sizeof(Load_In)),
      /* outSize */         (UINT16)(sizeof(Load_Out)),
      /* offsetOfTypes */   offsetof(Load_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Load_In, inPrivate)),
  			   (UINT16)(offsetof(Load_In, inPublic)),
  			   (UINT16)(offsetof(Load_Out, name))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_PRIVATE_P_UNMARSHAL,
  			   TPM2B_PUBLIC_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _LoadDataAddress (&_LoadData)
  #else
  #define _LoadDataAddress 0
  #endif
  #if CC_LoadExternal == YES
  #include "LoadExternal_fp.h"
  typedef TPM_RC  (LoadExternal_Entry)(
  				     LoadExternal_In *in,
  				     LoadExternal_Out *out
  				     );
  typedef const struct {
      LoadExternal_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[3];
      BYTE                  types[7];
  } LoadExternal_COMMAND_DESCRIPTOR_t;
  LoadExternal_COMMAND_DESCRIPTOR_t _LoadExternalData = {
      /* entry  */          &TPM2_LoadExternal,
      /* inSize */          (UINT16)(sizeof(LoadExternal_In)),
      /* outSize */         (UINT16)(sizeof(LoadExternal_Out)),
      /* offsetOfTypes */   offsetof(LoadExternal_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(LoadExternal_In, inPublic)),
  			   (UINT16)(offsetof(LoadExternal_In, hierarchy)),
  			   (UINT16)(offsetof(LoadExternal_Out, name))},
      /* types */           {TPM2B_SENSITIVE_P_UNMARSHAL,
  			   TPM2B_PUBLIC_P_UNMARSHAL + ADD_FLAG,
  			   TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _LoadExternalDataAddress (&_LoadExternalData)
  #else
  #define _LoadExternalDataAddress 0
  #endif
  #if CC_ReadPublic == YES
  #include "ReadPublic_fp.h"
  typedef TPM_RC  (ReadPublic_Entry)(
  				   ReadPublic_In *in,
  				   ReadPublic_Out *out
  				   );
  typedef const struct {
      ReadPublic_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      UINT16              paramOffsets[2];
      BYTE                types[6];
  } ReadPublic_COMMAND_DESCRIPTOR_t;
  ReadPublic_COMMAND_DESCRIPTOR_t _ReadPublicData = {
      /* entry  */          &TPM2_ReadPublic,
      /* inSize */          (UINT16)(sizeof(ReadPublic_In)),
      /* outSize */         (UINT16)(sizeof(ReadPublic_Out)),
      /* offsetOfTypes */   offsetof(ReadPublic_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ReadPublic_Out, name)),
  			   (UINT16)(offsetof(ReadPublic_Out, qualifiedName))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PUBLIC_P_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ReadPublicDataAddress (&_ReadPublicData)
  #else
  #define _ReadPublicDataAddress 0
  #endif
  #if CC_ActivateCredential == YES
  #include "ActivateCredential_fp.h"
  typedef TPM_RC  (ActivateCredential_Entry)(
  					   ActivateCredential_In *in,
  					   ActivateCredential_Out *out
  					   );
  typedef const struct {
      ActivateCredential_Entry    *entry;
      UINT16                      inSize;
      UINT16                      outSize;
      UINT16                      offsetOfTypes;
      UINT16                      paramOffsets[3];
      BYTE                        types[7];
  } ActivateCredential_COMMAND_DESCRIPTOR_t;
  ActivateCredential_COMMAND_DESCRIPTOR_t _ActivateCredentialData = {
      /* entry  */          &TPM2_ActivateCredential,
      /* inSize */          (UINT16)(sizeof(ActivateCredential_In)),
      /* outSize */         (UINT16)(sizeof(ActivateCredential_Out)),
      /* offsetOfTypes */   offsetof(ActivateCredential_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ActivateCredential_In, keyHandle)),
  			   (UINT16)(offsetof(ActivateCredential_In, credentialBlob)),
  			   (UINT16)(offsetof(ActivateCredential_In, secret))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_ID_OBJECT_P_UNMARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ActivateCredentialDataAddress (&_ActivateCredentialData)
  #else
  #define _ActivateCredentialDataAddress 0
  #endif
  #if CC_MakeCredential == YES
  #include "MakeCredential_fp.h"
  typedef TPM_RC  (MakeCredential_Entry)(
  				       MakeCredential_In *in,
  				       MakeCredential_Out *out
  				       );
  typedef const struct {
      MakeCredential_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[3];
      BYTE                    types[7];
  } MakeCredential_COMMAND_DESCRIPTOR_t;
  MakeCredential_COMMAND_DESCRIPTOR_t _MakeCredentialData = {
      /* entry  */          &TPM2_MakeCredential,
      /* inSize */          (UINT16)(sizeof(MakeCredential_In)),
      /* outSize */         (UINT16)(sizeof(MakeCredential_Out)),
      /* offsetOfTypes */   offsetof(MakeCredential_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(MakeCredential_In, credential)),
  			   (UINT16)(offsetof(MakeCredential_In, objectName)),
  			   (UINT16)(offsetof(MakeCredential_Out, secret))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ID_OBJECT_P_MARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _MakeCredentialDataAddress (&_MakeCredentialData)
  #else
  #define _MakeCredentialDataAddress 0
  #endif
  #if CC_Unseal == YES
  #include "Unseal_fp.h"
  typedef TPM_RC  (Unseal_Entry)(
  			       Unseal_In *in,
  			       Unseal_Out *out
  			       );
  typedef const struct {
      Unseal_Entry    *entry;
      UINT16          inSize;
      UINT16          outSize;
      UINT16          offsetOfTypes;
      BYTE            types[4];
  } Unseal_COMMAND_DESCRIPTOR_t;
  Unseal_COMMAND_DESCRIPTOR_t _UnsealData = {
      /* entry  */          &TPM2_Unseal,
      /* inSize */          (UINT16)(sizeof(Unseal_In)),
      /* outSize */         (UINT16)(sizeof(Unseal_Out)),
      /* offsetOfTypes */   offsetof(Unseal_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_SENSITIVE_DATA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _UnsealDataAddress (&_UnsealData)
  #else
  #define _UnsealDataAddress 0
  #endif
  #if CC_ObjectChangeAuth == YES
  #include "ObjectChangeAuth_fp.h"
  typedef TPM_RC  (ObjectChangeAuth_Entry)(
  					 ObjectChangeAuth_In *in,
  					 ObjectChangeAuth_Out *out
  					 );
  typedef const struct {
      ObjectChangeAuth_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[2];
      BYTE                      types[6];
  } ObjectChangeAuth_COMMAND_DESCRIPTOR_t;
  ObjectChangeAuth_COMMAND_DESCRIPTOR_t _ObjectChangeAuthData = {
      /* entry  */          &TPM2_ObjectChangeAuth,
      /* inSize */          (UINT16)(sizeof(ObjectChangeAuth_In)),
      /* outSize */         (UINT16)(sizeof(ObjectChangeAuth_Out)),
      /* offsetOfTypes */   offsetof(ObjectChangeAuth_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ObjectChangeAuth_In, parentHandle)),
  			   (UINT16)(offsetof(ObjectChangeAuth_In, newAuth))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ObjectChangeAuthDataAddress (&_ObjectChangeAuthData)
  #else
  #define _ObjectChangeAuthDataAddress 0
  #endif
  #if CC_CreateLoaded == YES
  #include "CreateLoaded_fp.h"
  typedef TPM_RC  (CreateLoaded_Entry)(
  				     CreateLoaded_In *in,
  				     CreateLoaded_Out *out
  				     );
  typedef const struct {
      CreateLoaded_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[5];
      BYTE                  types[9];
  } CreateLoaded_COMMAND_DESCRIPTOR_t;
  CreateLoaded_COMMAND_DESCRIPTOR_t _CreateLoadedData = {
      /* entry  */          &TPM2_CreateLoaded,
      /* inSize */          (UINT16)(sizeof(CreateLoaded_In)),
      /* outSize */         (UINT16)(sizeof(CreateLoaded_Out)),
      /* offsetOfTypes */   offsetof(CreateLoaded_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(CreateLoaded_In, inSensitive)),
  			   (UINT16)(offsetof(CreateLoaded_In, inPublic)),
  			   (UINT16)(offsetof(CreateLoaded_Out, outPrivate)),
  			   (UINT16)(offsetof(CreateLoaded_Out, outPublic)),
  			   (UINT16)(offsetof(CreateLoaded_Out, name))},
      /* types */           {TPMI_DH_PARENT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_SENSITIVE_CREATE_P_UNMARSHAL,
  			   TPM2B_TEMPLATE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   TPM2B_PUBLIC_P_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CreateLoadedDataAddress (&_CreateLoadedData)
  #else
  #define _CreateLoadedDataAddress 0
  #endif
  #if CC_Duplicate == YES
  #include "Duplicate_fp.h"
  typedef TPM_RC  (Duplicate_Entry)(
  				  Duplicate_In *in,
  				  Duplicate_Out *out
  				  );
  typedef const struct {
      Duplicate_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[5];
      BYTE               types[9];
  } Duplicate_COMMAND_DESCRIPTOR_t;
  Duplicate_COMMAND_DESCRIPTOR_t _DuplicateData = {
      /* entry  */          &TPM2_Duplicate,
      /* inSize */          (UINT16)(sizeof(Duplicate_In)),
      /* outSize */         (UINT16)(sizeof(Duplicate_Out)),
      /* offsetOfTypes */   offsetof(Duplicate_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Duplicate_In, newParentHandle)),
  			   (UINT16)(offsetof(Duplicate_In, encryptionKeyIn)),
  			   (UINT16)(offsetof(Duplicate_In, symmetricAlg)),
  			   (UINT16)(offsetof(Duplicate_Out, duplicate)),
  			   (UINT16)(offsetof(Duplicate_Out, outSymSeed))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SYM_DEF_OBJECT_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_DATA_P_MARSHAL,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _DuplicateDataAddress (&_DuplicateData)
  #else
  #define _DuplicateDataAddress 0
  #endif
  #if CC_Rewrap == YES
  #include "Rewrap_fp.h"
  typedef TPM_RC  (Rewrap_Entry)(
  			       Rewrap_In *in,
  			       Rewrap_Out *out
  			       );
  typedef const struct {
      Rewrap_Entry    *entry;
      UINT16          inSize;
      UINT16          outSize;
      UINT16          offsetOfTypes;
      UINT16          paramOffsets[5];
      BYTE            types[9];
  } Rewrap_COMMAND_DESCRIPTOR_t;
  Rewrap_COMMAND_DESCRIPTOR_t _RewrapData = {
      /* entry  */          &TPM2_Rewrap,
      /* inSize */          (UINT16)(sizeof(Rewrap_In)),
      /* outSize */         (UINT16)(sizeof(Rewrap_Out)),
      /* offsetOfTypes */   offsetof(Rewrap_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Rewrap_In, newParent)),
  			   (UINT16)(offsetof(Rewrap_In, inDuplicate)),
  			   (UINT16)(offsetof(Rewrap_In, name)),
  			   (UINT16)(offsetof(Rewrap_In, inSymSeed)),
  			   (UINT16)(offsetof(Rewrap_Out, outSymSeed))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_PRIVATE_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _RewrapDataAddress (&_RewrapData)
  #else
  #define _RewrapDataAddress 0
  #endif
  #if CC_Import == YES
  #include "Import_fp.h"
  typedef TPM_RC  (Import_Entry)(
  			       Import_In *in,
  			       Import_Out *out
  			       );
  typedef const struct {
      Import_Entry    *entry;
      UINT16          inSize;
      UINT16          outSize;
      UINT16          offsetOfTypes;
      UINT16          paramOffsets[5];
      BYTE            types[9];
  } Import_COMMAND_DESCRIPTOR_t;
  Import_COMMAND_DESCRIPTOR_t _ImportData = {
      /* entry  */          &TPM2_Import,
      /* inSize */          (UINT16)(sizeof(Import_In)),
      /* outSize */         (UINT16)(sizeof(Import_Out)),
      /* offsetOfTypes */   offsetof(Import_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Import_In, encryptionKey)),
  			   (UINT16)(offsetof(Import_In, objectPublic)),
  			   (UINT16)(offsetof(Import_In, duplicate)),
  			   (UINT16)(offsetof(Import_In, inSymSeed)),
  			   (UINT16)(offsetof(Import_In, symmetricAlg))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPM2B_PUBLIC_P_UNMARSHAL,
  			   TPM2B_PRIVATE_P_UNMARSHAL,
  			   TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL,
  			   TPMT_SYM_DEF_OBJECT_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_PRIVATE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ImportDataAddress (&_ImportData)
  #else
  #define _ImportDataAddress 0
  #endif
  #if CC_RSA_Encrypt == YES
  #include "RSA_Encrypt_fp.h"
  typedef TPM_RC  (RSA_Encrypt_Entry)(
  				    RSA_Encrypt_In *in,
  				    RSA_Encrypt_Out *out
  				    );
  typedef const struct {
      RSA_Encrypt_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[3];
      BYTE                 types[7];
  } RSA_Encrypt_COMMAND_DESCRIPTOR_t;
  RSA_Encrypt_COMMAND_DESCRIPTOR_t _RSA_EncryptData = {
      /* entry  */          &TPM2_RSA_Encrypt,
      /* inSize */          (UINT16)(sizeof(RSA_Encrypt_In)),
      /* outSize */         (UINT16)(sizeof(RSA_Encrypt_Out)),
      /* offsetOfTypes */   offsetof(RSA_Encrypt_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(RSA_Encrypt_In, message)),
  			   (UINT16)(offsetof(RSA_Encrypt_In, inScheme)),
  			   (UINT16)(offsetof(RSA_Encrypt_In, label))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL,
  			   TPMT_RSA_DECRYPT_P_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PUBLIC_KEY_RSA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _RSA_EncryptDataAddress (&_RSA_EncryptData)
  #else
  #define _RSA_EncryptDataAddress 0
  #endif
  #if CC_RSA_Decrypt == YES
  #include "RSA_Decrypt_fp.h"
  typedef TPM_RC  (RSA_Decrypt_Entry)(
  				    RSA_Decrypt_In *in,
  				    RSA_Decrypt_Out *out
  				    );
  typedef const struct {
      RSA_Decrypt_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[3];
      BYTE                 types[7];
  } RSA_Decrypt_COMMAND_DESCRIPTOR_t;
  RSA_Decrypt_COMMAND_DESCRIPTOR_t _RSA_DecryptData = {
      /* entry  */          &TPM2_RSA_Decrypt,
      /* inSize */          (UINT16)(sizeof(RSA_Decrypt_In)),
      /* outSize */         (UINT16)(sizeof(RSA_Decrypt_Out)),
      /* offsetOfTypes */   offsetof(RSA_Decrypt_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(RSA_Decrypt_In, cipherText)),
  			   (UINT16)(offsetof(RSA_Decrypt_In, inScheme)),
  			   (UINT16)(offsetof(RSA_Decrypt_In, label))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL,
  			   TPMT_RSA_DECRYPT_P_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_PUBLIC_KEY_RSA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _RSA_DecryptDataAddress (&_RSA_DecryptData)
  #else
  #define _RSA_DecryptDataAddress 0
  #endif
  #if CC_ECDH_KeyGen == YES
  #include "ECDH_KeyGen_fp.h"
  typedef TPM_RC  (ECDH_KeyGen_Entry)(
  				    ECDH_KeyGen_In *in,
  				    ECDH_KeyGen_Out *out
  				    );
  typedef const struct {
      ECDH_KeyGen_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[1];
      BYTE                 types[5];
  } ECDH_KeyGen_COMMAND_DESCRIPTOR_t;
  ECDH_KeyGen_COMMAND_DESCRIPTOR_t _ECDH_KeyGenData = {
      /* entry  */          &TPM2_ECDH_KeyGen,
      /* inSize */          (UINT16)(sizeof(ECDH_KeyGen_In)),
      /* outSize */         (UINT16)(sizeof(ECDH_KeyGen_Out)),
      /* offsetOfTypes */   offsetof(ECDH_KeyGen_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ECDH_KeyGen_Out, pubPoint))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ECDH_KeyGenDataAddress (&_ECDH_KeyGenData)
  #else
  #define _ECDH_KeyGenDataAddress 0
  #endif
  #if CC_ECDH_ZGen == YES
  #include "ECDH_ZGen_fp.h"
  typedef TPM_RC  (ECDH_ZGen_Entry)(
  				  ECDH_ZGen_In *in,
  				  ECDH_ZGen_Out *out
  				  );
  typedef const struct {
      ECDH_ZGen_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[1];
      BYTE               types[5];
  } ECDH_ZGen_COMMAND_DESCRIPTOR_t;
  ECDH_ZGen_COMMAND_DESCRIPTOR_t _ECDH_ZGenData = {
      /* entry  */          &TPM2_ECDH_ZGen,
      /* inSize */          (UINT16)(sizeof(ECDH_ZGen_In)),
      /* outSize */         (UINT16)(sizeof(ECDH_ZGen_Out)),
      /* offsetOfTypes */   offsetof(ECDH_ZGen_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ECDH_ZGen_In, inPoint))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_ECC_POINT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ECDH_ZGenDataAddress (&_ECDH_ZGenData)
  #else
  #define _ECDH_ZGenDataAddress 0
  #endif
  #if CC_ECC_Parameters == YES
  #include "ECC_Parameters_fp.h"
  typedef TPM_RC  (ECC_Parameters_Entry)(
  				       ECC_Parameters_In *in,
  				       ECC_Parameters_Out *out
  				       );
  typedef const struct {
      ECC_Parameters_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      BYTE                    types[4];
  } ECC_Parameters_COMMAND_DESCRIPTOR_t;
  ECC_Parameters_COMMAND_DESCRIPTOR_t _ECC_ParametersData = {
      /* entry  */          &TPM2_ECC_Parameters,
      /* inSize */          (UINT16)(sizeof(ECC_Parameters_In)),
      /* outSize */         (UINT16)(sizeof(ECC_Parameters_Out)),
      /* offsetOfTypes */   offsetof(ECC_Parameters_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_ECC_CURVE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ECC_ParametersDataAddress (&_ECC_ParametersData)
  #else
  #define _ECC_ParametersDataAddress 0
  #endif
  #if CC_ZGen_2Phase == YES
  #include "ZGen_2Phase_fp.h"
  typedef TPM_RC  (ZGen_2Phase_Entry)(
  				    ZGen_2Phase_In *in,
  				    ZGen_2Phase_Out *out
  				    );
  typedef const struct {
      ZGen_2Phase_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[5];
      BYTE                 types[9];
  } ZGen_2Phase_COMMAND_DESCRIPTOR_t;
  ZGen_2Phase_COMMAND_DESCRIPTOR_t _ZGen_2PhaseData = {
      /* entry  */          &TPM2_ZGen_2Phase,
      /* inSize */          (UINT16)(sizeof(ZGen_2Phase_In)),
      /* outSize */         (UINT16)(sizeof(ZGen_2Phase_Out)),
      /* offsetOfTypes */   offsetof(ZGen_2Phase_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ZGen_2Phase_In, inQsB)),
  			   (UINT16)(offsetof(ZGen_2Phase_In, inQeB)),
  			   (UINT16)(offsetof(ZGen_2Phase_In, inScheme)),
  			   (UINT16)(offsetof(ZGen_2Phase_In, counter)),
  			   (UINT16)(offsetof(ZGen_2Phase_Out, outZ2))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_ECC_POINT_P_UNMARSHAL,
  			   TPM2B_ECC_POINT_P_UNMARSHAL,
  			   TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ZGen_2PhaseDataAddress (&_ZGen_2PhaseData)
  #else
  #define _ZGen_2PhaseDataAddress 0
  #endif
  #if CC_EncryptDecrypt == YES
  #include "EncryptDecrypt_fp.h"
  typedef TPM_RC  (EncryptDecrypt_Entry)(
  				       EncryptDecrypt_In *in,
  				       EncryptDecrypt_Out *out
  				       );
  typedef const struct {
      EncryptDecrypt_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[5];
      BYTE                    types[9];
  } EncryptDecrypt_COMMAND_DESCRIPTOR_t;
  EncryptDecrypt_COMMAND_DESCRIPTOR_t _EncryptDecryptData = {
      /* entry  */          &TPM2_EncryptDecrypt,
      /* inSize */          (UINT16)(sizeof(EncryptDecrypt_In)),
      /* outSize */         (UINT16)(sizeof(EncryptDecrypt_Out)),
      /* offsetOfTypes */   offsetof(EncryptDecrypt_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(EncryptDecrypt_In, decrypt)),
  			   (UINT16)(offsetof(EncryptDecrypt_In, mode)),
  			   (UINT16)(offsetof(EncryptDecrypt_In, ivIn)),
  			   (UINT16)(offsetof(EncryptDecrypt_In, inData)),
  			   (UINT16)(offsetof(EncryptDecrypt_Out, ivOut))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + ADD_FLAG,
  			   TPM2B_IV_P_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_MAX_BUFFER_P_MARSHAL,
  			   TPM2B_IV_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _EncryptDecryptDataAddress (&_EncryptDecryptData)
  #else
  #define _EncryptDecryptDataAddress 0
  #endif
  #if CC_EncryptDecrypt2 == YES
  #include "EncryptDecrypt2_fp.h"
  typedef TPM_RC  (EncryptDecrypt2_Entry)(
  					EncryptDecrypt2_In *in,
  					EncryptDecrypt2_Out *out
  					);
  typedef const struct {
      EncryptDecrypt2_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[5];
      BYTE                     types[9];
  } EncryptDecrypt2_COMMAND_DESCRIPTOR_t;
  EncryptDecrypt2_COMMAND_DESCRIPTOR_t _EncryptDecrypt2Data = {
      /* entry  */          &TPM2_EncryptDecrypt2,
      /* inSize */          (UINT16)(sizeof(EncryptDecrypt2_In)),
      /* outSize */         (UINT16)(sizeof(EncryptDecrypt2_Out)),
      /* offsetOfTypes */   offsetof(EncryptDecrypt2_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(EncryptDecrypt2_In, inData)),
  			   (UINT16)(offsetof(EncryptDecrypt2_In, decrypt)),
  			   (UINT16)(offsetof(EncryptDecrypt2_In, mode)),
  			   (UINT16)(offsetof(EncryptDecrypt2_In, ivIn)),
  			   (UINT16)(offsetof(EncryptDecrypt2_Out, ivOut))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + ADD_FLAG,
  			   TPM2B_IV_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_MAX_BUFFER_P_MARSHAL,
  			   TPM2B_IV_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _EncryptDecrypt2DataAddress (&_EncryptDecrypt2Data)
  #else
  #define _EncryptDecrypt2DataAddress 0
  #endif
  #if CC_Hash == YES
  #include "Hash_fp.h"
  typedef TPM_RC  (Hash_Entry)(
  			     Hash_In *in,
  			     Hash_Out *out
  			     );
  typedef const struct {
      Hash_Entry    *entry;
      UINT16        inSize;
      UINT16        outSize;
      UINT16        offsetOfTypes;
      UINT16        paramOffsets[3];
      BYTE          types[7];
  } Hash_COMMAND_DESCRIPTOR_t;
  Hash_COMMAND_DESCRIPTOR_t _HashData = {
      /* entry  */          &TPM2_Hash,
      /* inSize */          (UINT16)(sizeof(Hash_In)),
      /* outSize */         (UINT16)(sizeof(Hash_Out)),
      /* offsetOfTypes */   offsetof(Hash_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Hash_In, hashAlg)),
  			   (UINT16)(offsetof(Hash_In, hierarchy)),
  			   (UINT16)(offsetof(Hash_Out, validation))},
      /* types */           {TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL,
  			   TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   TPMT_TK_HASHCHECK_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _HashDataAddress (&_HashData)
  #else
  #define _HashDataAddress 0
  #endif
  #if CC_HMAC == YES
  #include "HMAC_fp.h"
  typedef TPM_RC  (HMAC_Entry)(
  			     HMAC_In *in,
  			     HMAC_Out *out
  			     );
  typedef const struct {
      HMAC_Entry    *entry;
      UINT16        inSize;
      UINT16        outSize;
      UINT16        offsetOfTypes;
      UINT16        paramOffsets[2];
      BYTE          types[6];
  } HMAC_COMMAND_DESCRIPTOR_t;
  HMAC_COMMAND_DESCRIPTOR_t _HMACData = {
      /* entry  */          &TPM2_HMAC,
      /* inSize */          (UINT16)(sizeof(HMAC_In)),
      /* outSize */         (UINT16)(sizeof(HMAC_Out)),
      /* offsetOfTypes */   offsetof(HMAC_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(HMAC_In, buffer)),
  			   (UINT16)(offsetof(HMAC_In, hashAlg))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _HMACDataAddress (&_HMACData)
  #else
  #define _HMACDataAddress 0
  #endif
  #if CC_MAC == YES
  #include "MAC_fp.h"
  typedef TPM_RC  (MAC_Entry)(
  			    MAC_In *in,
  			    MAC_Out *out
  			    );
  typedef const struct {
      MAC_Entry    *entry;
      UINT16       inSize;
      UINT16       outSize;
      UINT16       offsetOfTypes;
      UINT16       paramOffsets[2];
      BYTE         types[6];
  } MAC_COMMAND_DESCRIPTOR_t;
  MAC_COMMAND_DESCRIPTOR_t _MACData = {
      /* entry  */          &TPM2_MAC,
      /* inSize */          (UINT16)(sizeof(MAC_In)),
      /* outSize */         (UINT16)(sizeof(MAC_Out)),
      /* offsetOfTypes */   offsetof(MAC_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(MAC_In, buffer)),
  			   (UINT16)(offsetof(MAC_In, inScheme))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _MACDataAddress (&_MACData)
  #else
  #define _MACDataAddress 0
  #endif
  #if CC_GetRandom == YES
  #include "GetRandom_fp.h"
  typedef TPM_RC  (GetRandom_Entry)(
  				  GetRandom_In *in,
  				  GetRandom_Out *out
  				  );
  typedef const struct {
      GetRandom_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[4];
  } GetRandom_COMMAND_DESCRIPTOR_t;
  GetRandom_COMMAND_DESCRIPTOR_t _GetRandomData = {
      /* entry  */          &TPM2_GetRandom,
      /* inSize */          (UINT16)(sizeof(GetRandom_In)),
      /* outSize */         (UINT16)(sizeof(GetRandom_Out)),
      /* offsetOfTypes */   offsetof(GetRandom_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {UINT16_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetRandomDataAddress (&_GetRandomData)
  #else
  #define _GetRandomDataAddress 0
  #endif
  #if CC_StirRandom == YES
  #include "StirRandom_fp.h"
  typedef TPM_RC  (StirRandom_Entry)(
  				   StirRandom_In *in
  				   );
  typedef const struct {
      StirRandom_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      BYTE                types[3];
  } StirRandom_COMMAND_DESCRIPTOR_t;
  StirRandom_COMMAND_DESCRIPTOR_t _StirRandomData = {
      /* entry  */          &TPM2_StirRandom,
      /* inSize */          (UINT16)(sizeof(StirRandom_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(StirRandom_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPM2B_SENSITIVE_DATA_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _StirRandomDataAddress (&_StirRandomData)
  #else
  #define _StirRandomDataAddress 0
  #endif
  #if CC_HMAC_Start == YES
  #include "HMAC_Start_fp.h"
  typedef TPM_RC  (HMAC_Start_Entry)(
  				   HMAC_Start_In *in,
  				   HMAC_Start_Out *out
  				   );
  typedef const struct {
      HMAC_Start_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      UINT16              paramOffsets[2];
      BYTE                types[6];
  } HMAC_Start_COMMAND_DESCRIPTOR_t;
  HMAC_Start_COMMAND_DESCRIPTOR_t _HMAC_StartData = {
      /* entry  */          &TPM2_HMAC_Start,
      /* inSize */          (UINT16)(sizeof(HMAC_Start_In)),
      /* outSize */         (UINT16)(sizeof(HMAC_Start_Out)),
      /* offsetOfTypes */   offsetof(HMAC_Start_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(HMAC_Start_In, auth)),
  			   (UINT16)(offsetof(HMAC_Start_In, hashAlg))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   END_OF_LIST}
  };
  #define _HMAC_StartDataAddress (&_HMAC_StartData)
  #else
  #define _HMAC_StartDataAddress 0
  #endif
  #if CC_MAC_Start == YES
  #include "MAC_Start_fp.h"
  typedef TPM_RC  (MAC_Start_Entry)(
  				  MAC_Start_In *in,
  				  MAC_Start_Out *out
  				  );
  typedef const struct {
      MAC_Start_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[2];
      BYTE               types[6];
  } MAC_Start_COMMAND_DESCRIPTOR_t;
  MAC_Start_COMMAND_DESCRIPTOR_t _MAC_StartData = {
      /* entry  */          &TPM2_MAC_Start,
      /* inSize */          (UINT16)(sizeof(MAC_Start_In)),
      /* outSize */         (UINT16)(sizeof(MAC_Start_Out)),
      /* offsetOfTypes */   offsetof(MAC_Start_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(MAC_Start_In, auth)),
  			   (UINT16)(offsetof(MAC_Start_In, inScheme))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   END_OF_LIST}
  };
  #define _MAC_StartDataAddress (&_MAC_StartData)
  #else
  #define _MAC_StartDataAddress 0
  #endif
  #if CC_HashSequenceStart == YES
  #include "HashSequenceStart_fp.h"
  typedef TPM_RC  (HashSequenceStart_Entry)(
  					  HashSequenceStart_In *in,
  					  HashSequenceStart_Out *out
  					  );
  typedef const struct {
      HashSequenceStart_Entry    *entry;
      UINT16                     inSize;
      UINT16                     outSize;
      UINT16                     offsetOfTypes;
      UINT16                     paramOffsets[1];
      BYTE                       types[5];
  } HashSequenceStart_COMMAND_DESCRIPTOR_t;
  HashSequenceStart_COMMAND_DESCRIPTOR_t _HashSequenceStartData = {
      /* entry  */          &TPM2_HashSequenceStart,
      /* inSize */          (UINT16)(sizeof(HashSequenceStart_In)),
      /* outSize */         (UINT16)(sizeof(HashSequenceStart_Out)),
      /* offsetOfTypes */   offsetof(HashSequenceStart_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(HashSequenceStart_In, hashAlg))},
      /* types */           {TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   END_OF_LIST}
  };
  #define _HashSequenceStartDataAddress (&_HashSequenceStartData)
  #else
  #define _HashSequenceStartDataAddress 0
  #endif
  #if CC_SequenceUpdate == YES
  #include "SequenceUpdate_fp.h"
  typedef TPM_RC  (SequenceUpdate_Entry)(
  				       SequenceUpdate_In *in
  				       );
  typedef const struct {
      SequenceUpdate_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[1];
      BYTE                    types[4];
  } SequenceUpdate_COMMAND_DESCRIPTOR_t;
  SequenceUpdate_COMMAND_DESCRIPTOR_t _SequenceUpdateData = {
      /* entry  */          &TPM2_SequenceUpdate,
      /* inSize */          (UINT16)(sizeof(SequenceUpdate_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(SequenceUpdate_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(SequenceUpdate_In, buffer))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _SequenceUpdateDataAddress (&_SequenceUpdateData)
  #else
  #define _SequenceUpdateDataAddress 0
  #endif
  #if CC_SequenceComplete == YES
  #include "SequenceComplete_fp.h"
  typedef TPM_RC  (SequenceComplete_Entry)(
  					 SequenceComplete_In *in,
  					 SequenceComplete_Out *out
  					 );
  typedef const struct {
      SequenceComplete_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[3];
      BYTE                      types[7];
  } SequenceComplete_COMMAND_DESCRIPTOR_t;
  SequenceComplete_COMMAND_DESCRIPTOR_t _SequenceCompleteData = {
      /* entry  */          &TPM2_SequenceComplete,
      /* inSize */          (UINT16)(sizeof(SequenceComplete_In)),
      /* outSize */         (UINT16)(sizeof(SequenceComplete_Out)),
      /* offsetOfTypes */   offsetof(SequenceComplete_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(SequenceComplete_In, buffer)),
  			   (UINT16)(offsetof(SequenceComplete_In, hierarchy)),
  			   (UINT16)(offsetof(SequenceComplete_Out, validation))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   TPMI_RH_HIERARCHY_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   TPMT_TK_HASHCHECK_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _SequenceCompleteDataAddress (&_SequenceCompleteData)
  #else
  #define _SequenceCompleteDataAddress 0
  #endif
  #if CC_EventSequenceComplete == YES
  #include "EventSequenceComplete_fp.h"
  typedef TPM_RC  (EventSequenceComplete_Entry)(
  					      EventSequenceComplete_In *in,
  					      EventSequenceComplete_Out *out
  					      );
  typedef const struct {
      EventSequenceComplete_Entry    *entry;
      UINT16                         inSize;
      UINT16                         outSize;
      UINT16                         offsetOfTypes;
      UINT16                         paramOffsets[2];
      BYTE                           types[6];
  } EventSequenceComplete_COMMAND_DESCRIPTOR_t;
  EventSequenceComplete_COMMAND_DESCRIPTOR_t _EventSequenceCompleteData = {
      /* entry  */          &TPM2_EventSequenceComplete,
      /* inSize */          (UINT16)(sizeof(EventSequenceComplete_In)),
      /* outSize */         (UINT16)(sizeof(EventSequenceComplete_Out)),
      /* offsetOfTypes */   offsetof(EventSequenceComplete_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(EventSequenceComplete_In, sequenceHandle)),
  			   (UINT16)(offsetof(EventSequenceComplete_In, buffer))},
      /* types */           {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPML_DIGEST_VALUES_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _EventSequenceCompleteDataAddress (&_EventSequenceCompleteData)
  #else
  #define _EventSequenceCompleteDataAddress 0
  #endif
  #if CC_Certify == YES
  #include "Certify_fp.h"
  typedef TPM_RC  (Certify_Entry)(
  				Certify_In *in,
  				Certify_Out *out
  				);
  typedef const struct {
      Certify_Entry    *entry;
      UINT16           inSize;
      UINT16           outSize;
      UINT16           offsetOfTypes;
      UINT16           paramOffsets[4];
      BYTE             types[8];
  } Certify_COMMAND_DESCRIPTOR_t;
  Certify_COMMAND_DESCRIPTOR_t _CertifyData = {
      /* entry  */          &TPM2_Certify,
      /* inSize */          (UINT16)(sizeof(Certify_In)),
      /* outSize */         (UINT16)(sizeof(Certify_Out)),
      /* offsetOfTypes */   offsetof(Certify_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Certify_In, signHandle)),
  			   (UINT16)(offsetof(Certify_In, qualifyingData)),
  			   (UINT16)(offsetof(Certify_In, inScheme)),
  			   (UINT16)(offsetof(Certify_Out, signature))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CertifyDataAddress (&_CertifyData)
  #else
  #define _CertifyDataAddress 0
  #endif
  #if CC_CertifyCreation == YES
  #include "CertifyCreation_fp.h"
  typedef TPM_RC  (CertifyCreation_Entry)(
  					CertifyCreation_In *in,
  					CertifyCreation_Out *out
  					);
  typedef const struct {
      CertifyCreation_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[6];
      BYTE                     types[10];
  } CertifyCreation_COMMAND_DESCRIPTOR_t;
  CertifyCreation_COMMAND_DESCRIPTOR_t _CertifyCreationData = {
      /* entry  */          &TPM2_CertifyCreation,
      /* inSize */          (UINT16)(sizeof(CertifyCreation_In)),
      /* outSize */         (UINT16)(sizeof(CertifyCreation_Out)),
      /* offsetOfTypes */   offsetof(CertifyCreation_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(CertifyCreation_In, objectHandle)),
  			   (UINT16)(offsetof(CertifyCreation_In, qualifyingData)),
  			   (UINT16)(offsetof(CertifyCreation_In, creationHash)),
  			   (UINT16)(offsetof(CertifyCreation_In, inScheme)),
  			   (UINT16)(offsetof(CertifyCreation_In, creationTicket)),
  			   (UINT16)(offsetof(CertifyCreation_Out, signature))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   TPMT_TK_CREATION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CertifyCreationDataAddress (&_CertifyCreationData)
  #else
  #define _CertifyCreationDataAddress 0
  #endif
  #if CC_Quote == YES
  #include "Quote_fp.h"
  typedef TPM_RC  (Quote_Entry)(
  			      Quote_In *in,
  			      Quote_Out *out
  			      );
  typedef const struct {
      Quote_Entry    *entry;
      UINT16         inSize;
      UINT16         outSize;
      UINT16         offsetOfTypes;
      UINT16         paramOffsets[4];
      BYTE           types[8];
  } Quote_COMMAND_DESCRIPTOR_t;
  Quote_COMMAND_DESCRIPTOR_t _QuoteData = {
      /* entry  */          &TPM2_Quote,
      /* inSize */          (UINT16)(sizeof(Quote_In)),
      /* outSize */         (UINT16)(sizeof(Quote_Out)),
      /* offsetOfTypes */   offsetof(Quote_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Quote_In, qualifyingData)),
  			   (UINT16)(offsetof(Quote_In, inScheme)),
  			   (UINT16)(offsetof(Quote_In, PCRselect)),
  			   (UINT16)(offsetof(Quote_Out, signature))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _QuoteDataAddress (&_QuoteData)
  #else
  #define _QuoteDataAddress 0
  #endif
  #if CC_GetSessionAuditDigest == YES
  #include "GetSessionAuditDigest_fp.h"
  typedef TPM_RC  (GetSessionAuditDigest_Entry)(
  					      GetSessionAuditDigest_In *in,
  					      GetSessionAuditDigest_Out *out
  					      );
  typedef const struct {
      GetSessionAuditDigest_Entry    *entry;
      UINT16                         inSize;
      UINT16                         outSize;
      UINT16                         offsetOfTypes;
      UINT16                         paramOffsets[5];
      BYTE                           types[9];
  } GetSessionAuditDigest_COMMAND_DESCRIPTOR_t;
  GetSessionAuditDigest_COMMAND_DESCRIPTOR_t _GetSessionAuditDigestData = {
      /* entry  */          &TPM2_GetSessionAuditDigest,
      /* inSize */          (UINT16)(sizeof(GetSessionAuditDigest_In)),
      /* outSize */         (UINT16)(sizeof(GetSessionAuditDigest_Out)),
      /* offsetOfTypes */   offsetof(GetSessionAuditDigest_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(GetSessionAuditDigest_In, signHandle)),
  			   (UINT16)(offsetof(GetSessionAuditDigest_In, sessionHandle)),
  			   (UINT16)(offsetof(GetSessionAuditDigest_In, qualifyingData)),
  			   (UINT16)(offsetof(GetSessionAuditDigest_In, inScheme)),
  			   (UINT16)(offsetof(GetSessionAuditDigest_Out, signature))},
      /* types */           {TPMI_RH_ENDORSEMENT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_SH_HMAC_H_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetSessionAuditDigestDataAddress (&_GetSessionAuditDigestData)
  #else
  #define _GetSessionAuditDigestDataAddress 0
  #endif
  #if CC_GetCommandAuditDigest == YES
  #include "GetCommandAuditDigest_fp.h"
  typedef TPM_RC  (GetCommandAuditDigest_Entry)(
  					      GetCommandAuditDigest_In *in,
  					      GetCommandAuditDigest_Out *out
  					      );
  typedef const struct {
      GetCommandAuditDigest_Entry    *entry;
      UINT16                         inSize;
      UINT16                         outSize;
      UINT16                         offsetOfTypes;
      UINT16                         paramOffsets[4];
      BYTE                           types[8];
  } GetCommandAuditDigest_COMMAND_DESCRIPTOR_t;
  GetCommandAuditDigest_COMMAND_DESCRIPTOR_t _GetCommandAuditDigestData = {
      /* entry  */          &TPM2_GetCommandAuditDigest,
      /* inSize */          (UINT16)(sizeof(GetCommandAuditDigest_In)),
      /* outSize */         (UINT16)(sizeof(GetCommandAuditDigest_Out)),
      /* offsetOfTypes */   offsetof(GetCommandAuditDigest_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(GetCommandAuditDigest_In, signHandle)),
  			   (UINT16)(offsetof(GetCommandAuditDigest_In, qualifyingData)),
  			   (UINT16)(offsetof(GetCommandAuditDigest_In, inScheme)),
  			   (UINT16)(offsetof(GetCommandAuditDigest_Out, signature))},
      /* types */           {TPMI_RH_ENDORSEMENT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetCommandAuditDigestDataAddress (&_GetCommandAuditDigestData)
  #else
  #define _GetCommandAuditDigestDataAddress 0
  #endif
  #if CC_GetTime == YES
  #include "GetTime_fp.h"
  typedef TPM_RC  (GetTime_Entry)(
  				GetTime_In *in,
  				GetTime_Out *out
  				);
  typedef const struct {
      GetTime_Entry    *entry;
      UINT16           inSize;
      UINT16           outSize;
      UINT16           offsetOfTypes;
      UINT16           paramOffsets[4];
      BYTE             types[8];
  } GetTime_COMMAND_DESCRIPTOR_t;
  GetTime_COMMAND_DESCRIPTOR_t _GetTimeData = {
      /* entry  */          &TPM2_GetTime,
      /* inSize */          (UINT16)(sizeof(GetTime_In)),
      /* outSize */         (UINT16)(sizeof(GetTime_Out)),
      /* offsetOfTypes */   offsetof(GetTime_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(GetTime_In, signHandle)),
  			   (UINT16)(offsetof(GetTime_In, qualifyingData)),
  			   (UINT16)(offsetof(GetTime_In, inScheme)),
  			   (UINT16)(offsetof(GetTime_Out, signature))},
      /* types */           {TPMI_RH_ENDORSEMENT_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetTimeDataAddress (&_GetTimeData)
  #else
  #define _GetTimeDataAddress 0
  #endif
  #if CC_Commit == YES
  #include "Commit_fp.h"
  typedef TPM_RC  (Commit_Entry)(
  			       Commit_In *in,
  			       Commit_Out *out
  			       );
  typedef const struct {
      Commit_Entry    *entry;
      UINT16          inSize;
      UINT16          outSize;
      UINT16          offsetOfTypes;
      UINT16          paramOffsets[6];
      BYTE            types[10];
  } Commit_COMMAND_DESCRIPTOR_t;
  Commit_COMMAND_DESCRIPTOR_t _CommitData = {
      /* entry  */          &TPM2_Commit,
      /* inSize */          (UINT16)(sizeof(Commit_In)),
      /* outSize */         (UINT16)(sizeof(Commit_Out)),
      /* offsetOfTypes */   offsetof(Commit_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Commit_In, P1)),
  			   (UINT16)(offsetof(Commit_In, s2)),
  			   (UINT16)(offsetof(Commit_In, y2)),
  			   (UINT16)(offsetof(Commit_Out, L)),
  			   (UINT16)(offsetof(Commit_Out, E)),
  			   (UINT16)(offsetof(Commit_Out, counter))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_ECC_POINT_P_UNMARSHAL,
  			   TPM2B_SENSITIVE_DATA_P_UNMARSHAL,
  			   TPM2B_ECC_PARAMETER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   UINT16_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CommitDataAddress (&_CommitData)
  #else
  #define _CommitDataAddress 0
  #endif
  #if CC_EC_Ephemeral == YES
  #include "EC_Ephemeral_fp.h"
  typedef TPM_RC  (EC_Ephemeral_Entry)(
  				     EC_Ephemeral_In *in,
  				     EC_Ephemeral_Out *out
  				     );
  typedef const struct {
      EC_Ephemeral_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[1];
      BYTE                  types[5];
  } EC_Ephemeral_COMMAND_DESCRIPTOR_t;
  EC_Ephemeral_COMMAND_DESCRIPTOR_t _EC_EphemeralData = {
      /* entry  */          &TPM2_EC_Ephemeral,
      /* inSize */          (UINT16)(sizeof(EC_Ephemeral_In)),
      /* outSize */         (UINT16)(sizeof(EC_Ephemeral_Out)),
      /* offsetOfTypes */   offsetof(EC_Ephemeral_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(EC_Ephemeral_Out, counter))},
      /* types */           {TPMI_ECC_CURVE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ECC_POINT_P_MARSHAL,
  			   UINT16_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _EC_EphemeralDataAddress (&_EC_EphemeralData)
  #else
  #define _EC_EphemeralDataAddress 0
  #endif
  #if CC_VerifySignature == YES
  #include "VerifySignature_fp.h"
  typedef TPM_RC  (VerifySignature_Entry)(
  					VerifySignature_In *in,
  					VerifySignature_Out *out
  					);
  typedef const struct {
      VerifySignature_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[2];
      BYTE                     types[6];
  } VerifySignature_COMMAND_DESCRIPTOR_t;
  VerifySignature_COMMAND_DESCRIPTOR_t _VerifySignatureData = {
      /* entry  */          &TPM2_VerifySignature,
      /* inSize */          (UINT16)(sizeof(VerifySignature_In)),
      /* outSize */         (UINT16)(sizeof(VerifySignature_Out)),
      /* offsetOfTypes */   offsetof(VerifySignature_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(VerifySignature_In, digest)),
  			   (UINT16)(offsetof(VerifySignature_In, signature))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMT_SIGNATURE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMT_TK_VERIFIED_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _VerifySignatureDataAddress (&_VerifySignatureData)
  #else
  #define _VerifySignatureDataAddress 0
  #endif
  #if CC_Sign == YES
  #include "Sign_fp.h"
  typedef TPM_RC  (Sign_Entry)(
  			     Sign_In *in,
  			     Sign_Out *out
  			     );
  typedef const struct {
      Sign_Entry    *entry;
      UINT16        inSize;
      UINT16        outSize;
      UINT16        offsetOfTypes;
      UINT16        paramOffsets[3];
      BYTE          types[7];
  } Sign_COMMAND_DESCRIPTOR_t;
  Sign_COMMAND_DESCRIPTOR_t _SignData = {
      /* entry  */          &TPM2_Sign,
      /* inSize */          (UINT16)(sizeof(Sign_In)),
      /* outSize */         (UINT16)(sizeof(Sign_Out)),
      /* offsetOfTypes */   offsetof(Sign_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Sign_In, digest)),
  			   (UINT16)(offsetof(Sign_In, inScheme)),
  			   (UINT16)(offsetof(Sign_In, validation))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   TPMT_TK_HASHCHECK_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _SignDataAddress (&_SignData)
  #else
  #define _SignDataAddress 0
  #endif
  #if CC_SetCommandCodeAuditStatus == YES
  #include "SetCommandCodeAuditStatus_fp.h"
  typedef TPM_RC  (SetCommandCodeAuditStatus_Entry)(
  						  SetCommandCodeAuditStatus_In *in
  						  );
  typedef const struct {
      SetCommandCodeAuditStatus_Entry    *entry;
      UINT16                             inSize;
      UINT16                             outSize;
      UINT16                             offsetOfTypes;
      UINT16                             paramOffsets[3];
      BYTE                               types[6];
  } SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t;
  SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t _SetCommandCodeAuditStatusData = {
      /* entry  */          &TPM2_SetCommandCodeAuditStatus,
      /* inSize */          (UINT16)(sizeof(SetCommandCodeAuditStatus_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(SetCommandCodeAuditStatus_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(SetCommandCodeAuditStatus_In, auditAlg)),
  			   (UINT16)(offsetof(SetCommandCodeAuditStatus_In, setList)),
  			   (UINT16)(offsetof(SetCommandCodeAuditStatus_In, clearList))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   TPML_CC_P_UNMARSHAL,
  			   TPML_CC_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _SetCommandCodeAuditStatusDataAddress (&_SetCommandCodeAuditStatusData)
  #else
  #define _SetCommandCodeAuditStatusDataAddress 0
  #endif
  #if CC_PCR_Extend == YES
  #include "PCR_Extend_fp.h"
  typedef TPM_RC  (PCR_Extend_Entry)(
  				   PCR_Extend_In *in
  				   );
  typedef const struct {
      PCR_Extend_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      UINT16              paramOffsets[1];
      BYTE                types[4];
  } PCR_Extend_COMMAND_DESCRIPTOR_t;
  PCR_Extend_COMMAND_DESCRIPTOR_t _PCR_ExtendData = {
      /* entry  */          &TPM2_PCR_Extend,
      /* inSize */          (UINT16)(sizeof(PCR_Extend_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PCR_Extend_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_Extend_In, digests))},
      /* types */           {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG,
  			   TPML_DIGEST_VALUES_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PCR_ExtendDataAddress (&_PCR_ExtendData)
  #else
  #define _PCR_ExtendDataAddress 0
  #endif
  #if CC_PCR_Event == YES
  #include "PCR_Event_fp.h"
  typedef TPM_RC  (PCR_Event_Entry)(
  				  PCR_Event_In *in,
  				  PCR_Event_Out *out
  				  );
  typedef const struct {
      PCR_Event_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[1];
      BYTE               types[5];
  } PCR_Event_COMMAND_DESCRIPTOR_t;
  PCR_Event_COMMAND_DESCRIPTOR_t _PCR_EventData = {
      /* entry  */          &TPM2_PCR_Event,
      /* inSize */          (UINT16)(sizeof(PCR_Event_In)),
      /* outSize */         (UINT16)(sizeof(PCR_Event_Out)),
      /* offsetOfTypes */   offsetof(PCR_Event_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_Event_In, eventData))},
      /* types */           {TPMI_DH_PCR_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_EVENT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPML_DIGEST_VALUES_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PCR_EventDataAddress (&_PCR_EventData)
  #else
  #define _PCR_EventDataAddress 0
  #endif
  #if CC_PCR_Read == YES
  #include "PCR_Read_fp.h"
  typedef TPM_RC  (PCR_Read_Entry)(
  				 PCR_Read_In *in,
  				 PCR_Read_Out *out
  				 );
  typedef const struct {
      PCR_Read_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      UINT16            paramOffsets[2];
      BYTE              types[6];
  } PCR_Read_COMMAND_DESCRIPTOR_t;
  PCR_Read_COMMAND_DESCRIPTOR_t _PCR_ReadData = {
      /* entry  */          &TPM2_PCR_Read,
      /* inSize */          (UINT16)(sizeof(PCR_Read_In)),
      /* outSize */         (UINT16)(sizeof(PCR_Read_Out)),
      /* offsetOfTypes */   offsetof(PCR_Read_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_Read_Out, pcrSelectionOut)),
  			   (UINT16)(offsetof(PCR_Read_Out, pcrValues))},
      /* types */           {TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_P_MARSHAL,
  			   TPML_PCR_SELECTION_P_MARSHAL,
  			   TPML_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PCR_ReadDataAddress (&_PCR_ReadData)
  #else
  #define _PCR_ReadDataAddress 0
  #endif
  #if CC_PCR_Allocate == YES
  #include "PCR_Allocate_fp.h"
  typedef TPM_RC  (PCR_Allocate_Entry)(
  				     PCR_Allocate_In *in,
  				     PCR_Allocate_Out *out
  				     );
  typedef const struct {
      PCR_Allocate_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[4];
      BYTE                  types[8];
  } PCR_Allocate_COMMAND_DESCRIPTOR_t;
  PCR_Allocate_COMMAND_DESCRIPTOR_t _PCR_AllocateData = {
      /* entry  */          &TPM2_PCR_Allocate,
      /* inSize */          (UINT16)(sizeof(PCR_Allocate_In)),
      /* outSize */         (UINT16)(sizeof(PCR_Allocate_Out)),
      /* offsetOfTypes */   offsetof(PCR_Allocate_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_Allocate_In, pcrAllocation)),
  			   (UINT16)(offsetof(PCR_Allocate_Out, maxPCR)),
  			   (UINT16)(offsetof(PCR_Allocate_Out, sizeNeeded)),
  			   (UINT16)(offsetof(PCR_Allocate_Out, sizeAvailable))},
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT8_P_MARSHAL,
  			   UINT32_P_MARSHAL,
  			   UINT32_P_MARSHAL,
  			   UINT32_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PCR_AllocateDataAddress (&_PCR_AllocateData)
  #else
  #define _PCR_AllocateDataAddress 0
  #endif
  #if CC_PCR_SetAuthPolicy == YES
  #include "PCR_SetAuthPolicy_fp.h"
  typedef TPM_RC  (PCR_SetAuthPolicy_Entry)(
  					  PCR_SetAuthPolicy_In *in
  					  );
  typedef const struct {
      PCR_SetAuthPolicy_Entry    *entry;
      UINT16                     inSize;
      UINT16                     outSize;
      UINT16                     offsetOfTypes;
      UINT16                     paramOffsets[3];
      BYTE                       types[6];
  } PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t;
  PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t _PCR_SetAuthPolicyData = {
      /* entry  */          &TPM2_PCR_SetAuthPolicy,
      /* inSize */          (UINT16)(sizeof(PCR_SetAuthPolicy_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PCR_SetAuthPolicy_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_SetAuthPolicy_In, authPolicy)),
  			   (UINT16)(offsetof(PCR_SetAuthPolicy_In, hashAlg)),
  			   (UINT16)(offsetof(PCR_SetAuthPolicy_In, pcrNum))},
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   TPMI_DH_PCR_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PCR_SetAuthPolicyDataAddress (&_PCR_SetAuthPolicyData)
  #else
  #define _PCR_SetAuthPolicyDataAddress 0
  #endif
  #if CC_PCR_SetAuthValue == YES
  #include "PCR_SetAuthValue_fp.h"
  typedef TPM_RC  (PCR_SetAuthValue_Entry)(
  					 PCR_SetAuthValue_In *in
  					 );
  typedef const struct {
      PCR_SetAuthValue_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[1];
      BYTE                      types[4];
  } PCR_SetAuthValue_COMMAND_DESCRIPTOR_t;
  PCR_SetAuthValue_COMMAND_DESCRIPTOR_t _PCR_SetAuthValueData = {
      /* entry  */          &TPM2_PCR_SetAuthValue,
      /* inSize */          (UINT16)(sizeof(PCR_SetAuthValue_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PCR_SetAuthValue_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PCR_SetAuthValue_In, auth))},
      /* types */           {TPMI_DH_PCR_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PCR_SetAuthValueDataAddress (&_PCR_SetAuthValueData)
  #else
  #define _PCR_SetAuthValueDataAddress 0
  #endif
  #if CC_PCR_Reset == YES
  #include "PCR_Reset_fp.h"
  typedef TPM_RC  (PCR_Reset_Entry)(
  				  PCR_Reset_In *in
  				  );
  typedef const struct {
      PCR_Reset_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[3];
  } PCR_Reset_COMMAND_DESCRIPTOR_t;
  PCR_Reset_COMMAND_DESCRIPTOR_t _PCR_ResetData = {
      /* entry  */          &TPM2_PCR_Reset,
      /* inSize */          (UINT16)(sizeof(PCR_Reset_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PCR_Reset_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_DH_PCR_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PCR_ResetDataAddress (&_PCR_ResetData)
  #else
  #define _PCR_ResetDataAddress 0
  #endif
  #if CC_PolicySigned == YES
  #include "PolicySigned_fp.h"
  typedef TPM_RC  (PolicySigned_Entry)(
  				     PolicySigned_In *in,
  				     PolicySigned_Out *out
  				     );
  typedef const struct {
      PolicySigned_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[7];
      BYTE                  types[11];
  } PolicySigned_COMMAND_DESCRIPTOR_t;
  PolicySigned_COMMAND_DESCRIPTOR_t _PolicySignedData = {
      /* entry  */          &TPM2_PolicySigned,
      /* inSize */          (UINT16)(sizeof(PolicySigned_In)),
      /* outSize */         (UINT16)(sizeof(PolicySigned_Out)),
      /* offsetOfTypes */   offsetof(PolicySigned_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicySigned_In, policySession)),
  			   (UINT16)(offsetof(PolicySigned_In, nonceTPM)),
  			   (UINT16)(offsetof(PolicySigned_In, cpHashA)),
  			   (UINT16)(offsetof(PolicySigned_In, policyRef)),
  			   (UINT16)(offsetof(PolicySigned_In, expiration)),
  			   (UINT16)(offsetof(PolicySigned_In, auth)),
  			   (UINT16)(offsetof(PolicySigned_Out, policyTicket))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   TPMT_SIGNATURE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_TIMEOUT_P_MARSHAL,
  			   TPMT_TK_AUTH_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PolicySignedDataAddress (&_PolicySignedData)
  #else
  #define _PolicySignedDataAddress 0
  #endif
  #if CC_PolicySecret == YES
  #include "PolicySecret_fp.h"
  typedef TPM_RC  (PolicySecret_Entry)(
  				     PolicySecret_In *in,
  				     PolicySecret_Out *out
  				     );
  typedef const struct {
      PolicySecret_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[6];
      BYTE                  types[10];
  } PolicySecret_COMMAND_DESCRIPTOR_t;
  PolicySecret_COMMAND_DESCRIPTOR_t _PolicySecretData = {
      /* entry  */          &TPM2_PolicySecret,
      /* inSize */          (UINT16)(sizeof(PolicySecret_In)),
      /* outSize */         (UINT16)(sizeof(PolicySecret_Out)),
      /* offsetOfTypes */   offsetof(PolicySecret_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicySecret_In, policySession)),
  			   (UINT16)(offsetof(PolicySecret_In, nonceTPM)),
  			   (UINT16)(offsetof(PolicySecret_In, cpHashA)),
  			   (UINT16)(offsetof(PolicySecret_In, policyRef)),
  			   (UINT16)(offsetof(PolicySecret_In, expiration)),
  			   (UINT16)(offsetof(PolicySecret_Out, policyTicket))},
      /* types */           {TPMI_DH_ENTITY_H_UNMARSHAL,
  			   TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_TIMEOUT_P_MARSHAL,
  			   TPMT_TK_AUTH_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PolicySecretDataAddress (&_PolicySecretData)
  #else
  #define _PolicySecretDataAddress 0
  #endif
  #if CC_PolicyTicket == YES
  #include "PolicyTicket_fp.h"
  typedef TPM_RC  (PolicyTicket_Entry)(
  				     PolicyTicket_In *in
  				     );
  typedef const struct {
      PolicyTicket_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[5];
      BYTE                  types[8];
  } PolicyTicket_COMMAND_DESCRIPTOR_t;
  PolicyTicket_COMMAND_DESCRIPTOR_t _PolicyTicketData = {
      /* entry  */          &TPM2_PolicyTicket,
      /* inSize */          (UINT16)(sizeof(PolicyTicket_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyTicket_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyTicket_In, timeout)),
  			   (UINT16)(offsetof(PolicyTicket_In, cpHashA)),
  			   (UINT16)(offsetof(PolicyTicket_In, policyRef)),
  			   (UINT16)(offsetof(PolicyTicket_In, authName)),
  			   (UINT16)(offsetof(PolicyTicket_In, ticket))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_TIMEOUT_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPMT_TK_AUTH_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyTicketDataAddress (&_PolicyTicketData)
  #else
  #define _PolicyTicketDataAddress 0
  #endif
  #if CC_PolicyOR == YES
  #include "PolicyOR_fp.h"
  typedef TPM_RC  (PolicyOR_Entry)(
  				 PolicyOR_In *in
  				 );
  typedef const struct {
      PolicyOR_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      UINT16            paramOffsets[1];
      BYTE              types[4];
  } PolicyOR_COMMAND_DESCRIPTOR_t;
  PolicyOR_COMMAND_DESCRIPTOR_t _PolicyORData = {
      /* entry  */          &TPM2_PolicyOR,
      /* inSize */          (UINT16)(sizeof(PolicyOR_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyOR_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyOR_In, pHashList))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPML_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyORDataAddress (&_PolicyORData)
  #else
  #define _PolicyORDataAddress 0
  #endif
  #if CC_PolicyPCR == YES
  #include "PolicyPCR_fp.h"
  typedef TPM_RC  (PolicyPCR_Entry)(
  				  PolicyPCR_In *in
  				  );
  typedef const struct {
      PolicyPCR_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[2];
      BYTE               types[5];
  } PolicyPCR_COMMAND_DESCRIPTOR_t;
  PolicyPCR_COMMAND_DESCRIPTOR_t _PolicyPCRData = {
      /* entry  */          &TPM2_PolicyPCR,
      /* inSize */          (UINT16)(sizeof(PolicyPCR_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyPCR_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyPCR_In, pcrDigest)),
  			   (UINT16)(offsetof(PolicyPCR_In, pcrs))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyPCRDataAddress (&_PolicyPCRData)
  #else
  #define _PolicyPCRDataAddress 0
  #endif
  #if CC_PolicyLocality == YES
  #include "PolicyLocality_fp.h"
  typedef TPM_RC  (PolicyLocality_Entry)(
  				       PolicyLocality_In *in
  				       );
  typedef const struct {
      PolicyLocality_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[1];
      BYTE                    types[4];
  } PolicyLocality_COMMAND_DESCRIPTOR_t;
  PolicyLocality_COMMAND_DESCRIPTOR_t _PolicyLocalityData = {
      /* entry  */          &TPM2_PolicyLocality,
      /* inSize */          (UINT16)(sizeof(PolicyLocality_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyLocality_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyLocality_In, locality))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   UINT8_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyLocalityDataAddress (&_PolicyLocalityData)
  #else
  #define _PolicyLocalityDataAddress 0
  #endif
  #if CC_PolicyNV == YES
  #include "PolicyNV_fp.h"
  typedef TPM_RC  (PolicyNV_Entry)(
  				 PolicyNV_In *in
  				 );
  typedef const struct {
      PolicyNV_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      UINT16            paramOffsets[5];
      BYTE              types[8];
  } PolicyNV_COMMAND_DESCRIPTOR_t;
  PolicyNV_COMMAND_DESCRIPTOR_t _PolicyNVData = {
      /* entry  */          &TPM2_PolicyNV,
      /* inSize */          (UINT16)(sizeof(PolicyNV_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyNV_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyNV_In, nvIndex)),
  			   (UINT16)(offsetof(PolicyNV_In, policySession)),
  			   (UINT16)(offsetof(PolicyNV_In, operandB)),
  			   (UINT16)(offsetof(PolicyNV_In, offset)),
  			   (UINT16)(offsetof(PolicyNV_In, operation))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   TPM_EO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyNVDataAddress (&_PolicyNVData)
  #else
  #define _PolicyNVDataAddress 0
  #endif
  #if CC_PolicyCounterTimer == YES
  #include "PolicyCounterTimer_fp.h"
  typedef TPM_RC  (PolicyCounterTimer_Entry)(
  					   PolicyCounterTimer_In *in
  					   );
  typedef const struct {
      PolicyCounterTimer_Entry    *entry;
      UINT16                      inSize;
      UINT16                      outSize;
      UINT16                      offsetOfTypes;
      UINT16                      paramOffsets[3];
      BYTE                        types[6];
  } PolicyCounterTimer_COMMAND_DESCRIPTOR_t;
  PolicyCounterTimer_COMMAND_DESCRIPTOR_t _PolicyCounterTimerData = {
      /* entry  */          &TPM2_PolicyCounterTimer,
      /* inSize */          (UINT16)(sizeof(PolicyCounterTimer_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyCounterTimer_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyCounterTimer_In, operandB)),
  			   (UINT16)(offsetof(PolicyCounterTimer_In, offset)),
  			   (UINT16)(offsetof(PolicyCounterTimer_In, operation))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   TPM_EO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyCounterTimerDataAddress (&_PolicyCounterTimerData)
  #else
  #define _PolicyCounterTimerDataAddress 0
  #endif
  #if CC_PolicyCommandCode == YES
  #include "PolicyCommandCode_fp.h"
  typedef TPM_RC  (PolicyCommandCode_Entry)(
  					  PolicyCommandCode_In *in
  					  );
  typedef const struct {
      PolicyCommandCode_Entry    *entry;
      UINT16                     inSize;
      UINT16                     outSize;
      UINT16                     offsetOfTypes;
      UINT16                     paramOffsets[1];
      BYTE                       types[4];
  } PolicyCommandCode_COMMAND_DESCRIPTOR_t;
  PolicyCommandCode_COMMAND_DESCRIPTOR_t _PolicyCommandCodeData = {
      /* entry  */          &TPM2_PolicyCommandCode,
      /* inSize */          (UINT16)(sizeof(PolicyCommandCode_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyCommandCode_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyCommandCode_In, code))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyCommandCodeDataAddress (&_PolicyCommandCodeData)
  #else
  #define _PolicyCommandCodeDataAddress 0
  #endif
  #if CC_PolicyPhysicalPresence == YES
  #include "PolicyPhysicalPresence_fp.h"
  typedef TPM_RC  (PolicyPhysicalPresence_Entry)(
  					       PolicyPhysicalPresence_In *in
  					       );
  typedef const struct {
      PolicyPhysicalPresence_Entry    *entry;
      UINT16                          inSize;
      UINT16                          outSize;
      UINT16                          offsetOfTypes;
      BYTE                            types[3];
  } PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t;
  PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t _PolicyPhysicalPresenceData = {
      /* entry  */          &TPM2_PolicyPhysicalPresence,
      /* inSize */          (UINT16)(sizeof(PolicyPhysicalPresence_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyPhysicalPresence_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyPhysicalPresenceDataAddress (&_PolicyPhysicalPresenceData)
  #else
  #define _PolicyPhysicalPresenceDataAddress 0
  #endif
  #if CC_PolicyCpHash == YES
  #include "PolicyCpHash_fp.h"
  typedef TPM_RC  (PolicyCpHash_Entry)(
  				     PolicyCpHash_In *in
  				     );
  typedef const struct {
      PolicyCpHash_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[1];
      BYTE                  types[4];
  } PolicyCpHash_COMMAND_DESCRIPTOR_t;
  PolicyCpHash_COMMAND_DESCRIPTOR_t _PolicyCpHashData = {
      /* entry  */          &TPM2_PolicyCpHash,
      /* inSize */          (UINT16)(sizeof(PolicyCpHash_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyCpHash_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyCpHash_In, cpHashA))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyCpHashDataAddress (&_PolicyCpHashData)
  #else
  #define _PolicyCpHashDataAddress 0
  #endif
  #if CC_PolicyNameHash == YES
  #include "PolicyNameHash_fp.h"
  typedef TPM_RC  (PolicyNameHash_Entry)(
  				       PolicyNameHash_In *in
  				       );
  typedef const struct {
      PolicyNameHash_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[1];
      BYTE                    types[4];
  } PolicyNameHash_COMMAND_DESCRIPTOR_t;
  PolicyNameHash_COMMAND_DESCRIPTOR_t _PolicyNameHashData = {
      /* entry  */          &TPM2_PolicyNameHash,
      /* inSize */          (UINT16)(sizeof(PolicyNameHash_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyNameHash_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyNameHash_In, nameHash))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyNameHashDataAddress (&_PolicyNameHashData)
  #else
  #define _PolicyNameHashDataAddress 0
  #endif
  #if CC_PolicyDuplicationSelect == YES
  #include "PolicyDuplicationSelect_fp.h"
  typedef TPM_RC  (PolicyDuplicationSelect_Entry)(
  						PolicyDuplicationSelect_In *in
  						);
  typedef const struct {
      PolicyDuplicationSelect_Entry    *entry;
      UINT16                           inSize;
      UINT16                           outSize;
      UINT16                           offsetOfTypes;
      UINT16                           paramOffsets[3];
      BYTE                             types[6];
  } PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t;
  PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t _PolicyDuplicationSelectData = {
      /* entry  */          &TPM2_PolicyDuplicationSelect,
      /* inSize */          (UINT16)(sizeof(PolicyDuplicationSelect_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyDuplicationSelect_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyDuplicationSelect_In, objectName)),
  			   (UINT16)(offsetof(PolicyDuplicationSelect_In, newParentName)),
  			   (UINT16)(offsetof(PolicyDuplicationSelect_In, includeObject))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyDuplicationSelectDataAddress (&_PolicyDuplicationSelectData)
  #else
  #define _PolicyDuplicationSelectDataAddress 0
  #endif
  #if CC_PolicyAuthorize == YES
  #include "PolicyAuthorize_fp.h"
  typedef TPM_RC  (PolicyAuthorize_Entry)(
  					PolicyAuthorize_In *in
  					);
  typedef const struct {
      PolicyAuthorize_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[4];
      BYTE                     types[7];
  } PolicyAuthorize_COMMAND_DESCRIPTOR_t;
  PolicyAuthorize_COMMAND_DESCRIPTOR_t _PolicyAuthorizeData = {
      /* entry  */          &TPM2_PolicyAuthorize,
      /* inSize */          (UINT16)(sizeof(PolicyAuthorize_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyAuthorize_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyAuthorize_In, approvedPolicy)),
  			   (UINT16)(offsetof(PolicyAuthorize_In, policyRef)),
  			   (UINT16)(offsetof(PolicyAuthorize_In, keySign)),
  			   (UINT16)(offsetof(PolicyAuthorize_In, checkTicket))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPMT_TK_VERIFIED_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyAuthorizeDataAddress (&_PolicyAuthorizeData)
  #else
  #define _PolicyAuthorizeDataAddress 0
  #endif
  #if CC_PolicyAuthValue == YES
  #include "PolicyAuthValue_fp.h"
  typedef TPM_RC  (PolicyAuthValue_Entry)(
  					PolicyAuthValue_In *in
  					);
  typedef const struct {
      PolicyAuthValue_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      BYTE                     types[3];
  } PolicyAuthValue_COMMAND_DESCRIPTOR_t;
  PolicyAuthValue_COMMAND_DESCRIPTOR_t _PolicyAuthValueData = {
      /* entry  */          &TPM2_PolicyAuthValue,
      /* inSize */          (UINT16)(sizeof(PolicyAuthValue_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyAuthValue_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyAuthValueDataAddress (&_PolicyAuthValueData)
  #else
  #define _PolicyAuthValueDataAddress 0
  #endif
  #if CC_PolicyPassword == YES
  #include "PolicyPassword_fp.h"
  typedef TPM_RC  (PolicyPassword_Entry)(
  				       PolicyPassword_In *in
  				       );
  typedef const struct {
      PolicyPassword_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      BYTE                    types[3];
  } PolicyPassword_COMMAND_DESCRIPTOR_t;
  PolicyPassword_COMMAND_DESCRIPTOR_t _PolicyPasswordData = {
      /* entry  */          &TPM2_PolicyPassword,
      /* inSize */          (UINT16)(sizeof(PolicyPassword_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyPassword_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyPasswordDataAddress (&_PolicyPasswordData)
  #else
  #define _PolicyPasswordDataAddress 0
  #endif
  #if CC_PolicyGetDigest == YES
  #include "PolicyGetDigest_fp.h"
  typedef TPM_RC  (PolicyGetDigest_Entry)(
  					PolicyGetDigest_In *in,
  					PolicyGetDigest_Out *out
  					);
  typedef const struct {
      PolicyGetDigest_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      BYTE                     types[4];
  } PolicyGetDigest_COMMAND_DESCRIPTOR_t;
  PolicyGetDigest_COMMAND_DESCRIPTOR_t _PolicyGetDigestData = {
      /* entry  */          &TPM2_PolicyGetDigest,
      /* inSize */          (UINT16)(sizeof(PolicyGetDigest_In)),
      /* outSize */         (UINT16)(sizeof(PolicyGetDigest_Out)),
      /* offsetOfTypes */   offsetof(PolicyGetDigest_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _PolicyGetDigestDataAddress (&_PolicyGetDigestData)
  #else
  #define _PolicyGetDigestDataAddress 0
  #endif
  #if CC_PolicyNvWritten == YES
  #include "PolicyNvWritten_fp.h"
  typedef TPM_RC  (PolicyNvWritten_Entry)(
  					PolicyNvWritten_In *in
  					);
  typedef const struct {
      PolicyNvWritten_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[1];
      BYTE                     types[4];
  } PolicyNvWritten_COMMAND_DESCRIPTOR_t;
  PolicyNvWritten_COMMAND_DESCRIPTOR_t _PolicyNvWrittenData = {
      /* entry  */          &TPM2_PolicyNvWritten,
      /* inSize */          (UINT16)(sizeof(PolicyNvWritten_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyNvWritten_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyNvWritten_In, writtenSet))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyNvWrittenDataAddress (&_PolicyNvWrittenData)
  #else
  #define _PolicyNvWrittenDataAddress 0
  #endif
  #if CC_PolicyTemplate == YES
  #include "PolicyTemplate_fp.h"
  typedef TPM_RC  (PolicyTemplate_Entry)(
  				       PolicyTemplate_In *in
  				       );
  typedef const struct {
      PolicyTemplate_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[1];
      BYTE                    types[4];
  } PolicyTemplate_COMMAND_DESCRIPTOR_t;
  PolicyTemplate_COMMAND_DESCRIPTOR_t _PolicyTemplateData = {
      /* entry  */          &TPM2_PolicyTemplate,
      /* inSize */          (UINT16)(sizeof(PolicyTemplate_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyTemplate_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyTemplate_In, templateHash))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyTemplateDataAddress (&_PolicyTemplateData)
  #else
  #define _PolicyTemplateDataAddress 0
  #endif
  #if CC_PolicyAuthorizeNV == YES
  #include "PolicyAuthorizeNV_fp.h"
  typedef TPM_RC  (PolicyAuthorizeNV_Entry)(
  					  PolicyAuthorizeNV_In *in
  					  );
  typedef const struct {
      PolicyAuthorizeNV_Entry    *entry;
      UINT16                     inSize;
      UINT16                     outSize;
      UINT16                     offsetOfTypes;
      UINT16                     paramOffsets[2];
      BYTE                       types[5];
  } PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t;
  PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t _PolicyAuthorizeNVData = {
      /* entry  */          &TPM2_PolicyAuthorizeNV,
      /* inSize */          (UINT16)(sizeof(PolicyAuthorizeNV_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PolicyAuthorizeNV_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PolicyAuthorizeNV_In, nvIndex)),
  			   (UINT16)(offsetof(PolicyAuthorizeNV_In, policySession))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPMI_SH_POLICY_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PolicyAuthorizeNVDataAddress (&_PolicyAuthorizeNVData)
  #else
  #define _PolicyAuthorizeNVDataAddress 0
  #endif
  #if CC_CreatePrimary == YES
  #include "CreatePrimary_fp.h"
  typedef TPM_RC  (CreatePrimary_Entry)(
  				      CreatePrimary_In *in,
  				      CreatePrimary_Out *out
  				      );
  typedef const struct {
      CreatePrimary_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      UINT16                 paramOffsets[9];
      BYTE                   types[13];
  } CreatePrimary_COMMAND_DESCRIPTOR_t;
  CreatePrimary_COMMAND_DESCRIPTOR_t _CreatePrimaryData = {
      /* entry  */          &TPM2_CreatePrimary,
      /* inSize */          (UINT16)(sizeof(CreatePrimary_In)),
      /* outSize */         (UINT16)(sizeof(CreatePrimary_Out)),
      /* offsetOfTypes */   offsetof(CreatePrimary_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(CreatePrimary_In, inSensitive)),
  			   (UINT16)(offsetof(CreatePrimary_In, inPublic)),
  			   (UINT16)(offsetof(CreatePrimary_In, outsideInfo)),
  			   (UINT16)(offsetof(CreatePrimary_In, creationPCR)),
  			   (UINT16)(offsetof(CreatePrimary_Out, outPublic)),
  			   (UINT16)(offsetof(CreatePrimary_Out, creationData)),
  			   (UINT16)(offsetof(CreatePrimary_Out, creationHash)),
  			   (UINT16)(offsetof(CreatePrimary_Out, creationTicket)),
  			   (UINT16)(offsetof(CreatePrimary_Out, name))},
      /* types */           {TPMI_RH_HIERARCHY_H_UNMARSHAL + ADD_FLAG,
  			   TPM2B_SENSITIVE_CREATE_P_UNMARSHAL,
  			   TPM2B_PUBLIC_P_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPML_PCR_SELECTION_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   TPM2B_PUBLIC_P_MARSHAL,
  			   TPM2B_CREATION_DATA_P_MARSHAL,
  			   TPM2B_DIGEST_P_MARSHAL,
  			   TPMT_TK_CREATION_P_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _CreatePrimaryDataAddress (&_CreatePrimaryData)
  #else
  #define _CreatePrimaryDataAddress 0
  #endif
  #if CC_HierarchyControl == YES
  #include "HierarchyControl_fp.h"
  typedef TPM_RC  (HierarchyControl_Entry)(
  					 HierarchyControl_In *in
  					 );
  typedef const struct {
      HierarchyControl_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[2];
      BYTE                      types[5];
  } HierarchyControl_COMMAND_DESCRIPTOR_t;
  HierarchyControl_COMMAND_DESCRIPTOR_t _HierarchyControlData = {
      /* entry  */          &TPM2_HierarchyControl,
      /* inSize */          (UINT16)(sizeof(HierarchyControl_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(HierarchyControl_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(HierarchyControl_In, enable)),
  			   (UINT16)(offsetof(HierarchyControl_In, state))},
      /* types */           {TPMI_RH_HIERARCHY_H_UNMARSHAL,
  			   TPMI_RH_ENABLES_P_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _HierarchyControlDataAddress (&_HierarchyControlData)
  #else
  #define _HierarchyControlDataAddress 0
  #endif
  #if CC_SetPrimaryPolicy == YES
  #include "SetPrimaryPolicy_fp.h"
  typedef TPM_RC  (SetPrimaryPolicy_Entry)(
  					 SetPrimaryPolicy_In *in
  					 );
  typedef const struct {
      SetPrimaryPolicy_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[2];
      BYTE                      types[5];
  } SetPrimaryPolicy_COMMAND_DESCRIPTOR_t;
  SetPrimaryPolicy_COMMAND_DESCRIPTOR_t _SetPrimaryPolicyData = {
      /* entry  */          &TPM2_SetPrimaryPolicy,
      /* inSize */          (UINT16)(sizeof(SetPrimaryPolicy_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(SetPrimaryPolicy_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(SetPrimaryPolicy_In, authPolicy)),
  			   (UINT16)(offsetof(SetPrimaryPolicy_In, hashAlg))},
      /* types */           {TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _SetPrimaryPolicyDataAddress (&_SetPrimaryPolicyData)
  #else
  #define _SetPrimaryPolicyDataAddress 0
  #endif
  #if CC_ChangePPS == YES
  #include "ChangePPS_fp.h"
  typedef TPM_RC  (ChangePPS_Entry)(
  				  ChangePPS_In *in
  				  );
  typedef const struct {
      ChangePPS_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[3];
  } ChangePPS_COMMAND_DESCRIPTOR_t;
  ChangePPS_COMMAND_DESCRIPTOR_t _ChangePPSData = {
      /* entry  */          &TPM2_ChangePPS,
      /* inSize */          (UINT16)(sizeof(ChangePPS_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(ChangePPS_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ChangePPSDataAddress (&_ChangePPSData)
  #else
  #define _ChangePPSDataAddress 0
  #endif
  #if CC_ChangeEPS == YES
  #include "ChangeEPS_fp.h"
  typedef TPM_RC  (ChangeEPS_Entry)(
  				  ChangeEPS_In *in
  				  );
  typedef const struct {
      ChangeEPS_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[3];
  } ChangeEPS_COMMAND_DESCRIPTOR_t;
  ChangeEPS_COMMAND_DESCRIPTOR_t _ChangeEPSData = {
      /* entry  */          &TPM2_ChangeEPS,
      /* inSize */          (UINT16)(sizeof(ChangeEPS_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(ChangeEPS_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ChangeEPSDataAddress (&_ChangeEPSData)
  #else
  #define _ChangeEPSDataAddress 0
  #endif
  #if CC_Clear == YES
  #include "Clear_fp.h"
  typedef TPM_RC  (Clear_Entry)(
  			      Clear_In *in
  			      );
  typedef const struct {
      Clear_Entry    *entry;
      UINT16         inSize;
      UINT16         outSize;
      UINT16         offsetOfTypes;
      BYTE           types[3];
  } Clear_COMMAND_DESCRIPTOR_t;
  Clear_COMMAND_DESCRIPTOR_t _ClearData = {
      /* entry  */          &TPM2_Clear,
      /* inSize */          (UINT16)(sizeof(Clear_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(Clear_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_RH_CLEAR_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ClearDataAddress (&_ClearData)
  #else
  #define _ClearDataAddress 0
  #endif
  #if CC_ClearControl == YES
  #include "ClearControl_fp.h"
  typedef TPM_RC  (ClearControl_Entry)(
  				     ClearControl_In *in
  				     );
  typedef const struct {
      ClearControl_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[1];
      BYTE                  types[4];
  } ClearControl_COMMAND_DESCRIPTOR_t;
  ClearControl_COMMAND_DESCRIPTOR_t _ClearControlData = {
      /* entry  */          &TPM2_ClearControl,
      /* inSize */          (UINT16)(sizeof(ClearControl_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(ClearControl_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ClearControl_In, disable))},
      /* types */           {TPMI_RH_CLEAR_H_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ClearControlDataAddress (&_ClearControlData)
  #else
  #define _ClearControlDataAddress 0
  #endif
  #if CC_HierarchyChangeAuth == YES
  #include "HierarchyChangeAuth_fp.h"
  typedef TPM_RC  (HierarchyChangeAuth_Entry)(
  					    HierarchyChangeAuth_In *in
  					    );
  typedef const struct {
      HierarchyChangeAuth_Entry    *entry;
      UINT16                       inSize;
      UINT16                       outSize;
      UINT16                       offsetOfTypes;
      UINT16                       paramOffsets[1];
      BYTE                         types[4];
  } HierarchyChangeAuth_COMMAND_DESCRIPTOR_t;
  HierarchyChangeAuth_COMMAND_DESCRIPTOR_t _HierarchyChangeAuthData = {
      /* entry  */          &TPM2_HierarchyChangeAuth,
      /* inSize */          (UINT16)(sizeof(HierarchyChangeAuth_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(HierarchyChangeAuth_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(HierarchyChangeAuth_In, newAuth))},
      /* types */           {TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _HierarchyChangeAuthDataAddress (&_HierarchyChangeAuthData)
  #else
  #define _HierarchyChangeAuthDataAddress 0
  #endif
  #if CC_DictionaryAttackLockReset == YES
  #include "DictionaryAttackLockReset_fp.h"
  typedef TPM_RC  (DictionaryAttackLockReset_Entry)(
  						  DictionaryAttackLockReset_In *in
  						  );
  typedef const struct {
      DictionaryAttackLockReset_Entry    *entry;
      UINT16                             inSize;
      UINT16                             outSize;
      UINT16                             offsetOfTypes;
      BYTE                               types[3];
  } DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t;
  DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t _DictionaryAttackLockResetData = {
      /* entry  */          &TPM2_DictionaryAttackLockReset,
      /* inSize */          (UINT16)(sizeof(DictionaryAttackLockReset_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(DictionaryAttackLockReset_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_RH_LOCKOUT_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _DictionaryAttackLockResetDataAddress (&_DictionaryAttackLockResetData)
  #else
  #define _DictionaryAttackLockResetDataAddress 0
  #endif
  #if CC_DictionaryAttackParameters == YES
  #include "DictionaryAttackParameters_fp.h"
  typedef TPM_RC  (DictionaryAttackParameters_Entry)(
  						   DictionaryAttackParameters_In *in
  						   );
  typedef const struct {
      DictionaryAttackParameters_Entry    *entry;
      UINT16                              inSize;
      UINT16                              outSize;
      UINT16                              offsetOfTypes;
      UINT16                              paramOffsets[3];
      BYTE                                types[6];
  } DictionaryAttackParameters_COMMAND_DESCRIPTOR_t;
  DictionaryAttackParameters_COMMAND_DESCRIPTOR_t _DictionaryAttackParametersData = {
      /* entry  */          &TPM2_DictionaryAttackParameters,
      /* inSize */          (UINT16)(sizeof(DictionaryAttackParameters_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(DictionaryAttackParameters_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(DictionaryAttackParameters_In, newMaxTries)),
  			   (UINT16)(offsetof(DictionaryAttackParameters_In, newRecoveryTime)),
  			   (UINT16)(offsetof(DictionaryAttackParameters_In, lockoutRecovery))},
      /* types */           {TPMI_RH_LOCKOUT_H_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _DictionaryAttackParametersDataAddress (&_DictionaryAttackParametersData)
  #else
  #define _DictionaryAttackParametersDataAddress 0
  #endif
  #if CC_PP_Commands == YES
  #include "PP_Commands_fp.h"
  typedef TPM_RC  (PP_Commands_Entry)(
  				    PP_Commands_In *in
  				    );
  typedef const struct {
      PP_Commands_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[2];
      BYTE                 types[5];
  } PP_Commands_COMMAND_DESCRIPTOR_t;
  PP_Commands_COMMAND_DESCRIPTOR_t _PP_CommandsData = {
      /* entry  */          &TPM2_PP_Commands,
      /* inSize */          (UINT16)(sizeof(PP_Commands_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(PP_Commands_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(PP_Commands_In, setList)),
  			   (UINT16)(offsetof(PP_Commands_In, clearList))},
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   TPML_CC_P_UNMARSHAL,
  			   TPML_CC_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _PP_CommandsDataAddress (&_PP_CommandsData)
  #else
  #define _PP_CommandsDataAddress 0
  #endif
  #if CC_SetAlgorithmSet == YES
  #include "SetAlgorithmSet_fp.h"
  typedef TPM_RC  (SetAlgorithmSet_Entry)(
  					SetAlgorithmSet_In *in
  					);
  typedef const struct {
      SetAlgorithmSet_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[1];
      BYTE                     types[4];
  } SetAlgorithmSet_COMMAND_DESCRIPTOR_t;
  SetAlgorithmSet_COMMAND_DESCRIPTOR_t _SetAlgorithmSetData = {
      /* entry  */          &TPM2_SetAlgorithmSet,
      /* inSize */          (UINT16)(sizeof(SetAlgorithmSet_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(SetAlgorithmSet_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(SetAlgorithmSet_In, algorithmSet))},
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _SetAlgorithmSetDataAddress (&_SetAlgorithmSetData)
  #else
  #define _SetAlgorithmSetDataAddress 0
  #endif
  #if CC_FieldUpgradeStart == YES
  #include "FieldUpgradeStart_fp.h"
  typedef TPM_RC  (FieldUpgradeStart_Entry)(
  					  FieldUpgradeStart_In *in
  					  );
  typedef const struct {
      FieldUpgradeStart_Entry    *entry;
      UINT16                     inSize;
      UINT16                     outSize;
      UINT16                     offsetOfTypes;
      UINT16                     paramOffsets[3];
      BYTE                       types[6];
  } FieldUpgradeStart_COMMAND_DESCRIPTOR_t;
  FieldUpgradeStart_COMMAND_DESCRIPTOR_t _FieldUpgradeStartData = {
      /* entry  */          &TPM2_FieldUpgradeStart,
      /* inSize */          (UINT16)(sizeof(FieldUpgradeStart_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(FieldUpgradeStart_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(FieldUpgradeStart_In, keyHandle)),
  			   (UINT16)(offsetof(FieldUpgradeStart_In, fuDigest)),
  			   (UINT16)(offsetof(FieldUpgradeStart_In, manifestSignature))},
      /* types */           {TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPMT_SIGNATURE_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _FieldUpgradeStartDataAddress (&_FieldUpgradeStartData)
  #else
  #define _FieldUpgradeStartDataAddress 0
  #endif
  #if CC_FieldUpgradeData == YES
  #include "FieldUpgradeData_fp.h"
  typedef TPM_RC  (FieldUpgradeData_Entry)(
  					 FieldUpgradeData_In *in,
  					 FieldUpgradeData_Out *out
  					 );
  typedef const struct {
      FieldUpgradeData_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[1];
      BYTE                      types[5];
  } FieldUpgradeData_COMMAND_DESCRIPTOR_t;
  FieldUpgradeData_COMMAND_DESCRIPTOR_t _FieldUpgradeDataData = {
      /* entry  */          &TPM2_FieldUpgradeData,
      /* inSize */          (UINT16)(sizeof(FieldUpgradeData_In)),
      /* outSize */         (UINT16)(sizeof(FieldUpgradeData_Out)),
      /* offsetOfTypes */   offsetof(FieldUpgradeData_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(FieldUpgradeData_Out, firstDigest))},
      /* types */           {TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMT_HA_P_MARSHAL,
  			   TPMT_HA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _FieldUpgradeDataDataAddress (&_FieldUpgradeDataData)
  #else
  #define _FieldUpgradeDataDataAddress 0
  #endif
  #if CC_FirmwareRead == YES
  #include "FirmwareRead_fp.h"
  typedef TPM_RC  (FirmwareRead_Entry)(
  				     FirmwareRead_In *in,
  				     FirmwareRead_Out *out
  				     );
  typedef const struct {
      FirmwareRead_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      BYTE                  types[4];
  } FirmwareRead_COMMAND_DESCRIPTOR_t;
  FirmwareRead_COMMAND_DESCRIPTOR_t _FirmwareReadData = {
      /* entry  */          &TPM2_FirmwareRead,
      /* inSize */          (UINT16)(sizeof(FirmwareRead_In)),
      /* outSize */         (UINT16)(sizeof(FirmwareRead_Out)),
      /* offsetOfTypes */   offsetof(FirmwareRead_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_MAX_BUFFER_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _FirmwareReadDataAddress (&_FirmwareReadData)
  #else
  #define _FirmwareReadDataAddress 0
  #endif
  #if CC_ContextSave == YES
  #include "ContextSave_fp.h"
  typedef TPM_RC  (ContextSave_Entry)(
  				    ContextSave_In *in,
  				    ContextSave_Out *out
  				    );
  typedef const struct {
      ContextSave_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      BYTE                 types[4];
  } ContextSave_COMMAND_DESCRIPTOR_t;
  ContextSave_COMMAND_DESCRIPTOR_t _ContextSaveData = {
      /* entry  */          &TPM2_ContextSave,
      /* inSize */          (UINT16)(sizeof(ContextSave_In)),
      /* outSize */         (UINT16)(sizeof(ContextSave_Out)),
      /* offsetOfTypes */   offsetof(ContextSave_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_DH_CONTEXT_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMS_CONTEXT_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ContextSaveDataAddress (&_ContextSaveData)
  #else
  #define _ContextSaveDataAddress 0
  #endif
  #if CC_ContextLoad == YES
  #include "ContextLoad_fp.h"
  typedef TPM_RC  (ContextLoad_Entry)(
  				    ContextLoad_In *in,
  				    ContextLoad_Out *out
  				    );
  typedef const struct {
      ContextLoad_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      BYTE                 types[4];
  } ContextLoad_COMMAND_DESCRIPTOR_t;
  ContextLoad_COMMAND_DESCRIPTOR_t _ContextLoadData = {
      /* entry  */          &TPM2_ContextLoad,
      /* inSize */          (UINT16)(sizeof(ContextLoad_In)),
      /* outSize */         (UINT16)(sizeof(ContextLoad_Out)),
      /* offsetOfTypes */   offsetof(ContextLoad_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMS_CONTEXT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT32_H_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ContextLoadDataAddress (&_ContextLoadData)
  #else
  #define _ContextLoadDataAddress 0
  #endif
  #if CC_FlushContext == YES
  #include "FlushContext_fp.h"
  typedef TPM_RC  (FlushContext_Entry)(
  				     FlushContext_In *in
  				     );
  typedef const struct {
      FlushContext_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      BYTE                  types[3];
  } FlushContext_COMMAND_DESCRIPTOR_t;
  FlushContext_COMMAND_DESCRIPTOR_t _FlushContextData = {
      /* entry  */          &TPM2_FlushContext,
      /* inSize */          (UINT16)(sizeof(FlushContext_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(FlushContext_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_DH_CONTEXT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _FlushContextDataAddress (&_FlushContextData)
  #else
  #define _FlushContextDataAddress 0
  #endif
  #if CC_EvictControl == YES
  #include "EvictControl_fp.h"
  typedef TPM_RC  (EvictControl_Entry)(
  				     EvictControl_In *in
  				     );
  typedef const struct {
      EvictControl_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[2];
      BYTE                  types[5];
  } EvictControl_COMMAND_DESCRIPTOR_t;
  EvictControl_COMMAND_DESCRIPTOR_t _EvictControlData = {
      /* entry  */          &TPM2_EvictControl,
      /* inSize */          (UINT16)(sizeof(EvictControl_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(EvictControl_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(EvictControl_In, objectHandle)),
  			   (UINT16)(offsetof(EvictControl_In, persistentHandle))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_DH_PERSISTENT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _EvictControlDataAddress (&_EvictControlData)
  #else
  #define _EvictControlDataAddress 0
  #endif
  #if CC_ReadClock == YES
  #include "ReadClock_fp.h"
  typedef TPM_RC  (ReadClock_Entry)(
  				  ReadClock_Out *out
  				  );
  typedef const struct {
      ReadClock_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[3];
  } ReadClock_COMMAND_DESCRIPTOR_t;
  ReadClock_COMMAND_DESCRIPTOR_t _ReadClockData = {
      /* entry  */          &TPM2_ReadClock,
      /* inSize */          0,
      /* outSize */         (UINT16)(sizeof(ReadClock_Out)),
      /* offsetOfTypes */   offsetof(ReadClock_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {END_OF_LIST,
  			   TPMS_TIME_INFO_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _ReadClockDataAddress (&_ReadClockData)
  #else
  #define _ReadClockDataAddress 0
  #endif
  #if CC_ClockSet == YES
  #include "ClockSet_fp.h"
  typedef TPM_RC  (ClockSet_Entry)(
  				 ClockSet_In *in
  				 );
  typedef const struct {
      ClockSet_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      UINT16            paramOffsets[1];
      BYTE              types[4];
  } ClockSet_COMMAND_DESCRIPTOR_t;
  ClockSet_COMMAND_DESCRIPTOR_t _ClockSetData = {
      /* entry  */          &TPM2_ClockSet,
      /* inSize */          (UINT16)(sizeof(ClockSet_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(ClockSet_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ClockSet_In, newTime))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   UINT64_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ClockSetDataAddress (&_ClockSetData)
  #else
  #define _ClockSetDataAddress 0
  #endif
  #if CC_ClockRateAdjust == YES
  #include "ClockRateAdjust_fp.h"
  typedef TPM_RC  (ClockRateAdjust_Entry)(
  					ClockRateAdjust_In *in
  					);
  typedef const struct {
      ClockRateAdjust_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      UINT16                   paramOffsets[1];
      BYTE                     types[4];
  } ClockRateAdjust_COMMAND_DESCRIPTOR_t;
  ClockRateAdjust_COMMAND_DESCRIPTOR_t _ClockRateAdjustData = {
      /* entry  */          &TPM2_ClockRateAdjust,
      /* inSize */          (UINT16)(sizeof(ClockRateAdjust_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(ClockRateAdjust_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(ClockRateAdjust_In, rateAdjust))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   TPM_CLOCK_ADJUST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _ClockRateAdjustDataAddress (&_ClockRateAdjustData)
  #else
  #define _ClockRateAdjustDataAddress 0
  #endif
  #if CC_GetCapability == YES
  #include "GetCapability_fp.h"
  typedef TPM_RC  (GetCapability_Entry)(
  				      GetCapability_In *in,
  				      GetCapability_Out *out
  				      );
  typedef const struct {
      GetCapability_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      UINT16                 paramOffsets[3];
      BYTE                   types[7];
  } GetCapability_COMMAND_DESCRIPTOR_t;
  GetCapability_COMMAND_DESCRIPTOR_t _GetCapabilityData = {
      /* entry  */          &TPM2_GetCapability,
      /* inSize */          (UINT16)(sizeof(GetCapability_In)),
      /* outSize */         (UINT16)(sizeof(GetCapability_Out)),
      /* offsetOfTypes */   offsetof(GetCapability_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(GetCapability_In, property)),
  			   (UINT16)(offsetof(GetCapability_In, propertyCount)),
  			   (UINT16)(offsetof(GetCapability_Out, capabilityData))},
      /* types */           {TPM_CAP_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT8_P_MARSHAL,
  			   TPMS_CAPABILITY_DATA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _GetCapabilityDataAddress (&_GetCapabilityData)
  #else
  #define _GetCapabilityDataAddress 0
  #endif
  #if CC_TestParms == YES
  #include "TestParms_fp.h"
  typedef TPM_RC  (TestParms_Entry)(
  				  TestParms_In *in
  				  );
  typedef const struct {
      TestParms_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      BYTE               types[3];
  } TestParms_COMMAND_DESCRIPTOR_t;
  TestParms_COMMAND_DESCRIPTOR_t _TestParmsData = {
      /* entry  */          &TPM2_TestParms,
      /* inSize */          (UINT16)(sizeof(TestParms_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(TestParms_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMT_PUBLIC_PARMS_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _TestParmsDataAddress (&_TestParmsData)
  #else
  #define _TestParmsDataAddress 0
  #endif
  #if CC_NV_DefineSpace == YES
  #include "NV_DefineSpace_fp.h"
  typedef TPM_RC  (NV_DefineSpace_Entry)(
  				       NV_DefineSpace_In *in
  				       );
  typedef const struct {
      NV_DefineSpace_Entry    *entry;
      UINT16                  inSize;
      UINT16                  outSize;
      UINT16                  offsetOfTypes;
      UINT16                  paramOffsets[2];
      BYTE                    types[5];
  } NV_DefineSpace_COMMAND_DESCRIPTOR_t;
  NV_DefineSpace_COMMAND_DESCRIPTOR_t _NV_DefineSpaceData = {
      /* entry  */          &TPM2_NV_DefineSpace,
      /* inSize */          (UINT16)(sizeof(NV_DefineSpace_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_DefineSpace_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_DefineSpace_In, auth)),
  			   (UINT16)(offsetof(NV_DefineSpace_In, publicInfo))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   TPM2B_NV_PUBLIC_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_DefineSpaceDataAddress (&_NV_DefineSpaceData)
  #else
  #define _NV_DefineSpaceDataAddress 0
  #endif
  #if CC_NV_UndefineSpace == YES
  #include "NV_UndefineSpace_fp.h"
  typedef TPM_RC  (NV_UndefineSpace_Entry)(
  					 NV_UndefineSpace_In *in
  					 );
  typedef const struct {
      NV_UndefineSpace_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[1];
      BYTE                      types[4];
  } NV_UndefineSpace_COMMAND_DESCRIPTOR_t;
  NV_UndefineSpace_COMMAND_DESCRIPTOR_t _NV_UndefineSpaceData = {
      /* entry  */          &TPM2_NV_UndefineSpace,
      /* inSize */          (UINT16)(sizeof(NV_UndefineSpace_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_UndefineSpace_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_UndefineSpace_In, nvIndex))},
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_UndefineSpaceDataAddress (&_NV_UndefineSpaceData)
  #else
  #define _NV_UndefineSpaceDataAddress 0
  #endif
  #if CC_NV_UndefineSpaceSpecial == YES
  #include "NV_UndefineSpaceSpecial_fp.h"
  typedef TPM_RC  (NV_UndefineSpaceSpecial_Entry)(
  						NV_UndefineSpaceSpecial_In *in
  						);
  typedef const struct {
      NV_UndefineSpaceSpecial_Entry    *entry;
      UINT16                           inSize;
      UINT16                           outSize;
      UINT16                           offsetOfTypes;
      UINT16                           paramOffsets[1];
      BYTE                             types[4];
  } NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t;
  NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t _NV_UndefineSpaceSpecialData = {
      /* entry  */          &TPM2_NV_UndefineSpaceSpecial,
      /* inSize */          (UINT16)(sizeof(NV_UndefineSpaceSpecial_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_UndefineSpaceSpecial_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_UndefineSpaceSpecial_In, platform))},
      /* types */           {TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPMI_RH_PLATFORM_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_UndefineSpaceSpecialDataAddress (&_NV_UndefineSpaceSpecialData)
  #else
  #define _NV_UndefineSpaceSpecialDataAddress 0
  #endif
  #if CC_NV_ReadPublic == YES
  #include "NV_ReadPublic_fp.h"
  typedef TPM_RC  (NV_ReadPublic_Entry)(
  				      NV_ReadPublic_In *in,
  				      NV_ReadPublic_Out *out
  				      );
  typedef const struct {
      NV_ReadPublic_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      UINT16                 paramOffsets[1];
      BYTE                   types[5];
  } NV_ReadPublic_COMMAND_DESCRIPTOR_t;
  NV_ReadPublic_COMMAND_DESCRIPTOR_t _NV_ReadPublicData = {
      /* entry  */          &TPM2_NV_ReadPublic,
      /* inSize */          (UINT16)(sizeof(NV_ReadPublic_In)),
      /* outSize */         (UINT16)(sizeof(NV_ReadPublic_Out)),
      /* offsetOfTypes */   offsetof(NV_ReadPublic_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_ReadPublic_Out, nvName))},
      /* types */           {TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_NV_PUBLIC_P_MARSHAL,
  			   TPM2B_NAME_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _NV_ReadPublicDataAddress (&_NV_ReadPublicData)
  #else
  #define _NV_ReadPublicDataAddress 0
  #endif
  #if CC_NV_Write == YES
  #include "NV_Write_fp.h"
  typedef TPM_RC  (NV_Write_Entry)(
  				 NV_Write_In *in
  				 );
  typedef const struct {
      NV_Write_Entry    *entry;
      UINT16            inSize;
      UINT16            outSize;
      UINT16            offsetOfTypes;
      UINT16            paramOffsets[3];
      BYTE              types[6];
  } NV_Write_COMMAND_DESCRIPTOR_t;
  NV_Write_COMMAND_DESCRIPTOR_t _NV_WriteData = {
      /* entry  */          &TPM2_NV_Write,
      /* inSize */          (UINT16)(sizeof(NV_Write_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_Write_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_Write_In, nvIndex)),
  			   (UINT16)(offsetof(NV_Write_In, data)),
  			   (UINT16)(offsetof(NV_Write_In, offset))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPM2B_MAX_NV_BUFFER_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_WriteDataAddress (&_NV_WriteData)
  #else
  #define _NV_WriteDataAddress 0
  #endif
  #if CC_NV_Increment == YES
  #include "NV_Increment_fp.h"
  typedef TPM_RC  (NV_Increment_Entry)(
  				     NV_Increment_In *in
  				     );
  typedef const struct {
      NV_Increment_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[1];
      BYTE                  types[4];
  } NV_Increment_COMMAND_DESCRIPTOR_t;
  NV_Increment_COMMAND_DESCRIPTOR_t _NV_IncrementData = {
      /* entry  */          &TPM2_NV_Increment,
      /* inSize */          (UINT16)(sizeof(NV_Increment_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_Increment_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_Increment_In, nvIndex))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_IncrementDataAddress (&_NV_IncrementData)
  #else
  #define _NV_IncrementDataAddress 0
  #endif
  #if CC_NV_Extend == YES
  #include "NV_Extend_fp.h"
  typedef TPM_RC  (NV_Extend_Entry)(
  				  NV_Extend_In *in
  				  );
  typedef const struct {
      NV_Extend_Entry    *entry;
      UINT16             inSize;
      UINT16             outSize;
      UINT16             offsetOfTypes;
      UINT16             paramOffsets[2];
      BYTE               types[5];
  } NV_Extend_COMMAND_DESCRIPTOR_t;
  NV_Extend_COMMAND_DESCRIPTOR_t _NV_ExtendData = {
      /* entry  */          &TPM2_NV_Extend,
      /* inSize */          (UINT16)(sizeof(NV_Extend_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_Extend_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_Extend_In, nvIndex)),
  			   (UINT16)(offsetof(NV_Extend_In, data))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPM2B_MAX_NV_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_ExtendDataAddress (&_NV_ExtendData)
  #else
  #define _NV_ExtendDataAddress 0
  #endif
  #if CC_NV_SetBits == YES
  #include "NV_SetBits_fp.h"
  typedef TPM_RC  (NV_SetBits_Entry)(
  				   NV_SetBits_In *in
  				   );
  typedef const struct {
      NV_SetBits_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      UINT16              paramOffsets[2];
      BYTE                types[5];
  } NV_SetBits_COMMAND_DESCRIPTOR_t;
  NV_SetBits_COMMAND_DESCRIPTOR_t _NV_SetBitsData = {
      /* entry  */          &TPM2_NV_SetBits,
      /* inSize */          (UINT16)(sizeof(NV_SetBits_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_SetBits_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_SetBits_In, nvIndex)),
  			   (UINT16)(offsetof(NV_SetBits_In, bits))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   UINT64_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_SetBitsDataAddress (&_NV_SetBitsData)
  #else
  #define _NV_SetBitsDataAddress 0
  #endif
  #if CC_NV_WriteLock == YES
  #include "NV_WriteLock_fp.h"
  typedef TPM_RC  (NV_WriteLock_Entry)(
  				     NV_WriteLock_In *in
  				     );
  typedef const struct {
      NV_WriteLock_Entry    *entry;
      UINT16                inSize;
      UINT16                outSize;
      UINT16                offsetOfTypes;
      UINT16                paramOffsets[1];
      BYTE                  types[4];
  } NV_WriteLock_COMMAND_DESCRIPTOR_t;
  NV_WriteLock_COMMAND_DESCRIPTOR_t _NV_WriteLockData = {
      /* entry  */          &TPM2_NV_WriteLock,
      /* inSize */          (UINT16)(sizeof(NV_WriteLock_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_WriteLock_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_WriteLock_In, nvIndex))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_WriteLockDataAddress (&_NV_WriteLockData)
  #else
  #define _NV_WriteLockDataAddress 0
  #endif
  #if CC_NV_GlobalWriteLock == YES
  #include "NV_GlobalWriteLock_fp.h"
  typedef TPM_RC  (NV_GlobalWriteLock_Entry)(
  					   NV_GlobalWriteLock_In *in
  					   );
  typedef const struct {
      NV_GlobalWriteLock_Entry    *entry;
      UINT16                      inSize;
      UINT16                      outSize;
      UINT16                      offsetOfTypes;
      BYTE                        types[3];
  } NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t;
  NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t _NV_GlobalWriteLockData = {
      /* entry  */          &TPM2_NV_GlobalWriteLock,
      /* inSize */          (UINT16)(sizeof(NV_GlobalWriteLock_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_GlobalWriteLock_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPMI_RH_PROVISION_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_GlobalWriteLockDataAddress (&_NV_GlobalWriteLockData)
  #else
  #define _NV_GlobalWriteLockDataAddress 0
  #endif
  #if CC_NV_Read == YES
  #include "NV_Read_fp.h"
  typedef TPM_RC  (NV_Read_Entry)(
  				NV_Read_In *in,
  				NV_Read_Out *out
  				);
  typedef const struct {
      NV_Read_Entry    *entry;
      UINT16           inSize;
      UINT16           outSize;
      UINT16           offsetOfTypes;
      UINT16           paramOffsets[3];
      BYTE             types[7];
  } NV_Read_COMMAND_DESCRIPTOR_t;
  NV_Read_COMMAND_DESCRIPTOR_t _NV_ReadData = {
      /* entry  */          &TPM2_NV_Read,
      /* inSize */          (UINT16)(sizeof(NV_Read_In)),
      /* outSize */         (UINT16)(sizeof(NV_Read_Out)),
      /* offsetOfTypes */   offsetof(NV_Read_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_Read_In, nvIndex)),
  			   (UINT16)(offsetof(NV_Read_In, size)),
  			   (UINT16)(offsetof(NV_Read_In, offset))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_MAX_NV_BUFFER_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _NV_ReadDataAddress (&_NV_ReadData)
  #else
  #define _NV_ReadDataAddress 0
  #endif
  #if CC_NV_ReadLock == YES
  #include "NV_ReadLock_fp.h"
  typedef TPM_RC  (NV_ReadLock_Entry)(
  				    NV_ReadLock_In *in
  				    );
  typedef const struct {
      NV_ReadLock_Entry    *entry;
      UINT16               inSize;
      UINT16               outSize;
      UINT16               offsetOfTypes;
      UINT16               paramOffsets[1];
      BYTE                 types[4];
  } NV_ReadLock_COMMAND_DESCRIPTOR_t;
  NV_ReadLock_COMMAND_DESCRIPTOR_t _NV_ReadLockData = {
      /* entry  */          &TPM2_NV_ReadLock,
      /* inSize */          (UINT16)(sizeof(NV_ReadLock_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_ReadLock_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_ReadLock_In, nvIndex))},
      /* types */           {TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_ReadLockDataAddress (&_NV_ReadLockData)
  #else
  #define _NV_ReadLockDataAddress 0
  #endif
  #if CC_NV_ChangeAuth == YES
  #include "NV_ChangeAuth_fp.h"
  typedef TPM_RC  (NV_ChangeAuth_Entry)(
  				      NV_ChangeAuth_In *in
  				      );
  typedef const struct {
      NV_ChangeAuth_Entry    *entry;
      UINT16                 inSize;
      UINT16                 outSize;
      UINT16                 offsetOfTypes;
      UINT16                 paramOffsets[1];
      BYTE                   types[4];
  } NV_ChangeAuth_COMMAND_DESCRIPTOR_t;
  NV_ChangeAuth_COMMAND_DESCRIPTOR_t _NV_ChangeAuthData = {
      /* entry  */          &TPM2_NV_ChangeAuth,
      /* inSize */          (UINT16)(sizeof(NV_ChangeAuth_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NV_ChangeAuth_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_ChangeAuth_In, newAuth))},
      /* types */           {TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPM2B_DIGEST_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _NV_ChangeAuthDataAddress (&_NV_ChangeAuthData)
  #else
  #define _NV_ChangeAuthDataAddress 0
  #endif
  #if CC_NV_Certify == YES
  #include "NV_Certify_fp.h"
  typedef TPM_RC  (NV_Certify_Entry)(
  				   NV_Certify_In *in,
  				   NV_Certify_Out *out
  				   );
  typedef const struct {
      NV_Certify_Entry    *entry;
      UINT16              inSize;
      UINT16              outSize;
      UINT16              offsetOfTypes;
      UINT16              paramOffsets[7];
      BYTE                types[11];
  } NV_Certify_COMMAND_DESCRIPTOR_t;
  NV_Certify_COMMAND_DESCRIPTOR_t _NV_CertifyData = {
      /* entry  */          &TPM2_NV_Certify,
      /* inSize */          (UINT16)(sizeof(NV_Certify_In)),
      /* outSize */         (UINT16)(sizeof(NV_Certify_Out)),
      /* offsetOfTypes */   offsetof(NV_Certify_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(NV_Certify_In, authHandle)),
  			   (UINT16)(offsetof(NV_Certify_In, nvIndex)),
  			   (UINT16)(offsetof(NV_Certify_In, qualifyingData)),
  			   (UINT16)(offsetof(NV_Certify_In, inScheme)),
  			   (UINT16)(offsetof(NV_Certify_In, size)),
  			   (UINT16)(offsetof(NV_Certify_In, offset)),
  			   (UINT16)(offsetof(NV_Certify_Out, signature))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL + ADD_FLAG,
  			   TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_NV_INDEX_H_UNMARSHAL,
  			   TPM2B_DATA_P_UNMARSHAL,
  			   TPMT_SIG_SCHEME_P_UNMARSHAL + ADD_FLAG,
  			   UINT16_P_UNMARSHAL,
  			   UINT16_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_ATTEST_P_MARSHAL,
  			   TPMT_SIGNATURE_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _NV_CertifyDataAddress (&_NV_CertifyData)
  #else
  #define _NV_CertifyDataAddress 0
  #endif
  #if CC_AC_GetCapability == YES
  #include "AC_GetCapability_fp.h"
  typedef TPM_RC  (AC_GetCapability_Entry)(
  					 AC_GetCapability_In *in,
  					 AC_GetCapability_Out *out
  					 );
  typedef const struct {
      AC_GetCapability_Entry    *entry;
      UINT16                    inSize;
      UINT16                    outSize;
      UINT16                    offsetOfTypes;
      UINT16                    paramOffsets[3];
      BYTE                      types[7];
  } AC_GetCapability_COMMAND_DESCRIPTOR_t;
  AC_GetCapability_COMMAND_DESCRIPTOR_t _AC_GetCapabilityData = {
      /* entry  */          &TPM2_AC_GetCapability,
      /* inSize */          (UINT16)(sizeof(AC_GetCapability_In)),
      /* outSize */         (UINT16)(sizeof(AC_GetCapability_Out)),
      /* offsetOfTypes */   offsetof(AC_GetCapability_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(AC_GetCapability_In, capability)),
  			   (UINT16)(offsetof(AC_GetCapability_In, count)),
  			   (UINT16)(offsetof(AC_GetCapability_Out, capabilitiesData))},
      /* types */           {TPMI_RH_AC_H_UNMARSHAL,
  			   TPM_AT_P_UNMARSHAL,
  			   UINT32_P_UNMARSHAL,
  			   END_OF_LIST,
  			   UINT8_P_MARSHAL,
  			   TPML_AC_CAPABILITIES_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _AC_GetCapabilityDataAddress (&_AC_GetCapabilityData)
  #else
  #define _AC_GetCapabilityDataAddress 0
  #endif
  #if CC_AC_Send == YES
  #include "AC_Send_fp.h"
  typedef TPM_RC  (AC_Send_Entry)(
  				AC_Send_In *in,
  				AC_Send_Out *out
  				);
  typedef const struct {
      AC_Send_Entry    *entry;
      UINT16           inSize;
      UINT16           outSize;
      UINT16           offsetOfTypes;
      UINT16           paramOffsets[3];
      BYTE             types[7];
  } AC_Send_COMMAND_DESCRIPTOR_t;
  AC_Send_COMMAND_DESCRIPTOR_t _AC_SendData = {
      /* entry  */          &TPM2_AC_Send,
      /* inSize */          (UINT16)(sizeof(AC_Send_In)),
      /* outSize */         (UINT16)(sizeof(AC_Send_Out)),
      /* offsetOfTypes */   offsetof(AC_Send_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(AC_Send_In, authHandle)),
  			   (UINT16)(offsetof(AC_Send_In, ac)),
  			   (UINT16)(offsetof(AC_Send_In, acDataIn))},
      /* types */           {TPMI_DH_OBJECT_H_UNMARSHAL,
  			   TPMI_RH_NV_AUTH_H_UNMARSHAL,
  			   TPMI_RH_AC_H_UNMARSHAL,
  			   TPM2B_MAX_BUFFER_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPMS_AC_OUTPUT_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _AC_SendDataAddress (&_AC_SendData)
  #else
  #define _AC_SendDataAddress 0
  #endif
  #if CC_Policy_AC_SendSelect == YES
  #include "Policy_AC_SendSelect_fp.h"
  typedef TPM_RC  (Policy_AC_SendSelect_Entry)(
  					     Policy_AC_SendSelect_In *in
  					     );
  typedef const struct {
      Policy_AC_SendSelect_Entry    *entry;
      UINT16                        inSize;
      UINT16                        outSize;
      UINT16                        offsetOfTypes;
      UINT16                        paramOffsets[4];
      BYTE                          types[7];
  } Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t;
  Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t _Policy_AC_SendSelectData = {
      /* entry  */          &TPM2_Policy_AC_SendSelect,
      /* inSize */          (UINT16)(sizeof(Policy_AC_SendSelect_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(Policy_AC_SendSelect_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         {(UINT16)(offsetof(Policy_AC_SendSelect_In, objectName)),
  			   (UINT16)(offsetof(Policy_AC_SendSelect_In, authHandleName)),
  			   (UINT16)(offsetof(Policy_AC_SendSelect_In, acName)),
  			   (UINT16)(offsetof(Policy_AC_SendSelect_In, includeObject))},
      /* types */           {TPMI_SH_POLICY_H_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPM2B_NAME_P_UNMARSHAL,
  			   TPMI_YES_NO_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  #define _Policy_AC_SendSelectDataAddress (&_Policy_AC_SendSelectData)
  #else
  #define _Policy_AC_SendSelectDataAddress 0
  #endif
  #if CC_Vendor_TCG_Test == YES
  #include "Vendor_TCG_Test_fp.h"
  typedef TPM_RC  (Vendor_TCG_Test_Entry)(
  					Vendor_TCG_Test_In *in,
  					Vendor_TCG_Test_Out *out
  					);
  typedef const struct {
      Vendor_TCG_Test_Entry    *entry;
      UINT16                   inSize;
      UINT16                   outSize;
      UINT16                   offsetOfTypes;
      BYTE                     types[4];
  } Vendor_TCG_Test_COMMAND_DESCRIPTOR_t;
  Vendor_TCG_Test_COMMAND_DESCRIPTOR_t _Vendor_TCG_TestData = {
      /* entry  */          &TPM2_Vendor_TCG_Test,
      /* inSize */          (UINT16)(sizeof(Vendor_TCG_Test_In)),
      /* outSize */         (UINT16)(sizeof(Vendor_TCG_Test_Out)),
      /* offsetOfTypes */   offsetof(Vendor_TCG_Test_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {TPM2B_DATA_P_UNMARSHAL,
  			   END_OF_LIST,
  			   TPM2B_DATA_P_MARSHAL,
  			   END_OF_LIST}
  };
  #define _Vendor_TCG_TestDataAddress (&_Vendor_TCG_TestData)
  #else
  #define _Vendor_TCG_TestDataAddress 0
  #endif
  
  #ifdef TPM_NUVOTON
  
  typedef TPM_RC (NTC2_PreConfig_Entry) (
  				       NTC2_PreConfig_In *in
  				       );
  
  typedef const struct {
      NTC2_PreConfig_Entry    	*entry;
      UINT16           		inSize;
      UINT16           		outSize;
      UINT16           		offsetOfTypes;
      BYTE             		types[3];
  } NTC2_PreConfig_COMMAND_DESCRIPTOR_t;
  
  NTC2_PreConfig_COMMAND_DESCRIPTOR_t _NTC2_PreConfigData = {
      /* entry  */          &NTC2_PreConfig,
      /* inSize */          (UINT16)(sizeof(NTC2_PreConfig_In)),
      /* outSize */         0,
      /* offsetOfTypes */   offsetof(NTC2_PreConfig_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */           {NTC2_CFG_STRUCT_P_UNMARSHAL,
  			   END_OF_LIST,
  			   END_OF_LIST}
  };
  
  #define _NTC2_PreConfigDataAddress (&_NTC2_PreConfigData)
  
  typedef TPM_RC (NTC2_LockPreConfig_Entry) ();
  				   
  typedef const struct {
      NTC2_LockPreConfig_Entry    *entry;
      UINT16           		inSize;
      UINT16           		outSize;
      UINT16             		offsetOfTypes;
      BYTE                        types[2];
  } NTC2_LockPreConfig_COMMAND_DESCRIPTOR_t;
  
  NTC2_LockPreConfig_COMMAND_DESCRIPTOR_t _NTC2_LockPreConfigData = {
      /* entry */		&NTC2_LockPreConfig,
      /* inSize */        0,
      /* outSize */       0,
      /* offsetOfTypes */ offsetof(NTC2_LockPreConfig_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */         {END_OF_LIST,
  			 END_OF_LIST}
  };
  
  #define _NTC2_LockPreConfigDataAddress (&_NTC2_LockPreConfigData)
  
  typedef TPM_RC (NTC2_GetConfig_Entry) (
  				       NTC2_GetConfig_Out *out
  				       );
  typedef const struct {
      NTC2_GetConfig_Entry	*entry;
      UINT16             		inSize;
      UINT16             		outSize;
      UINT16             		offsetOfTypes;
      BYTE               		types[3];
  } NTC2_GetConfig_COMMAND_DESCRIPTOR_t;
  
  NTC2_GetConfig_COMMAND_DESCRIPTOR_t _NTC2_GetConfigData = {
      /* entry */		&NTC2_GetConfig,
      /* inSize */        0,
      /* outSize */       (UINT16)(sizeof(NTC2_GetConfig_Out)),
      /* offsetOfTypes */ offsetof(NTC2_GetConfig_COMMAND_DESCRIPTOR_t, types),
      /* offsets */         // No parameter offsets
      /* types */         {END_OF_LIST,
  			 NTC2_CFG_STRUCT_P_MARSHAL,
  			 END_OF_LIST}
  };
  
  #define _NTC2_GetConfigDataAddress (&_NTC2_GetConfigData)
  
  #else
  #define _NTC2_PreConfigDataAddress 0
  #define _NTC2_LockPreConfigDataAddress 0
  #define _NTC2_GetConfigDataAddress 0
  #endif		/* TPM_NUVOTON */
  
  COMMAND_DESCRIPTOR_t *s_CommandDataArray[] = {
  #if (PAD_LIST || CC_NV_UndefineSpaceSpecial)
      (COMMAND_DESCRIPTOR_t *)_NV_UndefineSpaceSpecialDataAddress,
  #endif
  #if (PAD_LIST || CC_EvictControl)
      (COMMAND_DESCRIPTOR_t *)_EvictControlDataAddress,
  #endif
  #if (PAD_LIST || CC_HierarchyControl)
      (COMMAND_DESCRIPTOR_t *)_HierarchyControlDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_UndefineSpace)
      (COMMAND_DESCRIPTOR_t *)_NV_UndefineSpaceDataAddress,
  #endif
  #if (PAD_LIST)
      (COMMAND_DESCRIPTOR_t *)0,
  #endif
  #if (PAD_LIST || CC_ChangeEPS)
      (COMMAND_DESCRIPTOR_t *)_ChangeEPSDataAddress,
  #endif
  #if (PAD_LIST || CC_ChangePPS)
      (COMMAND_DESCRIPTOR_t *)_ChangePPSDataAddress,
  #endif
  #if (PAD_LIST || CC_Clear)
      (COMMAND_DESCRIPTOR_t *)_ClearDataAddress,
  #endif
  #if (PAD_LIST || CC_ClearControl)
      (COMMAND_DESCRIPTOR_t *)_ClearControlDataAddress,
  #endif
  #if (PAD_LIST || CC_ClockSet)
      (COMMAND_DESCRIPTOR_t *)_ClockSetDataAddress,
  #endif
  #if (PAD_LIST || CC_HierarchyChangeAuth)
      (COMMAND_DESCRIPTOR_t *)_HierarchyChangeAuthDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_DefineSpace)
      (COMMAND_DESCRIPTOR_t *)_NV_DefineSpaceDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_Allocate)
      (COMMAND_DESCRIPTOR_t *)_PCR_AllocateDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_SetAuthPolicy)
      (COMMAND_DESCRIPTOR_t *)_PCR_SetAuthPolicyDataAddress,
  #endif
  #if (PAD_LIST || CC_PP_Commands)
      (COMMAND_DESCRIPTOR_t *)_PP_CommandsDataAddress,
  #endif
  #if (PAD_LIST || CC_SetPrimaryPolicy)
      (COMMAND_DESCRIPTOR_t *)_SetPrimaryPolicyDataAddress,
  #endif
  #if (PAD_LIST || CC_FieldUpgradeStart)
      (COMMAND_DESCRIPTOR_t *)_FieldUpgradeStartDataAddress,
  #endif
  #if (PAD_LIST || CC_ClockRateAdjust)
      (COMMAND_DESCRIPTOR_t *)_ClockRateAdjustDataAddress,
  #endif
  #if (PAD_LIST || CC_CreatePrimary)
      (COMMAND_DESCRIPTOR_t *)_CreatePrimaryDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_GlobalWriteLock)
      (COMMAND_DESCRIPTOR_t *)_NV_GlobalWriteLockDataAddress,
  #endif
  #if (PAD_LIST || CC_GetCommandAuditDigest)
      (COMMAND_DESCRIPTOR_t *)_GetCommandAuditDigestDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_Increment)
      (COMMAND_DESCRIPTOR_t *)_NV_IncrementDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_SetBits)
      (COMMAND_DESCRIPTOR_t *)_NV_SetBitsDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_Extend)
      (COMMAND_DESCRIPTOR_t *)_NV_ExtendDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_Write)
      (COMMAND_DESCRIPTOR_t *)_NV_WriteDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_WriteLock)
      (COMMAND_DESCRIPTOR_t *)_NV_WriteLockDataAddress,
  #endif
  #if (PAD_LIST || CC_DictionaryAttackLockReset)
      (COMMAND_DESCRIPTOR_t *)_DictionaryAttackLockResetDataAddress,
  #endif
  #if (PAD_LIST || CC_DictionaryAttackParameters)
      (COMMAND_DESCRIPTOR_t *)_DictionaryAttackParametersDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_ChangeAuth)
      (COMMAND_DESCRIPTOR_t *)_NV_ChangeAuthDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_Event)
      (COMMAND_DESCRIPTOR_t *)_PCR_EventDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_Reset)
      (COMMAND_DESCRIPTOR_t *)_PCR_ResetDataAddress,
  #endif
  #if (PAD_LIST || CC_SequenceComplete)
      (COMMAND_DESCRIPTOR_t *)_SequenceCompleteDataAddress,
  #endif
  #if (PAD_LIST || CC_SetAlgorithmSet)
      (COMMAND_DESCRIPTOR_t *)_SetAlgorithmSetDataAddress,
  #endif
  #if (PAD_LIST || CC_SetCommandCodeAuditStatus)
      (COMMAND_DESCRIPTOR_t *)_SetCommandCodeAuditStatusDataAddress,
  #endif
  #if (PAD_LIST || CC_FieldUpgradeData)
      (COMMAND_DESCRIPTOR_t *)_FieldUpgradeDataDataAddress,
  #endif
  #if (PAD_LIST || CC_IncrementalSelfTest)
      (COMMAND_DESCRIPTOR_t *)_IncrementalSelfTestDataAddress,
  #endif
  #if (PAD_LIST || CC_SelfTest)
      (COMMAND_DESCRIPTOR_t *)_SelfTestDataAddress,
  #endif
  #if (PAD_LIST || CC_Startup)
      (COMMAND_DESCRIPTOR_t *)_StartupDataAddress,
  #endif
  #if (PAD_LIST || CC_Shutdown)
      (COMMAND_DESCRIPTOR_t *)_ShutdownDataAddress,
  #endif
  #if (PAD_LIST || CC_StirRandom)
      (COMMAND_DESCRIPTOR_t *)_StirRandomDataAddress,
  #endif
  #if (PAD_LIST || CC_ActivateCredential)
      (COMMAND_DESCRIPTOR_t *)_ActivateCredentialDataAddress,
  #endif
  #if (PAD_LIST || CC_Certify)
      (COMMAND_DESCRIPTOR_t *)_CertifyDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyNV)
      (COMMAND_DESCRIPTOR_t *)_PolicyNVDataAddress,
  #endif
  #if (PAD_LIST || CC_CertifyCreation)
      (COMMAND_DESCRIPTOR_t *)_CertifyCreationDataAddress,
  #endif
  #if (PAD_LIST || CC_Duplicate)
      (COMMAND_DESCRIPTOR_t *)_DuplicateDataAddress,
  #endif
  #if (PAD_LIST || CC_GetTime)
      (COMMAND_DESCRIPTOR_t *)_GetTimeDataAddress,
  #endif
  #if (PAD_LIST || CC_GetSessionAuditDigest)
      (COMMAND_DESCRIPTOR_t *)_GetSessionAuditDigestDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_Read)
      (COMMAND_DESCRIPTOR_t *)_NV_ReadDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_ReadLock)
      (COMMAND_DESCRIPTOR_t *)_NV_ReadLockDataAddress,
  #endif
  #if (PAD_LIST || CC_ObjectChangeAuth)
      (COMMAND_DESCRIPTOR_t *)_ObjectChangeAuthDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicySecret)
      (COMMAND_DESCRIPTOR_t *)_PolicySecretDataAddress,
  #endif
  #if (PAD_LIST || CC_Rewrap)
      (COMMAND_DESCRIPTOR_t *)_RewrapDataAddress,
  #endif
  #if (PAD_LIST || CC_Create)
      (COMMAND_DESCRIPTOR_t *)_CreateDataAddress,
  #endif
  #if (PAD_LIST || CC_ECDH_ZGen)
      (COMMAND_DESCRIPTOR_t *)_ECDH_ZGenDataAddress,
  #endif
  #if (PAD_LIST || (CC_HMAC || CC_MAC))
  #    if CC_HMAC
      (COMMAND_DESCRIPTOR_t *)_HMACDataAddress,
  #    endif
  #    if CC_MAC
      (COMMAND_DESCRIPTOR_t *)_MACDataAddress,
  #    endif
  #    if (CC_HMAC || CC_MAC) > 1
  #        error "More than one aliased command defined"
  #    endif
  #endif // CC_HMAC CC_MAC
  #if (PAD_LIST || CC_Import)
      (COMMAND_DESCRIPTOR_t *)_ImportDataAddress,
  #endif
  #if (PAD_LIST || CC_Load)
      (COMMAND_DESCRIPTOR_t *)_LoadDataAddress,
  #endif
  #if (PAD_LIST || CC_Quote)
      (COMMAND_DESCRIPTOR_t *)_QuoteDataAddress,
  #endif
  #if (PAD_LIST || CC_RSA_Decrypt)
      (COMMAND_DESCRIPTOR_t *)_RSA_DecryptDataAddress,
  #endif
  #if (PAD_LIST)
      (COMMAND_DESCRIPTOR_t *)0,
  #endif
  #if (PAD_LIST || (CC_HMAC_Start || CC_MAC_Start))
  #    if CC_HMAC_Start
      (COMMAND_DESCRIPTOR_t *)_HMAC_StartDataAddress,
  #    endif
  #    if CC_MAC_Start
      (COMMAND_DESCRIPTOR_t *)_MAC_StartDataAddress,
  #    endif
  #    if (CC_HMAC_Start || CC_MAC_Start) > 1
  #        error "More than one aliased command defined"
  #    endif
  #endif // CC_HMAC_Start CC_MAC_Start
  #if (PAD_LIST || CC_SequenceUpdate)
      (COMMAND_DESCRIPTOR_t *)_SequenceUpdateDataAddress,
  #endif
  #if (PAD_LIST || CC_Sign)
      (COMMAND_DESCRIPTOR_t *)_SignDataAddress,
  #endif
  #if (PAD_LIST || CC_Unseal)
      (COMMAND_DESCRIPTOR_t *)_UnsealDataAddress,
  #endif
  #if (PAD_LIST)
      (COMMAND_DESCRIPTOR_t *)0,
  #endif
  #if (PAD_LIST || CC_PolicySigned)
      (COMMAND_DESCRIPTOR_t *)_PolicySignedDataAddress,
  #endif
  #if (PAD_LIST || CC_ContextLoad)
      (COMMAND_DESCRIPTOR_t *)_ContextLoadDataAddress,
  #endif
  #if (PAD_LIST || CC_ContextSave)
      (COMMAND_DESCRIPTOR_t *)_ContextSaveDataAddress,
  #endif
  #if (PAD_LIST || CC_ECDH_KeyGen)
      (COMMAND_DESCRIPTOR_t *)_ECDH_KeyGenDataAddress,
  #endif
  #if (PAD_LIST || CC_EncryptDecrypt)
      (COMMAND_DESCRIPTOR_t *)_EncryptDecryptDataAddress,
  #endif
  #if (PAD_LIST || CC_FlushContext)
      (COMMAND_DESCRIPTOR_t *)_FlushContextDataAddress,
  #endif
  #if (PAD_LIST)
      (COMMAND_DESCRIPTOR_t *)0,
  #endif
  #if (PAD_LIST || CC_LoadExternal)
      (COMMAND_DESCRIPTOR_t *)_LoadExternalDataAddress,
  #endif
  #if (PAD_LIST || CC_MakeCredential)
      (COMMAND_DESCRIPTOR_t *)_MakeCredentialDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_ReadPublic)
      (COMMAND_DESCRIPTOR_t *)_NV_ReadPublicDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyAuthorize)
      (COMMAND_DESCRIPTOR_t *)_PolicyAuthorizeDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyAuthValue)
      (COMMAND_DESCRIPTOR_t *)_PolicyAuthValueDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyCommandCode)
      (COMMAND_DESCRIPTOR_t *)_PolicyCommandCodeDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyCounterTimer)
      (COMMAND_DESCRIPTOR_t *)_PolicyCounterTimerDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyCpHash)
      (COMMAND_DESCRIPTOR_t *)_PolicyCpHashDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyLocality)
      (COMMAND_DESCRIPTOR_t *)_PolicyLocalityDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyNameHash)
      (COMMAND_DESCRIPTOR_t *)_PolicyNameHashDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyOR)
      (COMMAND_DESCRIPTOR_t *)_PolicyORDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyTicket)
      (COMMAND_DESCRIPTOR_t *)_PolicyTicketDataAddress,
  #endif
  #if (PAD_LIST || CC_ReadPublic)
      (COMMAND_DESCRIPTOR_t *)_ReadPublicDataAddress,
  #endif
  #if (PAD_LIST || CC_RSA_Encrypt)
      (COMMAND_DESCRIPTOR_t *)_RSA_EncryptDataAddress,
  #endif
  #if (PAD_LIST)
      (COMMAND_DESCRIPTOR_t *)0,
  #endif
  #if (PAD_LIST || CC_StartAuthSession)
      (COMMAND_DESCRIPTOR_t *)_StartAuthSessionDataAddress,
  #endif
  #if (PAD_LIST || CC_VerifySignature)
      (COMMAND_DESCRIPTOR_t *)_VerifySignatureDataAddress,
  #endif
  #if (PAD_LIST || CC_ECC_Parameters)
      (COMMAND_DESCRIPTOR_t *)_ECC_ParametersDataAddress,
  #endif
  #if (PAD_LIST || CC_FirmwareRead)
      (COMMAND_DESCRIPTOR_t *)_FirmwareReadDataAddress,
  #endif
  #if (PAD_LIST || CC_GetCapability)
      (COMMAND_DESCRIPTOR_t *)_GetCapabilityDataAddress,
  #endif
  #if (PAD_LIST || CC_GetRandom)
      (COMMAND_DESCRIPTOR_t *)_GetRandomDataAddress,
  #endif
  #if (PAD_LIST || CC_GetTestResult)
      (COMMAND_DESCRIPTOR_t *)_GetTestResultDataAddress,
  #endif
  #if (PAD_LIST || CC_Hash)
      (COMMAND_DESCRIPTOR_t *)_HashDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_Read)
      (COMMAND_DESCRIPTOR_t *)_PCR_ReadDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyPCR)
      (COMMAND_DESCRIPTOR_t *)_PolicyPCRDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyRestart)
      (COMMAND_DESCRIPTOR_t *)_PolicyRestartDataAddress,
  #endif
  #if (PAD_LIST || CC_ReadClock)
      (COMMAND_DESCRIPTOR_t *)_ReadClockDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_Extend)
      (COMMAND_DESCRIPTOR_t *)_PCR_ExtendDataAddress,
  #endif
  #if (PAD_LIST || CC_PCR_SetAuthValue)
      (COMMAND_DESCRIPTOR_t *)_PCR_SetAuthValueDataAddress,
  #endif
  #if (PAD_LIST || CC_NV_Certify)
      (COMMAND_DESCRIPTOR_t *)_NV_CertifyDataAddress,
  #endif
  #if (PAD_LIST || CC_EventSequenceComplete)
      (COMMAND_DESCRIPTOR_t *)_EventSequenceCompleteDataAddress,
  #endif
  #if (PAD_LIST || CC_HashSequenceStart)
      (COMMAND_DESCRIPTOR_t *)_HashSequenceStartDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyPhysicalPresence)
      (COMMAND_DESCRIPTOR_t *)_PolicyPhysicalPresenceDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyDuplicationSelect)
      (COMMAND_DESCRIPTOR_t *)_PolicyDuplicationSelectDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyGetDigest)
      (COMMAND_DESCRIPTOR_t *)_PolicyGetDigestDataAddress,
  #endif
  #if (PAD_LIST || CC_TestParms)
      (COMMAND_DESCRIPTOR_t *)_TestParmsDataAddress,
  #endif
  #if (PAD_LIST || CC_Commit)
      (COMMAND_DESCRIPTOR_t *)_CommitDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyPassword)
      (COMMAND_DESCRIPTOR_t *)_PolicyPasswordDataAddress,
  #endif
  #if (PAD_LIST || CC_ZGen_2Phase)
      (COMMAND_DESCRIPTOR_t *)_ZGen_2PhaseDataAddress,
  #endif
  #if (PAD_LIST || CC_EC_Ephemeral)
      (COMMAND_DESCRIPTOR_t *)_EC_EphemeralDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyNvWritten)
      (COMMAND_DESCRIPTOR_t *)_PolicyNvWrittenDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyTemplate)
      (COMMAND_DESCRIPTOR_t *)_PolicyTemplateDataAddress,
  #endif
  #if (PAD_LIST || CC_CreateLoaded)
      (COMMAND_DESCRIPTOR_t *)_CreateLoadedDataAddress,
  #endif
  #if (PAD_LIST || CC_PolicyAuthorizeNV)
      (COMMAND_DESCRIPTOR_t *)_PolicyAuthorizeNVDataAddress,
  #endif
  #if (PAD_LIST || CC_EncryptDecrypt2)
      (COMMAND_DESCRIPTOR_t *)_EncryptDecrypt2DataAddress,
  #endif
  #if (PAD_LIST || CC_AC_GetCapability)
      (COMMAND_DESCRIPTOR_t *)_AC_GetCapabilityDataAddress,
  #endif // CC_AC_GetCapability
  #if (PAD_LIST || CC_AC_Send)
      (COMMAND_DESCRIPTOR_t *)_AC_SendDataAddress,
  #endif // CC_AC_Send
  #if (PAD_LIST || CC_Policy_AC_SendSelect)
      (COMMAND_DESCRIPTOR_t *)_Policy_AC_SendSelectDataAddress,
  #endif // CC_Policy_AC_SendSelect
  #if (PAD_LIST || CC_Vendor_TCG_Test)
      (COMMAND_DESCRIPTOR_t *)_Vendor_TCG_TestDataAddress,
  #endif
  #ifdef TPM_NUVOTON
  #if (PAD_LIST || TPM_NUVOTON)
      (COMMAND_DESCRIPTOR_t *)_NTC2_PreConfigDataAddress,
      (COMMAND_DESCRIPTOR_t *)_NTC2_LockPreConfigDataAddress,
      (COMMAND_DESCRIPTOR_t *)_NTC2_GetConfigDataAddress,
  #endif
  #endif    
      0
  };
  #endif
  