/* Microsoft Reference Implementation for TPM 2.0
 *
 *  The copyright in this software is being made available under the BSD License,
 *  included below. This software may be subject to other third party and
 *  contributor rights, including patent rights, and no such rights are granted
 *  under this license.
 *
 *  Copyright (c) Microsoft Corporation
 *
 *  All rights reserved.
 *
 *  BSD License
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice, this list
 *  of conditions and the following disclaimer.
 *
 *  Redistributions in binary form must reproduce the above copyright notice, this
 *  list of conditions and the following disclaimer in the documentation and/or
 *  other materials provided with the distribution.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*(Auto-generated)
 *  Created by TpmStructures; Version 4.4 Mar 26, 2019
 *  Date: Mar  6, 2020  Time: 01:50:09PM
 */

// This file should only be included by CommandCodeAttibutes.c
#ifdef _COMMAND_TABLE_DISPATCH_

// Define the stop value
#  define END_OF_LIST 0xff
#  define ADD_FLAG    0x80

// These macros provide some variability in how the data is encoded. They also make
// the lines a little shorter. ;-)
#  if TABLE_DRIVEN_MARSHAL
#    define UNMARSHAL_DISPATCH(name) (marshalIndex_t) name##_MARSHAL_REF
#    define MARSHAL_DISPATCH(name)   (marshalIndex_t) name##_MARSHAL_REF
#    define _UNMARSHAL_T_            marshalIndex_t
#    define _MARSHAL_T_              marshalIndex_t
#  else
#    define UNMARSHAL_DISPATCH(name) (UNMARSHAL_t) name##_Unmarshal
#    define MARSHAL_DISPATCH(name)   (MARSHAL_t) name##_Marshal
#    define _UNMARSHAL_T_            UNMARSHAL_t
#    define _MARSHAL_T_              MARSHAL_t
#  endif

// The unmarshalArray contains the dispatch functions for the unmarshaling code.
// The defines in this array are used to make it easier to cross reference the
// unmarshaling values in the types array of each command

const _UNMARSHAL_T_ unmarshalArray[] = {
#  define TPMI_DH_CONTEXT_H_UNMARSHAL 0
    UNMARSHAL_DISPATCH(TPMI_DH_CONTEXT),
#  define TPMI_RH_AC_H_UNMARSHAL (TPMI_DH_CONTEXT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_AC),
#  define TPMI_RH_ACT_H_UNMARSHAL (TPMI_RH_AC_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_ACT),
#  define TPMI_RH_CLEAR_H_UNMARSHAL (TPMI_RH_ACT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_CLEAR),
#  define TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL (TPMI_RH_CLEAR_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY_AUTH),
#  define TPMI_RH_HIERARCHY_POLICY_H_UNMARSHAL \
    (TPMI_RH_HIERARCHY_AUTH_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY_POLICY),
#  define TPMI_RH_LOCKOUT_H_UNMARSHAL (TPMI_RH_HIERARCHY_POLICY_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_LOCKOUT),
#  define TPMI_RH_NV_AUTH_H_UNMARSHAL (TPMI_RH_LOCKOUT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_NV_AUTH),
#  define TPMI_RH_NV_INDEX_H_UNMARSHAL (TPMI_RH_NV_AUTH_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_NV_INDEX),
#  define TPMI_RH_PLATFORM_H_UNMARSHAL (TPMI_RH_NV_INDEX_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_PLATFORM),
#  define TPMI_RH_PROVISION_H_UNMARSHAL (TPMI_RH_PLATFORM_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_PROVISION),
#  define TPMI_SH_HMAC_H_UNMARSHAL (TPMI_RH_PROVISION_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_SH_HMAC),
#  define TPMI_SH_POLICY_H_UNMARSHAL (TPMI_SH_HMAC_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_SH_POLICY),
// 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_DISPATCH(TPMI_DH_ENTITY),
#  define TPMI_DH_OBJECT_H_UNMARSHAL (TPMI_DH_ENTITY_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_OBJECT),
#  define TPMI_DH_PARENT_H_UNMARSHAL (TPMI_DH_OBJECT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_PARENT),
#  define TPMI_DH_PCR_H_UNMARSHAL (TPMI_DH_PARENT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_PCR),
#  define TPMI_RH_ENDORSEMENT_H_UNMARSHAL (TPMI_DH_PCR_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_ENDORSEMENT),
#  define TPMI_RH_HIERARCHY_H_UNMARSHAL (TPMI_RH_ENDORSEMENT_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY),
// PARAMETER_FIRST_TYPE marks the end of the handle list.
#  define PARAMETER_FIRST_TYPE   (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1)
#  define TPM2B_DATA_P_UNMARSHAL (TPMI_RH_HIERARCHY_H_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_DATA),
#  define TPM2B_DIGEST_P_UNMARSHAL (TPM2B_DATA_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_DIGEST),
#  define TPM2B_ECC_PARAMETER_P_UNMARSHAL (TPM2B_DIGEST_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_ECC_PARAMETER),
#  define TPM2B_ECC_POINT_P_UNMARSHAL (TPM2B_ECC_PARAMETER_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_ECC_POINT),
#  define TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL (TPM2B_ECC_POINT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_ENCRYPTED_SECRET),
#  define TPM2B_EVENT_P_UNMARSHAL (TPM2B_ENCRYPTED_SECRET_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_EVENT),
#  define TPM2B_ID_OBJECT_P_UNMARSHAL (TPM2B_EVENT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_ID_OBJECT),
#  define TPM2B_IV_P_UNMARSHAL (TPM2B_ID_OBJECT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_IV),
#  define TPM2B_MAX_BUFFER_P_UNMARSHAL (TPM2B_IV_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_MAX_BUFFER),
#  define TPM2B_MAX_NV_BUFFER_P_UNMARSHAL (TPM2B_MAX_BUFFER_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_MAX_NV_BUFFER),
#  define TPM2B_NAME_P_UNMARSHAL (TPM2B_MAX_NV_BUFFER_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_NAME),
#  define TPM2B_NV_PUBLIC_P_UNMARSHAL (TPM2B_NAME_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_NV_PUBLIC),
#  define TPM2B_PRIVATE_P_UNMARSHAL (TPM2B_NV_PUBLIC_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_PRIVATE),
#  define TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL (TPM2B_PRIVATE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_PUBLIC_KEY_RSA),
#  define TPM2B_SENSITIVE_P_UNMARSHAL (TPM2B_PUBLIC_KEY_RSA_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_SENSITIVE),
#  define TPM2B_SENSITIVE_CREATE_P_UNMARSHAL (TPM2B_SENSITIVE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_SENSITIVE_CREATE),
#  define TPM2B_SENSITIVE_DATA_P_UNMARSHAL (TPM2B_SENSITIVE_CREATE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_SENSITIVE_DATA),
#  define TPM2B_TEMPLATE_P_UNMARSHAL (TPM2B_SENSITIVE_DATA_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_TEMPLATE),
#  define TPM2B_TIMEOUT_P_UNMARSHAL (TPM2B_TEMPLATE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_TIMEOUT),
#  define TPMI_DH_CONTEXT_P_UNMARSHAL (TPM2B_TIMEOUT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_CONTEXT),
#  define TPMI_DH_PERSISTENT_P_UNMARSHAL (TPMI_DH_CONTEXT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_PERSISTENT),
#  define TPMI_ECC_CURVE_P_UNMARSHAL (TPMI_DH_PERSISTENT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_ECC_CURVE),
#  define TPMI_YES_NO_P_UNMARSHAL (TPMI_ECC_CURVE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_YES_NO),
#  define TPML_ALG_P_UNMARSHAL (TPMI_YES_NO_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPML_ALG),
#  define TPML_CC_P_UNMARSHAL (TPML_ALG_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPML_CC),
#  define TPML_DIGEST_P_UNMARSHAL (TPML_CC_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPML_DIGEST),
#  define TPML_DIGEST_VALUES_P_UNMARSHAL (TPML_DIGEST_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPML_DIGEST_VALUES),
#  define TPML_PCR_SELECTION_P_UNMARSHAL (TPML_DIGEST_VALUES_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPML_PCR_SELECTION),
#  define TPMS_CONTEXT_P_UNMARSHAL (TPML_PCR_SELECTION_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMS_CONTEXT),
#  define TPMT_PUBLIC_PARMS_P_UNMARSHAL (TPMS_CONTEXT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_PUBLIC_PARMS),
#  define TPMT_TK_AUTH_P_UNMARSHAL (TPMT_PUBLIC_PARMS_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_TK_AUTH),
#  define TPMT_TK_CREATION_P_UNMARSHAL (TPMT_TK_AUTH_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_TK_CREATION),
#  define TPMT_TK_HASHCHECK_P_UNMARSHAL (TPMT_TK_CREATION_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_TK_HASHCHECK),
#  define TPMT_TK_VERIFIED_P_UNMARSHAL (TPMT_TK_HASHCHECK_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_TK_VERIFIED),
#  define TPM_AT_P_UNMARSHAL (TPMT_TK_VERIFIED_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_AT),
#  define TPM_CAP_P_UNMARSHAL (TPM_AT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_CAP),
#  define TPM_CLOCK_ADJUST_P_UNMARSHAL (TPM_CAP_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_CLOCK_ADJUST),
#  define TPM_EO_P_UNMARSHAL (TPM_CLOCK_ADJUST_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_EO),
#  define TPM_SE_P_UNMARSHAL (TPM_EO_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_SE),
#  define TPM_SU_P_UNMARSHAL (TPM_SE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM_SU),
#  define UINT16_P_UNMARSHAL (TPM_SU_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(UINT16),
#  define UINT32_P_UNMARSHAL (UINT16_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(UINT32),
#  define UINT64_P_UNMARSHAL (UINT32_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(UINT64),
#  define UINT8_P_UNMARSHAL (UINT64_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(UINT8),
// PARAMETER_FIRST_FLAG_TYPE is the first parameter to need a flag.
#  define PARAMETER_FIRST_FLAG_TYPE (UINT8_P_UNMARSHAL + 1)
#  define TPM2B_PUBLIC_P_UNMARSHAL  (UINT8_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPM2B_PUBLIC),
#  define TPMI_ALG_CIPHER_MODE_P_UNMARSHAL (TPM2B_PUBLIC_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_ALG_CIPHER_MODE),
#  define TPMI_ALG_HASH_P_UNMARSHAL (TPMI_ALG_CIPHER_MODE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_ALG_HASH),
#  define TPMI_ALG_MAC_SCHEME_P_UNMARSHAL (TPMI_ALG_HASH_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_ALG_MAC_SCHEME),
#  define TPMI_DH_PCR_P_UNMARSHAL (TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_DH_PCR),
#  define TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL (TPMI_DH_PCR_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_ECC_KEY_EXCHANGE),
#  define TPMI_RH_ENABLES_P_UNMARSHAL (TPMI_ECC_KEY_EXCHANGE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_ENABLES),
#  define TPMI_RH_HIERARCHY_P_UNMARSHAL (TPMI_RH_ENABLES_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMI_RH_HIERARCHY),
#  define TPMT_KDF_SCHEME_P_UNMARSHAL (TPMI_RH_HIERARCHY_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_KDF_SCHEME),
#  define TPMT_RSA_DECRYPT_P_UNMARSHAL (TPMT_KDF_SCHEME_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_RSA_DECRYPT),
#  define TPMT_SIGNATURE_P_UNMARSHAL (TPMT_RSA_DECRYPT_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_SIGNATURE),
#  define TPMT_SIG_SCHEME_P_UNMARSHAL (TPMT_SIGNATURE_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_SIG_SCHEME),
#  define TPMT_SYM_DEF_P_UNMARSHAL (TPMT_SIG_SCHEME_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_SYM_DEF),
#  define TPMT_SYM_DEF_OBJECT_P_UNMARSHAL (TPMT_SYM_DEF_P_UNMARSHAL + 1)
    UNMARSHAL_DISPATCH(TPMT_SYM_DEF_OBJECT)
// PARAMETER_LAST_TYPE is the end of the command parameter list.
#  define PARAMETER_LAST_TYPE (TPMT_SYM_DEF_OBJECT_P_UNMARSHAL)
};

