I have problems reading a binary file into a 32 bit unsigned int and printing them to an output file

I am working on a project for a Computer Architecture class, where we are learning about MIPS and assembly language. The program takes a .bin as input and outputs a .txt. I am to take a binary MIPS executable file that looks like this:

00000000010000000000000000000000 00010000000000010000000000000000 01111111111111111110111111111100 00000000000000000000000000000011 00000000000000000000000000000001 00000000000000000000000000000010 00000000000000000000000000000011 00111100000000010001000000000001 00110100001010000000000000000000 00100100000010010000000000000011 00100100000010100000000000000000 00010001010010010000000000000110 10001101000010110000000000000000 00100011101111011111111111111100 10101111101010110000000000000000 00100001000010000000000000000100 00100001010010100000000000000001 00001000000100000000000000000100 00111100000000010001000000000001 00110100001010000000000000000000 00100100000011000000010011010010 10101101000011000000000000000100 00100100000000100000000000001010 00000000000000000000000000001100

And decode it to produce a human readable assembly language .txt file that looks like this:

initialPC: 4194304 dataStartAddress: 268500992 initialStackPointer: 2147479548 Number of data items: 3 268500992: 00000000000000000000000000000001 1 268500996: 00000000000000000000000000000010 2 268501000: 00000000000000000000000000000011 3 4194304: 00111100000000010001000000000001 lui $at, 4097 4194308: 00110100001010000000000000000000 ori $t0, $at, 0 4194312: 00100100000010010000000000000011 addiu $t1, $zero, 3 4194316: 00100100000010100000000000000000 addiu $t2, $zero, 0 4194320: 00010001010010010000000000000110 beq $t2, $t1, 6 4194324: 10001101000010110000000000000000 lw $t3, 0($t0) 4194328: 00100011101111011111111111111100 addi $sp, $sp, -4 4194332: 10101111101010110000000000000000 sw $t3, 0($sp) 4194336: 00100001000010000000000000000100 addi $t0, $t0, 4 4194340: 00100001010010100000000000000001 addi $t2, $t2, 1 4194344: 00001000000100000000000000000100 j 4194320 4194348: 00111100000000010001000000000001 lui $at, 4097 4194352: 00110100001010000000000000000000 ori $t0, $at, 0 4194356: 00100100000011000000010011010010 addiu $t4, $zero, 1234 4194360: 10101101000011000000000000000100 sw $t4, 4($t0) 4194364: 00100100000000100000000000001010 addiu $v0, $zero, 10 4194368: 00000000000000000000000000001100 syscall

Since the binary MIPS executable file is dumped into a binary TEXT file, I successfully created a program that converts the .txt to a .bin that passes a diff with the .bin my instructor included in the project materials with help from this community in a previous ask.

Currently I am running an issue of printing each word correctly. Here is the output file of my program currently:

initialPC: 16384 dataStartAddress: 272 initialStackPointer: 4243586943 Number of data items: 50331648 16777216 33554432 50331648 17826108 10292 50333988 2596 100682001 2957 4244618531 43951 67110945 16796193 67112968 17826108 10292 3523480612 67112109 167772708 201326592

Obviously I am doing something wrong here, so I would love some help explaining what I did wrong and how to correct it. My instructor is just expecting us to create this entire program using AI, and I don't jive with that. Going the long route may mean more work on my end, but I'm going to school to learn how to code, not create prompts.

Here is my code as of the moment:

#include <iostream> #include <fstream> #include <stdexcept> using namespace std; int main(int argc, char* argv[]) { // input error check the proper amount of command arguments if (argc != 3) { cerr << "Usage: " << argv[0] << " input.bin output.txt\n"; //cerr is used for unbuffered error messages return 1; } // open input and output streams, check they open properly ifstream in; in.open(argv[1], ios::binary);//reading in binary mode if (!in.is_open()) throw runtime_error("Error opening input file"); ofstream out; out.open(argv[2]); if (!out.is_open()) throw runtime_error("Error opening output file"); uint word = 0; int count = 0; while (in.read(reinterpret_cast<char*>(&word), 4)) { //read 32 bits (4 bytes) at a time switch (count) { case 0: out << "initialPC: " << word << endl; break; case 1: out << "dataStartAddress: " << word << endl; break; case 2: out << "initialStackPointer: " << word << endl; break; case 3: out << "Number of data items: " << word << endl; break; default: out << word << endl; break; } count++; } //close streams in.close(); out.close(); return 0; }

Coded in VSC, compiled with g++/GCC using a Makefile, and run through WSL. Here are the resources that I've been using to help me understand how to read from and write to binary files, but they don't say anything about what to do with the data after it's read:

https://cplusplus.com/doc/tutorial/files/

https://www.eecs.umich.edu/courses/eecs380/HANDOUTS/cppBinaryFileIO-2.html

The 2 biggest questions I would love answered:

How do I properly read each 32 bit unsigned int from the file and print to the file? Would it be easier to read them into an uint array so that I can freely access them? I believe endianess will need to be reversed.

How do I convert the decimal integers back into binary, for the lines after the first 4? Ignore the assembly decoding.