tenho seguinte código c++

#include "act.h"
#include <fstream>
#include <cassert>
#include <stdexcept>
#include <vector>

const std::vector<std::string> Act::fileExtensions = { "act" };
const std::string Act::filePath = "sprite";

Act::Act(const std::string& filename, const std::string& resourcePath)
    : Base(filename, resourcePath, filePath, fileExtensions) { }

void Act::load() {
    if (_filename.empty()) {
        return;
    }

    std::ifstream file(_filename, std::ios::binary | std::ios::ate);
    if (!file) {
        throw ResourceException("Error opening file: " + _filename);
    }

    size_t fileSize = static_cast<size_t>(file.tellg());  // Cast explícito
    file.seekg(0, std::ios::beg);

    _buffer.resize(fileSize);
    file.read(reinterpret_cast<char*>(_buffer.data()), fileSize);

    readData(_buffer);
    _usable = true;
}

void Act::load(const std::vector<uint8_t>& buffer) {
    readData(buffer);
    _usable = true;
}

uint16_t Act::ver() const noexcept {
    return _ver;
}

uint64_t Act::numberOfActions() const noexcept {
    return _actions.size();
}

uint64_t Act::numberOfEvents() const noexcept {
    return _events.size();
}

uint64_t Act::numberOfFrames(uint32_t action) const noexcept {
    if (action >= numberOfActions()) {
        return 0;
    }
    return _actions[action].frames.size();
}

uint64_t Act::numberOfSprites(uint32_t action, uint32_t frame) const noexcept {
    if (frame >= numberOfFrames(action)) {
        return 0;
    }
    return _actions[action].frames[frame].sprites.size();
}

uint64_t Act::numberOfAttachpoints(uint32_t action, uint32_t frame) const noexcept {
    if (frame >= numberOfFrames(action)) {
        return 0;
    }
    return _actions[action].frames[frame].attachPoints.size();
}

const ActAction& Act::action(uint32_t action) const noexcept {
    if (action >= numberOfActions()) {
        static ActAction emptyAction;
        return emptyAction;
    }
    return _actions[action];
}

const std::vector<ActAction>& Act::actions() const noexcept {
    return _actions;
}

const ActFrame& Act::frame(uint32_t action, uint32_t frame) const noexcept {
    if (frame >= numberOfFrames(action)) {
        static ActFrame emptyFrame;
        return emptyFrame;
    }
    return _actions[action].frames[frame];
}

const std::vector<ActFrame>& Act::frames(uint32_t action) const noexcept {
    if (action >= numberOfActions()) {
        static std::vector<ActFrame> emptyFrames;
        return emptyFrames;
    }
    return _actions[action].frames;
}

const ActSprite& Act::sprite(uint32_t action, uint32_t frame, uint32_t sprite) const noexcept {
    if (sprite >= numberOfSprites(action, frame)) {
        static ActSprite emptySprite;
        return emptySprite;
    }
    return _actions[action].frames[frame].sprites[sprite];
}

const std::vector<ActSprite>& Act::sprites(uint32_t action, uint32_t frame) const noexcept {
    if (frame >= numberOfFrames(action)) {
        static std::vector<ActSprite> emptySprites;
        return emptySprites;
    }
    return _actions[action].frames[frame].sprites;
}

const ActAttachPoint& Act::attachpoint(uint32_t action, uint32_t frame, uint32_t attachpoint) const noexcept {
    if (attachpoint >= numberOfAttachpoints(action, frame)) {
        static ActAttachPoint emptyAttachPoint;
        return emptyAttachPoint;
    }
    return _actions[action].frames[frame].attachPoints[attachpoint];
}

const std::vector<ActAttachPoint>& Act::attachpoints(uint32_t action, uint32_t frame) const noexcept {
    if (frame >= numberOfFrames(action)) {
        static std::vector<ActAttachPoint> emptyAttachPoints;
        return emptyAttachPoints;
    }
    return _actions[action].frames[frame].attachPoints;
}

