1{-# LANGUAGE BangPatterns #-}
2module Throughput.BlazePut (serialize) where
3
4import qualified Data.ByteString.Lazy as L
5import Blaze.ByteString.Builder
6import Throughput.BlazePutMonad as Put
7import Data.Monoid
8
9import Throughput.Utils
10
11
12------------------------------------------------------------------------
13
14serialize :: Int -> Int -> Endian -> Int -> L.ByteString
15serialize wordSize chunkSize end = runPut .
16  case (wordSize, chunkSize, end) of
17    (1, 1,_)   -> writeByteN1
18    (1, 2,_)   -> writeByteN2
19    (1, 4,_)   -> writeByteN4
20    (1, 8,_)   -> writeByteN8
21    (1, 16, _) -> writeByteN16
22
23    (2, 1,  Big)    -> writeWord16N1Big
24    (2, 2,  Big)    -> writeWord16N2Big
25    (2, 4,  Big)    -> writeWord16N4Big
26    (2, 8,  Big)    -> writeWord16N8Big
27    (2, 16, Big)    -> writeWord16N16Big
28    (2, 1,  Little) -> writeWord16N1Little
29    (2, 2,  Little) -> writeWord16N2Little
30    (2, 4,  Little) -> writeWord16N4Little
31    (2, 8,  Little) -> writeWord16N8Little
32    (2, 16, Little) -> writeWord16N16Little
33    (2, 1,  Host)   -> writeWord16N1Host
34    (2, 2,  Host)   -> writeWord16N2Host
35    (2, 4,  Host)   -> writeWord16N4Host
36    (2, 8,  Host)   -> writeWord16N8Host
37    (2, 16, Host)   -> writeWord16N16Host
38
39    (4, 1,  Big)    -> writeWord32N1Big
40    (4, 2,  Big)    -> writeWord32N2Big
41    (4, 4,  Big)    -> writeWord32N4Big
42    (4, 8,  Big)    -> writeWord32N8Big
43    (4, 16, Big)    -> writeWord32N16Big
44    (4, 1,  Little) -> writeWord32N1Little
45    (4, 2,  Little) -> writeWord32N2Little
46    (4, 4,  Little) -> writeWord32N4Little
47    (4, 8,  Little) -> writeWord32N8Little
48    (4, 16, Little) -> writeWord32N16Little
49    (4, 1,  Host)   -> writeWord32N1Host
50    (4, 2,  Host)   -> writeWord32N2Host
51    (4, 4,  Host)   -> writeWord32N4Host
52    (4, 8,  Host)   -> writeWord32N8Host
53    (4, 16, Host)   -> writeWord32N16Host
54
55    (8, 1,  Host)        -> writeWord64N1Host
56    (8, 2,  Host)        -> writeWord64N2Host
57    (8, 4,  Host)        -> writeWord64N4Host
58    (8, 8,  Host)        -> writeWord64N8Host
59    (8, 16, Host)        -> writeWord64N16Host
60    (8, 1,  Big)         -> writeWord64N1Big
61    (8, 2,  Big)         -> writeWord64N2Big
62    (8, 4,  Big)         -> writeWord64N4Big
63    (8, 8,  Big)         -> writeWord64N8Big
64    (8, 16, Big)         -> writeWord64N16Big
65    (8, 1,  Little)      -> writeWord64N1Little
66    (8, 2,  Little)      -> writeWord64N2Little
67    (8, 4,  Little)      -> writeWord64N4Little
68    (8, 8,  Little)      -> writeWord64N8Little
69    (8, 16, Little)      -> writeWord64N16Little
70
71------------------------------------------------------------------------
72
73writeByteN1 bytes = loop 0 0
74  where loop !s !n | n == bytes = return ()
75                   | otherwise  = do
76                       Put.putWrite ( writeWord8 s)
77                       loop (s+1) (n+1)
78
79writeByteN2 = loop 0
80  where loop s n | s `seq` n `seq` False = undefined
81        loop _ 0 = return ()
82        loop s n = do
83          do Put.putWrite (
84               writeWord8 (s+0) `mappend`
85               writeWord8 (s+1))
86             loop (s+2) (n-2)
87
88writeByteN4 = loop 0
89  where loop s n | s `seq` n `seq` False = undefined
90        loop _ 0 = return ()
91        loop s n = do
92          Put.putWrite (
93            writeWord8 (s+0) `mappend`
94            writeWord8 (s+1) `mappend`
95            writeWord8 (s+2) `mappend`
96            writeWord8 (s+3))
97          loop (s+4) (n-4)
98
99writeByteN8 = loop 0
100  where loop s n | s `seq` n `seq` False = undefined
101        loop _ 0 = return ()
102        loop s n = do
103          Put.putWrite (
104            writeWord8 (s+0) `mappend`
105            writeWord8 (s+1) `mappend`
106            writeWord8 (s+2) `mappend`
107            writeWord8 (s+3) `mappend`
108            writeWord8 (s+4) `mappend`
109            writeWord8 (s+5) `mappend`
110            writeWord8 (s+6) `mappend`
111            writeWord8 (s+7))
112          loop (s+8) (n-8)
113
114writeByteN16 = loop 0
115  where loop s n | s `seq` n `seq` False = undefined
116        loop _ 0 = return ()
117        loop s n = do
118          Put.putWrite (
119            writeWord8 (s+0) `mappend`
120            writeWord8 (s+1) `mappend`
121            writeWord8 (s+2) `mappend`
122            writeWord8 (s+3) `mappend`
123            writeWord8 (s+4) `mappend`
124            writeWord8 (s+5) `mappend`
125            writeWord8 (s+6) `mappend`
126            writeWord8 (s+7) `mappend`
127            writeWord8 (s+8) `mappend`
128            writeWord8 (s+9) `mappend`
129            writeWord8 (s+10) `mappend`
130            writeWord8 (s+11) `mappend`
131            writeWord8 (s+12) `mappend`
132            writeWord8 (s+13) `mappend`
133            writeWord8 (s+14) `mappend`
134            writeWord8 (s+15))
135          loop (s+16) (n-16)
136
137------------------------------------------------------------------------
138-- Big endian, word16 writes
139
140writeWord16N1Big = loop 0
141  where loop s n | s `seq` n `seq` False = undefined
142        loop _ 0 = return ()
143        loop s n = do
144          Put.putWord16be (s+0)
145          loop (s+1) (n-1)
146
147writeWord16N2Big = loop 0
148  where loop s n | s `seq` n `seq` False = undefined
149        loop _ 0 = return ()
150        loop s n = do
151          Put.putWrite (
152            writeWord16be (s+0) `mappend`
153            writeWord16be (s+1))
154          loop (s+2) (n-2)
155
156writeWord16N4Big = loop 0
157  where loop s n | s `seq` n `seq` False = undefined
158        loop _ 0 = return ()
159        loop s n = do
160          Put.putWrite (
161            writeWord16be (s+0) `mappend`
162            writeWord16be (s+1) `mappend`
163            writeWord16be (s+2) `mappend`
164            writeWord16be (s+3))
165          loop (s+4) (n-4)
166
167writeWord16N8Big = loop 0
168  where loop s n | s `seq` n `seq` False = undefined
169        loop _ 0 = return ()
170        loop s n = do
171          Put.putWrite (
172            writeWord16be (s+0) `mappend`
173            writeWord16be (s+1) `mappend`
174            writeWord16be (s+2) `mappend`
175            writeWord16be (s+3) `mappend`
176            writeWord16be (s+4) `mappend`
177            writeWord16be (s+5) `mappend`
178            writeWord16be (s+6) `mappend`
179            writeWord16be (s+7))
180          loop (s+8) (n-8)
181
182writeWord16N16Big = loop 0
183  where loop s n | s `seq` n `seq` False = undefined
184        loop _ 0 = return ()
185        loop s n = do
186          Put.putWrite (
187            writeWord16be (s+0) `mappend`
188            writeWord16be (s+1) `mappend`
189            writeWord16be (s+2) `mappend`
190            writeWord16be (s+3) `mappend`
191            writeWord16be (s+4) `mappend`
192            writeWord16be (s+5) `mappend`
193            writeWord16be (s+6) `mappend`
194            writeWord16be (s+7) `mappend`
195            writeWord16be (s+8) `mappend`
196            writeWord16be (s+9) `mappend`
197            writeWord16be (s+10) `mappend`
198            writeWord16be (s+11) `mappend`
199            writeWord16be (s+12) `mappend`
200            writeWord16be (s+13) `mappend`
201            writeWord16be (s+14) `mappend`
202            writeWord16be (s+15))
203          loop (s+16) (n-16)
204
205------------------------------------------------------------------------
206-- Little endian, word16 writes
207
208writeWord16N1Little = loop 0
209  where loop s n | s `seq` n `seq` False = undefined
210        loop _ 0 = return ()
211        loop s n =
212          do Put.putWord16le (s+0)
213             loop (s+1) (n-1)
214
215writeWord16N2Little = loop 0
216  where loop s n | s `seq` n `seq` False = undefined
217        loop _ 0 = return ()
218        loop s n = do
219          Put.putWrite (
220            writeWord16le (s+0) `mappend`
221            writeWord16le (s+1))
222          loop (s+2) (n-2)
223
224writeWord16N4Little = loop 0
225  where loop s n | s `seq` n `seq` False = undefined
226        loop _ 0 = return ()
227        loop s n = do
228          Put.putWrite (
229            writeWord16le (s+0) `mappend`
230            writeWord16le (s+1) `mappend`
231            writeWord16le (s+2) `mappend`
232            writeWord16le (s+3))
233          loop (s+4) (n-4)
234
235writeWord16N8Little = loop 0
236  where loop s n | s `seq` n `seq` False = undefined
237        loop _ 0 = return ()
238        loop s n = do
239          Put.putWrite (
240            writeWord16le (s+0) `mappend`
241            writeWord16le (s+1) `mappend`
242            writeWord16le (s+2) `mappend`
243            writeWord16le (s+3) `mappend`
244            writeWord16le (s+4) `mappend`
245            writeWord16le (s+5) `mappend`
246            writeWord16le (s+6) `mappend`
247            writeWord16le (s+7))
248          loop (s+8) (n-8)
249
250writeWord16N16Little = loop 0
251  where loop s n | s `seq` n `seq` False = undefined
252        loop _ 0 = return ()
253        loop s n = do
254          Put.putWrite (
255            writeWord16le (s+0) `mappend`
256            writeWord16le (s+1) `mappend`
257            writeWord16le (s+2) `mappend`
258            writeWord16le (s+3) `mappend`
259            writeWord16le (s+4) `mappend`
260            writeWord16le (s+5) `mappend`
261            writeWord16le (s+6) `mappend`
262            writeWord16le (s+7) `mappend`
263            writeWord16le (s+8) `mappend`
264            writeWord16le (s+9) `mappend`
265            writeWord16le (s+10) `mappend`
266            writeWord16le (s+11) `mappend`
267            writeWord16le (s+12) `mappend`
268            writeWord16le (s+13) `mappend`
269            writeWord16le (s+14) `mappend`
270            writeWord16le (s+15))
271          loop (s+16) (n-16)
272
273------------------------------------------------------------------------
274-- Host endian, unaligned, word16 writes
275
276writeWord16N1Host = loop 0
277  where loop s n | s `seq` n `seq` False = undefined
278        loop _ 0 = return ()
279        loop s n = do
280          Put.putWord16host (s+0)
281          loop (s+1) (n-1)
282
283writeWord16N2Host = loop 0
284  where loop s n | s `seq` n `seq` False = undefined
285        loop _ 0 = return ()
286        loop s n = do
287          Put.putWrite (
288            writeWord16host (s+0) `mappend`
289            writeWord16host (s+1))
290          loop (s+2) (n-2)
291
292writeWord16N4Host = loop 0
293  where loop s n | s `seq` n `seq` False = undefined
294        loop _ 0 = return ()
295        loop s n = do
296          Put.putWrite (
297            writeWord16host (s+0) `mappend`
298            writeWord16host (s+1) `mappend`
299            writeWord16host (s+2) `mappend`
300            writeWord16host (s+3))
301          loop (s+4) (n-4)
302
303writeWord16N8Host = loop 0
304  where loop s n | s `seq` n `seq` False = undefined
305        loop _ 0 = return ()
306        loop s n = do
307          Put.putWrite (
308            writeWord16host (s+0) `mappend`
309            writeWord16host (s+1) `mappend`
310            writeWord16host (s+2) `mappend`
311            writeWord16host (s+3) `mappend`
312            writeWord16host (s+4) `mappend`
313            writeWord16host (s+5) `mappend`
314            writeWord16host (s+6) `mappend`
315            writeWord16host (s+7))
316          loop (s+8) (n-8)
317
318writeWord16N16Host = loop 0
319  where loop s n | s `seq` n `seq` False = undefined
320        loop _ 0 = return ()
321        loop s n = do
322          Put.putWrite (
323            writeWord16host (s+0) `mappend`
324            writeWord16host (s+1) `mappend`
325            writeWord16host (s+2) `mappend`
326            writeWord16host (s+3) `mappend`
327            writeWord16host (s+4) `mappend`
328            writeWord16host (s+5) `mappend`
329            writeWord16host (s+6) `mappend`
330            writeWord16host (s+7) `mappend`
331            writeWord16host (s+8) `mappend`
332            writeWord16host (s+9) `mappend`
333            writeWord16host (s+10) `mappend`
334            writeWord16host (s+11) `mappend`
335            writeWord16host (s+12) `mappend`
336            writeWord16host (s+13) `mappend`
337            writeWord16host (s+14) `mappend`
338            writeWord16host (s+15))
339          loop (s+16) (n-16)
340
341------------------------------------------------------------------------
342
343writeWord32N1Big = loop 0
344  where loop s n | s `seq` n `seq` False = undefined
345        loop _ 0 = return ()
346        loop s n = do
347          Put.putWord32be (s+0)
348          loop (s+1) (n-1)
349
350writeWord32N2Big = loop 0
351  where loop s n | s `seq` n `seq` False = undefined
352        loop _ 0 = return ()
353        loop s n = do
354          Put.putWrite (
355            writeWord32be (s+0) `mappend`
356            writeWord32be (s+1))
357          loop (s+2) (n-2)
358
359writeWord32N4Big = loop 0
360  where loop s n | s `seq` n `seq` False = undefined
361        loop _ 0 = return ()
362        loop s n = do
363          Put.putWrite (
364            writeWord32be (s+0) `mappend`
365            writeWord32be (s+1) `mappend`
366            writeWord32be (s+2) `mappend`
367            writeWord32be (s+3))
368          loop (s+4) (n-4)
369
370writeWord32N8Big = loop 0
371  where loop s n | s `seq` n `seq` False = undefined
372        loop _ 0 = return ()
373        loop s n = do
374          Put.putWrite (
375            writeWord32be (s+0) `mappend`
376            writeWord32be (s+1) `mappend`
377            writeWord32be (s+2) `mappend`
378            writeWord32be (s+3) `mappend`
379            writeWord32be (s+4) `mappend`
380            writeWord32be (s+5) `mappend`
381            writeWord32be (s+6) `mappend`
382            writeWord32be (s+7))
383          loop (s+8) (n-8)
384
385writeWord32N16Big = loop 0
386  where loop s n | s `seq` n `seq` False = undefined
387        loop _ 0 = return ()
388        loop s n = do
389          Put.putWrite (
390            writeWord32be (s+0) `mappend`
391            writeWord32be (s+1) `mappend`
392            writeWord32be (s+2) `mappend`
393            writeWord32be (s+3) `mappend`
394            writeWord32be (s+4) `mappend`
395            writeWord32be (s+5) `mappend`
396            writeWord32be (s+6) `mappend`
397            writeWord32be (s+7) `mappend`
398            writeWord32be (s+8) `mappend`
399            writeWord32be (s+9) `mappend`
400            writeWord32be (s+10) `mappend`
401            writeWord32be (s+11) `mappend`
402            writeWord32be (s+12) `mappend`
403            writeWord32be (s+13) `mappend`
404            writeWord32be (s+14) `mappend`
405            writeWord32be (s+15))
406          loop (s+16) (n-16)
407
408------------------------------------------------------------------------
409
410writeWord32N1Little = loop 0
411  where loop s n | s `seq` n `seq` False = undefined
412        loop _ 0 = return ()
413        loop s n = do
414          Put.putWord32le (s+0)
415          loop (s+1) (n-1)
416
417writeWord32N2Little = loop 0
418  where loop s n | s `seq` n `seq` False = undefined
419        loop _ 0 = return ()
420        loop s n = do
421          Put.putWrite (
422            writeWord32le (s+0) `mappend`
423            writeWord32le (s+1))
424          loop (s+2) (n-2)
425
426writeWord32N4Little = loop 0
427  where loop s n | s `seq` n `seq` False = undefined
428        loop _ 0 = return ()
429        loop s n = do
430          Put.putWrite (
431            writeWord32le (s+0) `mappend`
432            writeWord32le (s+1) `mappend`
433            writeWord32le (s+2) `mappend`
434            writeWord32le (s+3))
435          loop (s+4) (n-4)
436
437writeWord32N8Little = loop 0
438  where loop s n | s `seq` n `seq` False = undefined
439        loop _ 0 = return ()
440        loop s n = do
441          Put.putWrite (
442            writeWord32le (s+0) `mappend`
443            writeWord32le (s+1) `mappend`
444            writeWord32le (s+2) `mappend`
445            writeWord32le (s+3) `mappend`
446            writeWord32le (s+4) `mappend`
447            writeWord32le (s+5) `mappend`
448            writeWord32le (s+6) `mappend`
449            writeWord32le (s+7))
450          loop (s+8) (n-8)
451
452writeWord32N16Little = loop 0
453  where loop s n | s `seq` n `seq` False = undefined
454        loop _ 0 = return ()
455        loop s n = do
456          Put.putWrite (
457            writeWord32le (s+0) `mappend`
458            writeWord32le (s+1) `mappend`
459            writeWord32le (s+2) `mappend`
460            writeWord32le (s+3) `mappend`
461            writeWord32le (s+4) `mappend`
462            writeWord32le (s+5) `mappend`
463            writeWord32le (s+6) `mappend`
464            writeWord32le (s+7) `mappend`
465            writeWord32le (s+8) `mappend`
466            writeWord32le (s+9) `mappend`
467            writeWord32le (s+10) `mappend`
468            writeWord32le (s+11) `mappend`
469            writeWord32le (s+12) `mappend`
470            writeWord32le (s+13) `mappend`
471            writeWord32le (s+14) `mappend`
472            writeWord32le (s+15))
473          loop (s+16) (n-16)
474
475------------------------------------------------------------------------
476
477writeWord32N1Host = loop 0
478  where loop s n | s `seq` n `seq` False = undefined
479        loop _ 0 = return ()
480        loop s n = do
481          Put.putWord32host (s+0)
482          loop (s+1) (n-1)
483
484writeWord32N2Host = loop 0
485  where loop s n | s `seq` n `seq` False = undefined
486        loop _ 0 = return ()
487        loop s n = do
488          Put.putWrite (
489            writeWord32host (s+0) `mappend`
490            writeWord32host (s+1))
491          loop (s+2) (n-2)
492
493writeWord32N4Host = loop 0
494  where loop s n | s `seq` n `seq` False = undefined
495        loop _ 0 = return ()
496        loop s n = do
497          Put.putWrite (
498            writeWord32host (s+0) `mappend`
499            writeWord32host (s+1) `mappend`
500            writeWord32host (s+2) `mappend`
501            writeWord32host (s+3))
502          loop (s+4) (n-4)
503
504writeWord32N8Host = loop 0
505  where loop s n | s `seq` n `seq` False = undefined
506        loop _ 0 = return ()
507        loop s n = do
508          Put.putWrite (
509            writeWord32host (s+0) `mappend`
510            writeWord32host (s+1) `mappend`
511            writeWord32host (s+2) `mappend`
512            writeWord32host (s+3) `mappend`
513            writeWord32host (s+4) `mappend`
514            writeWord32host (s+5) `mappend`
515            writeWord32host (s+6) `mappend`
516            writeWord32host (s+7))
517          loop (s+8) (n-8)
518
519writeWord32N16Host = loop 0
520  where loop s n | s `seq` n `seq` False = undefined
521        loop _ 0 = return ()
522        loop s n = do
523          Put.putWrite (
524            writeWord32host (s+0) `mappend`
525            writeWord32host (s+1) `mappend`
526            writeWord32host (s+2) `mappend`
527            writeWord32host (s+3) `mappend`
528            writeWord32host (s+4) `mappend`
529            writeWord32host (s+5) `mappend`
530            writeWord32host (s+6) `mappend`
531            writeWord32host (s+7) `mappend`
532            writeWord32host (s+8) `mappend`
533            writeWord32host (s+9) `mappend`
534            writeWord32host (s+10) `mappend`
535            writeWord32host (s+11) `mappend`
536            writeWord32host (s+12) `mappend`
537            writeWord32host (s+13) `mappend`
538            writeWord32host (s+14) `mappend`
539            writeWord32host (s+15))
540          loop (s+16) (n-16)
541
542------------------------------------------------------------------------
543
544writeWord64N1Big = loop 0
545  where loop s n | s `seq` n `seq` False = undefined
546        loop _ 0 = return ()
547        loop s n = do
548          Put.putWord64be (s+0)
549          loop (s+1) (n-1)
550
551writeWord64N2Big = loop 0
552  where loop s n | s `seq` n `seq` False = undefined
553        loop _ 0 = return ()
554        loop s n = do
555          Put.putWrite (
556            writeWord64be (s+0) `mappend`
557            writeWord64be (s+1))
558          loop (s+2) (n-2)
559
560writeWord64N4Big = loop 0
561  where loop s n | s `seq` n `seq` False = undefined
562        loop _ 0 = return ()
563        loop s n = do
564          Put.putWrite (
565            writeWord64be (s+0) `mappend`
566            writeWord64be (s+1) `mappend`
567            writeWord64be (s+2) `mappend`
568            writeWord64be (s+3))
569          loop (s+4) (n-4)
570
571writeWord64N8Big = loop 0
572  where loop s n | s `seq` n `seq` False = undefined
573        loop _ 0 = return ()
574        loop s n = do
575          Put.putWrite (
576            writeWord64be (s+0) `mappend`
577            writeWord64be (s+1) `mappend`
578            writeWord64be (s+2) `mappend`
579            writeWord64be (s+3) `mappend`
580            writeWord64be (s+4) `mappend`
581            writeWord64be (s+5) `mappend`
582            writeWord64be (s+6) `mappend`
583            writeWord64be (s+7))
584          loop (s+8) (n-8)
585
586writeWord64N16Big = loop 0
587  where loop s n | s `seq` n `seq` False = undefined
588        loop _ 0 = return ()
589        loop s n = do
590          Put.putWrite (
591            writeWord64be (s+0) `mappend`
592            writeWord64be (s+1) `mappend`
593            writeWord64be (s+2) `mappend`
594            writeWord64be (s+3) `mappend`
595            writeWord64be (s+4) `mappend`
596            writeWord64be (s+5) `mappend`
597            writeWord64be (s+6) `mappend`
598            writeWord64be (s+7) `mappend`
599            writeWord64be (s+8) `mappend`
600            writeWord64be (s+9) `mappend`
601            writeWord64be (s+10) `mappend`
602            writeWord64be (s+11) `mappend`
603            writeWord64be (s+12) `mappend`
604            writeWord64be (s+13) `mappend`
605            writeWord64be (s+14) `mappend`
606            writeWord64be (s+15))
607          loop (s+16) (n-16)
608
609------------------------------------------------------------------------
610
611writeWord64N1Little = loop 0
612  where loop s n | s `seq` n `seq` False = undefined
613        loop _ 0 = return ()
614        loop s n = do
615          Put.putWord64le (s+0)
616          loop (s+1) (n-1)
617
618writeWord64N2Little = loop 0
619  where loop s n | s `seq` n `seq` False = undefined
620        loop _ 0 = return ()
621        loop s n = do
622          Put.putWrite (
623            writeWord64le (s+0) `mappend`
624            writeWord64le (s+1))
625          loop (s+2) (n-2)
626
627writeWord64N4Little = loop 0
628  where loop s n | s `seq` n `seq` False = undefined
629        loop _ 0 = return ()
630        loop s n = do
631          Put.putWrite (
632            writeWord64le (s+0) `mappend`
633            writeWord64le (s+1) `mappend`
634            writeWord64le (s+2) `mappend`
635            writeWord64le (s+3))
636          loop (s+4) (n-4)
637
638writeWord64N8Little = loop 0
639  where loop s n | s `seq` n `seq` False = undefined
640        loop _ 0 = return ()
641        loop s n = do
642          Put.putWrite (
643            writeWord64le (s+0) `mappend`
644            writeWord64le (s+1) `mappend`
645            writeWord64le (s+2) `mappend`
646            writeWord64le (s+3) `mappend`
647            writeWord64le (s+4) `mappend`
648            writeWord64le (s+5) `mappend`
649            writeWord64le (s+6) `mappend`
650            writeWord64le (s+7))
651          loop (s+8) (n-8)
652
653writeWord64N16Little = loop 0
654  where loop s n | s `seq` n `seq` False = undefined
655        loop _ 0 = return ()
656        loop s n = do
657          Put.putWrite (
658            writeWord64le (s+0) `mappend`
659            writeWord64le (s+1) `mappend`
660            writeWord64le (s+2) `mappend`
661            writeWord64le (s+3) `mappend`
662            writeWord64le (s+4) `mappend`
663            writeWord64le (s+5) `mappend`
664            writeWord64le (s+6) `mappend`
665            writeWord64le (s+7) `mappend`
666            writeWord64le (s+8) `mappend`
667            writeWord64le (s+9) `mappend`
668            writeWord64le (s+10) `mappend`
669            writeWord64le (s+11) `mappend`
670            writeWord64le (s+12) `mappend`
671            writeWord64le (s+13) `mappend`
672            writeWord64le (s+14) `mappend`
673            writeWord64le (s+15))
674          loop (s+16) (n-16)
675
676------------------------------------------------------------------------
677
678writeWord64N1Host = loop 0
679  where loop s n | s `seq` n `seq` False = undefined
680        loop _ 0 = return ()
681        loop s n = do
682          Put.putWord64host (s+0)
683          loop (s+1) (n-1)
684
685writeWord64N2Host = loop 0
686  where loop s n | s `seq` n `seq` False = undefined
687        loop _ 0 = return ()
688        loop s n = do
689          Put.putWrite (
690            writeWord64host (s+0) `mappend`
691            writeWord64host (s+1))
692          loop (s+2) (n-2)
693
694writeWord64N4Host = loop 0
695  where loop s n | s `seq` n `seq` False = undefined
696        loop _ 0 = return ()
697        loop s n = do
698          Put.putWrite (
699            writeWord64host (s+0) `mappend`
700            writeWord64host (s+1) `mappend`
701            writeWord64host (s+2) `mappend`
702            writeWord64host (s+3))
703          loop (s+4) (n-4)
704
705writeWord64N8Host = loop 0
706  where loop s n | s `seq` n `seq` False = undefined
707        loop _ 0 = return ()
708        loop s n = do
709          Put.putWrite (
710            writeWord64host (s+0) `mappend`
711            writeWord64host (s+1) `mappend`
712            writeWord64host (s+2) `mappend`
713            writeWord64host (s+3) `mappend`
714            writeWord64host (s+4) `mappend`
715            writeWord64host (s+5) `mappend`
716            writeWord64host (s+6) `mappend`
717            writeWord64host (s+7))
718          loop (s+8) (n-8)
719
720writeWord64N16Host = loop 0
721  where loop s n | s `seq` n `seq` False = undefined
722        loop _ 0 = return ()
723        loop s n = do
724          Put.putWrite (
725            writeWord64host (s+0) `mappend`
726            writeWord64host (s+1) `mappend`
727            writeWord64host (s+2) `mappend`
728            writeWord64host (s+3) `mappend`
729            writeWord64host (s+4) `mappend`
730            writeWord64host (s+5) `mappend`
731            writeWord64host (s+6) `mappend`
732            writeWord64host (s+7) `mappend`
733            writeWord64host (s+8) `mappend`
734            writeWord64host (s+9) `mappend`
735            writeWord64host (s+10) `mappend`
736            writeWord64host (s+11) `mappend`
737            writeWord64host (s+12) `mappend`
738            writeWord64host (s+13) `mappend`
739            writeWord64host (s+14) `mappend`
740            writeWord64host (s+15))
741          loop (s+16) (n-16)
742
743