// THIS FILE IS GENERATED AUTOMATICALLY! EDITS WILL BE LOST!
// This file generated by convert-help.py

#include "src/include/pmix_config.h"
#include <stdio.h>
#include <string.h>

#include "src/include/pmix_globals.h"

static pmix_show_help_entry_t ini_entries_0[] = {
    { .topic = "fork-agent-not-found",
      .content = (const char *[]){
                 "The specified fork agent was not found:",
                 "",
                 "Node:        %s",
                 "Fork agent:  %s",
                 "",
                 "The application cannot be launched.",
                 NULL}
    },

    { .topic = "syscall fail",
      .content = (const char *[]){
                 "A system call failed that should not have.  In this particular case,",
                 "a warning or error message was not displayed that should have been.",
                 "Your job may behave unpredictably after this, or abort.",
                 "",
                 "Local host:        %s",
                 "Application name:  %s",
                 "Function:          %s",
                 "Location:          %s:%d",
                 NULL}
    },

    { .topic = "execve error",
      .content = (const char *[]){
                 "PMIx tried to fork a new process via the \"execve\" system call but",
                 "failed.  PMIx checks many things before attempting to launch a",
                 "child process, but nothing is perfect. This error may be indicative",
                 "of another problem on the target host, or even something as silly as",
                 "having specified a directory for your application.",
                 "",
                 "Local host:        %s",
                 "Working dir:       %s",
                 "Application name:  %s",
                 "Error:             %s",
                 NULL}
    },

    { .topic = "msg-too-large",
      .content = (const char *[]){
                 "The error message being sent back to parent by new child is too",
                 "large:",
                 "",
                 "Msg size:   %lu",
                 "Limit:      %lu",
                 "",
                 "This is an unrecoverable error.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_1[] = {
    { .topic = "target full",
      .content = (const char *[]){
                 "PMIx was unable to create a shared memory backing file due",
                 "to inadequate available space:",
                 "",
                 "File: %s",
                 "Node: %s",
                 "Shmem size: %lu",
                 "Space available: %llu",
                 "",
                 "Please set the \"PMIX_MCA_gds=hash\" environmental variable to",
                 "disable the shared memory system and try again.",
                 NULL}
    },

    { .topic = "sys call fail",
      .content = (const char *[]){
                 "",
                 "Node: %s",
                 "SysCall: %s",
                 "Error: %s (%d)",
                 "",
                 "Please set the \"PMIX_MCA_gds=hash\" environmental variable to",
                 "disable the shared memory system and try again.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_2[] = {
    { .topic = "find-available:not-valid",
      .content = (const char *[]){
                 "A requested component was not found, or was unable to be opened.  This",
                 "means that this component is either not installed or is unable to be",
                 "used on your system (e.g., sometimes this means that shared libraries",
                 "that the component requires are unable to be found/loaded).  Note that",
                 "PMIx stopped checking at the first component that it did not find.",
                 "",
                 "Host:      %s",
                 "Framework: %s",
                 "Component: %s",
                 NULL}
    },

    { .topic = "framework-param:too-many-negates",
      .content = (const char *[]){
                 "MCA framework parameters can only take a single negation operator",
                 "(\"^\"), and it must be at the beginning of the value.  The following",
                 "value violates this rule:",
                 "",
                 "%s",
                 "",
                 "When used, the negation operator sets the \"exclusive\" behavior mode,",
                 "meaning that it will exclude all specified components (and implicitly",
                 "include all others).  If the negation operator is not specified, the",
                 "\"inclusive\" mode is assumed, meaning that all specified components",
                 "will be included (and implicitly exclude all others).",
                 "",
                 "For example, \"^a,b\" specifies the exclusive behavior and means \"use",
                 "all components *except* a and b\", while \"c,d\" specifies the inclusive",
                 "behavior and means \"use *only* components c and d.\"",
                 "",
                 "You cannot mix inclusive and exclusive behavior.",
                 NULL}
    },

    { .topic = "internal error during init",
      .content = (const char *[]){
                 "An internal error has occurred during the startup of PMIx.  This",
                 "is highly unusual and shouldn't happen.",
                 "",
                 "The following message may provide additional insight into the error:",
                 "",
                 "Failure at:      %s (%s:%d)",
                 "Error:           %d (%s)",
                 NULL}
    },

    { .topic = "show_load_errors: too many /",
      .content = (const char *[]){
                 "The pmix_mca_base_component_show_load_errors MCA variable cannot",
                 "contain a token that has more than one \"/\" character in it.",
                 "",
                 "The pmix_mca_base_component_show_load_errors MCA variable can only",
                 "contain the values: all, none, or a comma-delimited list of tokens in",
                 "the form of \"framework\" or \"framework/component\".",
                 "",
                 "Erroneous value: %s",
                 NULL}
    },

    { .topic = "failed to add component dir",
      .content = (const char *[]){
                 "The pmix_mca_base_component_path MCA variable was used to add paths to",
                 "search for PMIx components.  At least one directory failed to add",
                 "properly:",
                 "",
                 "%s",
                 "",
                 "Check to make sure that this directory exists, is readable, etc.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_3[] = {
    { .topic = "missing-param-file",
      .content = (const char *[]){
                 "Process %d Unable to locate the variable file \"%s\" in the following search path:",
                 "%s",
                 NULL}
    },

    { .topic = "deprecated-mca-env",
      .content = (const char *[]){
                 "A deprecated MCA variable value was specified in the environment or",
                 "on the command line.  Deprecated MCA variables should be avoided;",
                 "they may disappear in future releases.",
                 "",
                 "Deprecated variable: %s",
                 "New variable:        %s",
                 NULL}
    },

    { .topic = "deprecated-mca-cli",
      .content = (const char *[]){
                 "A deprecated MCA variable value was specified on the command line.  Deprecated",
                 "MCA variables should be avoided; they may disappear in future releases.",
                 "",
                 "Deprecated variable: %s",
                 "New variable:        %s",
                 NULL}
    },

    { .topic = "deprecated-mca-file",
      .content = (const char *[]){
                 "A deprecated MCA variable value was specified in an MCA variable",
                 "file.  Deprecated MCA variables should be avoided; they may disappear",
                 "in future releases.",
                 "",
                 "Deprecated variable: %s",
                 "Source file:         %s",
                 "New variable:        %s",
                 NULL}
    },

    { .topic = "mutually-exclusive-vars",
      .content = (const char *[]){
                 "Two mutually-exclusive MCA variables were specified.  This can result",
                 "in undefined behavior, such as ignoring the components that the MCA",
                 "variables are supposed to affect.",
                 "",
                 "1st MCA variable: %s",
                 "Source of value: %s",
                 "2nd MCA variable: %s",
                 "Source of value: %s",
                 NULL}
    },

    { .topic = "re-register-with-different-type",
      .content = (const char *[]){
                 "An MCA variable was re-registered with a different type (i.e., it was",
                 "either originally registered as an INT and re-registered as a STRING,",
                 "or it was originally registered as a STRING and re-registered as an",
                 "INT).  This a developer error; your job may abort.",
                 "",
                 "MCA variable name: %s",
                 NULL}
    },

    { .topic = "var-name-conflict",
      .content = (const char *[]){
                 "A name collision was detected on an MCA variable name. This can happen",
                 "if two components try to register the same variable with slightly",
                 "different name components. The conflicting variables are listed below:",
                 "",
                 "MCA variable name: %s",
                 "New name: %s %s %s",
                 "Existing name: %s %s %s",
                 NULL}
    },

    { .topic = "overridden-param-set",
      .content = (const char *[]){
                 "WARNING: A user-supplied value attempted to set a variable that is set",
                 "in the override variable file (pmix-mca-params-override.conf).",
                 "",
                 "Variable: %s",
                 "",
                 "The user-supplied value was ignored.",
                 NULL}
    },

    { .topic = "invalid-value",
      .content = (const char *[]){
                 "An invalid value was supplied for an MCA variable.",
                 "",
                 "Variable     : %s",
                 "Value        : %s",
                 NULL}
    },

    { .topic = "invalid-value-enum",
      .content = (const char *[]){
                 "An invalid value was supplied for an enum variable.",
                 "",
                 "Variable     : %s",
                 "Value        : %s",
                 "Valid values : %s",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_4[] = {
    { .topic = "shmem2-segment-attach:address-mismatch",
      .content = (const char *[]){
                 "The gds/shmem2 component attempted to attach to a shared-memory segment at a",
                 "particular base address, but was given a different one. Your job will now likely",
                 "abort.",
                 "",
                 "Requested Address: 0x%zx",
                 "Acquired Address:  0x%zx",
                 "",
                 "If this problem persists, please consider disabling the gds/shmem2 component by",
                 "setting in your environment the following: PMIX_MCA_gds=hash",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_5[] = {
    { .topic = "unavailable",
      .content = (const char *[]){
                 "PMIx was unable to find a usable compression library",
                 "on the system. We will therefore be unable to compress",
                 "large data streams. This may result in longer-than-normal",
                 "startup times and larger memory footprints. We will",
                 "continue, but strongly recommend installing zlib or",
                 "a comparable compression library for better user experience.",
                 "",
                 "You can suppress this warning by adding \"pcompress_base_silence_warning=1\"",
                 "to your PMIx MCA default parameter file, or by adding",
                 "\"PMIX_MCA_pcompress_base_silence_warning=1\" to your environment.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_6[] = {
    { .topic = "reqd-not-found",
      .content = (const char *[]){
                 "The plog_base_order MCA parameter included a required logging",
                 "channel that is not available:",
                 "",
                 "Channel:  %s",
                 "",
                 "Please update the parameter and try again.",
                 NULL}
    },

    { .topic = "syslog:unrec-level",
      .content = (const char *[]){
                 "An unrecognized syslog level was given:",
                 "",
                 "Level:  %s",
                 "",
                 "Please see \"man syslog\" for a list of defined levels. Input",
                 "parameter strings and their corresponding syslog levels",
                 "recognized by PMIx include:",
                 "",
                 "Parameter       Level",
                 "err           LOG_ERR  (default)",
                 "alert         LOG_ALERT",
                 "crit          LOG_CRIT",
                 "emerg         LOG_EMERG",
                 "warn          LOG_WARNING",
                 "not           LOG_NOTICE",
                 "info          LOG_INFO",
                 "debug         LOG_DEBUG",
                 "",
                 "Please redefine the MCA parameter and try again.",
                 NULL}
    },

    { .topic = "syslog:unrec-facility",
      .content = (const char *[]){
                 "An unsupported or unrecognized value was given for the",
                 "syslog facility (i.e., the type of program calling syslog):",
                 "",
                 "Value:  %s",
                 "",
                 "Please see \"man syslog\" for a list of defined facility values.",
                 "PMIx currently supports only the following designations:",
                 "",
                 "Parameter       Level",
                 "auth          LOG_AUTH",
                 "priv          LOG_AUTHPRIV",
                 "daemon        LOG_DAEMON",
                 "user          LOG_USER  (default)",
                 "",
                 "Please redefine the MCA parameter and try again.",
                 NULL}
    },

    { .topic = "smtp:send_email failed",
      .content = (const char *[]){
                 "The PMIx smtp log component was unable to send an email:",
                 "",
                 "Failure: %s",
                 "Issue: %s",
                 "Error: %s (%d)",
                 "Message: %s",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_7[] = {
    { .topic = "missing-file",
      .content = (const char *[]){
                 "The specified configuration file was not found:",
                 "",
                 "File: %s",
                 "",
                 "Please fix and try again.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_8[] = {
    { .topic = "file-stalled",
      .content = (const char *[]){
                 "A specified file is not changing, indicating a possibly stalled application:",
                 "",
                 "File:              %s",
                 "Last size:         %lu",
                 "Last access:       %sLast modification: %s",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_9[] = {
    { .topic = "include-exclude",
      .content = (const char *[]){
                 "Both TCP interface include and exclude lists were specified:",
                 "",
                 "Include: %s",
                 "Exclude: %s",
                 "",
                 "Only one of these can be given.",
                 NULL}
    },

    { .topic = "not-parseable",
      .content = (const char *[]){
                 "The specified network is not parseable. Since we cannot determine",
                 "your desired intent, we cannot establish a TCP socket for PMIx",
                 "communications and will therefore abort. Please correct the network",
                 "specification and retry.",
                 NULL}
    },

    { .topic = "invalid if_inexclude",
      .content = (const char *[]){
                 "WARNING: An invalid value was given for pmix_ptl_base_if_%s.  This",
                 "value will be ignored.",
                 "",
                 "Local host: %s",
                 "Value:      %s",
                 "Message:    %s",
                 NULL}
    },

    { .topic = "accept failed",
      .content = (const char *[]){
                 "WARNING: The accept(3) system call failed on a TCP socket.  While this",
                 "should generally never happen on a well-configured HPC system, the",
                 "most common causes when it does occur are:",
                 "",
                 "* The process ran out of file descriptors",
                 "* The operating system ran out of file descriptors",
                 "* The operating system ran out of memory",
                 "",
                 "Your job may hang until the failure reason is fixed",
                 "(e.g., more file descriptors and/or memory becomes available), and may",
                 "eventually timeout / abort.",
                 "",
                 "Local host:     %s",
                 "Errno:          %d (%s)",
                 "Probable cause: %s",
                 NULL}
    },

    { .topic = "too-many-conns",
      .content = (const char *[]){
                 "PMIx has found multiple possible servers to which it could",
                 "connect. Further guidance is required to ensure the connection",
                 "is made to a desirable server. Guidance can be in the form",
                 "of the namespace or PID of a specific server, a directive to",
                 "connect to a system server, a specific URI to use, or the name",
                 "of a rendezvous file.",
                 "",
                 "Some connection handles have been read from files named pmix.*",
                 "in subdirectories of $TMPDIR; delete them if they are stale.",
                 NULL}
    },

    { .topic = "file-not-found",
      .content = (const char *[]){
                 "There was an error when attempting to access the specified server",
                 "rendezvous file:",
                 "",
                 "Filename:  %s",
                 "Error:     %s",
                 "",
                 "Please correct the error and try again.",
                 NULL}
    },

    { .topic = "mismatch-id",
      .content = (const char *[]){
                 "The %s ID of the client process does not match the ID registered",
                 "by the host runtime:",
                 "",
                 "Process:     %u",
                 "Registered:  %u",
                 "",
                 "This could be a security issue. Please check the situation and",
                 "try again.",
                 NULL}
    },

    { .topic = "no-remote-interfaces",
      .content = (const char *[]){
                 "You requested support for remote tool connections, but no non-loopback",
                 "interfaces were found after applying any include or exclude directives:",
                 "",
                 "Include:    %s",
                 "Exclude:    %s",
                 "Available:  %s",
                 "",
                 "Please adjust your include or exclude to allow selection of a",
                 "non-loopback interface.",
                 NULL}
    },

    { .topic = "no-loopback-interfaces",
      .content = (const char *[]){
                 "You requested support for only local tool connections, but no loopback",
                 "interfaces were found after applying any include or exclude directives:",
                 "",
                 "Include:    %s",
                 "Exclude:    %s",
                 "Available:  %s",
                 "",
                 "Please adjust your include or exclude to allow selection of a",
                 "loopback interface.",
                 NULL}
    },

    { .topic = "no-available-interfaces",
      .content = (const char *[]){
                 "You requested support for tool connections, but no available",
                 "interfaces were found after applying any include or exclude directives:",
                 "",
                 "Include:    %s",
                 "Exclude:    %s",
                 "Available:  %s",
                 "",
                 "Please adjust your include or exclude to allow selection of an",
                 "available interface.",
                 NULL}
    },

    { .topic = "unexpected-message",
      .content = (const char *[]){
                 "The PMIx messaging system has received an unexpected message:",
                 "",
                 "Peer: %s",
                 "Tag:  %u",
                 "",
                 "The message cannot be processed and will be ignored. Please",
                 "report this error to the PMIx developers.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_10[] = {
    { .topic = "pmix_init:startup:internal-failure",
      .content = (const char *[]){
                 "It looks like pmix_init failed for some reason; your parallel process is",
                 "likely to abort.  There are many reasons that a parallel process can",
                 "fail during pmix_init; some of which are due to configuration or",
                 "environment problems.  This failure appears to be an internal failure;",
                 "here's some additional information (which may only be relevant to an",
                 "PMIX developer):",
                 "",
                 "%s failed",
                 "--> Returned value %d instead of PMIX_SUCCESS",
                 NULL}
    },

    { .topic = "no-plugins",
      .content = (const char *[]){
                 "We were unable to find any usable plugins for the %s framework. This PMIx",
                 "framework requires at least one plugin in order to operate. This can be caused",
                 "by any of the following:",
                 "",
                 "* we were unable to build any of the plugins due to some combination",
                 "of configure directives and available system support",
                 "",
                 "* no plugin was selected due to some combination of MCA parameter",
                 "directives versus built plugins (i.e., you excluded all the plugins",
                 "that were built and/or could execute)",
                 "",
                 "* the PMIX_PREFIX environment variable, or the MCA parameter",
                 "\"mca_base_component_path\", is set and doesn't point to any location",
                 "that includes at least one usable plugin for this framework.",
                 "",
                 "Please check your installation and environment.",
                 NULL}
    },

    { .topic = "ptl:msg_size",
      .content = (const char *[]){
                 "A received msg header indicates a size that is too large:",
                 "",
                 "Requested size:  %lu",
                 "Size limit:      %lu",
                 "",
                 "If you believe this msg is legitimate, please increase the",
                 "max msg size via the ptl_base_max_msg_size parameter.",
                 NULL}
    },

    { .topic = "tool:no-server",
      .content = (const char *[]){
                 "A call was made to PMIx_tool_connect_to_server, but no information",
                 "was given as to which server the tool should be connected. Accepted",
                 "attributes include:",
                 "",
                 "- PMIX_CONNECT_TO_SYSTEM: connect solely to the system server",
                 "",
                 "- PMIX_CONNECT_SYSTEM_FIRST: a request to use the system server first,",
                 "if existing, and then look for the server specified in a different",
                 "attribute",
                 "",
                 "- PMIX_SERVER_URI: connect to the server at the given URI",
                 "",
                 "- PMIX_SERVER_NSPACE: connect to the server of a given nspace",
                 "",
                 "- PMIX_SERVER_PIDINFO: connect to a server embedded in the process with",
                 "the given pid",
                 "",
                 "Please correct your program and try again.",
                 NULL}
    },

    { .topic = "reentrant-init",
      .content = (const char *[]){
                 "An attempt was made to call an initialization routine, but the",
                 "PMIx library has already been initialized:",
                 "",
                 "Function: %s",
                 "",
                 "Multiple calls to init are not supported. Please correct your program.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_11[] = {
    { .topic = "listener-thread-start",
      .content = (const char *[]){
                 "The PMIx server's listener thread failed to start. We cannot",
                 "continue.",
                 NULL}
    },

    { .topic = "collection-mismatch",
      .content = (const char *[]){
                 "Collection strategy during a collective operation (e.g., PMIx_Fence)",
                 "is not homogeneous - at least one participating node has a",
                 "collection strategy (i.e., collect vs non-collect) that differs",
                 "from the other nodes. This must be corrected in order for us",
                 "to proceed.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_12[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION]...",
                 "PMIx Allocation Request tool",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--nspace <arg0>                   Synonym for \"namespace\"",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server-only              Connect only to a system-level server",
                 "--system-controller               Connect to the system controller",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--connect-order <arg0>            Specify search order for server connections - e.g., scheduler,",
                 "system controller, system-level server, or local server",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "",
                 "--request-id <arg0>               String identifier for this allocation request",
                 "-q|--queue <arg0>                    Scheduler queue this request should be passed to for processing",
                 "-N|--nodes <arg0>                    Number of nodes to be allocated",
                 "-i|--image <arg0>                    OS image to be provisioned on allocated nodes prior to initiating",
                 "execution of specified job, or turning nodes over to an interactive",
                 "session",
                 "-x|--exclude <arg0>                  Comma-delimited list of nodes that are to be excluded from",
                 "consideration for scheduling this allocation",
                 "--wait-all-nodes                  Wait for all nodes to be ready before starting execution of the",
                 "specified job.",
                 "-w|--nodelist <arg0>                 Comma-delimited list of ranges of specific nodes being requested",
                 NULL}
    },

    { .topic = "e.g., host0[1-5",
      .content = (const char *[]){
                 "using the \"file:<path>\" syntax. Ordering of names and/or duplicate",
                 "names are ignored.",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 "",
                 "",
                 NULL}
    },

    { .topic = "bad-option-input",
      .content = (const char *[]){
                 "%s was given an option that expected a string argument:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "expected: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "file-open-error",
      .content = (const char *[]){
                 "%s was unable to open the specified file provided as an option:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "bad-file",
      .content = (const char *[]){
                 "%s was unable to read the necessary info from the provided file:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option or the file and try again.",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "Specify the URI of the DVM master, or the name of the file (specified as",
                 "file:filename) that contains that info",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "Max number of times to try to connect to the specified server (int)",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*)",
                 NULL}
    },

    { .topic = "nspace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*) - synonym for \"namespace\"",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server-only",
      .content = (const char *[]){
                 "Connect only to a system-level server - abort if one is not found",
                 NULL}
    },

    { .topic = "system-controller",
      .content = (const char *[]){
                 "Look for a system controller and connect to it if found",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Define the root location for the session directory tree where the",
                 "rendezvous files can be found.",
                 "",
                 "The rendezvous files contain connection information for a target",
                 "server and are located in the session directory tree. It may be necessary to point the",
                 "tool at the location where those files can be found if that location is other than the",
                 "expected default.",
                 "",
                 "The root of the session directory defaults to the system temporary directory",
                 "as defined in the environment using (in precedence order) the envars TMPDIR, TEMP, and",
                 "finally TMP. In the absence of any of those variables, PMIx will default to the \"/tmp\"",
                 "location.",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "connect-order",
      .content = (const char *[]){
                 "Comma-delimited list of attributes defining the order in which",
                 "connections should be attempted, from first to last. If the",
                 "final entry is not an \"only\" flag (e.g., PMIX_CONNECT_TO_SYSTEM),",
                 "then connection will default to the local server if no preceding",
                 "option succeeds. Thus, the following list:",
                 "PMIX_CONNECT_TO_SCHEDULER",
                 "PMIX_CONNECT_TO_SYS_CONTROLLER",
                 "PMIX_CONNECT_TO_SYSTEM",
                 "would first attempt to connect to the scheduler, then the system",
                 "controller, and then the local system-level server. If none of those",
                 "succeed, then the connection attempt will error out.",
                 "",
                 "However, if the last entry were PMIX_CONNECT_SYSTEM_FIRST, then the",
                 "connection procedure would (after failing to connect to a local",
                 "system-level server) continue to include an attempt to connect",
                 "to any local server that accepted the connection request.",
                 NULL}
    },

    { .topic = "request-id",
      .content = (const char *[]){
                 "String identifier for this allocation request. The request ID can be used for",
                 "subsequent query of request status and as a synonym for the eventual session ID",
                 "assigned by the scheduler. Note that a request ID that matches a previously",
                 "submitted request will be rejected by the scheduler - so care should be taken",
                 "to ensure that the ID provided is unique and not previously used.",
                 NULL}
    },

    { .topic = "queue",
      .content = (const char *[]){
                 "Scheduler queue this request should be passed to for processing. Most schedulers",
                 "have a number of queues for requests, each queue typically representing a priority",
                 "or class of request used in the scheduling process. Users should check the names",
                 "of the queues for their system using the \"pquery\" tool and submit allocation",
                 "requests accordingly.",
                 NULL}
    },

    { .topic = "nodes",
      .content = (const char *[]){
                 "The number of nodes to be allocated. In systems where nodes are being subdivided for",
                 "allocation (e.g., allocating individual cores or hwthreads), it may be necessary to",
                 "provide a more detailed description of the requested resources.",
                 NULL}
    },

    { .topic = "image",
      .content = (const char *[]){
                 "OS image to be provisioned on allocated nodes prior to initiating",
                 "execution of specified job, or turning nodes over to an interactive",
                 "session. Names of the available images can be obtained using the",
                 "\"pquery\" tool.",
                 NULL}
    },

    { .topic = "exclude",
      .content = (const char *[]){
                 "Comma-delimited list of nodes that are to be excluded from",
                 "consideration for scheduling this allocation",
                 NULL}
    },

    { .topic = "wait-all-nodes",
      .content = (const char *[]){
                 "Wait for all nodes to be ready before starting execution of the",
                 "specified job.",
                 NULL}
    },

    { .topic = "nodelist",
      .content = (const char *[]){
                 "Comma-delimited list of ranges of specific nodes being requested",
                 NULL}
    },

    { .topic = "uid",
      .content = (const char *[]){
                 "Assign the resulting allocation to the specified user ID. Value",
                 "can be provided as either an integer or a username",
                 NULL}
    },

    { .topic = "gid",
      .content = (const char *[]){
                 "Assign the resulting allocation to the specified group ID. Value",
                 "can be provided as either an integer or a group name. Typically",
                 "used for determining file access permissions and for system",
                 "accounting.",
                 NULL}
    },

    { .topic = "time",
      .content = (const char *[]){
                 "Time limit on the assigned allocation.  When the time limit is reached,",
                 "each process executing in the session is sent SIGTERM followed by SIGKILL.",
                 "The session is then terminated and all resources returned to the",
                 "scheduler for reuse. Time is specified in the usual time format of",
                 "months:days:hours:minutes:seconds, scanning from right to left (i.e., a",
                 "value of \"2\" equates to 2 seconds)",
                 NULL}
    },

    { .topic = "signal",
      .content = (const char *[]){
                 "When a session is within the specified seconds of its end time, send all",
                 "processes executing within it the specified signal. The <arg0> signal may",
                 "be a signal number or string name. The optional <arg1> time is taken in",
                 "seconds, defaulting to 60 seconds if not specified.",
                 NULL}
    },

    { .topic = "share",
      .content = (const char *[]){
                 "Allocated resources can be shared with other allocations.",
                 NULL}
    },

    { .topic = "extend",
      .content = (const char *[]){
                 "Extend the specified existing session ID per the rest of the given request.",
                 "For example, an existing session can have additional nodes allocated to",
                 "it, or could have its time limit increased.",
                 NULL}
    },

    { .topic = "shrink",
      .content = (const char *[]){
                 "Shrink the specified existing session ID per the rest of the given request.",
                 "For example, an existing session could have a certain number of nodes",
                 "removed (returning them to the scheduler for reassignment), or its",
                 "time reduced.",
                 NULL}
    },

    { .topic = "no-shell",
      .content = (const char *[]){
                 "Immediately exit after allocating resources, without running a command.",
                 "However, the session will still be created and will remain active and own",
                 "the allocated resources as long as it is active - i.e., it will be an",
                 "active session with an assigned session ID with no job executing within it.",
                 "You can submit commands against this resource allocation (e.g., using \"prun\")",
                 "if you specify the appropriate connection identification for this allocation.",
                 "Note that the session is subject to the normal constraints on sessions, including",
                 "time limits, so that eventually the session will terminate and the resources",
                 "will be freed, or you can terminate the session manually using the \"pcancel\"",
                 "command.",
                 NULL}
    },

    { .topic = "begin",
      .content = (const char *[]){
                 "Direct the scheduler to defer allocation until the specified time. Time may be",
                 "of the form HH:MM:SS to schedule the session to start at a specific time of day",
                 "(seconds are optional). If that time is already past, the next day is assumed.",
                 "You may also specify \"midnight\" or \"noon\", and you can have a time-of-day suffixed",
                 "with AM or PM for running in the morning or the evening. You can also say what",
                 "day the session should start by specifying a date of the form MMDDYY or MM/DD/YY",
                 "YYYY-MM-DD. Combine date and time using the usual format YYYY-MM-DD[THH:MM[:SS]].",
                 "You can also give times like \"now + count\" time-units, where the time-units can",
                 "be \"seconds\" (default), \"minutes\", \"hours\", days, or weeks, or you can ask that",
                 "the allocation be made \"today\" or \"tomorrow\".",
                 NULL}
    },

    { .topic = "immediate",
      .content = (const char *[]){
                 "Exit if resources are not available within the time period specified. If no argument",
                 "is given, resources must be available immediately for the request to succeed. By",
                 "default, \"immediate\" is off, and the command will block until resources become",
                 "available. Since this",
                 "option's argument is optional, for proper parsing the single",
                 "letter option must be followed by an equal sign and the value - e.g., \"-I=60\"",
                 "for a time of 60 seconds or \"-I30:00\" for a time of 30 minutes.",
                 NULL}
    },

    { .topic = "dependency",
      .content = (const char *[]){
                 "Defer the start of this session until the specified dependencies have successfully",
                 "completed. The dependencies are provided as a comma-delimited list of session IDs.",
                 "All specified dependencies must be satisfied before the given allocation request",
                 "will be scheduled.",
                 NULL}
    },

    { .topic = "do-not-wait",
      .content = (const char *[]){
                 "Submit the allocation request to the scheduler, but do not wait for the allocation",
                 "to be assigned. Intended for use when submitting a job for batch execution. Users",
                 "should provide a string request ID to enable subsequent queries of request status.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_13[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION]...",
                 "PMIx Supported Attributes and Functions tool",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--do-not-connect                  Do not connect to a server",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server                   Connect to a system-level server",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "",
                 "--client <arg0>                   Comma-delimited list of client functions whose attributes are to be",
                 "printed (function or \"all\")",
                 "--server <arg0>                   Comma-delimited list of server functions whose attributes are to be",
                 "printed (function or \"all\")",
                 "--tool <arg0>                     Comma-delimited list of tool functions whose attributes are to be",
                 "printed (function or \"all\")",
                 "--host <arg0>                     Comma-delimited list of host functions whose attributes are to be",
                 "printed (function or \"all\")",
                 "--client-fns                      List the functions supported in this client library",
                 "--server-fns                      List the functions supported in this server library",
                 "--tool-fns                        List the functions supported in this tool library",
                 "--host-fns                        List the functions supported by this host environment",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 "",
                 NULL}
    },

    { .topic = "do-not-connect",
      .content = (const char *[]){
                 "Do not attempt to connect to a PMIx server",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "Specify the URI of the PMIx server we are to contact, or the name of the file (specified as",
                 "file:filename) that contains that info",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*)",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server",
      .content = (const char *[]){
                 "Connect only to a system-level server - abort if one is not found",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Set the root for the session directory tree",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "Max number of times to try to connect to the specified server (int)",
                 NULL}
    },

    { .topic = "client",
      .content = (const char *[]){
                 "Comma-delimited list of client functions whose attributes are to be printed (function or \"all\")",
                 NULL}
    },

    { .topic = "server",
      .content = (const char *[]){
                 "Comma-delimited list of server functions whose attributes are to be printed (function or \"all\")",
                 NULL}
    },

    { .topic = "tool",
      .content = (const char *[]){
                 "Comma-delimited list of tool functions whose attributes are to be printed (function or \"all\")",
                 NULL}
    },

    { .topic = "host",
      .content = (const char *[]){
                 "Comma-delimited list of host functions whose attributes are to be printed (function or \"all\")",
                 NULL}
    },

    { .topic = "client-fns",
      .content = (const char *[]){
                 "List the functions supported in this client library",
                 NULL}
    },

    { .topic = "server-fns",
      .content = (const char *[]){
                 "List the functions supported in this server library",
                 NULL}
    },

    { .topic = "tool-fns",
      .content = (const char *[]){
                 "List the functions supported in this tool library",
                 NULL}
    },

    { .topic = "host-fns",
      .content = (const char *[]){
                 "List the functions supported by this host environment",
                 NULL}
    },

    { .topic = "bad-option-input",
      .content = (const char *[]){
                 "%s was given an option that expected a string argument:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "expected: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "file-open-error",
      .content = (const char *[]){
                 "%s was unable to open the specified file provided as an option:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "bad-file",
      .content = (const char *[]){
                 "%s was unable to read the necessary info from the provided file:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option or the file and try again.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_14[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION]...",
                 "PMIx Job control tool",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--nspace <arg0>                   Synonym for \"namespace\"",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server-only              Connect only to a system-level server",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "",
                 "--request-id <arg0>               String identifier for this job control request",
                 "--pause                           Pause the specified processes",
                 "--resume                          \"Un-pause\" the specified processes",
                 "--cancel <arg0>                   Cancel the specified request ID (\"all\" => cancel all requests from this requestor)",
                 "--kill                            Force terminate the specified processes",
                 "--terminate                       Politely terminate the specified processes",
                 "--signal <arg0>                   Provide the specified processes with the given signal",
                 "--restart <arg0>                  Restart the specified processes using the given checkpoint ID",
                 "--checkpoint <arg0>               Checkpoint the specified processes and assign the given ID to it",
                 "--pset <arg0>                     Define a new pset (with the given name) whose membership is",
                 "comprised of the specified processes",
                 "--targets <arg0>                  Comma-delimited list of target processes for the requested",
                 "job-control operation",
                 "",
                 "Report bugs to %s",
                 "",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "Specify the URI of the DVM master, or the name of the file (specified as",
                 "file:filename) that contains that info",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "Max number of times to try to connect to the specified server (int)",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*)",
                 NULL}
    },

    { .topic = "nspace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*) - synonym for \"namespace\"",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server-only",
      .content = (const char *[]){
                 "Connect only to a system-level server - abort if one is not found",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Define the root location for the session directory tree where the",
                 "rendezvous files can be found.",
                 "",
                 "The rendezvous files contain connection information for a target",
                 "server and are located in the session directory tree. It may be necessary to point the",
                 "tool at the location where those files can be found if that location is other than the",
                 "expected default.",
                 "",
                 "The root of the session directory defaults to the system temporary directory",
                 "as defined in the environment using (in precedence order) the envars TMPDIR, TEMP, and",
                 "finally TMP. In the absence of any of those variables, PMIx will default to the \"/tmp\"",
                 "location.",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "request-id",
      .content = (const char *[]){
                 "String identifier for this job control request. The request ID can be used for",
                 "subsequent query of request status and/or cancellation of the request. Note that",
                 "a request ID that matches a currently active request will be rejected - so care should be taken",
                 "to ensure that the ID provided is unique and not currently in use.",
                 NULL}
    },

    { .topic = "pause",
      .content = (const char *[]){
                 "Pause the specified processes. This typically takes the form of applying a SIGSTOP",
                 "to the specified processes. The pctrl tool will return a status indicating whether",
                 "or not the operation succeeded.",
                 NULL}
    },

    { .topic = "resume",
      .content = (const char *[]){
                 "Direct the specified processes to resume execution. This typically takes the form",
                 "of applying a SIGCONT signal to the specified processes. The pctrl tool will return",
                 "a status indicating whether or not the operation succeeded.",
                 NULL}
    },

    { .topic = "cancel",
      .content = (const char *[]){
                 "Cancel the specified request ID. The provided ID must match the ID provided to",
                 "a prior request - if the ID cannot be found, then a PMIX_ERR_NOT_FOUND status",
                 "shall be returned by pctrl.",
                 NULL}
    },

    { .topic = "kill",
      .content = (const char *[]){
                 "Force terminate the specified processes. Precise behavior depends upon the",
                 "runtime environment. However, typically the specified processes will receive",
                 "the following sequence of signals:",
                 "",
                 "* SIGCONT - wakeup a sleeping process",
                 "* SIGTERM - provide a trappable signal indicating that the process",
                 "should cleanly exit, if possible",
                 "* SIGKILL - forcibly terminate the process",
                 "",
                 "The pctrl tool will return a status indicating whether or not the operation",
                 "succeeded (i.e., all processes exited).",
                 NULL}
    },

    { .topic = "terminate",
      .content = (const char *[]){
                 "Politely terminate the specified processes. Precise behavior depends upon the",
                 "runtime environment. However, typically the specified processes will receive",
                 "the following sequence of signals:",
                 "",
                 "* SIGCONT - wakeup a sleeping process",
                 "* SIGTERM - provide a trappable signal indicating that the process",
                 "should cleanly exit, if possible",
                 "",
                 "The pctrl tool will return a status indicating whether or not the operation",
                 "succeeded (i.e., the processes terminated)",
                 NULL}
    },

    { .topic = "signal",
      .content = (const char *[]){
                 "Provide the specified processes with the given signal. Signals are to be",
                 "provided via their name (e.g., SIGTERM, SIGKILL) or an integer value",
                 "(e.g., -9).",
                 NULL}
    },

    { .topic = "restart",
      .content = (const char *[]){
                 "\"Un-pause\" the specified processes - usually implemented by applying a",
                 "SIGCONT signal to the processes.",
                 NULL}
    },

    { .topic = "checkpoint",
      .content = (const char *[]){
                 "Checkpoint the specified processes and assign the given ID to it. The checkpoint",
                 "operation will be conducted according to the method specified when the processes",
                 "were originally spawned. Support for this operation therefore depends both on the",
                 "capabilities of the runtime environment _and_ the application being told to",
                 "checkpoint.",
                 NULL}
    },

    { .topic = "pset",
      .content = (const char *[]){
                 "Define a new pset (with the given name) whose membership is comprised of the",
                 "specified processes.",
                 NULL}
    },

    { .topic = "targets",
      .content = (const char *[]){
                 "Comma-delimited list of target processes for the requested job-control",
                 "operation. Wildcard ranks (e.g., to apply the request to all processes",
                 "in the specified namespace) can be indicated with an asterisk ('*'). Syntax",
                 "requires that each process be identified as \"nspace:rank\". Note that",
                 "typical command line restrictions may necessitate the use of special",
                 "delimiters - e.g., \"my;weird.nspace:5\".",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_15[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION] <EVENT>",
                 "Inject PMIx events",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server                   Connect to a system server if a local server isn't found",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "",
                 "--range <arg0>                    Range of event to be sent",
                 "",
                 "The provided event can be either an integer status code (e.g., -31) or",
                 "the string name of a status code (e.g., \"PMIX_EVENT_NODE_DOWN\")",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 "",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "range",
      .content = (const char *[]){
                 "Range (pmix_range_t) of event to be sent",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Set the root for the session directory tree",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "",
                 "Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "",
                 "Namespace of the daemon to which we should connect",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "",
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server",
      .content = (const char *[]){
                 "",
                 "Connect to a system server if a local server isn't found",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "",
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "",
                 "Max number of times to try to connect",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_16[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION] <KEY1>,<KEY2>,...",
                 "PMIx Lookup tool",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--timeout <arg0>                  Max number of seconds to wait for data to become available",
                 "--wait                            Wait for data to be available",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 "",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Set the root for the session directory tree",
                 NULL}
    },

    { .topic = "timeout",
      .content = (const char *[]){
                 "Max number of seconds to wait for data to become available",
                 NULL}
    },

    { .topic = "wait",
      .content = (const char *[]){
                 "Wait for data to be available",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_17[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION]...",
                 "PMIx Library Information",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <key> <value>           Pass context-specific PMIx MCA parameters (\"key\" is the parameter",
                 "name; \"value\" is the parameter value)",
                 "",
                 "-a|--all                             Show all configuration options and MCA parameters",
                 "--arch                            Show architecture PMIx was compiled on",
                 "-c|--config                          Show configuration options",
                 "--hostname                        Show the hostname that PMIx was configured and built on",
                 "--internal                        Show internal MCA parameters (not meant to be modified by users)",
                 "--param <arg0>:<arg1>,<arg2>      Show MCA parameters.  The first parameter is the framework (or the",
                 "keyword \"all\"); the second parameter is a comma-delimited list of",
                 "specific component names (if only <arg0> is given, then all",
                 "components will be reported).",
                 "--params <arg0>:<arg1>,<arg2>     Synonym for \"param\"",
                 "--path <type>                     Show paths with which PRRTE was configured. Accepts the following",
                 "parameters: \"prefix\", \"bindir\", \"libdir\", \"incdir\", \"mandir\",",
                 "\"pkglibdir\", \"sysconfdir\".",
                 "--show-version <arg0>:<arg1>      Show version of PMIx or a component.  The first parameter can be the",
                 "keywords \"pmix\" or \"all\", a framework name (indicating all components in",
                 "a framework), or a framework:component string (indicating a specific",
                 "component).  The second parameter can be one of: full, major, minor,",
                 "release, greek, svn.",
                 "--pretty-print                    When used in conjunction with other parameters, the output is",
                 "displayed in 'pretty-print' format (default)",
                 "--parsable                        When used in conjunction with other parameters, the output is",
                 "displayed in a machine-parsable format",
                 "--parseable                       Synonym for --parsable",
                 "--color <hue>                     Control color coding: auto (default), never, always",
                 "",
                 "--show-failed                     Show the components that failed to load along with the reason why they failed",
                 "--selected-only                   Show only variables from selected components",
                 "-t| --type                           Show MCA parameters of the type specified in parameter. Accepts the following",
                 "parameters: \"unsigned_int\", \"unsigned_long\", \"unsigned_long_long\", \"size_t\",",
                 "\"string\", \"version_string\", \"bool\", and \"double\"",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"--pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 NULL}
    },

    { .topic = "param",
      .content = (const char *[]){
                 "Syntax: param <arg0> <arg1>",
                 "Show MCA parameters.  The first parameter is the framework (or the",
                 "keyword \"all\"); the second parameter is the specific component name (or",
                 "the keyword \"all\").",
                 NULL}
    },

    { .topic = "params",
      .content = (const char *[]){
                 "Synonym for \"param\"",
                 NULL}
    },

    { .topic = "internal",
      .content = (const char *[]){
                 "Syntax: internal",
                 "Show internal MCA parameters (i.e., parameters not meant to be modified by users)",
                 NULL}
    },

    { .topic = "path",
      .content = (const char *[]){
                 "Syntax: path <arg0>",
                 "Show the paths with which PMIx was configured.  Accepts the following",
                 "parameters: prefix, bindir, libdir, incdir, mandir, pkglibdir,",
                 "sysconfdir",
                 NULL}
    },

    { .topic = "arch",
      .content = (const char *[]){
                 "Syntax: arch",
                 "Show architecture PMIx was compiled on",
                 NULL}
    },

    { .topic = "config",
      .content = (const char *[]){
                 "Syntax: c or config",
                 "Show configuration options used to configure PMIx",
                 NULL}
    },

    { .topic = "hostname",
      .content = (const char *[]){
                 "Syntax: hostname",
                 "Show the hostname upon which PMIx was configured and built",
                 NULL}
    },

    { .topic = "all",
      .content = (const char *[]){
                 "Syntax: a or all",
                 "Show all configuration options and MCA parameters",
                 NULL}
    },

    { .topic = "show-version",
      .content = (const char *[]){
                 "Show version of PMIx or a component.  The first parameter can be the",
                 "keywords \"pmix\" or \"all\", a framework name (indicating all components in",
                 "a framework), or a framework:component string (indicating a specific",
                 "component).  The second parameter can be one of: full, major, minor,",
                 "release, greek, repo.",
                 NULL}
    },

    { .topic = "pretty-print",
      .content = (const char *[]){
                 "When used in conjunction with other parameters, the output is",
                 "displayed in 'pretty-print' format (default)",
                 NULL}
    },

    { .topic = "parsable",
      .content = (const char *[]){
                 "When used in conjunction with other parameters, the output is",
                 "displayed in a machine-parsable format",
                 NULL}
    },

    { .topic = "parseable",
      .content = (const char *[]){
                 "When used in conjunction with other parameters, the output is",
                 "displayed in a machine-parsable format",
                 NULL}
    },

    { .topic = "color",
      .content = (const char *[]){
                 "Control color coding: auto (default), never, always",
                 NULL}
    },

    { .topic = "show-failed",
      .content = (const char *[]){
                 "Show the components that failed to load along with the reason why they failed",
                 NULL}
    },

    { .topic = "selected-only",
      .content = (const char *[]){
                 "Show only variables from selected (active) components",
                 NULL}
    },

    { .topic = "type",
      .content = (const char *[]){
                 "Show MCA parameters of the type specified in parameter. Accepts the following",
                 "parameters: \"unsigned_int\", \"unsigned_long\", \"unsigned_long_long\", \"size_t\",",
                 "\"string\", \"version_string\", \"bool\", and \"double\"",
                 NULL}
    },

    { .topic = "lib-call-fail",
      .content = (const char *[]){
                 "A library call unexpectedly failed.  This is a terminal error; please",
                 "show this message to an ORTE wizard:",
                 "",
                 "Library call: %s",
                 "Source file: %s",
                 "Source line number: %d",
                 "",
                 "Aborting...",
                 NULL}
    },

    { .topic = "developer warning: field too long",
      .content = (const char *[]){
                 "**************************************************************************",
                 "*** DEVELOPER WARNING: A field in pmix_info output is too long and",
                 "*** will appear poorly in the prettyprint output.",
                 "***",
                 "***   Value:      \"%s\"",
                 "***   Max length: %d",
                 "**************************************************************************",
                 NULL}
    },

    { .topic = "not-found",
      .content = (const char *[]){
                 "The specified framework could not be found:",
                 "",
                 "Framework: %s",
                 "",
                 "This could be due to a misspelling of the framework name, or because support",
                 "for that framework was not configured into this version of orte. Please see",
                 "the \"config\" option for a full report of how PMIx was configured.",
                 NULL}
    },

    { .topic = "missing-values",
      .content = (const char *[]){
                 "The %s option requires %d values, but fewer were provided:",
                 "",
                 "Option:  %s",
                 "Value:   %s",
                 "",
                 "Please correct this and try again.",
                 NULL}
    },

    { .topic = "no-args",
      .content = (const char *[]){
                 "",
                 "The %s command does not accept arguments other than those specifically",
                 "defined by the command. The following were not recognized:",
                 "",
                 "Args: %s",
                 "",
                 "Please see \"%s --help\" for a description of all accepted command",
                 "options.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_18[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION]...",
                 "PMIx Job and Process Status Tool",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server                   Connect to a system-level server",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "--nodes                           Display Node Information",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "Specify the URI of the PMIx server we are to contact, or the name of the file (specified as",
                 "file:filename) that contains that info",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "Namespace of the daemon we are to connect to (char*)",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server",
      .content = (const char *[]){
                 "Connect only to a system-level server - abort if one is not found",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Set the root for the session directory tree",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "Max number of times to try to connect to the specified server (int)",
                 NULL}
    },

    { .topic = "nodes",
      .content = (const char *[]){
                 "Display node-level information",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_19[] = {
    { .topic = "version",
      .content = (const char *[]){
                 "",
                 "%s (%s) %s",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION] KEY[qualifier(s)]",
                 "PMIx Query tool",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "-h|--help                            This help message",
                 "-h|--help <arg0>                     Help for the specified option",
                 "-v|--verbose                         Enable typical debug options",
                 "-V|--version                         Print version and exit",
                 "--pmixmca <arg0> <arg1>           Set MCA parameter value",
                 "",
                 "--uri <arg0>                      Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 "--namespace <arg0>                Namespace of the daemon to which we should connect",
                 "--pid <arg0>                      PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 "--system-server-first             First look for a system server and connect to it if found",
                 "--system-server                   Connect to a system-level server",
                 "--tmpdir <arg0>                   Set the root for the session directory tree",
                 "--wait-to-connect <arg0>          Delay specified number of seconds before trying to connect",
                 "--num-connect-retries <arg0>      Max number of times to try to connect",
                 "",
                 "Keys passed to pquery may optionally include one or more qualifiers, with the",
                 "individual qualifiers delimited by semi-colons. For example:",
                 "",
                 "PMIX_STORAGE_XFER_SIZE[PMIX_STORAGE_ID=lustre1,lustre2;PMIX_STORAGE_PATH=foo]",
                 "",
                 "Report bugs to %s",
                 NULL}
    },

    { .topic = "pmixmca",
      .content = (const char *[]){
                 "",
                 "Pass a PMIx MCA parameter",
                 "",
                 "Syntax: \"pmixmca <key> <value>\", where \"key\" is the parameter name",
                 "and \"value\" is the parameter value.",
                 NULL}
    },

    { .topic = "uri",
      .content = (const char *[]){
                 "",
                 "Specify the URI of the server to which we are to connect, or",
                 "the name of the file (specified as file:filename) that contains that info",
                 NULL}
    },

    { .topic = "namespace",
      .content = (const char *[]){
                 "",
                 "Namespace of the daemon to which we should connect",
                 NULL}
    },

    { .topic = "system-server-first",
      .content = (const char *[]){
                 "",
                 "First look for a system server and connect to it if found",
                 NULL}
    },

    { .topic = "system-server",
      .content = (const char *[]){
                 "",
                 "Connect to a system server if a local server isn't found",
                 NULL}
    },

    { .topic = "pid",
      .content = (const char *[]){
                 "PID of the daemon to which we should connect (int => PID or file:<file>",
                 "for file containing the PID",
                 NULL}
    },

    { .topic = "wait-to-connect",
      .content = (const char *[]){
                 "",
                 "Delay specified number of seconds before trying to connect",
                 NULL}
    },

    { .topic = "num-connect-retries",
      .content = (const char *[]){
                 "",
                 "Max number of times to try to connect",
                 NULL}
    },

    { .topic = "tmpdir",
      .content = (const char *[]){
                 "Set the root for the session directory tree",
                 NULL}
    },

    { .topic = "bad-option-input",
      .content = (const char *[]){
                 "%s was given an option that expected a string argument:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "expected: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "file-open-error",
      .content = (const char *[]){
                 "%s was unable to open the specified file provided as an option:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option and try again.",
                 NULL}
    },

    { .topic = "bad-file",
      .content = (const char *[]){
                 "%s was unable to read the necessary info from the provided file:",
                 "",
                 "option: %s",
                 "argument: %s",
                 "file: %s",
                 "",
                 "Please correct the option or the file and try again.",
                 NULL}
    },

    { .topic = "bad-quals",
      .content = (const char *[]){
                 "%s was unable to parse the command line because it found a",
                 "qualifier that is not correct:",
                 "",
                 "Qualifier: %s",
                 "",
                 "Qualifiers must be of the form \"[qual1=value1;qual2=val2;...]\".",
                 "Please correct the command line and try again.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_20[] = {
    { .topic = "usage",
      .content = (const char *[]){
                 "%s (%s) %s",
                 "",
                 "Usage: %s [OPTION] <args>",
                 "PMIx wrapper compiler",
                 "",
                 "",
                 "/*****      General Options      *****/",
                 "",
                 "--showme:command         Show command used to invoke real compiler",
                 "--showme:compile         Show flags added when compiling",
                 "--showme:link            Show flags added when linking",
                 "--showme:incdirs         Show list of include dirs added when compiling",
                 "--showme:libdirs         Show list of library dirs added when linking",
                 "--showme:libdirs_static  Show list of static library dirs added when linking",
                 "--showme:libs            Show list of libraries added when linking",
                 "--showme:libs_static     Show list of static libraries added when linking",
                 "--showme:version         Show version of PMIx library",
                 "--showme:help            This help message",
                 "",
                 "where \"args\" consists of compiler flags and sources that are to",
                 "be compiled",
                 "",
                 "Report bugs to %s",
                 "",
                 NULL}
    },

    { .topic = "version",
      .content = (const char *[]){
                 "%s: %s %s (Language: %s)",
                 NULL}
    },

    { .topic = "no-language-support",
      .content = (const char *[]){
                 "Unfortunately, this installation of PMIx was not compiled with",
                 "%s support.  As such, the %s compiler is non-functional.",
                 NULL}
    },

    { .topic = "no-compiler-specified",
      .content = (const char *[]){
                 "No underlying compiler was specified in the wrapper compiler data file",
                 "(e.g., pmixcc-wrapper-data.txt)",
                 NULL}
    },

    { .topic = "no-compiler-found",
      .content = (const char *[]){
                 "The PMIx wrapper compiler was unable to find the specified compiler",
                 "%s in your PATH.",
                 "",
                 "Note that this compiler was either specified at configure time or in",
                 "one of several possible environment variables.",
                 NULL}
    },

    { .topic = "showme:command",
      .content = (const char *[]){
                 "",
                 "Show command used to invoke real compiler",
                 NULL}
    },

    { .topic = "showme:compile",
      .content = (const char *[]){
                 "",
                 "Show flags added when compiling",
                 NULL}
    },

    { .topic = "showme:link",
      .content = (const char *[]){
                 "",
                 "Show flags added when linking",
                 NULL}
    },

    { .topic = "showme:incdirs",
      .content = (const char *[]){
                 "",
                 "Show list of include dirs added when compiling",
                 NULL}
    },

    { .topic = "showme:libdirs",
      .content = (const char *[]){
                 "",
                 "Show list of library dirs added when linking",
                 NULL}
    },

    { .topic = "showme:libdirs_static",
      .content = (const char *[]){
                 "",
                 "Show list of static library dirs added when linking",
                 NULL}
    },

    { .topic = "showme:libs",
      .content = (const char *[]){
                 "",
                 "Show list of libraries added when linking",
                 NULL}
    },

    { .topic = "showme:libs_static",
      .content = (const char *[]){
                 "",
                 "Show list of static libraries added when linking",
                 NULL}
    },

    { .topic = "showme:version",
      .content = (const char *[]){
                 "",
                 "Show version of wrapper compiler",
                 NULL}
    },

    { .topic = "showme:help",
      .content = (const char *[]){
                 "",
                 "Show usage message",
                 NULL}
    },

    { .topic = "file-not-found",
      .content = (const char *[]){
                 "%s could not find the file %s, needed for %s support.",
                 "This may indicate an incomplete install and linking will likely fail.",
                 NULL}
    },

    { .topic = "spawn-failed",
      .content = (const char *[]){
                 "Unable to call the compiler (%s). The failure return the error",
                 "%s.",
                 "The failed command was [%s].",
                 NULL}
    },

    { .topic = "compiler-failed",
      .content = (const char *[]){
                 "The child process (%s) exit with error %d.",
                 "The failed command was [%s].",
                 NULL}
    },

    { .topic = "no-options-support",
      .content = (const char *[]){
                 "The %s wrapper compiler was unable to find a block of options in its",
                 "configuration to support your compiler mode.  Your application was not",
                 "compiled. or linked.",
                 "",
                 "The wrapper compiler command line was:",
                 "",
                 "%s",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_21[] = {
    { .topic = "help",
      .content = (const char *[]){
                 "Help can be requested in two ways:",
                 "",
                 "- a directive to the cmd. For example, the command",
                 "\"%s --help\" or \"%s -h\"",
                 "will provide the high-level help output giving a general",
                 "description of each available option.",
                 "",
                 "- an option to the help directive. For example, the command",
                 "\"%s --help foo\" or \"%s -h foo\"",
                 "will provide detailed help about the \"foo\" command line",
                 "directive.",
                 NULL}
    },

    { .topic = "unknown-option",
      .content = (const char *[]){
                 "Help was requested for an unknown option:",
                 "",
                 "Option: %s",
                 "",
                 "Please use the \"%s --help\" command to obtain a list of all",
                 "supported options.",
                 NULL}
    },

    { .topic = "unrecognized-option",
      .content = (const char *[]){
                 "The help system for %s does not recognize the following:",
                 "",
                 "Option: %s",
                 "",
                 "This might require help from the developers.",
                 NULL}
    },

    { .topic = "version",
      .content = (const char *[]){
                 "Print version and exit",
                 NULL}
    },

    { .topic = "verbose",
      .content = (const char *[]){
                 "Enable debug options - number of times specified sets level of verbosity",
                 "(e.g., -vvv => 3rd level of debug information)",
                 NULL}
    },

    { .topic = "short-no-long",
      .content = (const char *[]){
                 "A short option was provided to %s and recognized by the parser,",
                 "but has no matching long option:",
                 "",
                 "Short option: %c",
                 "",
                 "This might require help from the developers.",
                 NULL}
    },

    { .topic = "unregistered-option",
      .content = (const char *[]){
                 "An unrecognized option was included on the %s command line:",
                 "",
                 "Option: %s",
                 "",
                 "Please use the \"%s --help\" command to obtain a list of all",
                 "supported options.",
                 NULL}
    },

    { .topic = "short-arg-error",
      .content = (const char *[]){
                 "A short option was provided to %s and recognized by the parser,",
                 "but included an argument while the option does not support one:",
                 "",
                 "Short option: %c",
                 "Given argument: %s",
                 "",
                 "Please correct the command line and try again.",
                 NULL}
    },

    { .topic = "missing-argument",
      .content = (const char *[]){
                 "An option was included on the %s command line that requires",
                 "an argument, but no argument was given:",
                 "",
                 "Option: %s",
                 "",
                 "Please use the \"%s --help %s\" command to learn more about",
                 "this option.",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

static pmix_show_help_entry_t ini_entries_22[] = {
    { .topic = "malformed net_private_ipv4",
      .content = (const char *[]){
                 "PMIx has detected at least one malformed IP address or netmask in",
                 "the value of the opal_net_private_ipv4 MCA parameter.  The",
                 "opal_net_private_ipv4 MCA parameter accepts a semicolon-delimited list",
                 "of Classless Inter-Domain Routing (CIDR) notation specifications, each",
                 "of the form <ipaddress>/<mask>.  For example:",
                 "",
                 "10.0.0.0/8;172.16.0.0/12;192.168.0.0/16;169.254.0.0/16",
                 "",
                 "The first detected malformed entry was %s.",
                 NULL}
    },

    { .topic = "invalid-net-mask",
      .content = (const char *[]){
                 "PMIx has detected a malformed IPv4 address or netmask:",
                 "",
                 "Value provided: %s",
                 "",
                 "Accepted values follow the Classless Inter-Domain",
                 "Routing (CIDR) notation specifications. For example:",
                 "",
                 "10.0.0.0/8",
                 "172.16/12",
                 "192.168",
                 "169.254.0.0/16",
                 NULL}
    },

    { .topic = "mkdir-failed",
      .content = (const char *[]){
                 "PMIx detected a call to mkdir was unable to create the desired directory:",
                 "",
                 "Directory: %s",
                 "Error:     %s",
                 "",
                 "Please check to ensure you have adequate permissions to perform",
                 "the desired operation.",
                 NULL}
    },

    { .topic = "unlink-error",
      .content = (const char *[]){
                 "We attempted to remove a file, but were unable to do so:",
                 "",
                 "Path:  %s",
                 "Error: %s",
                 NULL}
    },

    { .topic = "failed-file-open",
      .content = (const char *[]){
                 "An attempt was made to open a shared memory backing file, but the",
                 "attempt failed:",
                 "",
                 "File:  %s",
                 "Error: %s",
                 "",
                 "The PMIx shared memory subsystem will be disabled, but your job will",
                 "continue by using the \"hash\" subsystem.",
                 NULL}
    },

    { .topic = "duplicate-filename",
      .content = (const char *[]){
                 "The provided project show-help data array cannot be added as it",
                 "contains a filename that matches one already in the system:",
                 "",
                 "Project1: %s",
                 "Project2: %s",
                 "Filename: %s",
                 NULL}
    },

    { .topic = NULL, .content = NULL }
};

pmix_show_help_file_t pmix_show_help_data[] = {
    { "help-pfexec-base.txt", ini_entries_0},
    { "help-ploc.txt", ini_entries_1},
    { "help-pmix-mca-base.txt", ini_entries_2},
    { "help-pmix-mca-var.txt", ini_entries_3},
    { "help-gds-shmem2.txt", ini_entries_4},
    { "help-pcompress.txt", ini_entries_5},
    { "help-pmix-plog.txt", ini_entries_6},
    { "help-pnet-simptest.txt", ini_entries_7},
    { "help-pmix-psensor-file.txt", ini_entries_8},
    { "help-ptl-base.txt", ini_entries_9},
    { "help-pmix-runtime.txt", ini_entries_10},
    { "help-pmix-server.txt", ini_entries_11},
    { "help-palloc.txt", ini_entries_12},
    { "help-pattrs.txt", ini_entries_13},
    { "help-pctrl.txt", ini_entries_14},
    { "help-pevent.txt", ini_entries_15},
    { "help-plookup.txt", ini_entries_16},
    { "help-pmix_info.txt", ini_entries_17},
    { "help-pps.txt", ini_entries_18},
    { "help-pquery.txt", ini_entries_19},
    { "help-pmixcc.txt", ini_entries_20},
    { "help-cli.txt", ini_entries_21},
    { "help-pmix-util.txt", ini_entries_22},
    { NULL, NULL }
};