// The marshalArray contains the dispatch functions for the marshaling code.
// The defines in this array are used to make it easier to cross reference the
// marshaling values in the types array of each command
const _MARSHAL_T_ marshalArray[] = {

#  define UINT32_H_MARSHAL 0
    MARSHAL_DISPATCH(UINT32),
// RESPONSE_PARAMETER_FIRST_TYPE marks the end of the response handles.
#  define RESPONSE_PARAMETER_FIRST_TYPE (UINT32_H_MARSHAL + 1)
#  define TPM2B_ATTEST_P_MARSHAL        (UINT32_H_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_ATTEST),
#  define TPM2B_CREATION_DATA_P_MARSHAL (TPM2B_ATTEST_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_CREATION_DATA),
#  define TPM2B_DATA_P_MARSHAL (TPM2B_CREATION_DATA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_DATA),
#  define TPM2B_DIGEST_P_MARSHAL (TPM2B_DATA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_DIGEST),
#  define TPM2B_ECC_POINT_P_MARSHAL (TPM2B_DIGEST_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_ECC_POINT),
#  define TPM2B_ENCRYPTED_SECRET_P_MARSHAL (TPM2B_ECC_POINT_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_ENCRYPTED_SECRET),
#  define TPM2B_ID_OBJECT_P_MARSHAL (TPM2B_ENCRYPTED_SECRET_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_ID_OBJECT),
#  define TPM2B_IV_P_MARSHAL (TPM2B_ID_OBJECT_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_IV),
#  define TPM2B_MAX_BUFFER_P_MARSHAL (TPM2B_IV_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_MAX_BUFFER),
#  define TPM2B_MAX_NV_BUFFER_P_MARSHAL (TPM2B_MAX_BUFFER_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_MAX_NV_BUFFER),
#  define TPM2B_NAME_P_MARSHAL (TPM2B_MAX_NV_BUFFER_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_NAME),
#  define TPM2B_NV_PUBLIC_P_MARSHAL (TPM2B_NAME_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_NV_PUBLIC),
#  define TPM2B_PRIVATE_P_MARSHAL (TPM2B_NV_PUBLIC_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_PRIVATE),
#  define TPM2B_PUBLIC_P_MARSHAL (TPM2B_PRIVATE_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_PUBLIC),
#  define TPM2B_PUBLIC_KEY_RSA_P_MARSHAL (TPM2B_PUBLIC_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_PUBLIC_KEY_RSA),
#  define TPM2B_SENSITIVE_DATA_P_MARSHAL (TPM2B_PUBLIC_KEY_RSA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_SENSITIVE_DATA),
#  define TPM2B_TIMEOUT_P_MARSHAL (TPM2B_SENSITIVE_DATA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPM2B_TIMEOUT),
#  define UINT8_P_MARSHAL (TPM2B_TIMEOUT_P_MARSHAL + 1)
    MARSHAL_DISPATCH(UINT8),
#  define TPML_AC_CAPABILITIES_P_MARSHAL (UINT8_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPML_AC_CAPABILITIES),
#  define TPML_ALG_P_MARSHAL (TPML_AC_CAPABILITIES_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPML_ALG),
#  define TPML_DIGEST_P_MARSHAL (TPML_ALG_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPML_DIGEST),
#  define TPML_DIGEST_VALUES_P_MARSHAL (TPML_DIGEST_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPML_DIGEST_VALUES),
#  define TPML_PCR_SELECTION_P_MARSHAL (TPML_DIGEST_VALUES_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPML_PCR_SELECTION),
#  define TPMS_AC_OUTPUT_P_MARSHAL (TPML_PCR_SELECTION_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMS_AC_OUTPUT),
#  define TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL (TPMS_AC_OUTPUT_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMS_ALGORITHM_DETAIL_ECC),
#  define TPMS_CAPABILITY_DATA_P_MARSHAL (TPMS_ALGORITHM_DETAIL_ECC_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMS_CAPABILITY_DATA),
#  define TPMS_CONTEXT_P_MARSHAL (TPMS_CAPABILITY_DATA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMS_CONTEXT),
#  define TPMS_TIME_INFO_P_MARSHAL (TPMS_CONTEXT_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMS_TIME_INFO),
#  define TPMT_HA_P_MARSHAL (TPMS_TIME_INFO_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_HA),
#  define TPMT_SIGNATURE_P_MARSHAL (TPMT_HA_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_SIGNATURE),
#  define TPMT_TK_AUTH_P_MARSHAL (TPMT_SIGNATURE_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_TK_AUTH),
#  define TPMT_TK_CREATION_P_MARSHAL (TPMT_TK_AUTH_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_TK_CREATION),
#  define TPMT_TK_HASHCHECK_P_MARSHAL (TPMT_TK_CREATION_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_TK_HASHCHECK),
#  define TPMT_TK_VERIFIED_P_MARSHAL (TPMT_TK_HASHCHECK_P_MARSHAL + 1)
    MARSHAL_DISPATCH(TPMT_TK_VERIFIED),
#  define UINT32_P_MARSHAL (TPMT_TK_VERIFIED_P_MARSHAL + 1)
    MARSHAL_DISPATCH(UINT32),
#  define UINT16_P_MARSHAL (UINT32_P_MARSHAL + 1)
    MARSHAL_DISPATCH(UINT16)
// RESPONSE_PARAMETER_LAST_TYPE is the end of the response parameter list.
#  define RESPONSE_PARAMETER_LAST_TYPE (UINT16_P_MARSHAL)
};

