48917ec0e9196d2403099449b4fafcd0bd8cb72c
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
1 data instance MVector s (a, b)
2     = MV_2 {-# UNPACK #-} !Int (MVector s a)
3                                (MVector s b)
4 data instance Vector (a, b)
5     = V_2 {-# UNPACK #-} !Int (Vector a)
6                               (Vector b)
7 instance (Unbox a, Unbox b) => Unbox (a, b)
8 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
9   {-# INLINE length  #-}
10   length (MV_2 n_ as bs) = n_
11   {-# INLINE unsafeSlice  #-}
12   unsafeSlice (MV_2 n_ as bs) i_ m_
13       = MV_2 m_ (M.unsafeSlice as i_ m_)
14                 (M.unsafeSlice bs i_ m_)
15   {-# INLINE overlaps  #-}
16   overlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
17       = M.overlaps as1 as2
18         || M.overlaps bs1 bs2
19   {-# INLINE unsafeNew  #-}
20   unsafeNew n_
21       = do
22           as <- M.unsafeNew n_
23           bs <- M.unsafeNew n_
24           return $ MV_2 n_ as bs
25   {-# INLINE unsafeNewWith  #-}
26   unsafeNewWith n_ (a, b)
27       = do
28           as <- M.unsafeNewWith n_ a
29           bs <- M.unsafeNewWith n_ b
30           return $ MV_2 n_ as bs
31   {-# INLINE unsafeRead  #-}
32   unsafeRead (MV_2 n_ as bs) i_
33       = do
34           a <- M.unsafeRead as i_
35           b <- M.unsafeRead bs i_
36           return (a, b)
37   {-# INLINE unsafeWrite  #-}
38   unsafeWrite (MV_2 n_ as bs) i_ (a, b)
39       = do
40           M.unsafeWrite as i_ a
41           M.unsafeWrite bs i_ b
42   {-# INLINE clear  #-}
43   clear (MV_2 n_ as bs)
44       = do
45           M.clear as
46           M.clear bs
47   {-# INLINE set  #-}
48   set (MV_2 n_ as bs) (a, b)
49       = do
50           M.set as a
51           M.set bs b
52   {-# INLINE unsafeCopy  #-}
53   unsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
54       = do
55           M.unsafeCopy as1 as2
56           M.unsafeCopy bs1 bs2
57   {-# INLINE unsafeGrow  #-}
58   unsafeGrow (MV_2 n_ as bs) m_
59       = do
60           M.unsafeGrow as m_
61           M.unsafeGrow bs m_
62           return $ MV_2 (m_+n_) as bs
63 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
64   {-# INLINE unsafeFreeze  #-}
65   unsafeFreeze (MV_2 n_ as bs)
66       = do
67           as' <- G.unsafeFreeze as
68           bs' <- G.unsafeFreeze bs
69           return $ V_2 n_ as' bs'
70   {-# INLINE basicLength  #-}
71   basicLength (V_2 n_ as bs) = n_
72   {-# INLINE basicUnsafeSlice  #-}
73   basicUnsafeSlice (V_2 n_ as bs) i_ m_
74       = V_2 m_ (G.unsafeSlice as i_ m_)
75                (G.unsafeSlice bs i_ m_)
76   {-# INLINE basicUnsafeIndexM  #-}
77   basicUnsafeIndexM (V_2 n_ as bs) i_
78       = do
79           a <- G.basicUnsafeIndexM as i_
80           b <- G.basicUnsafeIndexM bs i_
81           return (a, b)
82 data instance MVector s (a, b, c)
83     = MV_3 {-# UNPACK #-} !Int (MVector s a)
84                                (MVector s b)
85                                (MVector s c)
86 data instance Vector (a, b, c)
87     = V_3 {-# UNPACK #-} !Int (Vector a)
88                               (Vector b)
89                               (Vector c)
90 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
91 instance (Unbox a,
92           Unbox b,
93           Unbox c) => M.MVector MVector (a, b, c) where
94   {-# INLINE length  #-}
95   length (MV_3 n_ as bs cs) = n_
96   {-# INLINE unsafeSlice  #-}
97   unsafeSlice (MV_3 n_ as bs cs) i_ m_
98       = MV_3 m_ (M.unsafeSlice as i_ m_)
99                 (M.unsafeSlice bs i_ m_)
100                 (M.unsafeSlice cs i_ m_)
101   {-# INLINE overlaps  #-}
102   overlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
103       = M.overlaps as1 as2
104         || M.overlaps bs1 bs2
105         || M.overlaps cs1 cs2
106   {-# INLINE unsafeNew  #-}
107   unsafeNew n_
108       = do
109           as <- M.unsafeNew n_
110           bs <- M.unsafeNew n_
111           cs <- M.unsafeNew n_
112           return $ MV_3 n_ as bs cs
113   {-# INLINE unsafeNewWith  #-}
114   unsafeNewWith n_ (a, b, c)
115       = do
116           as <- M.unsafeNewWith n_ a
117           bs <- M.unsafeNewWith n_ b
118           cs <- M.unsafeNewWith n_ c
119           return $ MV_3 n_ as bs cs
120   {-# INLINE unsafeRead  #-}
121   unsafeRead (MV_3 n_ as bs cs) i_
122       = do
123           a <- M.unsafeRead as i_
124           b <- M.unsafeRead bs i_
125           c <- M.unsafeRead cs i_
126           return (a, b, c)
127   {-# INLINE unsafeWrite  #-}
128   unsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
129       = do
130           M.unsafeWrite as i_ a
131           M.unsafeWrite bs i_ b
132           M.unsafeWrite cs i_ c
133   {-# INLINE clear  #-}
134   clear (MV_3 n_ as bs cs)
135       = do
136           M.clear as
137           M.clear bs
138           M.clear cs
139   {-# INLINE set  #-}
140   set (MV_3 n_ as bs cs) (a, b, c)
141       = do
142           M.set as a
143           M.set bs b
144           M.set cs c
145   {-# INLINE unsafeCopy  #-}
146   unsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
147       = do
148           M.unsafeCopy as1 as2
149           M.unsafeCopy bs1 bs2
150           M.unsafeCopy cs1 cs2
151   {-# INLINE unsafeGrow  #-}
152   unsafeGrow (MV_3 n_ as bs cs) m_
153       = do
154           M.unsafeGrow as m_
155           M.unsafeGrow bs m_
156           M.unsafeGrow cs m_
157           return $ MV_3 (m_+n_) as bs cs
158 instance (Unbox a,
159           Unbox b,
160           Unbox c) => G.Vector Vector (a, b, c) where
161   {-# INLINE unsafeFreeze  #-}
162   unsafeFreeze (MV_3 n_ as bs cs)
163       = do
164           as' <- G.unsafeFreeze as
165           bs' <- G.unsafeFreeze bs
166           cs' <- G.unsafeFreeze cs
167           return $ V_3 n_ as' bs' cs'
168   {-# INLINE basicLength  #-}
169   basicLength (V_3 n_ as bs cs) = n_
170   {-# INLINE basicUnsafeSlice  #-}
171   basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
172       = V_3 m_ (G.unsafeSlice as i_ m_)
173                (G.unsafeSlice bs i_ m_)
174                (G.unsafeSlice cs i_ m_)
175   {-# INLINE basicUnsafeIndexM  #-}
176   basicUnsafeIndexM (V_3 n_ as bs cs) i_
177       = do
178           a <- G.basicUnsafeIndexM as i_
179           b <- G.basicUnsafeIndexM bs i_
180           c <- G.basicUnsafeIndexM cs i_
181           return (a, b, c)
182 data instance MVector s (a, b, c, d)
183     = MV_4 {-# UNPACK #-} !Int (MVector s a)
184                                (MVector s b)
185                                (MVector s c)
186                                (MVector s d)
187 data instance Vector (a, b, c, d)
188     = V_4 {-# UNPACK #-} !Int (Vector a)
189                               (Vector b)
190                               (Vector c)
191                               (Vector d)
192 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
193 instance (Unbox a,
194           Unbox b,
195           Unbox c,
196           Unbox d) => M.MVector MVector (a, b, c, d) where
197   {-# INLINE length  #-}
198   length (MV_4 n_ as bs cs ds) = n_
199   {-# INLINE unsafeSlice  #-}
200   unsafeSlice (MV_4 n_ as bs cs ds) i_ m_
201       = MV_4 m_ (M.unsafeSlice as i_ m_)
202                 (M.unsafeSlice bs i_ m_)
203                 (M.unsafeSlice cs i_ m_)
204                 (M.unsafeSlice ds i_ m_)
205   {-# INLINE overlaps  #-}
206   overlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
207       = M.overlaps as1 as2
208         || M.overlaps bs1 bs2
209         || M.overlaps cs1 cs2
210         || M.overlaps ds1 ds2
211   {-# INLINE unsafeNew  #-}
212   unsafeNew n_
213       = do
214           as <- M.unsafeNew n_
215           bs <- M.unsafeNew n_
216           cs <- M.unsafeNew n_
217           ds <- M.unsafeNew n_
218           return $ MV_4 n_ as bs cs ds
219   {-# INLINE unsafeNewWith  #-}
220   unsafeNewWith n_ (a, b, c, d)
221       = do
222           as <- M.unsafeNewWith n_ a
223           bs <- M.unsafeNewWith n_ b
224           cs <- M.unsafeNewWith n_ c
225           ds <- M.unsafeNewWith n_ d
226           return $ MV_4 n_ as bs cs ds
227   {-# INLINE unsafeRead  #-}
228   unsafeRead (MV_4 n_ as bs cs ds) i_
229       = do
230           a <- M.unsafeRead as i_
231           b <- M.unsafeRead bs i_
232           c <- M.unsafeRead cs i_
233           d <- M.unsafeRead ds i_
234           return (a, b, c, d)
235   {-# INLINE unsafeWrite  #-}
236   unsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
237       = do
238           M.unsafeWrite as i_ a
239           M.unsafeWrite bs i_ b
240           M.unsafeWrite cs i_ c
241           M.unsafeWrite ds i_ d
242   {-# INLINE clear  #-}
243   clear (MV_4 n_ as bs cs ds)
244       = do
245           M.clear as
246           M.clear bs
247           M.clear cs
248           M.clear ds
249   {-# INLINE set  #-}
250   set (MV_4 n_ as bs cs ds) (a, b, c, d)
251       = do
252           M.set as a
253           M.set bs b
254           M.set cs c
255           M.set ds d
256   {-# INLINE unsafeCopy  #-}
257   unsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
258       = do
259           M.unsafeCopy as1 as2
260           M.unsafeCopy bs1 bs2
261           M.unsafeCopy cs1 cs2
262           M.unsafeCopy ds1 ds2
263   {-# INLINE unsafeGrow  #-}
264   unsafeGrow (MV_4 n_ as bs cs ds) m_
265       = do
266           M.unsafeGrow as m_
267           M.unsafeGrow bs m_
268           M.unsafeGrow cs m_
269           M.unsafeGrow ds m_
270           return $ MV_4 (m_+n_) as bs cs ds
271 instance (Unbox a,
272           Unbox b,
273           Unbox c,
274           Unbox d) => G.Vector Vector (a, b, c, d) where
275   {-# INLINE unsafeFreeze  #-}
276   unsafeFreeze (MV_4 n_ as bs cs ds)
277       = do
278           as' <- G.unsafeFreeze as
279           bs' <- G.unsafeFreeze bs
280           cs' <- G.unsafeFreeze cs
281           ds' <- G.unsafeFreeze ds
282           return $ V_4 n_ as' bs' cs' ds'
283   {-# INLINE basicLength  #-}
284   basicLength (V_4 n_ as bs cs ds) = n_
285   {-# INLINE basicUnsafeSlice  #-}
286   basicUnsafeSlice (V_4 n_ as bs cs ds) i_ m_
287       = V_4 m_ (G.unsafeSlice as i_ m_)
288                (G.unsafeSlice bs i_ m_)
289                (G.unsafeSlice cs i_ m_)
290                (G.unsafeSlice ds i_ m_)
291   {-# INLINE basicUnsafeIndexM  #-}
292   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
293       = do
294           a <- G.basicUnsafeIndexM as i_
295           b <- G.basicUnsafeIndexM bs i_
296           c <- G.basicUnsafeIndexM cs i_
297           d <- G.basicUnsafeIndexM ds i_
298           return (a, b, c, d)
299 data instance MVector s (a, b, c, d, e)
300     = MV_5 {-# UNPACK #-} !Int (MVector s a)
301                                (MVector s b)
302                                (MVector s c)
303                                (MVector s d)
304                                (MVector s e)
305 data instance Vector (a, b, c, d, e)
306     = V_5 {-# UNPACK #-} !Int (Vector a)
307                               (Vector b)
308                               (Vector c)
309                               (Vector d)
310                               (Vector e)
311 instance (Unbox a,
312           Unbox b,
313           Unbox c,
314           Unbox d,
315           Unbox e) => Unbox (a, b, c, d, e)
316 instance (Unbox a,
317           Unbox b,
318           Unbox c,
319           Unbox d,
320           Unbox e) => M.MVector MVector (a, b, c, d, e) where
321   {-# INLINE length  #-}
322   length (MV_5 n_ as bs cs ds es) = n_
323   {-# INLINE unsafeSlice  #-}
324   unsafeSlice (MV_5 n_ as bs cs ds es) i_ m_
325       = MV_5 m_ (M.unsafeSlice as i_ m_)
326                 (M.unsafeSlice bs i_ m_)
327                 (M.unsafeSlice cs i_ m_)
328                 (M.unsafeSlice ds i_ m_)
329                 (M.unsafeSlice es i_ m_)
330   {-# INLINE overlaps  #-}
331   overlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
332                                                     bs2
333                                                     cs2
334                                                     ds2
335                                                     es2)
336       = M.overlaps as1 as2
337         || M.overlaps bs1 bs2
338         || M.overlaps cs1 cs2
339         || M.overlaps ds1 ds2
340         || M.overlaps es1 es2
341   {-# INLINE unsafeNew  #-}
342   unsafeNew n_
343       = do
344           as <- M.unsafeNew n_
345           bs <- M.unsafeNew n_
346           cs <- M.unsafeNew n_
347           ds <- M.unsafeNew n_
348           es <- M.unsafeNew n_
349           return $ MV_5 n_ as bs cs ds es
350   {-# INLINE unsafeNewWith  #-}
351   unsafeNewWith n_ (a, b, c, d, e)
352       = do
353           as <- M.unsafeNewWith n_ a
354           bs <- M.unsafeNewWith n_ b
355           cs <- M.unsafeNewWith n_ c
356           ds <- M.unsafeNewWith n_ d
357           es <- M.unsafeNewWith n_ e
358           return $ MV_5 n_ as bs cs ds es
359   {-# INLINE unsafeRead  #-}
360   unsafeRead (MV_5 n_ as bs cs ds es) i_
361       = do
362           a <- M.unsafeRead as i_
363           b <- M.unsafeRead bs i_
364           c <- M.unsafeRead cs i_
365           d <- M.unsafeRead ds i_
366           e <- M.unsafeRead es i_
367           return (a, b, c, d, e)
368   {-# INLINE unsafeWrite  #-}
369   unsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
370       = do
371           M.unsafeWrite as i_ a
372           M.unsafeWrite bs i_ b
373           M.unsafeWrite cs i_ c
374           M.unsafeWrite ds i_ d
375           M.unsafeWrite es i_ e
376   {-# INLINE clear  #-}
377   clear (MV_5 n_ as bs cs ds es)
378       = do
379           M.clear as
380           M.clear bs
381           M.clear cs
382           M.clear ds
383           M.clear es
384   {-# INLINE set  #-}
385   set (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
386       = do
387           M.set as a
388           M.set bs b
389           M.set cs c
390           M.set ds d
391           M.set es e
392   {-# INLINE unsafeCopy  #-}
393   unsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
394                                                       bs2
395                                                       cs2
396                                                       ds2
397                                                       es2)
398       = do
399           M.unsafeCopy as1 as2
400           M.unsafeCopy bs1 bs2
401           M.unsafeCopy cs1 cs2
402           M.unsafeCopy ds1 ds2
403           M.unsafeCopy es1 es2
404   {-# INLINE unsafeGrow  #-}
405   unsafeGrow (MV_5 n_ as bs cs ds es) m_
406       = do
407           M.unsafeGrow as m_
408           M.unsafeGrow bs m_
409           M.unsafeGrow cs m_
410           M.unsafeGrow ds m_
411           M.unsafeGrow es m_
412           return $ MV_5 (m_+n_) as bs cs ds es
413 instance (Unbox a,
414           Unbox b,
415           Unbox c,
416           Unbox d,
417           Unbox e) => G.Vector Vector (a, b, c, d, e) where
418   {-# INLINE unsafeFreeze  #-}
419   unsafeFreeze (MV_5 n_ as bs cs ds es)
420       = do
421           as' <- G.unsafeFreeze as
422           bs' <- G.unsafeFreeze bs
423           cs' <- G.unsafeFreeze cs
424           ds' <- G.unsafeFreeze ds
425           es' <- G.unsafeFreeze es
426           return $ V_5 n_ as' bs' cs' ds' es'
427   {-# INLINE basicLength  #-}
428   basicLength (V_5 n_ as bs cs ds es) = n_
429   {-# INLINE basicUnsafeSlice  #-}
430   basicUnsafeSlice (V_5 n_ as bs cs ds es) i_ m_
431       = V_5 m_ (G.unsafeSlice as i_ m_)
432                (G.unsafeSlice bs i_ m_)
433                (G.unsafeSlice cs i_ m_)
434                (G.unsafeSlice ds i_ m_)
435                (G.unsafeSlice es i_ m_)
436   {-# INLINE basicUnsafeIndexM  #-}
437   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
438       = do
439           a <- G.basicUnsafeIndexM as i_
440           b <- G.basicUnsafeIndexM bs i_
441           c <- G.basicUnsafeIndexM cs i_
442           d <- G.basicUnsafeIndexM ds i_
443           e <- G.basicUnsafeIndexM es i_
444           return (a, b, c, d, e)
445 data instance MVector s (a, b, c, d, e, f)
446     = MV_6 {-# UNPACK #-} !Int (MVector s a)
447                                (MVector s b)
448                                (MVector s c)
449                                (MVector s d)
450                                (MVector s e)
451                                (MVector s f)
452 data instance Vector (a, b, c, d, e, f)
453     = V_6 {-# UNPACK #-} !Int (Vector a)
454                               (Vector b)
455                               (Vector c)
456                               (Vector d)
457                               (Vector e)
458                               (Vector f)
459 instance (Unbox a,
460           Unbox b,
461           Unbox c,
462           Unbox d,
463           Unbox e,
464           Unbox f) => Unbox (a, b, c, d, e, f)
465 instance (Unbox a,
466           Unbox b,
467           Unbox c,
468           Unbox d,
469           Unbox e,
470           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
471   {-# INLINE length  #-}
472   length (MV_6 n_ as bs cs ds es fs) = n_
473   {-# INLINE unsafeSlice  #-}
474   unsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
475       = MV_6 m_ (M.unsafeSlice as i_ m_)
476                 (M.unsafeSlice bs i_ m_)
477                 (M.unsafeSlice cs i_ m_)
478                 (M.unsafeSlice ds i_ m_)
479                 (M.unsafeSlice es i_ m_)
480                 (M.unsafeSlice fs i_ m_)
481   {-# INLINE overlaps  #-}
482   overlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
483                                                         bs2
484                                                         cs2
485                                                         ds2
486                                                         es2
487                                                         fs2)
488       = M.overlaps as1 as2
489         || M.overlaps bs1 bs2
490         || M.overlaps cs1 cs2
491         || M.overlaps ds1 ds2
492         || M.overlaps es1 es2
493         || M.overlaps fs1 fs2
494   {-# INLINE unsafeNew  #-}
495   unsafeNew n_
496       = do
497           as <- M.unsafeNew n_
498           bs <- M.unsafeNew n_
499           cs <- M.unsafeNew n_
500           ds <- M.unsafeNew n_
501           es <- M.unsafeNew n_
502           fs <- M.unsafeNew n_
503           return $ MV_6 n_ as bs cs ds es fs
504   {-# INLINE unsafeNewWith  #-}
505   unsafeNewWith n_ (a, b, c, d, e, f)
506       = do
507           as <- M.unsafeNewWith n_ a
508           bs <- M.unsafeNewWith n_ b
509           cs <- M.unsafeNewWith n_ c
510           ds <- M.unsafeNewWith n_ d
511           es <- M.unsafeNewWith n_ e
512           fs <- M.unsafeNewWith n_ f
513           return $ MV_6 n_ as bs cs ds es fs
514   {-# INLINE unsafeRead  #-}
515   unsafeRead (MV_6 n_ as bs cs ds es fs) i_
516       = do
517           a <- M.unsafeRead as i_
518           b <- M.unsafeRead bs i_
519           c <- M.unsafeRead cs i_
520           d <- M.unsafeRead ds i_
521           e <- M.unsafeRead es i_
522           f <- M.unsafeRead fs i_
523           return (a, b, c, d, e, f)
524   {-# INLINE unsafeWrite  #-}
525   unsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
526       = do
527           M.unsafeWrite as i_ a
528           M.unsafeWrite bs i_ b
529           M.unsafeWrite cs i_ c
530           M.unsafeWrite ds i_ d
531           M.unsafeWrite es i_ e
532           M.unsafeWrite fs i_ f
533   {-# INLINE clear  #-}
534   clear (MV_6 n_ as bs cs ds es fs)
535       = do
536           M.clear as
537           M.clear bs
538           M.clear cs
539           M.clear ds
540           M.clear es
541           M.clear fs
542   {-# INLINE set  #-}
543   set (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
544       = do
545           M.set as a
546           M.set bs b
547           M.set cs c
548           M.set ds d
549           M.set es e
550           M.set fs f
551   {-# INLINE unsafeCopy  #-}
552   unsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
553                                                           bs2
554                                                           cs2
555                                                           ds2
556                                                           es2
557                                                           fs2)
558       = do
559           M.unsafeCopy as1 as2
560           M.unsafeCopy bs1 bs2
561           M.unsafeCopy cs1 cs2
562           M.unsafeCopy ds1 ds2
563           M.unsafeCopy es1 es2
564           M.unsafeCopy fs1 fs2
565   {-# INLINE unsafeGrow  #-}
566   unsafeGrow (MV_6 n_ as bs cs ds es fs) m_
567       = do
568           M.unsafeGrow as m_
569           M.unsafeGrow bs m_
570           M.unsafeGrow cs m_
571           M.unsafeGrow ds m_
572           M.unsafeGrow es m_
573           M.unsafeGrow fs m_
574           return $ MV_6 (m_+n_) as bs cs ds es fs
575 instance (Unbox a,
576           Unbox b,
577           Unbox c,
578           Unbox d,
579           Unbox e,
580           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
581   {-# INLINE unsafeFreeze  #-}
582   unsafeFreeze (MV_6 n_ as bs cs ds es fs)
583       = do
584           as' <- G.unsafeFreeze as
585           bs' <- G.unsafeFreeze bs
586           cs' <- G.unsafeFreeze cs
587           ds' <- G.unsafeFreeze ds
588           es' <- G.unsafeFreeze es
589           fs' <- G.unsafeFreeze fs
590           return $ V_6 n_ as' bs' cs' ds' es' fs'
591   {-# INLINE basicLength  #-}
592   basicLength (V_6 n_ as bs cs ds es fs) = n_
593   {-# INLINE basicUnsafeSlice  #-}
594   basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
595       = V_6 m_ (G.unsafeSlice as i_ m_)
596                (G.unsafeSlice bs i_ m_)
597                (G.unsafeSlice cs i_ m_)
598                (G.unsafeSlice ds i_ m_)
599                (G.unsafeSlice es i_ m_)
600                (G.unsafeSlice fs i_ m_)
601   {-# INLINE basicUnsafeIndexM  #-}
602   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
603       = do
604           a <- G.basicUnsafeIndexM as i_
605           b <- G.basicUnsafeIndexM bs i_
606           c <- G.basicUnsafeIndexM cs i_
607           d <- G.basicUnsafeIndexM ds i_
608           e <- G.basicUnsafeIndexM es i_
609           f <- G.basicUnsafeIndexM fs i_
610           return (a, b, c, d, e, f)
611 data instance MVector s (a, b, c, d, e, f, g)
612     = MV_7 {-# UNPACK #-} !Int (MVector s a)
613                                (MVector s b)
614                                (MVector s c)
615                                (MVector s d)
616                                (MVector s e)
617                                (MVector s f)
618                                (MVector s g)
619 data instance Vector (a, b, c, d, e, f, g)
620     = V_7 {-# UNPACK #-} !Int (Vector a)
621                               (Vector b)
622                               (Vector c)
623                               (Vector d)
624                               (Vector e)
625                               (Vector f)
626                               (Vector g)
627 instance (Unbox a,
628           Unbox b,
629           Unbox c,
630           Unbox d,
631           Unbox e,
632           Unbox f,
633           Unbox g) => Unbox (a, b, c, d, e, f, g)
634 instance (Unbox a,
635           Unbox b,
636           Unbox c,
637           Unbox d,
638           Unbox e,
639           Unbox f,
640           Unbox g) => M.MVector MVector (a, b, c, d, e, f, g) where
641   {-# INLINE length  #-}
642   length (MV_7 n_ as bs cs ds es fs gs) = n_
643   {-# INLINE unsafeSlice  #-}
644   unsafeSlice (MV_7 n_ as bs cs ds es fs gs) i_ m_
645       = MV_7 m_ (M.unsafeSlice as i_ m_)
646                 (M.unsafeSlice bs i_ m_)
647                 (M.unsafeSlice cs i_ m_)
648                 (M.unsafeSlice ds i_ m_)
649                 (M.unsafeSlice es i_ m_)
650                 (M.unsafeSlice fs i_ m_)
651                 (M.unsafeSlice gs i_ m_)
652   {-# INLINE overlaps  #-}
653   overlaps (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
654                                                             bs2
655                                                             cs2
656                                                             ds2
657                                                             es2
658                                                             fs2
659                                                             gs2)
660       = M.overlaps as1 as2
661         || M.overlaps bs1 bs2
662         || M.overlaps cs1 cs2
663         || M.overlaps ds1 ds2
664         || M.overlaps es1 es2
665         || M.overlaps fs1 fs2
666         || M.overlaps gs1 gs2
667   {-# INLINE unsafeNew  #-}
668   unsafeNew n_
669       = do
670           as <- M.unsafeNew n_
671           bs <- M.unsafeNew n_
672           cs <- M.unsafeNew n_
673           ds <- M.unsafeNew n_
674           es <- M.unsafeNew n_
675           fs <- M.unsafeNew n_
676           gs <- M.unsafeNew n_
677           return $ MV_7 n_ as bs cs ds es fs gs
678   {-# INLINE unsafeNewWith  #-}
679   unsafeNewWith n_ (a, b, c, d, e, f, g)
680       = do
681           as <- M.unsafeNewWith n_ a
682           bs <- M.unsafeNewWith n_ b
683           cs <- M.unsafeNewWith n_ c
684           ds <- M.unsafeNewWith n_ d
685           es <- M.unsafeNewWith n_ e
686           fs <- M.unsafeNewWith n_ f
687           gs <- M.unsafeNewWith n_ g
688           return $ MV_7 n_ as bs cs ds es fs gs
689   {-# INLINE unsafeRead  #-}
690   unsafeRead (MV_7 n_ as bs cs ds es fs gs) i_
691       = do
692           a <- M.unsafeRead as i_
693           b <- M.unsafeRead bs i_
694           c <- M.unsafeRead cs i_
695           d <- M.unsafeRead ds i_
696           e <- M.unsafeRead es i_
697           f <- M.unsafeRead fs i_
698           g <- M.unsafeRead gs i_
699           return (a, b, c, d, e, f, g)
700   {-# INLINE unsafeWrite  #-}
701   unsafeWrite (MV_7 n_ as bs cs ds es fs gs) i_ (a, b, c, d, e, f, g)
702       = do
703           M.unsafeWrite as i_ a
704           M.unsafeWrite bs i_ b
705           M.unsafeWrite cs i_ c
706           M.unsafeWrite ds i_ d
707           M.unsafeWrite es i_ e
708           M.unsafeWrite fs i_ f
709           M.unsafeWrite gs i_ g
710   {-# INLINE clear  #-}
711   clear (MV_7 n_ as bs cs ds es fs gs)
712       = do
713           M.clear as
714           M.clear bs
715           M.clear cs
716           M.clear ds
717           M.clear es
718           M.clear fs
719           M.clear gs
720   {-# INLINE set  #-}
721   set (MV_7 n_ as bs cs ds es fs gs) (a, b, c, d, e, f, g)
722       = do
723           M.set as a
724           M.set bs b
725           M.set cs c
726           M.set ds d
727           M.set es e
728           M.set fs f
729           M.set gs g
730   {-# INLINE unsafeCopy  #-}
731   unsafeCopy (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
732                                                               bs2
733                                                               cs2
734                                                               ds2
735                                                               es2
736                                                               fs2
737                                                               gs2)
738       = do
739           M.unsafeCopy as1 as2
740           M.unsafeCopy bs1 bs2
741           M.unsafeCopy cs1 cs2
742           M.unsafeCopy ds1 ds2
743           M.unsafeCopy es1 es2
744           M.unsafeCopy fs1 fs2
745           M.unsafeCopy gs1 gs2
746   {-# INLINE unsafeGrow  #-}
747   unsafeGrow (MV_7 n_ as bs cs ds es fs gs) m_
748       = do
749           M.unsafeGrow as m_
750           M.unsafeGrow bs m_
751           M.unsafeGrow cs m_
752           M.unsafeGrow ds m_
753           M.unsafeGrow es m_
754           M.unsafeGrow fs m_
755           M.unsafeGrow gs m_
756           return $ MV_7 (m_+n_) as bs cs ds es fs gs
757 instance (Unbox a,
758           Unbox b,
759           Unbox c,
760           Unbox d,
761           Unbox e,
762           Unbox f,
763           Unbox g) => G.Vector Vector (a, b, c, d, e, f, g) where
764   {-# INLINE unsafeFreeze  #-}
765   unsafeFreeze (MV_7 n_ as bs cs ds es fs gs)
766       = do
767           as' <- G.unsafeFreeze as
768           bs' <- G.unsafeFreeze bs
769           cs' <- G.unsafeFreeze cs
770           ds' <- G.unsafeFreeze ds
771           es' <- G.unsafeFreeze es
772           fs' <- G.unsafeFreeze fs
773           gs' <- G.unsafeFreeze gs
774           return $ V_7 n_ as' bs' cs' ds' es' fs' gs'
775   {-# INLINE basicLength  #-}
776   basicLength (V_7 n_ as bs cs ds es fs gs) = n_
777   {-# INLINE basicUnsafeSlice  #-}
778   basicUnsafeSlice (V_7 n_ as bs cs ds es fs gs) i_ m_
779       = V_7 m_ (G.unsafeSlice as i_ m_)
780                (G.unsafeSlice bs i_ m_)
781                (G.unsafeSlice cs i_ m_)
782                (G.unsafeSlice ds i_ m_)
783                (G.unsafeSlice es i_ m_)
784                (G.unsafeSlice fs i_ m_)
785                (G.unsafeSlice gs i_ m_)
786   {-# INLINE basicUnsafeIndexM  #-}
787   basicUnsafeIndexM (V_7 n_ as bs cs ds es fs gs) i_
788       = do
789           a <- G.basicUnsafeIndexM as i_
790           b <- G.basicUnsafeIndexM bs i_
791           c <- G.basicUnsafeIndexM cs i_
792           d <- G.basicUnsafeIndexM ds i_
793           e <- G.basicUnsafeIndexM es i_
794           f <- G.basicUnsafeIndexM fs i_
795           g <- G.basicUnsafeIndexM gs i_
796           return (a, b, c, d, e, f, g)
797 data instance MVector s (a, b, c, d, e, f, g, h)
798     = MV_8 {-# UNPACK #-} !Int (MVector s a)
799                                (MVector s b)
800                                (MVector s c)
801                                (MVector s d)
802                                (MVector s e)
803                                (MVector s f)
804                                (MVector s g)
805                                (MVector s h)
806 data instance Vector (a, b, c, d, e, f, g, h)
807     = V_8 {-# UNPACK #-} !Int (Vector a)
808                               (Vector b)
809                               (Vector c)
810                               (Vector d)
811                               (Vector e)
812                               (Vector f)
813                               (Vector g)
814                               (Vector h)
815 instance (Unbox a,
816           Unbox b,
817           Unbox c,
818           Unbox d,
819           Unbox e,
820           Unbox f,
821           Unbox g,
822           Unbox h) => Unbox (a, b, c, d, e, f, g, h)
823 instance (Unbox a,
824           Unbox b,
825           Unbox c,
826           Unbox d,
827           Unbox e,
828           Unbox f,
829           Unbox g,
830           Unbox h) => M.MVector MVector (a, b, c, d, e, f, g, h) where
831   {-# INLINE length  #-}
832   length (MV_8 n_ as bs cs ds es fs gs hs) = n_
833   {-# INLINE unsafeSlice  #-}
834   unsafeSlice (MV_8 n_ as bs cs ds es fs gs hs) i_ m_
835       = MV_8 m_ (M.unsafeSlice as i_ m_)
836                 (M.unsafeSlice bs i_ m_)
837                 (M.unsafeSlice cs i_ m_)
838                 (M.unsafeSlice ds i_ m_)
839                 (M.unsafeSlice es i_ m_)
840                 (M.unsafeSlice fs i_ m_)
841                 (M.unsafeSlice gs i_ m_)
842                 (M.unsafeSlice hs i_ m_)
843   {-# INLINE overlaps  #-}
844   overlaps (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
845                                                                 bs2
846                                                                 cs2
847                                                                 ds2
848                                                                 es2
849                                                                 fs2
850                                                                 gs2
851                                                                 hs2)
852       = M.overlaps as1 as2
853         || M.overlaps bs1 bs2
854         || M.overlaps cs1 cs2
855         || M.overlaps ds1 ds2
856         || M.overlaps es1 es2
857         || M.overlaps fs1 fs2
858         || M.overlaps gs1 gs2
859         || M.overlaps hs1 hs2
860   {-# INLINE unsafeNew  #-}
861   unsafeNew n_
862       = do
863           as <- M.unsafeNew n_
864           bs <- M.unsafeNew n_
865           cs <- M.unsafeNew n_
866           ds <- M.unsafeNew n_
867           es <- M.unsafeNew n_
868           fs <- M.unsafeNew n_
869           gs <- M.unsafeNew n_
870           hs <- M.unsafeNew n_
871           return $ MV_8 n_ as bs cs ds es fs gs hs
872   {-# INLINE unsafeNewWith  #-}
873   unsafeNewWith n_ (a, b, c, d, e, f, g, h)
874       = do
875           as <- M.unsafeNewWith n_ a
876           bs <- M.unsafeNewWith n_ b
877           cs <- M.unsafeNewWith n_ c
878           ds <- M.unsafeNewWith n_ d
879           es <- M.unsafeNewWith n_ e
880           fs <- M.unsafeNewWith n_ f
881           gs <- M.unsafeNewWith n_ g
882           hs <- M.unsafeNewWith n_ h
883           return $ MV_8 n_ as bs cs ds es fs gs hs
884   {-# INLINE unsafeRead  #-}
885   unsafeRead (MV_8 n_ as bs cs ds es fs gs hs) i_
886       = do
887           a <- M.unsafeRead as i_
888           b <- M.unsafeRead bs i_
889           c <- M.unsafeRead cs i_
890           d <- M.unsafeRead ds i_
891           e <- M.unsafeRead es i_
892           f <- M.unsafeRead fs i_
893           g <- M.unsafeRead gs i_
894           h <- M.unsafeRead hs i_
895           return (a, b, c, d, e, f, g, h)
896   {-# INLINE unsafeWrite  #-}
897   unsafeWrite (MV_8 n_ as
898                        bs
899                        cs
900                        ds
901                        es
902                        fs
903                        gs
904                        hs) i_ (a, b, c, d, e, f, g, h)
905       = do
906           M.unsafeWrite as i_ a
907           M.unsafeWrite bs i_ b
908           M.unsafeWrite cs i_ c
909           M.unsafeWrite ds i_ d
910           M.unsafeWrite es i_ e
911           M.unsafeWrite fs i_ f
912           M.unsafeWrite gs i_ g
913           M.unsafeWrite hs i_ h
914   {-# INLINE clear  #-}
915   clear (MV_8 n_ as bs cs ds es fs gs hs)
916       = do
917           M.clear as
918           M.clear bs
919           M.clear cs
920           M.clear ds
921           M.clear es
922           M.clear fs
923           M.clear gs
924           M.clear hs
925   {-# INLINE set  #-}
926   set (MV_8 n_ as bs cs ds es fs gs hs) (a, b, c, d, e, f, g, h)
927       = do
928           M.set as a
929           M.set bs b
930           M.set cs c
931           M.set ds d
932           M.set es e
933           M.set fs f
934           M.set gs g
935           M.set hs h
936   {-# INLINE unsafeCopy  #-}
937   unsafeCopy (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
938                                                                   bs2
939                                                                   cs2
940                                                                   ds2
941                                                                   es2
942                                                                   fs2
943                                                                   gs2
944                                                                   hs2)
945       = do
946           M.unsafeCopy as1 as2
947           M.unsafeCopy bs1 bs2
948           M.unsafeCopy cs1 cs2
949           M.unsafeCopy ds1 ds2
950           M.unsafeCopy es1 es2
951           M.unsafeCopy fs1 fs2
952           M.unsafeCopy gs1 gs2
953           M.unsafeCopy hs1 hs2
954   {-# INLINE unsafeGrow  #-}
955   unsafeGrow (MV_8 n_ as bs cs ds es fs gs hs) m_
956       = do
957           M.unsafeGrow as m_
958           M.unsafeGrow bs m_
959           M.unsafeGrow cs m_
960           M.unsafeGrow ds m_
961           M.unsafeGrow es m_
962           M.unsafeGrow fs m_
963           M.unsafeGrow gs m_
964           M.unsafeGrow hs m_
965           return $ MV_8 (m_+n_) as bs cs ds es fs gs hs
966 instance (Unbox a,
967           Unbox b,
968           Unbox c,
969           Unbox d,
970           Unbox e,
971           Unbox f,
972           Unbox g,
973           Unbox h) => G.Vector Vector (a, b, c, d, e, f, g, h) where
974   {-# INLINE unsafeFreeze  #-}
975   unsafeFreeze (MV_8 n_ as bs cs ds es fs gs hs)
976       = do
977           as' <- G.unsafeFreeze as
978           bs' <- G.unsafeFreeze bs
979           cs' <- G.unsafeFreeze cs
980           ds' <- G.unsafeFreeze ds
981           es' <- G.unsafeFreeze es
982           fs' <- G.unsafeFreeze fs
983           gs' <- G.unsafeFreeze gs
984           hs' <- G.unsafeFreeze hs
985           return $ V_8 n_ as' bs' cs' ds' es' fs' gs' hs'
986   {-# INLINE basicLength  #-}
987   basicLength (V_8 n_ as bs cs ds es fs gs hs) = n_
988   {-# INLINE basicUnsafeSlice  #-}
989   basicUnsafeSlice (V_8 n_ as bs cs ds es fs gs hs) i_ m_
990       = V_8 m_ (G.unsafeSlice as i_ m_)
991                (G.unsafeSlice bs i_ m_)
992                (G.unsafeSlice cs i_ m_)
993                (G.unsafeSlice ds i_ m_)
994                (G.unsafeSlice es i_ m_)
995                (G.unsafeSlice fs i_ m_)
996                (G.unsafeSlice gs i_ m_)
997                (G.unsafeSlice hs i_ m_)
998   {-# INLINE basicUnsafeIndexM  #-}
999   basicUnsafeIndexM (V_8 n_ as bs cs ds es fs gs hs) i_
1000       = do
1001           a <- G.basicUnsafeIndexM as i_
1002           b <- G.basicUnsafeIndexM bs i_
1003           c <- G.basicUnsafeIndexM cs i_
1004           d <- G.basicUnsafeIndexM ds i_
1005           e <- G.basicUnsafeIndexM es i_
1006           f <- G.basicUnsafeIndexM fs i_
1007           g <- G.basicUnsafeIndexM gs i_
1008           h <- G.basicUnsafeIndexM hs i_
1009           return (a, b, c, d, e, f, g, h)
1010 data instance MVector s (a, b, c, d, e, f, g, h, i)
1011     = MV_9 {-# UNPACK #-} !Int (MVector s a)
1012                                (MVector s b)
1013                                (MVector s c)
1014                                (MVector s d)
1015                                (MVector s e)
1016                                (MVector s f)
1017                                (MVector s g)
1018                                (MVector s h)
1019                                (MVector s i)
1020 data instance Vector (a, b, c, d, e, f, g, h, i)
1021     = V_9 {-# UNPACK #-} !Int (Vector a)
1022                               (Vector b)
1023                               (Vector c)
1024                               (Vector d)
1025                               (Vector e)
1026                               (Vector f)
1027                               (Vector g)
1028                               (Vector h)
1029                               (Vector i)
1030 instance (Unbox a,
1031           Unbox b,
1032           Unbox c,
1033           Unbox d,
1034           Unbox e,
1035           Unbox f,
1036           Unbox g,
1037           Unbox h,
1038           Unbox i) => Unbox (a, b, c, d, e, f, g, h, i)
1039 instance (Unbox a,
1040           Unbox b,
1041           Unbox c,
1042           Unbox d,
1043           Unbox e,
1044           Unbox f,
1045           Unbox g,
1046           Unbox h,
1047           Unbox i) => M.MVector MVector (a, b, c, d, e, f, g, h, i) where
1048   {-# INLINE length  #-}
1049   length (MV_9 n_ as bs cs ds es fs gs hs is) = n_
1050   {-# INLINE unsafeSlice  #-}
1051   unsafeSlice (MV_9 n_ as bs cs ds es fs gs hs is) i_ m_
1052       = MV_9 m_ (M.unsafeSlice as i_ m_)
1053                 (M.unsafeSlice bs i_ m_)
1054                 (M.unsafeSlice cs i_ m_)
1055                 (M.unsafeSlice ds i_ m_)
1056                 (M.unsafeSlice es i_ m_)
1057                 (M.unsafeSlice fs i_ m_)
1058                 (M.unsafeSlice gs i_ m_)
1059                 (M.unsafeSlice hs i_ m_)
1060                 (M.unsafeSlice is i_ m_)
1061   {-# INLINE overlaps  #-}
1062   overlaps (MV_9 n_1 as1
1063                      bs1
1064                      cs1
1065                      ds1
1066                      es1
1067                      fs1
1068                      gs1
1069                      hs1
1070                      is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
1071       = M.overlaps as1 as2
1072         || M.overlaps bs1 bs2
1073         || M.overlaps cs1 cs2
1074         || M.overlaps ds1 ds2
1075         || M.overlaps es1 es2
1076         || M.overlaps fs1 fs2
1077         || M.overlaps gs1 gs2
1078         || M.overlaps hs1 hs2
1079         || M.overlaps is1 is2
1080   {-# INLINE unsafeNew  #-}
1081   unsafeNew n_
1082       = do
1083           as <- M.unsafeNew n_
1084           bs <- M.unsafeNew n_
1085           cs <- M.unsafeNew n_
1086           ds <- M.unsafeNew n_
1087           es <- M.unsafeNew n_
1088           fs <- M.unsafeNew n_
1089           gs <- M.unsafeNew n_
1090           hs <- M.unsafeNew n_
1091           is <- M.unsafeNew n_
1092           return $ MV_9 n_ as bs cs ds es fs gs hs is
1093   {-# INLINE unsafeNewWith  #-}
1094   unsafeNewWith n_ (a, b, c, d, e, f, g, h, i)
1095       = do
1096           as <- M.unsafeNewWith n_ a
1097           bs <- M.unsafeNewWith n_ b
1098           cs <- M.unsafeNewWith n_ c
1099           ds <- M.unsafeNewWith n_ d
1100           es <- M.unsafeNewWith n_ e
1101           fs <- M.unsafeNewWith n_ f
1102           gs <- M.unsafeNewWith n_ g
1103           hs <- M.unsafeNewWith n_ h
1104           is <- M.unsafeNewWith n_ i
1105           return $ MV_9 n_ as bs cs ds es fs gs hs is
1106   {-# INLINE unsafeRead  #-}
1107   unsafeRead (MV_9 n_ as bs cs ds es fs gs hs is) i_
1108       = do
1109           a <- M.unsafeRead as i_
1110           b <- M.unsafeRead bs i_
1111           c <- M.unsafeRead cs i_
1112           d <- M.unsafeRead ds i_
1113           e <- M.unsafeRead es i_
1114           f <- M.unsafeRead fs i_
1115           g <- M.unsafeRead gs i_
1116           h <- M.unsafeRead hs i_
1117           i <- M.unsafeRead is i_
1118           return (a, b, c, d, e, f, g, h, i)
1119   {-# INLINE unsafeWrite  #-}
1120   unsafeWrite (MV_9 n_ as
1121                        bs
1122                        cs
1123                        ds
1124                        es
1125                        fs
1126                        gs
1127                        hs
1128                        is) i_ (a, b, c, d, e, f, g, h, i)
1129       = do
1130           M.unsafeWrite as i_ a
1131           M.unsafeWrite bs i_ b
1132           M.unsafeWrite cs i_ c
1133           M.unsafeWrite ds i_ d
1134           M.unsafeWrite es i_ e
1135           M.unsafeWrite fs i_ f
1136           M.unsafeWrite gs i_ g
1137           M.unsafeWrite hs i_ h
1138           M.unsafeWrite is i_ i
1139   {-# INLINE clear  #-}
1140   clear (MV_9 n_ as bs cs ds es fs gs hs is)
1141       = do
1142           M.clear as
1143           M.clear bs
1144           M.clear cs
1145           M.clear ds
1146           M.clear es
1147           M.clear fs
1148           M.clear gs
1149           M.clear hs
1150           M.clear is
1151   {-# INLINE set  #-}
1152   set (MV_9 n_ as
1153                bs
1154                cs
1155                ds
1156                es
1157                fs
1158                gs
1159                hs
1160                is) (a, b, c, d, e, f, g, h, i)
1161       = do
1162           M.set as a
1163           M.set bs b
1164           M.set cs c
1165           M.set ds d
1166           M.set es e
1167           M.set fs f
1168           M.set gs g
1169           M.set hs h
1170           M.set is i
1171   {-# INLINE unsafeCopy  #-}
1172   unsafeCopy (MV_9 n_1 as1
1173                        bs1
1174                        cs1
1175                        ds1
1176                        es1
1177                        fs1
1178                        gs1
1179                        hs1
1180                        is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
1181       = do
1182           M.unsafeCopy as1 as2
1183           M.unsafeCopy bs1 bs2
1184           M.unsafeCopy cs1 cs2
1185           M.unsafeCopy ds1 ds2
1186           M.unsafeCopy es1 es2
1187           M.unsafeCopy fs1 fs2
1188           M.unsafeCopy gs1 gs2
1189           M.unsafeCopy hs1 hs2
1190           M.unsafeCopy is1 is2
1191   {-# INLINE unsafeGrow  #-}
1192   unsafeGrow (MV_9 n_ as bs cs ds es fs gs hs is) m_
1193       = do
1194           M.unsafeGrow as m_
1195           M.unsafeGrow bs m_
1196           M.unsafeGrow cs m_
1197           M.unsafeGrow ds m_
1198           M.unsafeGrow es m_
1199           M.unsafeGrow fs m_
1200           M.unsafeGrow gs m_
1201           M.unsafeGrow hs m_
1202           M.unsafeGrow is m_
1203           return $ MV_9 (m_+n_) as bs cs ds es fs gs hs is
1204 instance (Unbox a,
1205           Unbox b,
1206           Unbox c,
1207           Unbox d,
1208           Unbox e,
1209           Unbox f,
1210           Unbox g,
1211           Unbox h,
1212           Unbox i) => G.Vector Vector (a, b, c, d, e, f, g, h, i) where
1213   {-# INLINE unsafeFreeze  #-}
1214   unsafeFreeze (MV_9 n_ as bs cs ds es fs gs hs is)
1215       = do
1216           as' <- G.unsafeFreeze as
1217           bs' <- G.unsafeFreeze bs
1218           cs' <- G.unsafeFreeze cs
1219           ds' <- G.unsafeFreeze ds
1220           es' <- G.unsafeFreeze es
1221           fs' <- G.unsafeFreeze fs
1222           gs' <- G.unsafeFreeze gs
1223           hs' <- G.unsafeFreeze hs
1224           is' <- G.unsafeFreeze is
1225           return $ V_9 n_ as' bs' cs' ds' es' fs' gs' hs' is'
1226   {-# INLINE basicLength  #-}
1227   basicLength (V_9 n_ as bs cs ds es fs gs hs is) = n_
1228   {-# INLINE basicUnsafeSlice  #-}
1229   basicUnsafeSlice (V_9 n_ as bs cs ds es fs gs hs is) i_ m_
1230       = V_9 m_ (G.unsafeSlice as i_ m_)
1231                (G.unsafeSlice bs i_ m_)
1232                (G.unsafeSlice cs i_ m_)
1233                (G.unsafeSlice ds i_ m_)
1234                (G.unsafeSlice es i_ m_)
1235                (G.unsafeSlice fs i_ m_)
1236                (G.unsafeSlice gs i_ m_)
1237                (G.unsafeSlice hs i_ m_)
1238                (G.unsafeSlice is i_ m_)
1239   {-# INLINE basicUnsafeIndexM  #-}
1240   basicUnsafeIndexM (V_9 n_ as bs cs ds es fs gs hs is) i_
1241       = do
1242           a <- G.basicUnsafeIndexM as i_
1243           b <- G.basicUnsafeIndexM bs i_
1244           c <- G.basicUnsafeIndexM cs i_
1245           d <- G.basicUnsafeIndexM ds i_
1246           e <- G.basicUnsafeIndexM es i_
1247           f <- G.basicUnsafeIndexM fs i_
1248           g <- G.basicUnsafeIndexM gs i_
1249           h <- G.basicUnsafeIndexM hs i_
1250           i <- G.basicUnsafeIndexM is i_
1251           return (a, b, c, d, e, f, g, h, i)
1252 data instance MVector s (a, b, c, d, e, f, g, h, i, j)
1253     = MV_10 {-# UNPACK #-} !Int (MVector s a)
1254                                 (MVector s b)
1255                                 (MVector s c)
1256                                 (MVector s d)
1257                                 (MVector s e)
1258                                 (MVector s f)
1259                                 (MVector s g)
1260                                 (MVector s h)
1261                                 (MVector s i)
1262                                 (MVector s j)
1263 data instance Vector (a, b, c, d, e, f, g, h, i, j)
1264     = V_10 {-# UNPACK #-} !Int (Vector a)
1265                                (Vector b)
1266                                (Vector c)
1267                                (Vector d)
1268                                (Vector e)
1269                                (Vector f)
1270                                (Vector g)
1271                                (Vector h)
1272                                (Vector i)
1273                                (Vector j)
1274 instance (Unbox a,
1275           Unbox b,
1276           Unbox c,
1277           Unbox d,
1278           Unbox e,
1279           Unbox f,
1280           Unbox g,
1281           Unbox h,
1282           Unbox i,
1283           Unbox j) => Unbox (a, b, c, d, e, f, g, h, i, j)
1284 instance (Unbox a,
1285           Unbox b,
1286           Unbox c,
1287           Unbox d,
1288           Unbox e,
1289           Unbox f,
1290           Unbox g,
1291           Unbox h,
1292           Unbox i,
1293           Unbox j) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j) where
1294   {-# INLINE length  #-}
1295   length (MV_10 n_ as bs cs ds es fs gs hs is js) = n_
1296   {-# INLINE unsafeSlice  #-}
1297   unsafeSlice (MV_10 n_ as bs cs ds es fs gs hs is js) i_ m_
1298       = MV_10 m_ (M.unsafeSlice as i_ m_)
1299                  (M.unsafeSlice bs i_ m_)
1300                  (M.unsafeSlice cs i_ m_)
1301                  (M.unsafeSlice ds i_ m_)
1302                  (M.unsafeSlice es i_ m_)
1303                  (M.unsafeSlice fs i_ m_)
1304                  (M.unsafeSlice gs i_ m_)
1305                  (M.unsafeSlice hs i_ m_)
1306                  (M.unsafeSlice is i_ m_)
1307                  (M.unsafeSlice js i_ m_)
1308   {-# INLINE overlaps  #-}
1309   overlaps (MV_10 n_1 as1
1310                       bs1
1311                       cs1
1312                       ds1
1313                       es1
1314                       fs1
1315                       gs1
1316                       hs1
1317                       is1
1318                       js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
1319       = M.overlaps as1 as2
1320         || M.overlaps bs1 bs2
1321         || M.overlaps cs1 cs2
1322         || M.overlaps ds1 ds2
1323         || M.overlaps es1 es2
1324         || M.overlaps fs1 fs2
1325         || M.overlaps gs1 gs2
1326         || M.overlaps hs1 hs2
1327         || M.overlaps is1 is2
1328         || M.overlaps js1 js2
1329   {-# INLINE unsafeNew  #-}
1330   unsafeNew n_
1331       = do
1332           as <- M.unsafeNew n_
1333           bs <- M.unsafeNew n_
1334           cs <- M.unsafeNew n_
1335           ds <- M.unsafeNew n_
1336           es <- M.unsafeNew n_
1337           fs <- M.unsafeNew n_
1338           gs <- M.unsafeNew n_
1339           hs <- M.unsafeNew n_
1340           is <- M.unsafeNew n_
1341           js <- M.unsafeNew n_
1342           return $ MV_10 n_ as bs cs ds es fs gs hs is js
1343   {-# INLINE unsafeNewWith  #-}
1344   unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j)
1345       = do
1346           as <- M.unsafeNewWith n_ a
1347           bs <- M.unsafeNewWith n_ b
1348           cs <- M.unsafeNewWith n_ c
1349           ds <- M.unsafeNewWith n_ d
1350           es <- M.unsafeNewWith n_ e
1351           fs <- M.unsafeNewWith n_ f
1352           gs <- M.unsafeNewWith n_ g
1353           hs <- M.unsafeNewWith n_ h
1354           is <- M.unsafeNewWith n_ i
1355           js <- M.unsafeNewWith n_ j
1356           return $ MV_10 n_ as bs cs ds es fs gs hs is js
1357   {-# INLINE unsafeRead  #-}
1358   unsafeRead (MV_10 n_ as bs cs ds es fs gs hs is js) i_
1359       = do
1360           a <- M.unsafeRead as i_
1361           b <- M.unsafeRead bs i_
1362           c <- M.unsafeRead cs i_
1363           d <- M.unsafeRead ds i_
1364           e <- M.unsafeRead es i_
1365           f <- M.unsafeRead fs i_
1366           g <- M.unsafeRead gs i_
1367           h <- M.unsafeRead hs i_
1368           i <- M.unsafeRead is i_
1369           j <- M.unsafeRead js i_
1370           return (a, b, c, d, e, f, g, h, i, j)
1371   {-# INLINE unsafeWrite  #-}
1372   unsafeWrite (MV_10 n_ as
1373                         bs
1374                         cs
1375                         ds
1376                         es
1377                         fs
1378                         gs
1379                         hs
1380                         is
1381                         js) i_ (a, b, c, d, e, f, g, h, i, j)
1382       = do
1383           M.unsafeWrite as i_ a
1384           M.unsafeWrite bs i_ b
1385           M.unsafeWrite cs i_ c
1386           M.unsafeWrite ds i_ d
1387           M.unsafeWrite es i_ e
1388           M.unsafeWrite fs i_ f
1389           M.unsafeWrite gs i_ g
1390           M.unsafeWrite hs i_ h
1391           M.unsafeWrite is i_ i
1392           M.unsafeWrite js i_ j
1393   {-# INLINE clear  #-}
1394   clear (MV_10 n_ as bs cs ds es fs gs hs is js)
1395       = do
1396           M.clear as
1397           M.clear bs
1398           M.clear cs
1399           M.clear ds
1400           M.clear es
1401           M.clear fs
1402           M.clear gs
1403           M.clear hs
1404           M.clear is
1405           M.clear js
1406   {-# INLINE set  #-}
1407   set (MV_10 n_ as
1408                 bs
1409                 cs
1410                 ds
1411                 es
1412                 fs
1413                 gs
1414                 hs
1415                 is
1416                 js) (a, b, c, d, e, f, g, h, i, j)
1417       = do
1418           M.set as a
1419           M.set bs b
1420           M.set cs c
1421           M.set ds d
1422           M.set es e
1423           M.set fs f
1424           M.set gs g
1425           M.set hs h
1426           M.set is i
1427           M.set js j
1428   {-# INLINE unsafeCopy  #-}
1429   unsafeCopy (MV_10 n_1 as1
1430                         bs1
1431                         cs1
1432                         ds1
1433                         es1
1434                         fs1
1435                         gs1
1436                         hs1
1437                         is1
1438                         js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
1439       = do
1440           M.unsafeCopy as1 as2
1441           M.unsafeCopy bs1 bs2
1442           M.unsafeCopy cs1 cs2
1443           M.unsafeCopy ds1 ds2
1444           M.unsafeCopy es1 es2
1445           M.unsafeCopy fs1 fs2
1446           M.unsafeCopy gs1 gs2
1447           M.unsafeCopy hs1 hs2
1448           M.unsafeCopy is1 is2
1449           M.unsafeCopy js1 js2
1450   {-# INLINE unsafeGrow  #-}
1451   unsafeGrow (MV_10 n_ as bs cs ds es fs gs hs is js) m_
1452       = do
1453           M.unsafeGrow as m_
1454           M.unsafeGrow bs m_
1455           M.unsafeGrow cs m_
1456           M.unsafeGrow ds m_
1457           M.unsafeGrow es m_
1458           M.unsafeGrow fs m_
1459           M.unsafeGrow gs m_
1460           M.unsafeGrow hs m_
1461           M.unsafeGrow is m_
1462           M.unsafeGrow js m_
1463           return $ MV_10 (m_+n_) as bs cs ds es fs gs hs is js
1464 instance (Unbox a,
1465           Unbox b,
1466           Unbox c,
1467           Unbox d,
1468           Unbox e,
1469           Unbox f,
1470           Unbox g,
1471           Unbox h,
1472           Unbox i,
1473           Unbox j) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j) where
1474   {-# INLINE unsafeFreeze  #-}
1475   unsafeFreeze (MV_10 n_ as bs cs ds es fs gs hs is js)
1476       = do
1477           as' <- G.unsafeFreeze as
1478           bs' <- G.unsafeFreeze bs
1479           cs' <- G.unsafeFreeze cs
1480           ds' <- G.unsafeFreeze ds
1481           es' <- G.unsafeFreeze es
1482           fs' <- G.unsafeFreeze fs
1483           gs' <- G.unsafeFreeze gs
1484           hs' <- G.unsafeFreeze hs
1485           is' <- G.unsafeFreeze is
1486           js' <- G.unsafeFreeze js
1487           return $ V_10 n_ as' bs' cs' ds' es' fs' gs' hs' is' js'
1488   {-# INLINE basicLength  #-}
1489   basicLength (V_10 n_ as bs cs ds es fs gs hs is js) = n_
1490   {-# INLINE basicUnsafeSlice  #-}
1491   basicUnsafeSlice (V_10 n_ as bs cs ds es fs gs hs is js) i_ m_
1492       = V_10 m_ (G.unsafeSlice as i_ m_)
1493                 (G.unsafeSlice bs i_ m_)
1494                 (G.unsafeSlice cs i_ m_)
1495                 (G.unsafeSlice ds i_ m_)
1496                 (G.unsafeSlice es i_ m_)
1497                 (G.unsafeSlice fs i_ m_)
1498                 (G.unsafeSlice gs i_ m_)
1499                 (G.unsafeSlice hs i_ m_)
1500                 (G.unsafeSlice is i_ m_)
1501                 (G.unsafeSlice js i_ m_)
1502   {-# INLINE basicUnsafeIndexM  #-}
1503   basicUnsafeIndexM (V_10 n_ as bs cs ds es fs gs hs is js) i_
1504       = do
1505           a <- G.basicUnsafeIndexM as i_
1506           b <- G.basicUnsafeIndexM bs i_
1507           c <- G.basicUnsafeIndexM cs i_
1508           d <- G.basicUnsafeIndexM ds i_
1509           e <- G.basicUnsafeIndexM es i_
1510           f <- G.basicUnsafeIndexM fs i_
1511           g <- G.basicUnsafeIndexM gs i_
1512           h <- G.basicUnsafeIndexM hs i_
1513           i <- G.basicUnsafeIndexM is i_
1514           j <- G.basicUnsafeIndexM js i_
1515           return (a, b, c, d, e, f, g, h, i, j)
1516 data instance MVector s (a, b, c, d, e, f, g, h, i, j, k)
1517     = MV_11 {-# UNPACK #-} !Int (MVector s a)
1518                                 (MVector s b)
1519                                 (MVector s c)
1520                                 (MVector s d)
1521                                 (MVector s e)
1522                                 (MVector s f)
1523                                 (MVector s g)
1524                                 (MVector s h)
1525                                 (MVector s i)
1526                                 (MVector s j)
1527                                 (MVector s k)
1528 data instance Vector (a, b, c, d, e, f, g, h, i, j, k)
1529     = V_11 {-# UNPACK #-} !Int (Vector a)
1530                                (Vector b)
1531                                (Vector c)
1532                                (Vector d)
1533                                (Vector e)
1534                                (Vector f)
1535                                (Vector g)
1536                                (Vector h)
1537                                (Vector i)
1538                                (Vector j)
1539                                (Vector k)
1540 instance (Unbox a,
1541           Unbox b,
1542           Unbox c,
1543           Unbox d,
1544           Unbox e,
1545           Unbox f,
1546           Unbox g,
1547           Unbox h,
1548           Unbox i,
1549           Unbox j,
1550           Unbox k) => Unbox (a, b, c, d, e, f, g, h, i, j, k)
1551 instance (Unbox a,
1552           Unbox b,
1553           Unbox c,
1554           Unbox d,
1555           Unbox e,
1556           Unbox f,
1557           Unbox g,
1558           Unbox h,
1559           Unbox i,
1560           Unbox j,
1561           Unbox k) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k) where
1562   {-# INLINE length  #-}
1563   length (MV_11 n_ as bs cs ds es fs gs hs is js ks) = n_
1564   {-# INLINE unsafeSlice  #-}
1565   unsafeSlice (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
1566       = MV_11 m_ (M.unsafeSlice as i_ m_)
1567                  (M.unsafeSlice bs i_ m_)
1568                  (M.unsafeSlice cs i_ m_)
1569                  (M.unsafeSlice ds i_ m_)
1570                  (M.unsafeSlice es i_ m_)
1571                  (M.unsafeSlice fs i_ m_)
1572                  (M.unsafeSlice gs i_ m_)
1573                  (M.unsafeSlice hs i_ m_)
1574                  (M.unsafeSlice is i_ m_)
1575                  (M.unsafeSlice js i_ m_)
1576                  (M.unsafeSlice ks i_ m_)
1577   {-# INLINE overlaps  #-}
1578   overlaps (MV_11 n_1 as1
1579                       bs1
1580                       cs1
1581                       ds1
1582                       es1
1583                       fs1
1584                       gs1
1585                       hs1
1586                       is1
1587                       js1
1588                       ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
1589       = M.overlaps as1 as2
1590         || M.overlaps bs1 bs2
1591         || M.overlaps cs1 cs2
1592         || M.overlaps ds1 ds2
1593         || M.overlaps es1 es2
1594         || M.overlaps fs1 fs2
1595         || M.overlaps gs1 gs2
1596         || M.overlaps hs1 hs2
1597         || M.overlaps is1 is2
1598         || M.overlaps js1 js2
1599         || M.overlaps ks1 ks2
1600   {-# INLINE unsafeNew  #-}
1601   unsafeNew n_
1602       = do
1603           as <- M.unsafeNew n_
1604           bs <- M.unsafeNew n_
1605           cs <- M.unsafeNew n_
1606           ds <- M.unsafeNew n_
1607           es <- M.unsafeNew n_
1608           fs <- M.unsafeNew n_
1609           gs <- M.unsafeNew n_
1610           hs <- M.unsafeNew n_
1611           is <- M.unsafeNew n_
1612           js <- M.unsafeNew n_
1613           ks <- M.unsafeNew n_
1614           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
1615   {-# INLINE unsafeNewWith  #-}
1616   unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k)
1617       = do
1618           as <- M.unsafeNewWith n_ a
1619           bs <- M.unsafeNewWith n_ b
1620           cs <- M.unsafeNewWith n_ c
1621           ds <- M.unsafeNewWith n_ d
1622           es <- M.unsafeNewWith n_ e
1623           fs <- M.unsafeNewWith n_ f
1624           gs <- M.unsafeNewWith n_ g
1625           hs <- M.unsafeNewWith n_ h
1626           is <- M.unsafeNewWith n_ i
1627           js <- M.unsafeNewWith n_ j
1628           ks <- M.unsafeNewWith n_ k
1629           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
1630   {-# INLINE unsafeRead  #-}
1631   unsafeRead (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_
1632       = do
1633           a <- M.unsafeRead as i_
1634           b <- M.unsafeRead bs i_
1635           c <- M.unsafeRead cs i_
1636           d <- M.unsafeRead ds i_
1637           e <- M.unsafeRead es i_
1638           f <- M.unsafeRead fs i_
1639           g <- M.unsafeRead gs i_
1640           h <- M.unsafeRead hs i_
1641           i <- M.unsafeRead is i_
1642           j <- M.unsafeRead js i_
1643           k <- M.unsafeRead ks i_
1644           return (a, b, c, d, e, f, g, h, i, j, k)
1645   {-# INLINE unsafeWrite  #-}
1646   unsafeWrite (MV_11 n_ as
1647                         bs
1648                         cs
1649                         ds
1650                         es
1651                         fs
1652                         gs
1653                         hs
1654                         is
1655                         js
1656                         ks) i_ (a, b, c, d, e, f, g, h, i, j, k)
1657       = do
1658           M.unsafeWrite as i_ a
1659           M.unsafeWrite bs i_ b
1660           M.unsafeWrite cs i_ c
1661           M.unsafeWrite ds i_ d
1662           M.unsafeWrite es i_ e
1663           M.unsafeWrite fs i_ f
1664           M.unsafeWrite gs i_ g
1665           M.unsafeWrite hs i_ h
1666           M.unsafeWrite is i_ i
1667           M.unsafeWrite js i_ j
1668           M.unsafeWrite ks i_ k
1669   {-# INLINE clear  #-}
1670   clear (MV_11 n_ as bs cs ds es fs gs hs is js ks)
1671       = do
1672           M.clear as
1673           M.clear bs
1674           M.clear cs
1675           M.clear ds
1676           M.clear es
1677           M.clear fs
1678           M.clear gs
1679           M.clear hs
1680           M.clear is
1681           M.clear js
1682           M.clear ks
1683   {-# INLINE set  #-}
1684   set (MV_11 n_ as
1685                 bs
1686                 cs
1687                 ds
1688                 es
1689                 fs
1690                 gs
1691                 hs
1692                 is
1693                 js
1694                 ks) (a, b, c, d, e, f, g, h, i, j, k)
1695       = do
1696           M.set as a
1697           M.set bs b
1698           M.set cs c
1699           M.set ds d
1700           M.set es e
1701           M.set fs f
1702           M.set gs g
1703           M.set hs h
1704           M.set is i
1705           M.set js j
1706           M.set ks k
1707   {-# INLINE unsafeCopy  #-}
1708   unsafeCopy (MV_11 n_1 as1
1709                         bs1
1710                         cs1
1711                         ds1
1712                         es1
1713                         fs1
1714                         gs1
1715                         hs1
1716                         is1
1717                         js1
1718                         ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
1719       = do
1720           M.unsafeCopy as1 as2
1721           M.unsafeCopy bs1 bs2
1722           M.unsafeCopy cs1 cs2
1723           M.unsafeCopy ds1 ds2
1724           M.unsafeCopy es1 es2
1725           M.unsafeCopy fs1 fs2
1726           M.unsafeCopy gs1 gs2
1727           M.unsafeCopy hs1 hs2
1728           M.unsafeCopy is1 is2
1729           M.unsafeCopy js1 js2
1730           M.unsafeCopy ks1 ks2
1731   {-# INLINE unsafeGrow  #-}
1732   unsafeGrow (MV_11 n_ as bs cs ds es fs gs hs is js ks) m_
1733       = do
1734           M.unsafeGrow as m_
1735           M.unsafeGrow bs m_
1736           M.unsafeGrow cs m_
1737           M.unsafeGrow ds m_
1738           M.unsafeGrow es m_
1739           M.unsafeGrow fs m_
1740           M.unsafeGrow gs m_
1741           M.unsafeGrow hs m_
1742           M.unsafeGrow is m_
1743           M.unsafeGrow js m_
1744           M.unsafeGrow ks m_
1745           return $ MV_11 (m_+n_) as bs cs ds es fs gs hs is js ks
1746 instance (Unbox a,
1747           Unbox b,
1748           Unbox c,
1749           Unbox d,
1750           Unbox e,
1751           Unbox f,
1752           Unbox g,
1753           Unbox h,
1754           Unbox i,
1755           Unbox j,
1756           Unbox k) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k) where
1757   {-# INLINE unsafeFreeze  #-}
1758   unsafeFreeze (MV_11 n_ as bs cs ds es fs gs hs is js ks)
1759       = do
1760           as' <- G.unsafeFreeze as
1761           bs' <- G.unsafeFreeze bs
1762           cs' <- G.unsafeFreeze cs
1763           ds' <- G.unsafeFreeze ds
1764           es' <- G.unsafeFreeze es
1765           fs' <- G.unsafeFreeze fs
1766           gs' <- G.unsafeFreeze gs
1767           hs' <- G.unsafeFreeze hs
1768           is' <- G.unsafeFreeze is
1769           js' <- G.unsafeFreeze js
1770           ks' <- G.unsafeFreeze ks
1771           return $ V_11 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks'
1772   {-# INLINE basicLength  #-}
1773   basicLength (V_11 n_ as bs cs ds es fs gs hs is js ks) = n_
1774   {-# INLINE basicUnsafeSlice  #-}
1775   basicUnsafeSlice (V_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
1776       = V_11 m_ (G.unsafeSlice as i_ m_)
1777                 (G.unsafeSlice bs i_ m_)
1778                 (G.unsafeSlice cs i_ m_)
1779                 (G.unsafeSlice ds i_ m_)
1780                 (G.unsafeSlice es i_ m_)
1781                 (G.unsafeSlice fs i_ m_)
1782                 (G.unsafeSlice gs i_ m_)
1783                 (G.unsafeSlice hs i_ m_)
1784                 (G.unsafeSlice is i_ m_)
1785                 (G.unsafeSlice js i_ m_)
1786                 (G.unsafeSlice ks i_ m_)
1787   {-# INLINE basicUnsafeIndexM  #-}
1788   basicUnsafeIndexM (V_11 n_ as bs cs ds es fs gs hs is js ks) i_
1789       = do
1790           a <- G.basicUnsafeIndexM as i_
1791           b <- G.basicUnsafeIndexM bs i_
1792           c <- G.basicUnsafeIndexM cs i_
1793           d <- G.basicUnsafeIndexM ds i_
1794           e <- G.basicUnsafeIndexM es i_
1795           f <- G.basicUnsafeIndexM fs i_
1796           g <- G.basicUnsafeIndexM gs i_
1797           h <- G.basicUnsafeIndexM hs i_
1798           i <- G.basicUnsafeIndexM is i_
1799           j <- G.basicUnsafeIndexM js i_
1800           k <- G.basicUnsafeIndexM ks i_
1801           return (a, b, c, d, e, f, g, h, i, j, k)
1802 data instance MVector s (a, b, c, d, e, f, g, h, i, j, k, l)
1803     = MV_12 {-# UNPACK #-} !Int (MVector s a)
1804                                 (MVector s b)
1805                                 (MVector s c)
1806                                 (MVector s d)
1807                                 (MVector s e)
1808                                 (MVector s f)
1809                                 (MVector s g)
1810                                 (MVector s h)
1811                                 (MVector s i)
1812                                 (MVector s j)
1813                                 (MVector s k)
1814                                 (MVector s l)
1815 data instance Vector (a, b, c, d, e, f, g, h, i, j, k, l)
1816     = V_12 {-# UNPACK #-} !Int (Vector a)
1817                                (Vector b)
1818                                (Vector c)
1819                                (Vector d)
1820                                (Vector e)
1821                                (Vector f)
1822                                (Vector g)
1823                                (Vector h)
1824                                (Vector i)
1825                                (Vector j)
1826                                (Vector k)
1827                                (Vector l)
1828 instance (Unbox a,
1829           Unbox b,
1830           Unbox c,
1831           Unbox d,
1832           Unbox e,
1833           Unbox f,
1834           Unbox g,
1835           Unbox h,
1836           Unbox i,
1837           Unbox j,
1838           Unbox k,
1839           Unbox l) => Unbox (a, b, c, d, e, f, g, h, i, j, k, l)
1840 instance (Unbox a,
1841           Unbox b,
1842           Unbox c,
1843           Unbox d,
1844           Unbox e,
1845           Unbox f,
1846           Unbox g,
1847           Unbox h,
1848           Unbox i,
1849           Unbox j,
1850           Unbox k,
1851           Unbox l) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k, l) where
1852   {-# INLINE length  #-}
1853   length (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
1854   {-# INLINE unsafeSlice  #-}
1855   unsafeSlice (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_ m_
1856       = MV_12 m_ (M.unsafeSlice as i_ m_)
1857                  (M.unsafeSlice bs i_ m_)
1858                  (M.unsafeSlice cs i_ m_)
1859                  (M.unsafeSlice ds i_ m_)
1860                  (M.unsafeSlice es i_ m_)
1861                  (M.unsafeSlice fs i_ m_)
1862                  (M.unsafeSlice gs i_ m_)
1863                  (M.unsafeSlice hs i_ m_)
1864                  (M.unsafeSlice is i_ m_)
1865                  (M.unsafeSlice js i_ m_)
1866                  (M.unsafeSlice ks i_ m_)
1867                  (M.unsafeSlice ls i_ m_)
1868   {-# INLINE overlaps  #-}
1869   overlaps (MV_12 n_1 as1
1870                       bs1
1871                       cs1
1872                       ds1
1873                       es1
1874                       fs1
1875                       gs1
1876                       hs1
1877                       is1
1878                       js1
1879                       ks1
1880                       ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
1881       = M.overlaps as1 as2
1882         || M.overlaps bs1 bs2
1883         || M.overlaps cs1 cs2
1884         || M.overlaps ds1 ds2
1885         || M.overlaps es1 es2
1886         || M.overlaps fs1 fs2
1887         || M.overlaps gs1 gs2
1888         || M.overlaps hs1 hs2
1889         || M.overlaps is1 is2
1890         || M.overlaps js1 js2
1891         || M.overlaps ks1 ks2
1892         || M.overlaps ls1 ls2
1893   {-# INLINE unsafeNew  #-}
1894   unsafeNew n_
1895       = do
1896           as <- M.unsafeNew n_
1897           bs <- M.unsafeNew n_
1898           cs <- M.unsafeNew n_
1899           ds <- M.unsafeNew n_
1900           es <- M.unsafeNew n_
1901           fs <- M.unsafeNew n_
1902           gs <- M.unsafeNew n_
1903           hs <- M.unsafeNew n_
1904           is <- M.unsafeNew n_
1905           js <- M.unsafeNew n_
1906           ks <- M.unsafeNew n_
1907           ls <- M.unsafeNew n_
1908           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
1909   {-# INLINE unsafeNewWith  #-}
1910   unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k, l)
1911       = do
1912           as <- M.unsafeNewWith n_ a
1913           bs <- M.unsafeNewWith n_ b
1914           cs <- M.unsafeNewWith n_ c
1915           ds <- M.unsafeNewWith n_ d
1916           es <- M.unsafeNewWith n_ e
1917           fs <- M.unsafeNewWith n_ f
1918           gs <- M.unsafeNewWith n_ g
1919           hs <- M.unsafeNewWith n_ h
1920           is <- M.unsafeNewWith n_ i
1921           js <- M.unsafeNewWith n_ j
1922           ks <- M.unsafeNewWith n_ k
1923           ls <- M.unsafeNewWith n_ l
1924           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
1925   {-# INLINE unsafeRead  #-}
1926   unsafeRead (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
1927       = do
1928           a <- M.unsafeRead as i_
1929           b <- M.unsafeRead bs i_
1930           c <- M.unsafeRead cs i_
1931           d <- M.unsafeRead ds i_
1932           e <- M.unsafeRead es i_
1933           f <- M.unsafeRead fs i_
1934           g <- M.unsafeRead gs i_
1935           h <- M.unsafeRead hs i_
1936           i <- M.unsafeRead is i_
1937           j <- M.unsafeRead js i_
1938           k <- M.unsafeRead ks i_
1939           l <- M.unsafeRead ls i_
1940           return (a, b, c, d, e, f, g, h, i, j, k, l)
1941   {-# INLINE unsafeWrite  #-}
1942   unsafeWrite (MV_12 n_ as
1943                         bs
1944                         cs
1945                         ds
1946                         es
1947                         fs
1948                         gs
1949                         hs
1950                         is
1951                         js
1952                         ks
1953                         ls) i_ (a, b, c, d, e, f, g, h, i, j, k, l)
1954       = do
1955           M.unsafeWrite as i_ a
1956           M.unsafeWrite bs i_ b
1957           M.unsafeWrite cs i_ c
1958           M.unsafeWrite ds i_ d
1959           M.unsafeWrite es i_ e
1960           M.unsafeWrite fs i_ f
1961           M.unsafeWrite gs i_ g
1962           M.unsafeWrite hs i_ h
1963           M.unsafeWrite is i_ i
1964           M.unsafeWrite js i_ j
1965           M.unsafeWrite ks i_ k
1966           M.unsafeWrite ls i_ l
1967   {-# INLINE clear  #-}
1968   clear (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
1969       = do
1970           M.clear as
1971           M.clear bs
1972           M.clear cs
1973           M.clear ds
1974           M.clear es
1975           M.clear fs
1976           M.clear gs
1977           M.clear hs
1978           M.clear is
1979           M.clear js
1980           M.clear ks
1981           M.clear ls
1982   {-# INLINE set  #-}
1983   set (MV_12 n_ as
1984                 bs
1985                 cs
1986                 ds
1987                 es
1988                 fs
1989                 gs
1990                 hs
1991                 is
1992                 js
1993                 ks
1994                 ls) (a, b, c, d, e, f, g, h, i, j, k, l)
1995       = do
1996           M.set as a
1997           M.set bs b
1998           M.set cs c
1999           M.set ds d
2000           M.set es e
2001           M.set fs f
2002           M.set gs g
2003           M.set hs h
2004           M.set is i
2005           M.set js j
2006           M.set ks k
2007           M.set ls l
2008   {-# INLINE unsafeCopy  #-}
2009   unsafeCopy (MV_12 n_1 as1
2010                         bs1
2011                         cs1
2012                         ds1
2013                         es1
2014                         fs1
2015                         gs1
2016                         hs1
2017                         is1
2018                         js1
2019                         ks1
2020                         ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
2021       = do
2022           M.unsafeCopy as1 as2
2023           M.unsafeCopy bs1 bs2
2024           M.unsafeCopy cs1 cs2
2025           M.unsafeCopy ds1 ds2
2026           M.unsafeCopy es1 es2
2027           M.unsafeCopy fs1 fs2
2028           M.unsafeCopy gs1 gs2
2029           M.unsafeCopy hs1 hs2
2030           M.unsafeCopy is1 is2
2031           M.unsafeCopy js1 js2
2032           M.unsafeCopy ks1 ks2
2033           M.unsafeCopy ls1 ls2
2034   {-# INLINE unsafeGrow  #-}
2035   unsafeGrow (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) m_
2036       = do
2037           M.unsafeGrow as m_
2038           M.unsafeGrow bs m_
2039           M.unsafeGrow cs m_
2040           M.unsafeGrow ds m_
2041           M.unsafeGrow es m_
2042           M.unsafeGrow fs m_
2043           M.unsafeGrow gs m_
2044           M.unsafeGrow hs m_
2045           M.unsafeGrow is m_
2046           M.unsafeGrow js m_
2047           M.unsafeGrow ks m_
2048           M.unsafeGrow ls m_
2049           return $ MV_12 (m_+n_) as bs cs ds es fs gs hs is js ks ls
2050 instance (Unbox a,
2051           Unbox b,
2052           Unbox c,
2053           Unbox d,
2054           Unbox e,
2055           Unbox f,
2056           Unbox g,
2057           Unbox h,
2058           Unbox i,
2059           Unbox j,
2060           Unbox k,
2061           Unbox l) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k, l) where
2062   {-# INLINE unsafeFreeze  #-}
2063   unsafeFreeze (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
2064       = do
2065           as' <- G.unsafeFreeze as
2066           bs' <- G.unsafeFreeze bs
2067           cs' <- G.unsafeFreeze cs
2068           ds' <- G.unsafeFreeze ds
2069           es' <- G.unsafeFreeze es
2070           fs' <- G.unsafeFreeze fs
2071           gs' <- G.unsafeFreeze gs
2072           hs' <- G.unsafeFreeze hs
2073           is' <- G.unsafeFreeze is
2074           js' <- G.unsafeFreeze js
2075           ks' <- G.unsafeFreeze ks
2076           ls' <- G.unsafeFreeze ls
2077           return $ V_12 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks' ls'
2078   {-# INLINE basicLength  #-}
2079   basicLength (V_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
2080   {-# INLINE basicUnsafeSlice  #-}
2081   basicUnsafeSlice (V_12 n_ as
2082                             bs
2083                             cs
2084                             ds
2085                             es
2086                             fs
2087                             gs
2088                             hs
2089                             is
2090                             js
2091                             ks
2092                             ls) i_ m_
2093       = V_12 m_ (G.unsafeSlice as i_ m_)
2094                 (G.unsafeSlice bs i_ m_)
2095                 (G.unsafeSlice cs i_ m_)
2096                 (G.unsafeSlice ds i_ m_)
2097                 (G.unsafeSlice es i_ m_)
2098                 (G.unsafeSlice fs i_ m_)
2099                 (G.unsafeSlice gs i_ m_)
2100                 (G.unsafeSlice hs i_ m_)
2101                 (G.unsafeSlice is i_ m_)
2102                 (G.unsafeSlice js i_ m_)
2103                 (G.unsafeSlice ks i_ m_)
2104                 (G.unsafeSlice ls i_ m_)
2105   {-# INLINE basicUnsafeIndexM  #-}
2106   basicUnsafeIndexM (V_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
2107       = do
2108           a <- G.basicUnsafeIndexM as i_
2109           b <- G.basicUnsafeIndexM bs i_
2110           c <- G.basicUnsafeIndexM cs i_
2111           d <- G.basicUnsafeIndexM ds i_
2112           e <- G.basicUnsafeIndexM es i_
2113           f <- G.basicUnsafeIndexM fs i_
2114           g <- G.basicUnsafeIndexM gs i_
2115           h <- G.basicUnsafeIndexM hs i_
2116           i <- G.basicUnsafeIndexM is i_
2117           j <- G.basicUnsafeIndexM js i_
2118           k <- G.basicUnsafeIndexM ks i_
2119           l <- G.basicUnsafeIndexM ls i_
2120           return (a, b, c, d, e, f, g, h, i, j, k, l)