void Act::readData(const std::vector<uint8_t>& buffer) {
    uint64_t offset = 0;

    if (buffer.size() < 18 + 2 + 10) {
        throw ResourceException("Act file is too small to be valid");
    }

    if (buffer[0] != 'A' || buffer[1] != 'C') {
        throw ResourceException("Act file signature is invalid");
    }

    offset += 2;
    _ver = *reinterpret_cast<const uint16_t*>(&buffer[offset]);
    offset += 2;

    uint16_t numActions = *reinterpret_cast<const uint16_t*>(&buffer[offset]);
    offset += 10;  // Skipping reserved bytes

    _actions.resize(numActions);
    for (auto& action : _actions) {
        uint32_t numFrames = *reinterpret_cast<const uint32_t*>(&buffer[offset]);
        offset += 4;

        action.frames.resize(numFrames);
        for (auto& frame : action.frames) {
            readFrame(buffer, frame, offset);
        }
    }
}

void Act::readFrame(const std::vector<uint8_t>& buffer, ActFrame& frame, uint64_t& offset) {
    offset += static_cast<uint64_t>(8) * sizeof(uint32_t);  // Cast explícito

    uint32_t numSprites = *reinterpret_cast<const uint32_t*>(&buffer[offset]);
    offset += 4;

    frame.sprites.resize(numSprites);
    for (auto& sprite : frame.sprites) {
        readSprite(buffer, sprite, offset);
    }

    if (_ver >= 0x200) {
        frame.eventId = *reinterpret_cast<const int*>(&buffer[offset]);
        offset += sizeof(int);

        if (_ver >= 0x203) {
            uint32_t numAttachPoints = *reinterpret_cast<const uint32_t*>(&buffer[offset]);
            offset += 4;

            frame.attachPoints.resize(static_cast<unsigned int>(numAttachPoints));  // Cast explícito
            for (auto& attachPoint : frame.attachPoints) {
                readAttachPoint(buffer, attachPoint, offset);
            }
        }
    }
}

void Act::readSprite(const std::vector<uint8_t>& buffer, ActSprite& sprite, uint64_t& offset) const {
    sprite.x = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    sprite.y = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    sprite.sprId = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    sprite.flags = *reinterpret_cast<const uint32_t*>(&buffer[offset]);
    offset += sizeof(uint32_t);

    sprite.tint = *reinterpret_cast<const Color*>(&buffer[offset]);
    offset += sizeof(uint32_t);

    sprite.xScale = *reinterpret_cast<const float*>(&buffer[offset]);
    offset += sizeof(float);

    if (_ver >= 0x204) {
        sprite.yScale = *reinterpret_cast<const float*>(&buffer[offset]);
        offset += sizeof(float);
    }
    else {
        sprite.yScale = sprite.xScale;
    }

    sprite.rotation = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    sprite.sprType = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    if (_ver >= 0x205) {
        sprite.width = *reinterpret_cast<const int*>(&buffer[offset]);
        offset += sizeof(int);

        sprite.height = *reinterpret_cast<const int*>(&buffer[offset]);
        offset += sizeof(int);
    }
}

void Act::readAttachPoint(const std::vector<uint8_t>& buffer, ActAttachPoint& attachPoint, uint64_t& offset) {
    offset += static_cast<uint64_t>(4) * sizeof(uint8_t);  // Cast explícito

    attachPoint.x = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    attachPoint.y = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);

    attachPoint.attr = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);
}


recebo erro

1>act.cpp(143,55): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(146,70): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(151,73): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(164,70): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(173,63): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(177,83): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(189,54): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(192,54): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(195,58): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(198,63): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(201,59): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(204,61): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(208,65): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(215,61): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(218,60): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(222,62): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(225,63): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(233,59): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(236,59): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados
1>act.cpp(239,62): warning C4244: 'argumento': conversão de 'uint64_t' para 'const unsigned int', possível perda de dados