// This list of aliases allows the types in the _COMMAND_DESCRIPTOR_T to match the
// types in the command/response templates of part 3.
#  define INT32_P_UNMARSHAL              UINT32_P_UNMARSHAL
#  define TPM2B_AUTH_P_UNMARSHAL         TPM2B_DIGEST_P_UNMARSHAL
#  define TPM2B_NONCE_P_UNMARSHAL        TPM2B_DIGEST_P_UNMARSHAL
#  define TPM2B_OPERAND_P_UNMARSHAL      TPM2B_DIGEST_P_UNMARSHAL
#  define TPMA_LOCALITY_P_UNMARSHAL      UINT8_P_UNMARSHAL
#  define TPM_CC_P_UNMARSHAL             UINT32_P_UNMARSHAL
#  define TPMI_DH_CONTEXT_H_MARSHAL      UINT32_H_MARSHAL
#  define TPMI_DH_OBJECT_H_MARSHAL       UINT32_H_MARSHAL
#  define TPMI_SH_AUTH_SESSION_H_MARSHAL UINT32_H_MARSHAL
#  define TPM_HANDLE_H_MARSHAL           UINT32_H_MARSHAL
#  define TPM2B_NONCE_P_MARSHAL          TPM2B_DIGEST_P_MARSHAL
#  define TPMI_YES_NO_P_MARSHAL          UINT8_P_MARSHAL
#  define TPM_RC_P_MARSHAL               UINT32_P_MARSHAL

#  if CC_Startup

#    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  // CC_Startup

#  if CC_Shutdown

#    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  // CC_Shutdown

#  if CC_SelfTest

#    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  // CC_SelfTest

#  if CC_IncrementalSelfTest

#    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  // CC_IncrementalSelfTest

#  if CC_GetTestResult

#    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, TPM_RC_P_MARSHAL, END_OF_LIST}};

#    define _GetTestResultDataAddress (&_GetTestResultData)
#  else
#    define _GetTestResultDataAddress 0
#  endif  // CC_GetTestResult

#  if CC_StartAuthSession

#    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_NONCE_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,
     TPMI_SH_AUTH_SESSION_H_MARSHAL,
     TPM2B_NONCE_P_MARSHAL,
     END_OF_LIST}};

#    define _StartAuthSessionDataAddress (&_StartAuthSessionData)
#  else
#    define _StartAuthSessionDataAddress 0
#  endif  // CC_StartAuthSession

#  if CC_PolicyRestart

#    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  // CC_PolicyRestart

#  if CC_Create

#    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  // CC_Create

#  if CC_Load

#    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,
     TPM_HANDLE_H_MARSHAL,
     TPM2B_NAME_P_MARSHAL,
     END_OF_LIST}};

#    define _LoadDataAddress (&_LoadData)
#  else
#    define _LoadDataAddress 0
#  endif  // CC_Load

#  if CC_LoadExternal

#    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,
     TPM_HANDLE_H_MARSHAL,
     TPM2B_NAME_P_MARSHAL,
     END_OF_LIST}};

#    define _LoadExternalDataAddress (&_LoadExternalData)
#  else
#    define _LoadExternalDataAddress 0
#  endif  // CC_LoadExternal

#  if CC_ReadPublic

#    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  // CC_ReadPublic

#  if CC_ActivateCredential

#    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  // CC_ActivateCredential

#  if CC_MakeCredential

#    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  // CC_MakeCredential

#  if CC_Unseal

#    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  // CC_Unseal

#  if CC_ObjectChangeAuth

#    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_AUTH_P_UNMARSHAL,
     END_OF_LIST,
     TPM2B_PRIVATE_P_MARSHAL,
     END_OF_LIST}};

#    define _ObjectChangeAuthDataAddress (&_ObjectChangeAuthData)
#  else
#    define _ObjectChangeAuthDataAddress 0
#  endif  // CC_ObjectChangeAuth

#  if CC_CreateLoaded

#    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,
     TPM_HANDLE_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  // CC_CreateLoaded

#  if CC_Duplicate

#    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  // CC_Duplicate

#  if CC_Rewrap

#    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  // CC_Rewrap

#  if CC_Import

#    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  // CC_Import

#  if CC_RSA_Encrypt

#    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  // CC_RSA_Encrypt

#  if CC_RSA_Decrypt

#    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  // CC_RSA_Decrypt

#  if CC_ECDH_KeyGen

#    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  // CC_ECDH_KeyGen

#  if CC_ECDH_ZGen

#    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  // CC_ECDH_ZGen

#  if CC_ECC_Parameters

#    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  // CC_ECC_Parameters

#  if CC_ZGen_2Phase

#    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  // CC_ZGen_2Phase

#  if CC_ECC_Encrypt

#    include "ECC_Encrypt_fp.h"

typedef TPM_RC(ECC_Encrypt_Entry)(ECC_Encrypt_In* in, ECC_Encrypt_Out* out);

typedef const struct
{
    ECC_Encrypt_Entry* entry;
    UINT16             inSize;
    UINT16             outSize;
    UINT16             offsetOfTypes;
    UINT16             paramOffsets[4];
    BYTE               types[8];
} ECC_Encrypt_COMMAND_DESCRIPTOR_t;

ECC_Encrypt_COMMAND_DESCRIPTOR_t _ECC_EncryptData = {
    /* entry         */ &TPM2_ECC_Encrypt,
    /* inSize        */ (UINT16)(sizeof(ECC_Encrypt_In)),
    /* outSize       */ (UINT16)(sizeof(ECC_Encrypt_Out)),
    /* offsetOfTypes */ offsetof(ECC_Encrypt_COMMAND_DESCRIPTOR_t, types),
    /* offsets       */
    {(UINT16)(offsetof(ECC_Encrypt_In, plainText)),
     (UINT16)(offsetof(ECC_Encrypt_In, inScheme)),
     (UINT16)(offsetof(ECC_Encrypt_Out, C2)),
     (UINT16)(offsetof(ECC_Encrypt_Out, C3))},
    /* types         */
    {TPMI_DH_OBJECT_H_UNMARSHAL,
     TPM2B_MAX_BUFFER_P_UNMARSHAL,
     TPMT_KDF_SCHEME_P_UNMARSHAL + ADD_FLAG,
     END_OF_LIST,
     TPM2B_ECC_POINT_P_MARSHAL,
     TPM2B_MAX_BUFFER_P_MARSHAL,
     TPM2B_DIGEST_P_MARSHAL,
     END_OF_LIST}};

