I need help with this IPO Chart in my class here is the instructions

The IPO chart is complete and accurate.

The IPO chart follows the style introduced in class examples.

All the major variables are listed, one per row.

All variables have been given valid names and meaningful data types.

Data type names are listed as Integer, Float, Character, String, or Boolean only; rather than using language-specific type names.

The Float type is not used for variables whose values will only be whole numbers; the Integer type is not used for variables whose values may reasonably have a fractional part.

All variables are correctly identified as input, processing, and/or output.

The list of constants is complete and accurate.

All literal values in the program that may be reasonably expected to change over the lifetime of the program have been given a symbolic constant name.

These symbolic constants are listed in the analysis between the IPO chart and list of formulas, along with an initial value for each.

No symbolic constants appear in the IPO chart.

The symbolic constant names replace their corresponding literals throughout the remainder of the analysis and design documentation (including formulas and pseudocode) and source code.

The list of formulas is complete and accurate.

For each variable identified as processing in the IPO chart, there is a formula showing how its value is computed or otherwise obtained.

Meaningful variable and constant names are used, and are consistent across all documentation and source code. Data types are also consistent.

A single case style is used for all variable names (e.g., lowercase with underscores or camel casing).

A single case style is used for all symbolic constant names (e.g., uppercase with underscores), and are visually distinct from the variable names.

The selected case styles are used consistently for names in the analysis, design, and source code.

Variable and constant names are used consistently across the analysis, design, and source code.

Data types are used consistently across the analysis, design, and source code.

The program makes use of modules as specified in the assignment.

The program includes independent input, processing, and output modules.

These modules are called in an appropriate sequence by the main module.

Each module performs tasks in keeping with the IPO chart (e.g., values for variables flagged as input are obtained by the input module).

All information about the employee is gathered by (and/or coordinated through) a single module called by main.

Each of the three major processing steps (computation of gross pay, tax, and net pay) is performed in its own processing module.

Proper parameter syntax is used; in C/C++, the ampersand (&) only appears on out parameters.

Modules do not include any needless parameters that would be better implemented as local variables.

The structure chart accurately reflects the modular structure of the program.

Each module is represented in the structure chart with a box.

Modules appear in a hierarchy, with modules being called shown as children below their calling module.

Module names are consistent between the structure chart and program source code, including case style.

Data flow in and out of a module is shown using arrows that point correctly between child modules and callers.

Data flow arrows are labeled using the module's parameter names.

Data flow arrows are not used to indicate input by the user or output to the screen.

Pseudocode is provided for the main module.

Declarations for all variables belonging to main are provided.

A correct sequence of calls to modules is provided.

Valid arguments are listed for all calls.

The source code for the main module reasonably follows from the pseudocode.

The source code includes complete header comments; modules, variables, and constants are documented per class style.

The header is complete, containing information as in the examples given in the lecture notes.

Each module (other than main) is documented with a description of its role or purpose.

If variable or constant names are not self-documenting (i.e., cryptic or having potentially ambiguous abbreviated names), then comments are used to provide descriptions of each variable or constant's role or purpose when they are declared.

Additional comments are included as needed to help explain any unusual portions of the code (i.e., things about the underlying algorithm itself or individual steps that might not be understood by a reader even one who is familiar with C++).

The program prompts and output closely match the sample runs given in the assignment.

Input is read from the user in the same order shown in the sample runs.

Output is neatly displayed in a tabular format.

Employee names are left-aligned in their column, as indicated by the header.

All numbers are right-aligned in their columns, as indicated by the header.

All numbers in the table are consistently displayed with two digits after the decimal point.

The program computes correct results when given reasonable inputs.

Submissions whose programs do not compile without errors, do not use a modular style (i.e., all of the program code appears in the main module), or contain any of the items listed below, will receive a grade of zero:

Global variables

Selection statements, repetition statements, recursive module calls, return statements (excepting the optional return 0; at the end of main), arrays, vectors, structs, or classes

The line using namespace std;

Inclusion of libraries that have not been introduced as part of the class (including those that are specific to a particular operating system), or use of their commands Calls to the system function