     
     @inlinable
     @inline(__always)
-    mutating func _read_aligned_pixels<T: FixedWidthInteger, R: BinaryFloatingPoint>(_ bitmap: RawBitmap, _ channel_idx: Int, _ is_opaque: Bool, _ : T.Type, _ : R.Type) {
+    mutating func _read_unsigned_aligned_channel<T: FixedWidthInteger & UnsignedInteger>(_ bitmap: RawBitmap, _ channel_idx: Int, _ is_opaque: Bool, _ : T.Type) {
+        
+        let width = self.width
+        let height = self.height
+        
+        guard bitmap.startsRow < height else { return }
+        
+        let bytesPerPixel = bitmap.bitsPerPixel >> 3
+        
+        let channel = bitmap.channels[channel_idx]
+        let byteOffset = channel.bitRange.lowerBound >> 3
+        
+        self.withUnsafeMutableBytes {
+            
+            guard var dest = $0.baseAddress?.bindMemory(to: T.self, capacity: Pixel.numberOfComponents * $0.count) else { return }
+            
+            let row = Pixel.numberOfComponents * width
+            
+            dest += bitmap.startsRow * row
+            
+            var data = bitmap.data
+            
+            for _ in bitmap.startsRow..<height {
+                
+                let _length = min(bitmap.bytesPerRow, data.count)
+                guard _length != 0 else { return }
+                
+                data.popFirst(bitmap.bytesPerRow).withUnsafeBytes { (bytes: UnsafePointer<UInt8>) in
+                    
+                    var destination = dest
+                    var source = UnsafeRawPointer(bytes)
+                    let source_end = source + _length
+                    
+                    for _ in 0..<width {
+                        
+                        guard source + bytesPerPixel <= source_end else { return }
+                        
+                        let _destination = destination + channel.index
+                        let _source = source + byteOffset
+                        
+                        switch channel.endianness {
+                        case .big: _destination.pointee = T(bigEndian: _source.bindMemory(to: T.self, capacity: 1).pointee)
+                        case .little: _destination.pointee = T(littleEndian: _source.bindMemory(to: T.self, capacity: 1).pointee)
+                        }
+                        
+                        switch bitmap.tiff_predictor {
+                        case 1: break
+                        case 2:
+                            if destination > dest {
+                                let lhs = _destination - Pixel.numberOfComponents
+                                _destination.pointee &+= lhs.pointee
+                            }
+                        default: fatalError("Unsupported tiff predictor.")
+                        }
+                        
+                        source += bytesPerPixel
+                        
+                        if is_opaque {
+                            destination[Pixel.numberOfComponents - 1] = 1
+                        }
+                        
+                        destination += Pixel.numberOfComponents
+                    }
+                    
+                    dest += row
+                }
+            }
+        }
+    }
+    
+    @inlinable
+    @inline(__always)
+    mutating func _read_aligned_channel<T: FixedWidthInteger, R: BinaryFloatingPoint>(_ bitmap: RawBitmap, _ channel_idx: Int, _ is_opaque: Bool, _ : T.Type, _ : R.Type) {
         
         let width = self.width
         let height = self.height

            
            for bitmap in bitmaps {
                for (channel_idx, channel) in bitmap.channels.enumerated() {
                    
                }
            }
            

        
        for bitmap in bitmaps {
            for (channel_idx, channel) in bitmap.channels.enumerated() {
                switch (bitmap.bitsPerPixel % 8, bitmap.endianness, channel.bitRange.lowerBound % 8, channel.bitRange.count, channel.format) {
                case (0, .big, 0, 8, .unsigned): image._read_aligned_channel(bitmap, channel_idx, is_opaque, UInt8.self, Double.self)
                case (0, .big, 0, 8, .signed): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Int8.self, Double.self)
                case (0, .big, 0, 16, .unsigned): image._read_aligned_channel(bitmap, channel_idx, is_opaque, UInt16.self, Double.self)
                case (0, .big, 0, 16, .signed): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Int16.self, Double.self)
                case (0, .big, 0, 32, .unsigned): image._read_aligned_channel(bitmap, channel_idx, is_opaque, UInt32.self, Double.self)
                case (0, .big, 0, 32, .signed): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Int32.self, Double.self)
                case (0, .big, 0, 32, .float): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Float.self, Double.self)
                case (0, .big, 0, 64, .unsigned): image._read_aligned_channel(bitmap, channel_idx, is_opaque, UInt64.self, Double.self)
                case (0, .big, 0, 64, .signed): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Int64.self, Double.self)
                case (0, .big, 0, 64, .float): image._read_aligned_channel(bitmap, channel_idx, is_opaque, Double.self, Double.self)
                case (_, _, _, _, .unsigned): image._read_unsigned_channel(bitmap, channel_idx, is_opaque, Double.self)
                case (_, _, _, _, .signed): image._read_signed_channel(bitmap, channel_idx, is_opaque, Double.self)
                default: break
                }
            }
        }
        