#    define _ECC_EncryptDataAddress (&_ECC_EncryptData)
#  else
#    define _ECC_EncryptDataAddress 0
#  endif  // CC_ECC_Encrypt

#  if CC_ECC_Decrypt

#    include "ECC_Decrypt_fp.h"

typedef TPM_RC(ECC_Decrypt_Entry)(ECC_Decrypt_In* in, ECC_Decrypt_Out* out);

typedef const struct
{
    ECC_Decrypt_Entry* entry;
    UINT16             inSize;
    UINT16             outSize;
    UINT16             offsetOfTypes;
    UINT16             paramOffsets[4];
    BYTE               types[8];
} ECC_Decrypt_COMMAND_DESCRIPTOR_t;

ECC_Decrypt_COMMAND_DESCRIPTOR_t _ECC_DecryptData = {
    /* entry         */ &TPM2_ECC_Decrypt,
    /* inSize        */ (UINT16)(sizeof(ECC_Decrypt_In)),
    /* outSize       */ (UINT16)(sizeof(ECC_Decrypt_Out)),
    /* offsetOfTypes */ offsetof(ECC_Decrypt_COMMAND_DESCRIPTOR_t, types),
    /* offsets       */
    {(UINT16)(offsetof(ECC_Decrypt_In, C1)),
     (UINT16)(offsetof(ECC_Decrypt_In, C2)),
     (UINT16)(offsetof(ECC_Decrypt_In, C3)),
     (UINT16)(offsetof(ECC_Decrypt_In, inScheme))},
    /* types         */
    {TPMI_DH_OBJECT_H_UNMARSHAL,
     TPM2B_ECC_POINT_P_UNMARSHAL,
     TPM2B_MAX_BUFFER_P_UNMARSHAL,
     TPM2B_DIGEST_P_UNMARSHAL,
     TPMT_KDF_SCHEME_P_UNMARSHAL + ADD_FLAG,
     END_OF_LIST,
     TPM2B_MAX_BUFFER_P_MARSHAL,
     END_OF_LIST}};

#    define _ECC_DecryptDataAddress (&_ECC_DecryptData)
#  else
#    define _ECC_DecryptDataAddress 0
#  endif  // CC_ECC_Decrypt

#  if CC_EncryptDecrypt

#    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  // CC_EncryptDecrypt

#  if CC_EncryptDecrypt2

#    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  // CC_EncryptDecrypt2

#  if CC_Hash

#    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  // CC_Hash

#  if CC_HMAC

#    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  // CC_HMAC

#  if CC_MAC

#    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  // CC_MAC

#  if CC_GetRandom

#    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  // CC_GetRandom

#  if CC_StirRandom

#    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  // CC_StirRandom

#  if CC_HMAC_Start

#    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_AUTH_P_UNMARSHAL,
     TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
     END_OF_LIST,
     TPMI_DH_OBJECT_H_MARSHAL,
     END_OF_LIST}};

#    define _HMAC_StartDataAddress (&_HMAC_StartData)
#  else
#    define _HMAC_StartDataAddress 0
#  endif  // CC_HMAC_Start

#  if CC_MAC_Start

#    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_AUTH_P_UNMARSHAL,
     TPMI_ALG_MAC_SCHEME_P_UNMARSHAL + ADD_FLAG,
     END_OF_LIST,
     TPMI_DH_OBJECT_H_MARSHAL,
     END_OF_LIST}};

#    define _MAC_StartDataAddress (&_MAC_StartData)
#  else
#    define _MAC_StartDataAddress 0
#  endif  // CC_MAC_Start

#  if CC_HashSequenceStart

#    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_AUTH_P_UNMARSHAL,
     TPMI_ALG_HASH_P_UNMARSHAL + ADD_FLAG,
     END_OF_LIST,
     TPMI_DH_OBJECT_H_MARSHAL,
     END_OF_LIST}};

#    define _HashSequenceStartDataAddress (&_HashSequenceStartData)
#  else
#    define _HashSequenceStartDataAddress 0
#  endif  // CC_HashSequenceStart

#  if CC_SequenceUpdate

#    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  // CC_SequenceUpdate

#  if CC_SequenceComplete

#    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  // CC_SequenceComplete

#  if CC_EventSequenceComplete

#    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  // CC_EventSequenceComplete

#  if CC_Certify

#    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  // CC_Certify

#  if CC_CertifyCreation

#    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  // CC_CertifyCreation

#  if CC_Quote

#    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  // CC_Quote

#  if CC_GetSessionAuditDigest

#    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  // CC_GetSessionAuditDigest

#  if CC_GetCommandAuditDigest

#    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  // CC_GetCommandAuditDigest

#  if CC_GetTime

#    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  // CC_GetTime

#  if CC_CertifyX509

#    include "CertifyX509_fp.h"

typedef TPM_RC(CertifyX509_Entry)(CertifyX509_In* in, CertifyX509_Out* out);

typedef const struct
{
    CertifyX509_Entry* entry;
    UINT16             inSize;
    UINT16             outSize;
    UINT16             offsetOfTypes;
    UINT16             paramOffsets[6];
    BYTE               types[10];
} CertifyX509_COMMAND_DESCRIPTOR_t;

CertifyX509_COMMAND_DESCRIPTOR_t _CertifyX509Data = {
    /* entry         */ &TPM2_CertifyX509,
    /* inSize        */ (UINT16)(sizeof(CertifyX509_In)),
    /* outSize       */ (UINT16)(sizeof(CertifyX509_Out)),
    /* offsetOfTypes */ offsetof(CertifyX509_COMMAND_DESCRIPTOR_t, types),
    /* offsets       */
    {(UINT16)(offsetof(CertifyX509_In, signHandle)),
     (UINT16)(offsetof(CertifyX509_In, reserved)),
     (UINT16)(offsetof(CertifyX509_In, inScheme)),
     (UINT16)(offsetof(CertifyX509_In, partialCertificate)),
     (UINT16)(offsetof(CertifyX509_Out, tbsDigest)),
     (UINT16)(offsetof(CertifyX509_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,
     TPM2B_MAX_BUFFER_P_UNMARSHAL,
     END_OF_LIST,
     TPM2B_MAX_BUFFER_P_MARSHAL,
     TPM2B_DIGEST_P_MARSHAL,
     TPMT_SIGNATURE_P_MARSHAL,
     END_OF_LIST}};

#    define _CertifyX509DataAddress (&_CertifyX509Data)
#  else
#    define _CertifyX509DataAddress 0
#  endif  // CC_CertifyX509

#  if CC_Commit

#    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  // CC_Commit

#  if CC_EC_Ephemeral

#    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  // CC_EC_Ephemeral

#  if CC_VerifySignature

#    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  // CC_VerifySignature

#  if CC_Sign

#    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  // CC_Sign

#  if CC_SetCommandCodeAuditStatus

#    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  // CC_SetCommandCodeAuditStatus

#  if CC_PCR_Extend

#    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  // CC_PCR_Extend

#  if CC_PCR_Event

#    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  // CC_PCR_Event

#  if CC_PCR_Read

#    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  // CC_PCR_Read

#  if CC_PCR_Allocate

#    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,
     TPMI_YES_NO_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  // CC_PCR_Allocate

#  if CC_PCR_SetAuthPolicy

#    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  // CC_PCR_SetAuthPolicy

#  if CC_PCR_SetAuthValue

#    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  // CC_PCR_SetAuthValue

#  if CC_PCR_Reset

#    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  // CC_PCR_Reset

#  if CC_PolicySigned

#    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_NONCE_P_UNMARSHAL,
     TPM2B_DIGEST_P_UNMARSHAL,
     TPM2B_NONCE_P_UNMARSHAL,
     INT32_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  // CC_PolicySigned

#  if CC_PolicySecret

#    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_NONCE_P_UNMARSHAL,
     TPM2B_DIGEST_P_UNMARSHAL,
     TPM2B_NONCE_P_UNMARSHAL,
     INT32_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  // CC_PolicySecret

#  if CC_PolicyTicket

#    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_NONCE_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  // CC_PolicyTicket

#  if CC_PolicyOR

#    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  // CC_PolicyOR

#  if CC_PolicyPCR

#    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  // CC_PolicyPCR

#  if CC_PolicyLocality

#    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,
     TPMA_LOCALITY_P_UNMARSHAL,
     END_OF_LIST,
     END_OF_LIST}};

