                 guard let byte = UInt8(exactly: number)
                     else { return false }
                 
-                bytes[index] = byte
+                withUnsafeMutablePointer(to: &bytes) {
+                    $0.withMemoryRebound(to: UInt8.self, capacity: 6) {
+                        $0.advanced(by: index).pointee = byte
+                    }
+                }
+                
                 cString = cString.advanced(by: 3)
             }
             

            
        }) else { return nil }
        
        guard let address = Address(data: bytes)
            else { fatalError("Could not initialize \(Address.self) from \(bytes)") }
        
        self.init(bigEndian: address)
    }
    
    public var rawValue: String {
        
        let bytes = self.bigEndian.bytes
        
        let byteValue = [bytes.0, bytes.1, bytes.2, bytes.3, bytes.4, bytes.5]
        
        var string = ""
        
        for (index, byte) in byteValue.enumerated() {
            
            string += byte.toHexadecimal()
            
            if index != byteValue.count - 1 {
                
                string += ":"
            }
        }
        
        assert(string.utf8.count == 17, "\"\(string)\" should be 17 characters")
        
        return string
    }
}


        guard rawValue.utf8.count == 17
            else { return nil }
        
        var bytes: ByteValue = (0, 0, 0, 0, 0, 0)
        
        // parse bytes
        guard rawValue.withCString({ (cString) -> Bool in
