We now send the rotation as a quaternion using 18 bits per component instead of 16. Implementation learned from https://gafferongames.com/post/snapshot_compression/ "Optimizing Orientation" Here's snippets of the code for deserializing the quaternion:

struct FQuat
{
    // redacted lots of FQuat stuff...

    struct Component
    {
        enum Type
        {
            X,
            Y,
            Z,
            W,
            Num
        };
    };

    struct FNetCompressedData
    {
        // The 3 smallest components converted to compressed INT
        DWORD A, B, C;

        // Which component of the quaternion is largest
        DWORD LargestComponent;
    };
}

void FQuat::SerializeCompressed(FArchive& Ar, BYTE Bits) // we use 18 Bits
{
    FNetCompressedData Data;
    Ar.SerializeInt(Data.LargestComponent, FQuat::Component::Num); // 2 bits

    const INT MaxValue = (1 << Bits) - 1;
    Ar.SerializeInt(Data.A, MaxValue + 1);
    Ar.SerializeInt(Data.B, MaxValue + 1);
    Ar.SerializeInt(Data.C, MaxValue + 1);

    *this = FromNetCompressedData(Data, Bits);
}

FQuat FQuat::FromNetCompressedData(const FNetCompressedData& Data, BYTE Bits)
{
    return QuatNetCompression::FromNetCompressedData(Data, Bits);
}

namespace QuatNetCompression
{
    const FLOAT MAX_QUAT_VALUE = 0.7071067811865475244f; // 1/sqrt(2)
    const FLOAT INV_MAX_QUAT_VALUE = 1.0f / MAX_QUAT_VALUE;

    FLOAT UncompressComponent(BYTE Bits, DWORD iValue)
    {
        const INT MaxValue = (1 << Bits) - 1;
        const FLOAT PositiveRangedValue = iValue / (FLOAT)MaxValue;
        const FLOAT RangedValue = (PositiveRangedValue - 0.50f) * 2.0f;
        const FLOAT Value = RangedValue * MAX_QUAT_VALUE;
        return Value;
    }

    void UncompressComponents(const FQuat::FNetCompressedData& Data, BYTE Bits, FLOAT& A, FLOAT& B, FLOAT& C, FLOAT& Missing)
    {
        A = UncompressComponent(Bits, Data.A);
        B = UncompressComponent(Bits, Data.B);
        C = UncompressComponent(Bits, Data.C);
        Missing = appSqrt(1.0f - (A*A) - (B*B) - (C*C));
    }

    FQuat FromNetCompressedData(const FQuat::FNetCompressedData& Data, BYTE Bits)
    {
        FQuat Q;

        switch (Data.LargestComponent)
        {
        case FQuat::Component::X:
            UncompressComponents(Data, Bits, Q.Y, Q.Z, Q.W, Q.X);
            break;
        case FQuat::Component::Y:
            UncompressComponents(Data, Bits, Q.X, Q.Z, Q.W, Q.Y);
            break;
        case FQuat::Component::Z:
            UncompressComponents(Data, Bits, Q.X, Q.Y, Q.W, Q.Z);
            break;
        case FQuat::Component::W:
            UncompressComponents(Data, Bits, Q.X, Q.Y, Q.Z, Q.W);
            break;
        }

        Q.Normalize();

        return Q;
    }
}