#    define _PolicyLocalityDataAddress (&_PolicyLocalityData)
#  else
#    define _PolicyLocalityDataAddress 0
#  endif  // CC_PolicyLocality

#  if CC_PolicyNV

#    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_OPERAND_P_UNMARSHAL,
     UINT16_P_UNMARSHAL,
     TPM_EO_P_UNMARSHAL,
     END_OF_LIST,
     END_OF_LIST}};

#    define _PolicyNVDataAddress (&_PolicyNVData)
#  else
#    define _PolicyNVDataAddress 0
#  endif  // CC_PolicyNV

#  if CC_PolicyCounterTimer

#    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_OPERAND_P_UNMARSHAL,
     UINT16_P_UNMARSHAL,
     TPM_EO_P_UNMARSHAL,
     END_OF_LIST,
     END_OF_LIST}};

#    define _PolicyCounterTimerDataAddress (&_PolicyCounterTimerData)
#  else
#    define _PolicyCounterTimerDataAddress 0
#  endif  // CC_PolicyCounterTimer

#  if CC_PolicyCommandCode

#    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, TPM_CC_P_UNMARSHAL, END_OF_LIST, END_OF_LIST}};

#    define _PolicyCommandCodeDataAddress (&_PolicyCommandCodeData)
#  else
#    define _PolicyCommandCodeDataAddress 0
#  endif  // CC_PolicyCommandCode

#  if CC_PolicyPhysicalPresence

#    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  // CC_PolicyPhysicalPresence

#  if CC_PolicyCpHash

#    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  // CC_PolicyCpHash

#  if CC_PolicyNameHash

#    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  // CC_PolicyNameHash

#  if CC_PolicyDuplicationSelect

#    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  // CC_PolicyDuplicationSelect

#  if CC_PolicyAuthorize

#    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_NONCE_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  // CC_PolicyAuthorize

#  if CC_PolicyAuthValue

#    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  // CC_PolicyAuthValue

#  if CC_PolicyPassword

#    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  // CC_PolicyPassword

#  if CC_PolicyGetDigest

#    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  // CC_PolicyGetDigest

#  if CC_PolicyNvWritten

#    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  // CC_PolicyNvWritten

#  if CC_PolicyTemplate

#    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  // CC_PolicyTemplate

#  if CC_PolicyAuthorizeNV

#    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  // CC_PolicyAuthorizeNV

#  if CC_CreatePrimary

#    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,
     TPM_HANDLE_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  // CC_CreatePrimary

#  if CC_HierarchyControl

#    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  // CC_HierarchyControl

#  if CC_SetPrimaryPolicy

#    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_POLICY_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  // CC_SetPrimaryPolicy

#  if CC_ChangePPS

#    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  // CC_ChangePPS

#  if CC_ChangeEPS

#    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  // CC_ChangeEPS

#  if CC_Clear

#    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  // CC_Clear

#  if CC_ClearControl

#    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  // CC_ClearControl

#  if CC_HierarchyChangeAuth

#    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_AUTH_P_UNMARSHAL,
     END_OF_LIST,
     END_OF_LIST}};

#    define _HierarchyChangeAuthDataAddress (&_HierarchyChangeAuthData)
#  else
#    define _HierarchyChangeAuthDataAddress 0
#  endif  // CC_HierarchyChangeAuth

#  if CC_DictionaryAttackLockReset

#    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  // CC_DictionaryAttackLockReset

#  if CC_DictionaryAttackParameters

#    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  // CC_DictionaryAttackParameters

#  if CC_PP_Commands

#    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  // CC_PP_Commands

#  if CC_SetAlgorithmSet

#    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  // CC_SetAlgorithmSet

#  if CC_FieldUpgradeStart

#    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  // CC_FieldUpgradeStart

#  if CC_FieldUpgradeData

#    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  // CC_FieldUpgradeData

#  if CC_FirmwareRead

#    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  // CC_FirmwareRead

#  if CC_ContextSave

#    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  // CC_ContextSave

#  if CC_ContextLoad

#    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, TPMI_DH_CONTEXT_H_MARSHAL, END_OF_LIST}};

#    define _ContextLoadDataAddress (&_ContextLoadData)
#  else
#    define _ContextLoadDataAddress 0
#  endif  // CC_ContextLoad

#  if CC_FlushContext

#    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  // CC_FlushContext

#  if CC_EvictControl

#    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  // CC_EvictControl

#  if CC_ReadClock

#    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  // CC_ReadClock

#  if CC_ClockSet

#    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  // CC_ClockSet

#  if CC_ClockRateAdjust

#    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  // CC_ClockRateAdjust

#  if CC_GetCapability

#    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,
     TPMI_YES_NO_P_MARSHAL,
     TPMS_CAPABILITY_DATA_P_MARSHAL,
     END_OF_LIST}};

#    define _GetCapabilityDataAddress (&_GetCapabilityData)
#  else
#    define _GetCapabilityDataAddress 0
#  endif  // CC_GetCapability

#  if CC_TestParms

#    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  // CC_TestParms

#  if CC_NV_DefineSpace

#    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_AUTH_P_UNMARSHAL,
     TPM2B_NV_PUBLIC_P_UNMARSHAL,
     END_OF_LIST,
     END_OF_LIST}};

#    define _NV_DefineSpaceDataAddress (&_NV_DefineSpaceData)
#  else
#    define _NV_DefineSpaceDataAddress 0
#  endif  // CC_NV_DefineSpace

#  if CC_NV_UndefineSpace

#    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  // CC_NV_UndefineSpace

#  if CC_NV_UndefineSpaceSpecial

#    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  // CC_NV_UndefineSpaceSpecial

#  if CC_NV_ReadPublic

#    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  // CC_NV_ReadPublic

#  if CC_NV_Write

#    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  // CC_NV_Write

#  if CC_NV_Increment

#    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  // CC_NV_Increment

#  if CC_NV_Extend

#    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  // CC_NV_Extend

#  if CC_NV_SetBits

#    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  // CC_NV_SetBits

#  if CC_NV_WriteLock

#    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  // CC_NV_WriteLock

#  if CC_NV_GlobalWriteLock

#    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  // CC_NV_GlobalWriteLock

#  if CC_NV_Read

#    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  // CC_NV_Read

#  if CC_NV_ReadLock

#    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  // CC_NV_ReadLock

#  if CC_NV_ChangeAuth

#    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_AUTH_P_UNMARSHAL, END_OF_LIST, END_OF_LIST}};

#    define _NV_ChangeAuthDataAddress (&_NV_ChangeAuthData)
#  else
#    define _NV_ChangeAuthDataAddress 0
#  endif  // CC_NV_ChangeAuth

#  if CC_NV_Certify

#    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  // CC_NV_Certify

#  if CC_AC_GetCapability

#    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,
     TPMI_YES_NO_P_MARSHAL,
     TPML_AC_CAPABILITIES_P_MARSHAL,
     END_OF_LIST}};

#    define _AC_GetCapabilityDataAddress (&_AC_GetCapabilityData)
#  else
#    define _AC_GetCapabilityDataAddress 0
#  endif  // CC_AC_GetCapability

#  if CC_AC_Send

#    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  // CC_AC_Send

#  if CC_Policy_AC_SendSelect

#    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  // CC_Policy_AC_SendSelect

#  if CC_ACT_SetTimeout

#    include "ACT_SetTimeout_fp.h"

typedef TPM_RC(ACT_SetTimeout_Entry)(ACT_SetTimeout_In* in);

typedef const struct
{
    ACT_SetTimeout_Entry* entry;
    UINT16                inSize;
    UINT16                outSize;
    UINT16                offsetOfTypes;
    UINT16                paramOffsets[1];
    BYTE                  types[4];
} ACT_SetTimeout_COMMAND_DESCRIPTOR_t;

ACT_SetTimeout_COMMAND_DESCRIPTOR_t _ACT_SetTimeoutData = {
    /* entry         */ &TPM2_ACT_SetTimeout,
    /* inSize        */ (UINT16)(sizeof(ACT_SetTimeout_In)),
    /* outSize       */ 0,
    /* offsetOfTypes */ offsetof(ACT_SetTimeout_COMMAND_DESCRIPTOR_t, types),
    /* offsets       */ {(UINT16)(offsetof(ACT_SetTimeout_In, startTimeout))},
    /* types         */
    {TPMI_RH_ACT_H_UNMARSHAL, UINT32_P_UNMARSHAL, END_OF_LIST, END_OF_LIST}};

#    define _ACT_SetTimeoutDataAddress (&_ACT_SetTimeoutData)
#  else
#    define _ACT_SetTimeoutDataAddress 0
#  endif  // CC_ACT_SetTimeout

#  if CC_Vendor_TCG_Test

#    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  // CC_Vendor_TCG_Test

COMMAND_DESCRIPTOR_t* s_CommandDataArray[] = {
#  if(PAD_LIST || CC_NV_UndefineSpaceSpecial)
    (COMMAND_DESCRIPTOR_t*)_NV_UndefineSpaceSpecialDataAddress,
#  endif  // CC_NV_UndefineSpaceSpecial
#  if(PAD_LIST || CC_EvictControl)
    (COMMAND_DESCRIPTOR_t*)_EvictControlDataAddress,
#  endif  // CC_EvictControl
#  if(PAD_LIST || CC_HierarchyControl)
    (COMMAND_DESCRIPTOR_t*)_HierarchyControlDataAddress,
#  endif  // CC_HierarchyControl
#  if(PAD_LIST || CC_NV_UndefineSpace)
    (COMMAND_DESCRIPTOR_t*)_NV_UndefineSpaceDataAddress,
#  endif  // CC_NV_UndefineSpace
#  if(PAD_LIST)
    (COMMAND_DESCRIPTOR_t*)0,
#  endif  //
#  if(PAD_LIST || CC_ChangeEPS)
    (COMMAND_DESCRIPTOR_t*)_ChangeEPSDataAddress,
#  endif  // CC_ChangeEPS
#  if(PAD_LIST || CC_ChangePPS)
    (COMMAND_DESCRIPTOR_t*)_ChangePPSDataAddress,
#  endif  // CC_ChangePPS
#  if(PAD_LIST || CC_Clear)
    (COMMAND_DESCRIPTOR_t*)_ClearDataAddress,
#  endif  // CC_Clear
#  if(PAD_LIST || CC_ClearControl)
    (COMMAND_DESCRIPTOR_t*)_ClearControlDataAddress,
#  endif  // CC_ClearControl
#  if(PAD_LIST || CC_ClockSet)
    (COMMAND_DESCRIPTOR_t*)_ClockSetDataAddress,
#  endif  // CC_ClockSet
#  if(PAD_LIST || CC_HierarchyChangeAuth)
    (COMMAND_DESCRIPTOR_t*)_HierarchyChangeAuthDataAddress,
#  endif  // CC_HierarchyChangeAuth
#  if(PAD_LIST || CC_NV_DefineSpace)
    (COMMAND_DESCRIPTOR_t*)_NV_DefineSpaceDataAddress,
#  endif  // CC_NV_DefineSpace
#  if(PAD_LIST || CC_PCR_Allocate)
    (COMMAND_DESCRIPTOR_t*)_PCR_AllocateDataAddress,
#  endif  // CC_PCR_Allocate
#  if(PAD_LIST || CC_PCR_SetAuthPolicy)
    (COMMAND_DESCRIPTOR_t*)_PCR_SetAuthPolicyDataAddress,
#  endif  // CC_PCR_SetAuthPolicy
#  if(PAD_LIST || CC_PP_Commands)
    (COMMAND_DESCRIPTOR_t*)_PP_CommandsDataAddress,
#  endif  // CC_PP_Commands
#  if(PAD_LIST || CC_SetPrimaryPolicy)
    (COMMAND_DESCRIPTOR_t*)_SetPrimaryPolicyDataAddress,
#  endif  // CC_SetPrimaryPolicy
#  if(PAD_LIST || CC_FieldUpgradeStart)
    (COMMAND_DESCRIPTOR_t*)_FieldUpgradeStartDataAddress,
#  endif  // CC_FieldUpgradeStart
#  if(PAD_LIST || CC_ClockRateAdjust)
    (COMMAND_DESCRIPTOR_t*)_ClockRateAdjustDataAddress,
#  endif  // CC_ClockRateAdjust
#  if(PAD_LIST || CC_CreatePrimary)
    (COMMAND_DESCRIPTOR_t*)_CreatePrimaryDataAddress,
#  endif  // CC_CreatePrimary
#  if(PAD_LIST || CC_NV_GlobalWriteLock)
    (COMMAND_DESCRIPTOR_t*)_NV_GlobalWriteLockDataAddress,
#  endif  // CC_NV_GlobalWriteLock
#  if(PAD_LIST || CC_GetCommandAuditDigest)
    (COMMAND_DESCRIPTOR_t*)_GetCommandAuditDigestDataAddress,
#  endif  // CC_GetCommandAuditDigest
#  if(PAD_LIST || CC_NV_Increment)
    (COMMAND_DESCRIPTOR_t*)_NV_IncrementDataAddress,
#  endif  // CC_NV_Increment
#  if(PAD_LIST || CC_NV_SetBits)
    (COMMAND_DESCRIPTOR_t*)_NV_SetBitsDataAddress,
#  endif  // CC_NV_SetBits
#  if(PAD_LIST || CC_NV_Extend)
    (COMMAND_DESCRIPTOR_t*)_NV_ExtendDataAddress,
#  endif  // CC_NV_Extend
#  if(PAD_LIST || CC_NV_Write)
    (COMMAND_DESCRIPTOR_t*)_NV_WriteDataAddress,
#  endif  // CC_NV_Write
#  if(PAD_LIST || CC_NV_WriteLock)
    (COMMAND_DESCRIPTOR_t*)_NV_WriteLockDataAddress,
#  endif  // CC_NV_WriteLock
#  if(PAD_LIST || CC_DictionaryAttackLockReset)
    (COMMAND_DESCRIPTOR_t*)_DictionaryAttackLockResetDataAddress,
#  endif  // CC_DictionaryAttackLockReset
#  if(PAD_LIST || CC_DictionaryAttackParameters)
    (COMMAND_DESCRIPTOR_t*)_DictionaryAttackParametersDataAddress,
#  endif  // CC_DictionaryAttackParameters
#  if(PAD_LIST || CC_NV_ChangeAuth)
    (COMMAND_DESCRIPTOR_t*)_NV_ChangeAuthDataAddress,
#  endif  // CC_NV_ChangeAuth
#  if(PAD_LIST || CC_PCR_Event)
    (COMMAND_DESCRIPTOR_t*)_PCR_EventDataAddress,
#  endif  // CC_PCR_Event
#  if(PAD_LIST || CC_PCR_Reset)
    (COMMAND_DESCRIPTOR_t*)_PCR_ResetDataAddress,
#  endif  // CC_PCR_Reset
#  if(PAD_LIST || CC_SequenceComplete)
    (COMMAND_DESCRIPTOR_t*)_SequenceCompleteDataAddress,
#  endif  // CC_SequenceComplete
#  if(PAD_LIST || CC_SetAlgorithmSet)
    (COMMAND_DESCRIPTOR_t*)_SetAlgorithmSetDataAddress,
#  endif  // CC_SetAlgorithmSet
#  if(PAD_LIST || CC_SetCommandCodeAuditStatus)
    (COMMAND_DESCRIPTOR_t*)_SetCommandCodeAuditStatusDataAddress,
#  endif  // CC_SetCommandCodeAuditStatus
#  if(PAD_LIST || CC_FieldUpgradeData)
    (COMMAND_DESCRIPTOR_t*)_FieldUpgradeDataDataAddress,
#  endif  // CC_FieldUpgradeData
#  if(PAD_LIST || CC_IncrementalSelfTest)
    (COMMAND_DESCRIPTOR_t*)_IncrementalSelfTestDataAddress,
#  endif  // CC_IncrementalSelfTest
#  if(PAD_LIST || CC_SelfTest)
    (COMMAND_DESCRIPTOR_t*)_SelfTestDataAddress,
#  endif  // CC_SelfTest
#  if(PAD_LIST || CC_Startup)
    (COMMAND_DESCRIPTOR_t*)_StartupDataAddress,
#  endif  // CC_Startup
#  if(PAD_LIST || CC_Shutdown)
    (COMMAND_DESCRIPTOR_t*)_ShutdownDataAddress,
#  endif  // CC_Shutdown
#  if(PAD_LIST || CC_StirRandom)
    (COMMAND_DESCRIPTOR_t*)_StirRandomDataAddress,
#  endif  // CC_StirRandom
#  if(PAD_LIST || CC_ActivateCredential)
    (COMMAND_DESCRIPTOR_t*)_ActivateCredentialDataAddress,
#  endif  // CC_ActivateCredential
#  if(PAD_LIST || CC_Certify)
    (COMMAND_DESCRIPTOR_t*)_CertifyDataAddress,
#  endif  // CC_Certify
#  if(PAD_LIST || CC_PolicyNV)
    (COMMAND_DESCRIPTOR_t*)_PolicyNVDataAddress,
#  endif  // CC_PolicyNV
#  if(PAD_LIST || CC_CertifyCreation)
    (COMMAND_DESCRIPTOR_t*)_CertifyCreationDataAddress,
#  endif  // CC_CertifyCreation
#  if(PAD_LIST || CC_Duplicate)
    (COMMAND_DESCRIPTOR_t*)_DuplicateDataAddress,
#  endif  // CC_Duplicate
#  if(PAD_LIST || CC_GetTime)
    (COMMAND_DESCRIPTOR_t*)_GetTimeDataAddress,
#  endif  // CC_GetTime
#  if(PAD_LIST || CC_GetSessionAuditDigest)
    (COMMAND_DESCRIPTOR_t*)_GetSessionAuditDigestDataAddress,
#  endif  // CC_GetSessionAuditDigest
#  if(PAD_LIST || CC_NV_Read)
    (COMMAND_DESCRIPTOR_t*)_NV_ReadDataAddress,
#  endif  // CC_NV_Read
#  if(PAD_LIST || CC_NV_ReadLock)
    (COMMAND_DESCRIPTOR_t*)_NV_ReadLockDataAddress,
#  endif  // CC_NV_ReadLock
#  if(PAD_LIST || CC_ObjectChangeAuth)
    (COMMAND_DESCRIPTOR_t*)_ObjectChangeAuthDataAddress,
#  endif  // CC_ObjectChangeAuth
#  if(PAD_LIST || CC_PolicySecret)
    (COMMAND_DESCRIPTOR_t*)_PolicySecretDataAddress,
#  endif  // CC_PolicySecret
#  if(PAD_LIST || CC_Rewrap)
    (COMMAND_DESCRIPTOR_t*)_RewrapDataAddress,
#  endif  // CC_Rewrap
#  if(PAD_LIST || CC_Create)
    (COMMAND_DESCRIPTOR_t*)_CreateDataAddress,
#  endif  // CC_Create
#  if(PAD_LIST || CC_ECDH_ZGen)
    (COMMAND_DESCRIPTOR_t*)_ECDH_ZGenDataAddress,
#  endif  // CC_ECDH_ZGen
#  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  // CC_Import
#  if(PAD_LIST || CC_Load)
    (COMMAND_DESCRIPTOR_t*)_LoadDataAddress,
#  endif  // CC_Load
#  if(PAD_LIST || CC_Quote)
    (COMMAND_DESCRIPTOR_t*)_QuoteDataAddress,
#  endif  // CC_Quote
#  if(PAD_LIST || CC_RSA_Decrypt)
    (COMMAND_DESCRIPTOR_t*)_RSA_DecryptDataAddress,
#  endif  // CC_RSA_Decrypt
#  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  // CC_SequenceUpdate
#  if(PAD_LIST || CC_Sign)
    (COMMAND_DESCRIPTOR_t*)_SignDataAddress,
#  endif  // CC_Sign
#  if(PAD_LIST || CC_Unseal)
    (COMMAND_DESCRIPTOR_t*)_UnsealDataAddress,
#  endif  // CC_Unseal
#  if(PAD_LIST)
    (COMMAND_DESCRIPTOR_t*)0,
#  endif  //
#  if(PAD_LIST || CC_PolicySigned)
    (COMMAND_DESCRIPTOR_t*)_PolicySignedDataAddress,
#  endif  // CC_PolicySigned
#  if(PAD_LIST || CC_ContextLoad)
    (COMMAND_DESCRIPTOR_t*)_ContextLoadDataAddress,
#  endif  // CC_ContextLoad
#  if(PAD_LIST || CC_ContextSave)
    (COMMAND_DESCRIPTOR_t*)_ContextSaveDataAddress,
#  endif  // CC_ContextSave
#  if(PAD_LIST || CC_ECDH_KeyGen)
    (COMMAND_DESCRIPTOR_t*)_ECDH_KeyGenDataAddress,
#  endif  // CC_ECDH_KeyGen
#  if(PAD_LIST || CC_EncryptDecrypt)
    (COMMAND_DESCRIPTOR_t*)_EncryptDecryptDataAddress,
#  endif  // CC_EncryptDecrypt
#  if(PAD_LIST || CC_FlushContext)
    (COMMAND_DESCRIPTOR_t*)_FlushContextDataAddress,
#  endif  // CC_FlushContext
#  if(PAD_LIST)
    (COMMAND_DESCRIPTOR_t*)0,
#  endif  //
#  if(PAD_LIST || CC_LoadExternal)
    (COMMAND_DESCRIPTOR_t*)_LoadExternalDataAddress,
#  endif  // CC_LoadExternal
#  if(PAD_LIST || CC_MakeCredential)
    (COMMAND_DESCRIPTOR_t*)_MakeCredentialDataAddress,
#  endif  // CC_MakeCredential
#  if(PAD_LIST || CC_NV_ReadPublic)
    (COMMAND_DESCRIPTOR_t*)_NV_ReadPublicDataAddress,
#  endif  // CC_NV_ReadPublic
#  if(PAD_LIST || CC_PolicyAuthorize)
    (COMMAND_DESCRIPTOR_t*)_PolicyAuthorizeDataAddress,
#  endif  // CC_PolicyAuthorize
#  if(PAD_LIST || CC_PolicyAuthValue)
    (COMMAND_DESCRIPTOR_t*)_PolicyAuthValueDataAddress,
#  endif  // CC_PolicyAuthValue
#  if(PAD_LIST || CC_PolicyCommandCode)
    (COMMAND_DESCRIPTOR_t*)_PolicyCommandCodeDataAddress,
#  endif  // CC_PolicyCommandCode
#  if(PAD_LIST || CC_PolicyCounterTimer)
    (COMMAND_DESCRIPTOR_t*)_PolicyCounterTimerDataAddress,
#  endif  // CC_PolicyCounterTimer
#  if(PAD_LIST || CC_PolicyCpHash)
    (COMMAND_DESCRIPTOR_t*)_PolicyCpHashDataAddress,
#  endif  // CC_PolicyCpHash
#  if(PAD_LIST || CC_PolicyLocality)
    (COMMAND_DESCRIPTOR_t*)_PolicyLocalityDataAddress,
#  endif  // CC_PolicyLocality
#  if(PAD_LIST || CC_PolicyNameHash)
    (COMMAND_DESCRIPTOR_t*)_PolicyNameHashDataAddress,
#  endif  // CC_PolicyNameHash
#  if(PAD_LIST || CC_PolicyOR)
    (COMMAND_DESCRIPTOR_t*)_PolicyORDataAddress,
#  endif  // CC_PolicyOR
#  if(PAD_LIST || CC_PolicyTicket)
    (COMMAND_DESCRIPTOR_t*)_PolicyTicketDataAddress,
#  endif  // CC_PolicyTicket
#  if(PAD_LIST || CC_ReadPublic)
    (COMMAND_DESCRIPTOR_t*)_ReadPublicDataAddress,
#  endif  // CC_ReadPublic
#  if(PAD_LIST || CC_RSA_Encrypt)
    (COMMAND_DESCRIPTOR_t*)_RSA_EncryptDataAddress,
#  endif  // CC_RSA_Encrypt
#  if(PAD_LIST)
    (COMMAND_DESCRIPTOR_t*)0,
#  endif  //
#  if(PAD_LIST || CC_StartAuthSession)
    (COMMAND_DESCRIPTOR_t*)_StartAuthSessionDataAddress,
#  endif  // CC_StartAuthSession
#  if(PAD_LIST || CC_VerifySignature)
    (COMMAND_DESCRIPTOR_t*)_VerifySignatureDataAddress,
#  endif  // CC_VerifySignature
#  if(PAD_LIST || CC_ECC_Parameters)
    (COMMAND_DESCRIPTOR_t*)_ECC_ParametersDataAddress,
#  endif  // CC_ECC_Parameters
#  if(PAD_LIST || CC_FirmwareRead)
    (COMMAND_DESCRIPTOR_t*)_FirmwareReadDataAddress,
#  endif  // CC_FirmwareRead
#  if(PAD_LIST || CC_GetCapability)
    (COMMAND_DESCRIPTOR_t*)_GetCapabilityDataAddress,
#  endif  // CC_GetCapability
#  if(PAD_LIST || CC_GetRandom)
    (COMMAND_DESCRIPTOR_t*)_GetRandomDataAddress,
#  endif  // CC_GetRandom
#  if(PAD_LIST || CC_GetTestResult)
    (COMMAND_DESCRIPTOR_t*)_GetTestResultDataAddress,
#  endif  // CC_GetTestResult
#  if(PAD_LIST || CC_Hash)
    (COMMAND_DESCRIPTOR_t*)_HashDataAddress,
#  endif  // CC_Hash
#  if(PAD_LIST || CC_PCR_Read)
    (COMMAND_DESCRIPTOR_t*)_PCR_ReadDataAddress,
#  endif  // CC_PCR_Read
#  if(PAD_LIST || CC_PolicyPCR)
    (COMMAND_DESCRIPTOR_t*)_PolicyPCRDataAddress,
#  endif  // CC_PolicyPCR
#  if(PAD_LIST || CC_PolicyRestart)
    (COMMAND_DESCRIPTOR_t*)_PolicyRestartDataAddress,
#  endif  // CC_PolicyRestart
#  if(PAD_LIST || CC_ReadClock)
    (COMMAND_DESCRIPTOR_t*)_ReadClockDataAddress,
#  endif  // CC_ReadClock
#  if(PAD_LIST || CC_PCR_Extend)
    (COMMAND_DESCRIPTOR_t*)_PCR_ExtendDataAddress,
#  endif  // CC_PCR_Extend
#  if(PAD_LIST || CC_PCR_SetAuthValue)
    (COMMAND_DESCRIPTOR_t*)_PCR_SetAuthValueDataAddress,
#  endif  // CC_PCR_SetAuthValue
#  if(PAD_LIST || CC_NV_Certify)
    (COMMAND_DESCRIPTOR_t*)_NV_CertifyDataAddress,
#  endif  // CC_NV_Certify
#  if(PAD_LIST || CC_EventSequenceComplete)
    (COMMAND_DESCRIPTOR_t*)_EventSequenceCompleteDataAddress,
#  endif  // CC_EventSequenceComplete
#  if(PAD_LIST || CC_HashSequenceStart)
    (COMMAND_DESCRIPTOR_t*)_HashSequenceStartDataAddress,
#  endif  // CC_HashSequenceStart
#  if(PAD_LIST || CC_PolicyPhysicalPresence)
    (COMMAND_DESCRIPTOR_t*)_PolicyPhysicalPresenceDataAddress,
#  endif  // CC_PolicyPhysicalPresence
#  if(PAD_LIST || CC_PolicyDuplicationSelect)
    (COMMAND_DESCRIPTOR_t*)_PolicyDuplicationSelectDataAddress,
#  endif  // CC_PolicyDuplicationSelect
#  if(PAD_LIST || CC_PolicyGetDigest)
    (COMMAND_DESCRIPTOR_t*)_PolicyGetDigestDataAddress,
#  endif  // CC_PolicyGetDigest
#  if(PAD_LIST || CC_TestParms)
    (COMMAND_DESCRIPTOR_t*)_TestParmsDataAddress,
#  endif  // CC_TestParms
#  if(PAD_LIST || CC_Commit)
    (COMMAND_DESCRIPTOR_t*)_CommitDataAddress,
#  endif  // CC_Commit
#  if(PAD_LIST || CC_PolicyPassword)
    (COMMAND_DESCRIPTOR_t*)_PolicyPasswordDataAddress,
#  endif  // CC_PolicyPassword
#  if(PAD_LIST || CC_ZGen_2Phase)
    (COMMAND_DESCRIPTOR_t*)_ZGen_2PhaseDataAddress,
#  endif  // CC_ZGen_2Phase
#  if(PAD_LIST || CC_EC_Ephemeral)
    (COMMAND_DESCRIPTOR_t*)_EC_EphemeralDataAddress,
#  endif  // CC_EC_Ephemeral
#  if(PAD_LIST || CC_PolicyNvWritten)
    (COMMAND_DESCRIPTOR_t*)_PolicyNvWrittenDataAddress,
#  endif  // CC_PolicyNvWritten
#  if(PAD_LIST || CC_PolicyTemplate)
    (COMMAND_DESCRIPTOR_t*)_PolicyTemplateDataAddress,
#  endif  // CC_PolicyTemplate
#  if(PAD_LIST || CC_CreateLoaded)
    (COMMAND_DESCRIPTOR_t*)_CreateLoadedDataAddress,
#  endif  // CC_CreateLoaded
#  if(PAD_LIST || CC_PolicyAuthorizeNV)
    (COMMAND_DESCRIPTOR_t*)_PolicyAuthorizeNVDataAddress,
#  endif  // CC_PolicyAuthorizeNV
#  if(PAD_LIST || CC_EncryptDecrypt2)
    (COMMAND_DESCRIPTOR_t*)_EncryptDecrypt2DataAddress,
#  endif  // CC_EncryptDecrypt2
#  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_CertifyX509)
    (COMMAND_DESCRIPTOR_t*)_CertifyX509DataAddress,
#  endif  // CC_CertifyX509
#  if(PAD_LIST || CC_ACT_SetTimeout)
    (COMMAND_DESCRIPTOR_t*)_ACT_SetTimeoutDataAddress,
#  endif  // CC_ACT_SetTimeout
#  if(PAD_LIST || CC_ECC_Encrypt)
    (COMMAND_DESCRIPTOR_t*)_ECC_EncryptDataAddress,
#  endif  // CC_ECC_Encrypt
#  if(PAD_LIST || CC_ECC_Decrypt)
    (COMMAND_DESCRIPTOR_t*)_ECC_DecryptDataAddress,
#  endif  // CC_ECC_Decrypt
#  if(PAD_LIST || CC_Vendor_TCG_Test)
    (COMMAND_DESCRIPTOR_t*)_Vendor_TCG_TestDataAddress,
#  endif  // CC_Vendor_TCG_Test
    0};

#endif  // _COMMAND_TABLE_DISPATCH_
