ea01a0145270bf0337f8811b12605e3965f7bb61
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
1 #ifdef DEFINE_INSTANCES
2 data instance MVector s (a, b)
3     = MV_2 {-# UNPACK #-} !Int (MVector s a)
4                                (MVector s b)
5 data instance Vector (a, b)
6     = V_2 {-# UNPACK #-} !Int (Vector a)
7                               (Vector b)
8 instance (Unbox a, Unbox b) => Unbox (a, b)
9 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
10   {-# INLINE basicLength  #-}
11   basicLength (MV_2 n_ as bs) = n_
12   {-# INLINE basicUnsafeSlice  #-}
13   basicUnsafeSlice (MV_2 n_ as bs) i_ m_
14       = MV_2 m_ (M.basicUnsafeSlice as i_ m_)
15                 (M.basicUnsafeSlice bs i_ m_)
16   {-# INLINE basicOverlaps  #-}
17   basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
18       = M.basicOverlaps as1 as2
19         || M.basicOverlaps bs1 bs2
20   {-# INLINE basicUnsafeNew  #-}
21   basicUnsafeNew n_
22       = do
23           as <- M.basicUnsafeNew n_
24           bs <- M.basicUnsafeNew n_
25           return $ MV_2 n_ as bs
26   {-# INLINE basicUnsafeNewWith  #-}
27   basicUnsafeNewWith n_ (a, b)
28       = do
29           as <- M.basicUnsafeNewWith n_ a
30           bs <- M.basicUnsafeNewWith n_ b
31           return $ MV_2 n_ as bs
32   {-# INLINE basicUnsafeRead  #-}
33   basicUnsafeRead (MV_2 n_ as bs) i_
34       = do
35           a <- M.basicUnsafeRead as i_
36           b <- M.basicUnsafeRead bs i_
37           return (a, b)
38   {-# INLINE basicUnsafeWrite  #-}
39   basicUnsafeWrite (MV_2 n_ as bs) i_ (a, b)
40       = do
41           M.basicUnsafeWrite as i_ a
42           M.basicUnsafeWrite bs i_ b
43   {-# INLINE basicClear  #-}
44   basicClear (MV_2 n_ as bs)
45       = do
46           M.basicClear as
47           M.basicClear bs
48   {-# INLINE basicSet  #-}
49   basicSet (MV_2 n_ as bs) (a, b)
50       = do
51           M.basicSet as a
52           M.basicSet bs b
53   {-# INLINE basicUnsafeCopy  #-}
54   basicUnsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
55       = do
56           M.basicUnsafeCopy as1 as2
57           M.basicUnsafeCopy bs1 bs2
58   {-# INLINE basicUnsafeGrow  #-}
59   basicUnsafeGrow (MV_2 n_ as bs) m_
60       = do
61           M.basicUnsafeGrow as m_
62           M.basicUnsafeGrow bs m_
63           return $ MV_2 (m_+n_) as bs
64 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
65   {-# INLINE unsafeFreeze  #-}
66   unsafeFreeze (MV_2 n_ as bs)
67       = do
68           as' <- G.unsafeFreeze as
69           bs' <- G.unsafeFreeze bs
70           return $ V_2 n_ as' bs'
71   {-# INLINE basicLength  #-}
72   basicLength (V_2 n_ as bs) = n_
73   {-# INLINE basicUnsafeSlice  #-}
74   basicUnsafeSlice (V_2 n_ as bs) i_ m_
75       = V_2 m_ (G.basicUnsafeSlice as i_ m_)
76                (G.basicUnsafeSlice bs i_ m_)
77   {-# INLINE basicUnsafeIndexM  #-}
78   basicUnsafeIndexM (V_2 n_ as bs) i_
79       = do
80           a <- G.basicUnsafeIndexM as i_
81           b <- G.basicUnsafeIndexM bs i_
82           return (a, b)
83 #endif
84 #ifdef DEFINE_MUTABLE
85 zip :: (Unbox a, Unbox b) => MVector s a ->
86                              MVector s b -> MVector s (a, b)
87 {-# INLINE zip #-}
88 zip as bs = MV_2 len (unsafeSlice as 0 len) (unsafeSlice bs 0 len)
89   where len = length as `min` length bs
90 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
91                                                     MVector s b)
92 {-# INLINE unzip #-}
93 unzip (MV_2 n_ as bs) = (as, bs)
94 #endif
95 #ifdef DEFINE_IMMUTABLE
96 zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
97 {-# INLINE zip #-}
98 zip as bs = V_2 len (unsafeSlice as 0 len) (unsafeSlice bs 0 len)
99   where len = length as `min` length bs
100 unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
101                                                  Vector b)
102 {-# INLINE unzip #-}
103 unzip (V_2 n_ as bs) = (as, bs)
104 #endif
105 #ifdef DEFINE_INSTANCES
106 data instance MVector s (a, b, c)
107     = MV_3 {-# UNPACK #-} !Int (MVector s a)
108                                (MVector s b)
109                                (MVector s c)
110 data instance Vector (a, b, c)
111     = V_3 {-# UNPACK #-} !Int (Vector a)
112                               (Vector b)
113                               (Vector c)
114 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
115 instance (Unbox a,
116           Unbox b,
117           Unbox c) => M.MVector MVector (a, b, c) where
118   {-# INLINE basicLength  #-}
119   basicLength (MV_3 n_ as bs cs) = n_
120   {-# INLINE basicUnsafeSlice  #-}
121   basicUnsafeSlice (MV_3 n_ as bs cs) i_ m_
122       = MV_3 m_ (M.basicUnsafeSlice as i_ m_)
123                 (M.basicUnsafeSlice bs i_ m_)
124                 (M.basicUnsafeSlice cs i_ m_)
125   {-# INLINE basicOverlaps  #-}
126   basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
127       = M.basicOverlaps as1 as2
128         || M.basicOverlaps bs1 bs2
129         || M.basicOverlaps cs1 cs2
130   {-# INLINE basicUnsafeNew  #-}
131   basicUnsafeNew n_
132       = do
133           as <- M.basicUnsafeNew n_
134           bs <- M.basicUnsafeNew n_
135           cs <- M.basicUnsafeNew n_
136           return $ MV_3 n_ as bs cs
137   {-# INLINE basicUnsafeNewWith  #-}
138   basicUnsafeNewWith n_ (a, b, c)
139       = do
140           as <- M.basicUnsafeNewWith n_ a
141           bs <- M.basicUnsafeNewWith n_ b
142           cs <- M.basicUnsafeNewWith n_ c
143           return $ MV_3 n_ as bs cs
144   {-# INLINE basicUnsafeRead  #-}
145   basicUnsafeRead (MV_3 n_ as bs cs) i_
146       = do
147           a <- M.basicUnsafeRead as i_
148           b <- M.basicUnsafeRead bs i_
149           c <- M.basicUnsafeRead cs i_
150           return (a, b, c)
151   {-# INLINE basicUnsafeWrite  #-}
152   basicUnsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
153       = do
154           M.basicUnsafeWrite as i_ a
155           M.basicUnsafeWrite bs i_ b
156           M.basicUnsafeWrite cs i_ c
157   {-# INLINE basicClear  #-}
158   basicClear (MV_3 n_ as bs cs)
159       = do
160           M.basicClear as
161           M.basicClear bs
162           M.basicClear cs
163   {-# INLINE basicSet  #-}
164   basicSet (MV_3 n_ as bs cs) (a, b, c)
165       = do
166           M.basicSet as a
167           M.basicSet bs b
168           M.basicSet cs c
169   {-# INLINE basicUnsafeCopy  #-}
170   basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
171       = do
172           M.basicUnsafeCopy as1 as2
173           M.basicUnsafeCopy bs1 bs2
174           M.basicUnsafeCopy cs1 cs2
175   {-# INLINE basicUnsafeGrow  #-}
176   basicUnsafeGrow (MV_3 n_ as bs cs) m_
177       = do
178           M.basicUnsafeGrow as m_
179           M.basicUnsafeGrow bs m_
180           M.basicUnsafeGrow cs m_
181           return $ MV_3 (m_+n_) as bs cs
182 instance (Unbox a,
183           Unbox b,
184           Unbox c) => G.Vector Vector (a, b, c) where
185   {-# INLINE unsafeFreeze  #-}
186   unsafeFreeze (MV_3 n_ as bs cs)
187       = do
188           as' <- G.unsafeFreeze as
189           bs' <- G.unsafeFreeze bs
190           cs' <- G.unsafeFreeze cs
191           return $ V_3 n_ as' bs' cs'
192   {-# INLINE basicLength  #-}
193   basicLength (V_3 n_ as bs cs) = n_
194   {-# INLINE basicUnsafeSlice  #-}
195   basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
196       = V_3 m_ (G.basicUnsafeSlice as i_ m_)
197                (G.basicUnsafeSlice bs i_ m_)
198                (G.basicUnsafeSlice cs i_ m_)
199   {-# INLINE basicUnsafeIndexM  #-}
200   basicUnsafeIndexM (V_3 n_ as bs cs) i_
201       = do
202           a <- G.basicUnsafeIndexM as i_
203           b <- G.basicUnsafeIndexM bs i_
204           c <- G.basicUnsafeIndexM cs i_
205           return (a, b, c)
206 #endif
207 #ifdef DEFINE_MUTABLE
208 zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
209                                        MVector s b ->
210                                        MVector s c -> MVector s (a, b, c)
211 {-# INLINE zip3 #-}
212 zip3 as bs cs = MV_3 len (unsafeSlice as 0 len)
213                          (unsafeSlice bs 0 len)
214                          (unsafeSlice cs 0 len)
215   where len = length as `min` length bs `min` length cs
216 unzip3 :: (Unbox a,
217            Unbox b,
218            Unbox c) => MVector s (a, b, c) -> (MVector s a,
219                                                MVector s b,
220                                                MVector s c)
221 {-# INLINE unzip3 #-}
222 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
223 #endif
224 #ifdef DEFINE_IMMUTABLE
225 zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
226                                        Vector b ->
227                                        Vector c -> Vector (a, b, c)
228 {-# INLINE zip3 #-}
229 zip3 as bs cs = V_3 len (unsafeSlice as 0 len)
230                         (unsafeSlice bs 0 len)
231                         (unsafeSlice cs 0 len)
232   where len = length as `min` length bs `min` length cs
233 unzip3 :: (Unbox a,
234            Unbox b,
235            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
236 {-# INLINE unzip3 #-}
237 unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
238 #endif
239 #ifdef DEFINE_INSTANCES
240 data instance MVector s (a, b, c, d)
241     = MV_4 {-# UNPACK #-} !Int (MVector s a)
242                                (MVector s b)
243                                (MVector s c)
244                                (MVector s d)
245 data instance Vector (a, b, c, d)
246     = V_4 {-# UNPACK #-} !Int (Vector a)
247                               (Vector b)
248                               (Vector c)
249                               (Vector d)
250 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
251 instance (Unbox a,
252           Unbox b,
253           Unbox c,
254           Unbox d) => M.MVector MVector (a, b, c, d) where
255   {-# INLINE basicLength  #-}
256   basicLength (MV_4 n_ as bs cs ds) = n_
257   {-# INLINE basicUnsafeSlice  #-}
258   basicUnsafeSlice (MV_4 n_ as bs cs ds) i_ m_
259       = MV_4 m_ (M.basicUnsafeSlice as i_ m_)
260                 (M.basicUnsafeSlice bs i_ m_)
261                 (M.basicUnsafeSlice cs i_ m_)
262                 (M.basicUnsafeSlice ds i_ m_)
263   {-# INLINE basicOverlaps  #-}
264   basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
265       = M.basicOverlaps as1 as2
266         || M.basicOverlaps bs1 bs2
267         || M.basicOverlaps cs1 cs2
268         || M.basicOverlaps ds1 ds2
269   {-# INLINE basicUnsafeNew  #-}
270   basicUnsafeNew n_
271       = do
272           as <- M.basicUnsafeNew n_
273           bs <- M.basicUnsafeNew n_
274           cs <- M.basicUnsafeNew n_
275           ds <- M.basicUnsafeNew n_
276           return $ MV_4 n_ as bs cs ds
277   {-# INLINE basicUnsafeNewWith  #-}
278   basicUnsafeNewWith n_ (a, b, c, d)
279       = do
280           as <- M.basicUnsafeNewWith n_ a
281           bs <- M.basicUnsafeNewWith n_ b
282           cs <- M.basicUnsafeNewWith n_ c
283           ds <- M.basicUnsafeNewWith n_ d
284           return $ MV_4 n_ as bs cs ds
285   {-# INLINE basicUnsafeRead  #-}
286   basicUnsafeRead (MV_4 n_ as bs cs ds) i_
287       = do
288           a <- M.basicUnsafeRead as i_
289           b <- M.basicUnsafeRead bs i_
290           c <- M.basicUnsafeRead cs i_
291           d <- M.basicUnsafeRead ds i_
292           return (a, b, c, d)
293   {-# INLINE basicUnsafeWrite  #-}
294   basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
295       = do
296           M.basicUnsafeWrite as i_ a
297           M.basicUnsafeWrite bs i_ b
298           M.basicUnsafeWrite cs i_ c
299           M.basicUnsafeWrite ds i_ d
300   {-# INLINE basicClear  #-}
301   basicClear (MV_4 n_ as bs cs ds)
302       = do
303           M.basicClear as
304           M.basicClear bs
305           M.basicClear cs
306           M.basicClear ds
307   {-# INLINE basicSet  #-}
308   basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
309       = do
310           M.basicSet as a
311           M.basicSet bs b
312           M.basicSet cs c
313           M.basicSet ds d
314   {-# INLINE basicUnsafeCopy  #-}
315   basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
316                                                        bs2
317                                                        cs2
318                                                        ds2)
319       = do
320           M.basicUnsafeCopy as1 as2
321           M.basicUnsafeCopy bs1 bs2
322           M.basicUnsafeCopy cs1 cs2
323           M.basicUnsafeCopy ds1 ds2
324   {-# INLINE basicUnsafeGrow  #-}
325   basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
326       = do
327           M.basicUnsafeGrow as m_
328           M.basicUnsafeGrow bs m_
329           M.basicUnsafeGrow cs m_
330           M.basicUnsafeGrow ds m_
331           return $ MV_4 (m_+n_) as bs cs ds
332 instance (Unbox a,
333           Unbox b,
334           Unbox c,
335           Unbox d) => G.Vector Vector (a, b, c, d) where
336   {-# INLINE unsafeFreeze  #-}
337   unsafeFreeze (MV_4 n_ as bs cs ds)
338       = do
339           as' <- G.unsafeFreeze as
340           bs' <- G.unsafeFreeze bs
341           cs' <- G.unsafeFreeze cs
342           ds' <- G.unsafeFreeze ds
343           return $ V_4 n_ as' bs' cs' ds'
344   {-# INLINE basicLength  #-}
345   basicLength (V_4 n_ as bs cs ds) = n_
346   {-# INLINE basicUnsafeSlice  #-}
347   basicUnsafeSlice (V_4 n_ as bs cs ds) i_ m_
348       = V_4 m_ (G.basicUnsafeSlice as i_ m_)
349                (G.basicUnsafeSlice bs i_ m_)
350                (G.basicUnsafeSlice cs i_ m_)
351                (G.basicUnsafeSlice ds i_ m_)
352   {-# INLINE basicUnsafeIndexM  #-}
353   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
354       = do
355           a <- G.basicUnsafeIndexM as i_
356           b <- G.basicUnsafeIndexM bs i_
357           c <- G.basicUnsafeIndexM cs i_
358           d <- G.basicUnsafeIndexM ds i_
359           return (a, b, c, d)
360 #endif
361 #ifdef DEFINE_MUTABLE
362 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
363                                                 MVector s b ->
364                                                 MVector s c ->
365                                                 MVector s d -> MVector s (a, b, c, d)
366 {-# INLINE zip4 #-}
367 zip4 as bs cs ds = MV_4 len (unsafeSlice as 0 len)
368                             (unsafeSlice bs 0 len)
369                             (unsafeSlice cs 0 len)
370                             (unsafeSlice ds 0 len)
371   where
372     len = length as `min` length bs `min` length cs `min` length ds
373 unzip4 :: (Unbox a,
374            Unbox b,
375            Unbox c,
376            Unbox d) => MVector s (a, b, c, d) -> (MVector s a,
377                                                   MVector s b,
378                                                   MVector s c,
379                                                   MVector s d)
380 {-# INLINE unzip4 #-}
381 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
382 #endif
383 #ifdef DEFINE_IMMUTABLE
384 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
385                                                 Vector b ->
386                                                 Vector c ->
387                                                 Vector d -> Vector (a, b, c, d)
388 {-# INLINE zip4 #-}
389 zip4 as bs cs ds = V_4 len (unsafeSlice as 0 len)
390                            (unsafeSlice bs 0 len)
391                            (unsafeSlice cs 0 len)
392                            (unsafeSlice ds 0 len)
393   where
394     len = length as `min` length bs `min` length cs `min` length ds
395 unzip4 :: (Unbox a,
396            Unbox b,
397            Unbox c,
398            Unbox d) => Vector (a, b, c, d) -> (Vector a,
399                                                Vector b,
400                                                Vector c,
401                                                Vector d)
402 {-# INLINE unzip4 #-}
403 unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
404 #endif
405 #ifdef DEFINE_INSTANCES
406 data instance MVector s (a, b, c, d, e)
407     = MV_5 {-# UNPACK #-} !Int (MVector s a)
408                                (MVector s b)
409                                (MVector s c)
410                                (MVector s d)
411                                (MVector s e)
412 data instance Vector (a, b, c, d, e)
413     = V_5 {-# UNPACK #-} !Int (Vector a)
414                               (Vector b)
415                               (Vector c)
416                               (Vector d)
417                               (Vector e)
418 instance (Unbox a,
419           Unbox b,
420           Unbox c,
421           Unbox d,
422           Unbox e) => Unbox (a, b, c, d, e)
423 instance (Unbox a,
424           Unbox b,
425           Unbox c,
426           Unbox d,
427           Unbox e) => M.MVector MVector (a, b, c, d, e) where
428   {-# INLINE basicLength  #-}
429   basicLength (MV_5 n_ as bs cs ds es) = n_
430   {-# INLINE basicUnsafeSlice  #-}
431   basicUnsafeSlice (MV_5 n_ as bs cs ds es) i_ m_
432       = MV_5 m_ (M.basicUnsafeSlice as i_ m_)
433                 (M.basicUnsafeSlice bs i_ m_)
434                 (M.basicUnsafeSlice cs i_ m_)
435                 (M.basicUnsafeSlice ds i_ m_)
436                 (M.basicUnsafeSlice es i_ m_)
437   {-# INLINE basicOverlaps  #-}
438   basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
439                                                          bs2
440                                                          cs2
441                                                          ds2
442                                                          es2)
443       = M.basicOverlaps as1 as2
444         || M.basicOverlaps bs1 bs2
445         || M.basicOverlaps cs1 cs2
446         || M.basicOverlaps ds1 ds2
447         || M.basicOverlaps es1 es2
448   {-# INLINE basicUnsafeNew  #-}
449   basicUnsafeNew n_
450       = do
451           as <- M.basicUnsafeNew n_
452           bs <- M.basicUnsafeNew n_
453           cs <- M.basicUnsafeNew n_
454           ds <- M.basicUnsafeNew n_
455           es <- M.basicUnsafeNew n_
456           return $ MV_5 n_ as bs cs ds es
457   {-# INLINE basicUnsafeNewWith  #-}
458   basicUnsafeNewWith n_ (a, b, c, d, e)
459       = do
460           as <- M.basicUnsafeNewWith n_ a
461           bs <- M.basicUnsafeNewWith n_ b
462           cs <- M.basicUnsafeNewWith n_ c
463           ds <- M.basicUnsafeNewWith n_ d
464           es <- M.basicUnsafeNewWith n_ e
465           return $ MV_5 n_ as bs cs ds es
466   {-# INLINE basicUnsafeRead  #-}
467   basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
468       = do
469           a <- M.basicUnsafeRead as i_
470           b <- M.basicUnsafeRead bs i_
471           c <- M.basicUnsafeRead cs i_
472           d <- M.basicUnsafeRead ds i_
473           e <- M.basicUnsafeRead es i_
474           return (a, b, c, d, e)
475   {-# INLINE basicUnsafeWrite  #-}
476   basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
477       = do
478           M.basicUnsafeWrite as i_ a
479           M.basicUnsafeWrite bs i_ b
480           M.basicUnsafeWrite cs i_ c
481           M.basicUnsafeWrite ds i_ d
482           M.basicUnsafeWrite es i_ e
483   {-# INLINE basicClear  #-}
484   basicClear (MV_5 n_ as bs cs ds es)
485       = do
486           M.basicClear as
487           M.basicClear bs
488           M.basicClear cs
489           M.basicClear ds
490           M.basicClear es
491   {-# INLINE basicSet  #-}
492   basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
493       = do
494           M.basicSet as a
495           M.basicSet bs b
496           M.basicSet cs c
497           M.basicSet ds d
498           M.basicSet es e
499   {-# INLINE basicUnsafeCopy  #-}
500   basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
501                                                            bs2
502                                                            cs2
503                                                            ds2
504                                                            es2)
505       = do
506           M.basicUnsafeCopy as1 as2
507           M.basicUnsafeCopy bs1 bs2
508           M.basicUnsafeCopy cs1 cs2
509           M.basicUnsafeCopy ds1 ds2
510           M.basicUnsafeCopy es1 es2
511   {-# INLINE basicUnsafeGrow  #-}
512   basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
513       = do
514           M.basicUnsafeGrow as m_
515           M.basicUnsafeGrow bs m_
516           M.basicUnsafeGrow cs m_
517           M.basicUnsafeGrow ds m_
518           M.basicUnsafeGrow es m_
519           return $ MV_5 (m_+n_) as bs cs ds es
520 instance (Unbox a,
521           Unbox b,
522           Unbox c,
523           Unbox d,
524           Unbox e) => G.Vector Vector (a, b, c, d, e) where
525   {-# INLINE unsafeFreeze  #-}
526   unsafeFreeze (MV_5 n_ as bs cs ds es)
527       = do
528           as' <- G.unsafeFreeze as
529           bs' <- G.unsafeFreeze bs
530           cs' <- G.unsafeFreeze cs
531           ds' <- G.unsafeFreeze ds
532           es' <- G.unsafeFreeze es
533           return $ V_5 n_ as' bs' cs' ds' es'
534   {-# INLINE basicLength  #-}
535   basicLength (V_5 n_ as bs cs ds es) = n_
536   {-# INLINE basicUnsafeSlice  #-}
537   basicUnsafeSlice (V_5 n_ as bs cs ds es) i_ m_
538       = V_5 m_ (G.basicUnsafeSlice as i_ m_)
539                (G.basicUnsafeSlice bs i_ m_)
540                (G.basicUnsafeSlice cs i_ m_)
541                (G.basicUnsafeSlice ds i_ m_)
542                (G.basicUnsafeSlice es i_ m_)
543   {-# INLINE basicUnsafeIndexM  #-}
544   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
545       = do
546           a <- G.basicUnsafeIndexM as i_
547           b <- G.basicUnsafeIndexM bs i_
548           c <- G.basicUnsafeIndexM cs i_
549           d <- G.basicUnsafeIndexM ds i_
550           e <- G.basicUnsafeIndexM es i_
551           return (a, b, c, d, e)
552 #endif
553 #ifdef DEFINE_MUTABLE
554 zip5 :: (Unbox a,
555          Unbox b,
556          Unbox c,
557          Unbox d,
558          Unbox e) => MVector s a ->
559                      MVector s b ->
560                      MVector s c ->
561                      MVector s d ->
562                      MVector s e -> MVector s (a, b, c, d, e)
563 {-# INLINE zip5 #-}
564 zip5 as bs cs ds es = MV_5 len (unsafeSlice as 0 len)
565                                (unsafeSlice bs 0 len)
566                                (unsafeSlice cs 0 len)
567                                (unsafeSlice ds 0 len)
568                                (unsafeSlice es 0 len)
569   where
570     len = length as `min`
571           length bs `min`
572           length cs `min`
573           length ds `min`
574           length es
575 unzip5 :: (Unbox a,
576            Unbox b,
577            Unbox c,
578            Unbox d,
579            Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
580                                                      MVector s b,
581                                                      MVector s c,
582                                                      MVector s d,
583                                                      MVector s e)
584 {-# INLINE unzip5 #-}
585 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
586 #endif
587 #ifdef DEFINE_IMMUTABLE
588 zip5 :: (Unbox a,
589          Unbox b,
590          Unbox c,
591          Unbox d,
592          Unbox e) => Vector a ->
593                      Vector b ->
594                      Vector c ->
595                      Vector d ->
596                      Vector e -> Vector (a, b, c, d, e)
597 {-# INLINE zip5 #-}
598 zip5 as bs cs ds es = V_5 len (unsafeSlice as 0 len)
599                               (unsafeSlice bs 0 len)
600                               (unsafeSlice cs 0 len)
601                               (unsafeSlice ds 0 len)
602                               (unsafeSlice es 0 len)
603   where
604     len = length as `min`
605           length bs `min`
606           length cs `min`
607           length ds `min`
608           length es
609 unzip5 :: (Unbox a,
610            Unbox b,
611            Unbox c,
612            Unbox d,
613            Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
614                                                   Vector b,
615                                                   Vector c,
616                                                   Vector d,
617                                                   Vector e)
618 {-# INLINE unzip5 #-}
619 unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
620 #endif
621 #ifdef DEFINE_INSTANCES
622 data instance MVector s (a, b, c, d, e, f)
623     = MV_6 {-# UNPACK #-} !Int (MVector s a)
624                                (MVector s b)
625                                (MVector s c)
626                                (MVector s d)
627                                (MVector s e)
628                                (MVector s f)
629 data instance Vector (a, b, c, d, e, f)
630     = V_6 {-# UNPACK #-} !Int (Vector a)
631                               (Vector b)
632                               (Vector c)
633                               (Vector d)
634                               (Vector e)
635                               (Vector f)
636 instance (Unbox a,
637           Unbox b,
638           Unbox c,
639           Unbox d,
640           Unbox e,
641           Unbox f) => Unbox (a, b, c, d, e, f)
642 instance (Unbox a,
643           Unbox b,
644           Unbox c,
645           Unbox d,
646           Unbox e,
647           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
648   {-# INLINE basicLength  #-}
649   basicLength (MV_6 n_ as bs cs ds es fs) = n_
650   {-# INLINE basicUnsafeSlice  #-}
651   basicUnsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
652       = MV_6 m_ (M.basicUnsafeSlice as i_ m_)
653                 (M.basicUnsafeSlice bs i_ m_)
654                 (M.basicUnsafeSlice cs i_ m_)
655                 (M.basicUnsafeSlice ds i_ m_)
656                 (M.basicUnsafeSlice es i_ m_)
657                 (M.basicUnsafeSlice fs i_ m_)
658   {-# INLINE basicOverlaps  #-}
659   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
660                                                              bs2
661                                                              cs2
662                                                              ds2
663                                                              es2
664                                                              fs2)
665       = M.basicOverlaps as1 as2
666         || M.basicOverlaps bs1 bs2
667         || M.basicOverlaps cs1 cs2
668         || M.basicOverlaps ds1 ds2
669         || M.basicOverlaps es1 es2
670         || M.basicOverlaps fs1 fs2
671   {-# INLINE basicUnsafeNew  #-}
672   basicUnsafeNew n_
673       = do
674           as <- M.basicUnsafeNew n_
675           bs <- M.basicUnsafeNew n_
676           cs <- M.basicUnsafeNew n_
677           ds <- M.basicUnsafeNew n_
678           es <- M.basicUnsafeNew n_
679           fs <- M.basicUnsafeNew n_
680           return $ MV_6 n_ as bs cs ds es fs
681   {-# INLINE basicUnsafeNewWith  #-}
682   basicUnsafeNewWith n_ (a, b, c, d, e, f)
683       = do
684           as <- M.basicUnsafeNewWith n_ a
685           bs <- M.basicUnsafeNewWith n_ b
686           cs <- M.basicUnsafeNewWith n_ c
687           ds <- M.basicUnsafeNewWith n_ d
688           es <- M.basicUnsafeNewWith n_ e
689           fs <- M.basicUnsafeNewWith n_ f
690           return $ MV_6 n_ as bs cs ds es fs
691   {-# INLINE basicUnsafeRead  #-}
692   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
693       = do
694           a <- M.basicUnsafeRead as i_
695           b <- M.basicUnsafeRead bs i_
696           c <- M.basicUnsafeRead cs i_
697           d <- M.basicUnsafeRead ds i_
698           e <- M.basicUnsafeRead es i_
699           f <- M.basicUnsafeRead fs i_
700           return (a, b, c, d, e, f)
701   {-# INLINE basicUnsafeWrite  #-}
702   basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
703       = do
704           M.basicUnsafeWrite as i_ a
705           M.basicUnsafeWrite bs i_ b
706           M.basicUnsafeWrite cs i_ c
707           M.basicUnsafeWrite ds i_ d
708           M.basicUnsafeWrite es i_ e
709           M.basicUnsafeWrite fs i_ f
710   {-# INLINE basicClear  #-}
711   basicClear (MV_6 n_ as bs cs ds es fs)
712       = do
713           M.basicClear as
714           M.basicClear bs
715           M.basicClear cs
716           M.basicClear ds
717           M.basicClear es
718           M.basicClear fs
719   {-# INLINE basicSet  #-}
720   basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
721       = do
722           M.basicSet as a
723           M.basicSet bs b
724           M.basicSet cs c
725           M.basicSet ds d
726           M.basicSet es e
727           M.basicSet fs f
728   {-# INLINE basicUnsafeCopy  #-}
729   basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
730                                                                bs2
731                                                                cs2
732                                                                ds2
733                                                                es2
734                                                                fs2)
735       = do
736           M.basicUnsafeCopy as1 as2
737           M.basicUnsafeCopy bs1 bs2
738           M.basicUnsafeCopy cs1 cs2
739           M.basicUnsafeCopy ds1 ds2
740           M.basicUnsafeCopy es1 es2
741           M.basicUnsafeCopy fs1 fs2
742   {-# INLINE basicUnsafeGrow  #-}
743   basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
744       = do
745           M.basicUnsafeGrow as m_
746           M.basicUnsafeGrow bs m_
747           M.basicUnsafeGrow cs m_
748           M.basicUnsafeGrow ds m_
749           M.basicUnsafeGrow es m_
750           M.basicUnsafeGrow fs m_
751           return $ MV_6 (m_+n_) as bs cs ds es fs
752 instance (Unbox a,
753           Unbox b,
754           Unbox c,
755           Unbox d,
756           Unbox e,
757           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
758   {-# INLINE unsafeFreeze  #-}
759   unsafeFreeze (MV_6 n_ as bs cs ds es fs)
760       = do
761           as' <- G.unsafeFreeze as
762           bs' <- G.unsafeFreeze bs
763           cs' <- G.unsafeFreeze cs
764           ds' <- G.unsafeFreeze ds
765           es' <- G.unsafeFreeze es
766           fs' <- G.unsafeFreeze fs
767           return $ V_6 n_ as' bs' cs' ds' es' fs'
768   {-# INLINE basicLength  #-}
769   basicLength (V_6 n_ as bs cs ds es fs) = n_
770   {-# INLINE basicUnsafeSlice  #-}
771   basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
772       = V_6 m_ (G.basicUnsafeSlice as i_ m_)
773                (G.basicUnsafeSlice bs i_ m_)
774                (G.basicUnsafeSlice cs i_ m_)
775                (G.basicUnsafeSlice ds i_ m_)
776                (G.basicUnsafeSlice es i_ m_)
777                (G.basicUnsafeSlice fs i_ m_)
778   {-# INLINE basicUnsafeIndexM  #-}
779   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
780       = do
781           a <- G.basicUnsafeIndexM as i_
782           b <- G.basicUnsafeIndexM bs i_
783           c <- G.basicUnsafeIndexM cs i_
784           d <- G.basicUnsafeIndexM ds i_
785           e <- G.basicUnsafeIndexM es i_
786           f <- G.basicUnsafeIndexM fs i_
787           return (a, b, c, d, e, f)
788 #endif
789 #ifdef DEFINE_MUTABLE
790 zip6 :: (Unbox a,
791          Unbox b,
792          Unbox c,
793          Unbox d,
794          Unbox e,
795          Unbox f) => MVector s a ->
796                      MVector s b ->
797                      MVector s c ->
798                      MVector s d ->
799                      MVector s e ->
800                      MVector s f -> MVector s (a, b, c, d, e, f)
801 {-# INLINE zip6 #-}
802 zip6 as bs cs ds es fs = MV_6 len (unsafeSlice as 0 len)
803                                   (unsafeSlice bs 0 len)
804                                   (unsafeSlice cs 0 len)
805                                   (unsafeSlice ds 0 len)
806                                   (unsafeSlice es 0 len)
807                                   (unsafeSlice fs 0 len)
808   where
809     len = length as `min`
810           length bs `min`
811           length cs `min`
812           length ds `min`
813           length es `min`
814           length fs
815 unzip6 :: (Unbox a,
816            Unbox b,
817            Unbox c,
818            Unbox d,
819            Unbox e,
820            Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
821                                                         MVector s b,
822                                                         MVector s c,
823                                                         MVector s d,
824                                                         MVector s e,
825                                                         MVector s f)
826 {-# INLINE unzip6 #-}
827 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
828 #endif
829 #ifdef DEFINE_IMMUTABLE
830 zip6 :: (Unbox a,
831          Unbox b,
832          Unbox c,
833          Unbox d,
834          Unbox e,
835          Unbox f) => Vector a ->
836                      Vector b ->
837                      Vector c ->
838                      Vector d ->
839                      Vector e ->
840                      Vector f -> Vector (a, b, c, d, e, f)
841 {-# INLINE zip6 #-}
842 zip6 as bs cs ds es fs = V_6 len (unsafeSlice as 0 len)
843                                  (unsafeSlice bs 0 len)
844                                  (unsafeSlice cs 0 len)
845                                  (unsafeSlice ds 0 len)
846                                  (unsafeSlice es 0 len)
847                                  (unsafeSlice fs 0 len)
848   where
849     len = length as `min`
850           length bs `min`
851           length cs `min`
852           length ds `min`
853           length es `min`
854           length fs
855 unzip6 :: (Unbox a,
856            Unbox b,
857            Unbox c,
858            Unbox d,
859            Unbox e,
860            Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
861                                                      Vector b,
862                                                      Vector c,
863                                                      Vector d,
864                                                      Vector e,
865                                                      Vector f)
866 {-# INLINE unzip6 #-}
867 unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
868 #endif
869 #ifdef DEFINE_INSTANCES
870 data instance MVector s (a, b, c, d, e, f, g)
871     = MV_7 {-# UNPACK #-} !Int (MVector s a)
872                                (MVector s b)
873                                (MVector s c)
874                                (MVector s d)
875                                (MVector s e)
876                                (MVector s f)
877                                (MVector s g)
878 data instance Vector (a, b, c, d, e, f, g)
879     = V_7 {-# UNPACK #-} !Int (Vector a)
880                               (Vector b)
881                               (Vector c)
882                               (Vector d)
883                               (Vector e)
884                               (Vector f)
885                               (Vector g)
886 instance (Unbox a,
887           Unbox b,
888           Unbox c,
889           Unbox d,
890           Unbox e,
891           Unbox f,
892           Unbox g) => Unbox (a, b, c, d, e, f, g)
893 instance (Unbox a,
894           Unbox b,
895           Unbox c,
896           Unbox d,
897           Unbox e,
898           Unbox f,
899           Unbox g) => M.MVector MVector (a, b, c, d, e, f, g) where
900   {-# INLINE basicLength  #-}
901   basicLength (MV_7 n_ as bs cs ds es fs gs) = n_
902   {-# INLINE basicUnsafeSlice  #-}
903   basicUnsafeSlice (MV_7 n_ as bs cs ds es fs gs) i_ m_
904       = MV_7 m_ (M.basicUnsafeSlice as i_ m_)
905                 (M.basicUnsafeSlice bs i_ m_)
906                 (M.basicUnsafeSlice cs i_ m_)
907                 (M.basicUnsafeSlice ds i_ m_)
908                 (M.basicUnsafeSlice es i_ m_)
909                 (M.basicUnsafeSlice fs i_ m_)
910                 (M.basicUnsafeSlice gs i_ m_)
911   {-# INLINE basicOverlaps  #-}
912   basicOverlaps (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
913                                                                  bs2
914                                                                  cs2
915                                                                  ds2
916                                                                  es2
917                                                                  fs2
918                                                                  gs2)
919       = M.basicOverlaps as1 as2
920         || M.basicOverlaps bs1 bs2
921         || M.basicOverlaps cs1 cs2
922         || M.basicOverlaps ds1 ds2
923         || M.basicOverlaps es1 es2
924         || M.basicOverlaps fs1 fs2
925         || M.basicOverlaps gs1 gs2
926   {-# INLINE basicUnsafeNew  #-}
927   basicUnsafeNew n_
928       = do
929           as <- M.basicUnsafeNew n_
930           bs <- M.basicUnsafeNew n_
931           cs <- M.basicUnsafeNew n_
932           ds <- M.basicUnsafeNew n_
933           es <- M.basicUnsafeNew n_
934           fs <- M.basicUnsafeNew n_
935           gs <- M.basicUnsafeNew n_
936           return $ MV_7 n_ as bs cs ds es fs gs
937   {-# INLINE basicUnsafeNewWith  #-}
938   basicUnsafeNewWith n_ (a, b, c, d, e, f, g)
939       = do
940           as <- M.basicUnsafeNewWith n_ a
941           bs <- M.basicUnsafeNewWith n_ b
942           cs <- M.basicUnsafeNewWith n_ c
943           ds <- M.basicUnsafeNewWith n_ d
944           es <- M.basicUnsafeNewWith n_ e
945           fs <- M.basicUnsafeNewWith n_ f
946           gs <- M.basicUnsafeNewWith n_ g
947           return $ MV_7 n_ as bs cs ds es fs gs
948   {-# INLINE basicUnsafeRead  #-}
949   basicUnsafeRead (MV_7 n_ as bs cs ds es fs gs) i_
950       = do
951           a <- M.basicUnsafeRead as i_
952           b <- M.basicUnsafeRead bs i_
953           c <- M.basicUnsafeRead cs i_
954           d <- M.basicUnsafeRead ds i_
955           e <- M.basicUnsafeRead es i_
956           f <- M.basicUnsafeRead fs i_
957           g <- M.basicUnsafeRead gs i_
958           return (a, b, c, d, e, f, g)
959   {-# INLINE basicUnsafeWrite  #-}
960   basicUnsafeWrite (MV_7 n_ as
961                             bs
962                             cs
963                             ds
964                             es
965                             fs
966                             gs) i_ (a, b, c, d, e, f, g)
967       = do
968           M.basicUnsafeWrite as i_ a
969           M.basicUnsafeWrite bs i_ b
970           M.basicUnsafeWrite cs i_ c
971           M.basicUnsafeWrite ds i_ d
972           M.basicUnsafeWrite es i_ e
973           M.basicUnsafeWrite fs i_ f
974           M.basicUnsafeWrite gs i_ g
975   {-# INLINE basicClear  #-}
976   basicClear (MV_7 n_ as bs cs ds es fs gs)
977       = do
978           M.basicClear as
979           M.basicClear bs
980           M.basicClear cs
981           M.basicClear ds
982           M.basicClear es
983           M.basicClear fs
984           M.basicClear gs
985   {-# INLINE basicSet  #-}
986   basicSet (MV_7 n_ as bs cs ds es fs gs) (a, b, c, d, e, f, g)
987       = do
988           M.basicSet as a
989           M.basicSet bs b
990           M.basicSet cs c
991           M.basicSet ds d
992           M.basicSet es e
993           M.basicSet fs f
994           M.basicSet gs g
995   {-# INLINE basicUnsafeCopy  #-}
996   basicUnsafeCopy (MV_7 n_1 as1
997                             bs1
998                             cs1
999                             ds1
1000                             es1
1001                             fs1
1002                             gs1) (MV_7 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2)
1003       = do
1004           M.basicUnsafeCopy as1 as2
1005           M.basicUnsafeCopy bs1 bs2
1006           M.basicUnsafeCopy cs1 cs2
1007           M.basicUnsafeCopy ds1 ds2
1008           M.basicUnsafeCopy es1 es2
1009           M.basicUnsafeCopy fs1 fs2
1010           M.basicUnsafeCopy gs1 gs2
1011   {-# INLINE basicUnsafeGrow  #-}
1012   basicUnsafeGrow (MV_7 n_ as bs cs ds es fs gs) m_
1013       = do
1014           M.basicUnsafeGrow as m_
1015           M.basicUnsafeGrow bs m_
1016           M.basicUnsafeGrow cs m_
1017           M.basicUnsafeGrow ds m_
1018           M.basicUnsafeGrow es m_
1019           M.basicUnsafeGrow fs m_
1020           M.basicUnsafeGrow gs m_
1021           return $ MV_7 (m_+n_) as bs cs ds es fs gs
1022 instance (Unbox a,
1023           Unbox b,
1024           Unbox c,
1025           Unbox d,
1026           Unbox e,
1027           Unbox f,
1028           Unbox g) => G.Vector Vector (a, b, c, d, e, f, g) where
1029   {-# INLINE unsafeFreeze  #-}
1030   unsafeFreeze (MV_7 n_ as bs cs ds es fs gs)
1031       = do
1032           as' <- G.unsafeFreeze as
1033           bs' <- G.unsafeFreeze bs
1034           cs' <- G.unsafeFreeze cs
1035           ds' <- G.unsafeFreeze ds
1036           es' <- G.unsafeFreeze es
1037           fs' <- G.unsafeFreeze fs
1038           gs' <- G.unsafeFreeze gs
1039           return $ V_7 n_ as' bs' cs' ds' es' fs' gs'
1040   {-# INLINE basicLength  #-}
1041   basicLength (V_7 n_ as bs cs ds es fs gs) = n_
1042   {-# INLINE basicUnsafeSlice  #-}
1043   basicUnsafeSlice (V_7 n_ as bs cs ds es fs gs) i_ m_
1044       = V_7 m_ (G.basicUnsafeSlice as i_ m_)
1045                (G.basicUnsafeSlice bs i_ m_)
1046                (G.basicUnsafeSlice cs i_ m_)
1047                (G.basicUnsafeSlice ds i_ m_)
1048                (G.basicUnsafeSlice es i_ m_)
1049                (G.basicUnsafeSlice fs i_ m_)
1050                (G.basicUnsafeSlice gs i_ m_)
1051   {-# INLINE basicUnsafeIndexM  #-}
1052   basicUnsafeIndexM (V_7 n_ as bs cs ds es fs gs) i_
1053       = do
1054           a <- G.basicUnsafeIndexM as i_
1055           b <- G.basicUnsafeIndexM bs i_
1056           c <- G.basicUnsafeIndexM cs i_
1057           d <- G.basicUnsafeIndexM ds i_
1058           e <- G.basicUnsafeIndexM es i_
1059           f <- G.basicUnsafeIndexM fs i_
1060           g <- G.basicUnsafeIndexM gs i_
1061           return (a, b, c, d, e, f, g)
1062 #endif
1063 #ifdef DEFINE_MUTABLE
1064 zip7 :: (Unbox a,
1065          Unbox b,
1066          Unbox c,
1067          Unbox d,
1068          Unbox e,
1069          Unbox f,
1070          Unbox g) => MVector s a ->
1071                      MVector s b ->
1072                      MVector s c ->
1073                      MVector s d ->
1074                      MVector s e ->
1075                      MVector s f ->
1076                      MVector s g -> MVector s (a, b, c, d, e, f, g)
1077 {-# INLINE zip7 #-}
1078 zip7 as bs cs ds es fs gs = MV_7 len (unsafeSlice as 0 len)
1079                                      (unsafeSlice bs 0 len)
1080                                      (unsafeSlice cs 0 len)
1081                                      (unsafeSlice ds 0 len)
1082                                      (unsafeSlice es 0 len)
1083                                      (unsafeSlice fs 0 len)
1084                                      (unsafeSlice gs 0 len)
1085   where
1086     len = length as `min`
1087           length bs `min`
1088           length cs `min`
1089           length ds `min`
1090           length es `min`
1091           length fs `min`
1092           length gs
1093 unzip7 :: (Unbox a,
1094            Unbox b,
1095            Unbox c,
1096            Unbox d,
1097            Unbox e,
1098            Unbox f,
1099            Unbox g) => MVector s (a, b, c, d, e, f, g) -> (MVector s a,
1100                                                            MVector s b,
1101                                                            MVector s c,
1102                                                            MVector s d,
1103                                                            MVector s e,
1104                                                            MVector s f,
1105                                                            MVector s g)
1106 {-# INLINE unzip7 #-}
1107 unzip7 (MV_7 n_ as bs cs ds es fs gs) = (as,
1108                                          bs,
1109                                          cs,
1110                                          ds,
1111                                          es,
1112                                          fs,
1113                                          gs)
1114 #endif
1115 #ifdef DEFINE_IMMUTABLE
1116 zip7 :: (Unbox a,
1117          Unbox b,
1118          Unbox c,
1119          Unbox d,
1120          Unbox e,
1121          Unbox f,
1122          Unbox g) => Vector a ->
1123                      Vector b ->
1124                      Vector c ->
1125                      Vector d ->
1126                      Vector e ->
1127                      Vector f ->
1128                      Vector g -> Vector (a, b, c, d, e, f, g)
1129 {-# INLINE zip7 #-}
1130 zip7 as bs cs ds es fs gs = V_7 len (unsafeSlice as 0 len)
1131                                     (unsafeSlice bs 0 len)
1132                                     (unsafeSlice cs 0 len)
1133                                     (unsafeSlice ds 0 len)
1134                                     (unsafeSlice es 0 len)
1135                                     (unsafeSlice fs 0 len)
1136                                     (unsafeSlice gs 0 len)
1137   where
1138     len = length as `min`
1139           length bs `min`
1140           length cs `min`
1141           length ds `min`
1142           length es `min`
1143           length fs `min`
1144           length gs
1145 unzip7 :: (Unbox a,
1146            Unbox b,
1147            Unbox c,
1148            Unbox d,
1149            Unbox e,
1150            Unbox f,
1151            Unbox g) => Vector (a, b, c, d, e, f, g) -> (Vector a,
1152                                                         Vector b,
1153                                                         Vector c,
1154                                                         Vector d,
1155                                                         Vector e,
1156                                                         Vector f,
1157                                                         Vector g)
1158 {-# INLINE unzip7 #-}
1159 unzip7 (V_7 n_ as bs cs ds es fs gs) = (as, bs, cs, ds, es, fs, gs)
1160 #endif
1161 #ifdef DEFINE_INSTANCES
1162 data instance MVector s (a, b, c, d, e, f, g, h)
1163     = MV_8 {-# UNPACK #-} !Int (MVector s a)
1164                                (MVector s b)
1165                                (MVector s c)
1166                                (MVector s d)
1167                                (MVector s e)
1168                                (MVector s f)
1169                                (MVector s g)
1170                                (MVector s h)
1171 data instance Vector (a, b, c, d, e, f, g, h)
1172     = V_8 {-# UNPACK #-} !Int (Vector a)
1173                               (Vector b)
1174                               (Vector c)
1175                               (Vector d)
1176                               (Vector e)
1177                               (Vector f)
1178                               (Vector g)
1179                               (Vector h)
1180 instance (Unbox a,
1181           Unbox b,
1182           Unbox c,
1183           Unbox d,
1184           Unbox e,
1185           Unbox f,
1186           Unbox g,
1187           Unbox h) => Unbox (a, b, c, d, e, f, g, h)
1188 instance (Unbox a,
1189           Unbox b,
1190           Unbox c,
1191           Unbox d,
1192           Unbox e,
1193           Unbox f,
1194           Unbox g,
1195           Unbox h) => M.MVector MVector (a, b, c, d, e, f, g, h) where
1196   {-# INLINE basicLength  #-}
1197   basicLength (MV_8 n_ as bs cs ds es fs gs hs) = n_
1198   {-# INLINE basicUnsafeSlice  #-}
1199   basicUnsafeSlice (MV_8 n_ as bs cs ds es fs gs hs) i_ m_
1200       = MV_8 m_ (M.basicUnsafeSlice as i_ m_)
1201                 (M.basicUnsafeSlice bs i_ m_)
1202                 (M.basicUnsafeSlice cs i_ m_)
1203                 (M.basicUnsafeSlice ds i_ m_)
1204                 (M.basicUnsafeSlice es i_ m_)
1205                 (M.basicUnsafeSlice fs i_ m_)
1206                 (M.basicUnsafeSlice gs i_ m_)
1207                 (M.basicUnsafeSlice hs i_ m_)
1208   {-# INLINE basicOverlaps  #-}
1209   basicOverlaps (MV_8 n_1 as1
1210                           bs1
1211                           cs1
1212                           ds1
1213                           es1
1214                           fs1
1215                           gs1
1216                           hs1) (MV_8 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2)
1217       = M.basicOverlaps as1 as2
1218         || M.basicOverlaps bs1 bs2
1219         || M.basicOverlaps cs1 cs2
1220         || M.basicOverlaps ds1 ds2
1221         || M.basicOverlaps es1 es2
1222         || M.basicOverlaps fs1 fs2
1223         || M.basicOverlaps gs1 gs2
1224         || M.basicOverlaps hs1 hs2
1225   {-# INLINE basicUnsafeNew  #-}
1226   basicUnsafeNew n_
1227       = do
1228           as <- M.basicUnsafeNew n_
1229           bs <- M.basicUnsafeNew n_
1230           cs <- M.basicUnsafeNew n_
1231           ds <- M.basicUnsafeNew n_
1232           es <- M.basicUnsafeNew n_
1233           fs <- M.basicUnsafeNew n_
1234           gs <- M.basicUnsafeNew n_
1235           hs <- M.basicUnsafeNew n_
1236           return $ MV_8 n_ as bs cs ds es fs gs hs
1237   {-# INLINE basicUnsafeNewWith  #-}
1238   basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h)
1239       = do
1240           as <- M.basicUnsafeNewWith n_ a
1241           bs <- M.basicUnsafeNewWith n_ b
1242           cs <- M.basicUnsafeNewWith n_ c
1243           ds <- M.basicUnsafeNewWith n_ d
1244           es <- M.basicUnsafeNewWith n_ e
1245           fs <- M.basicUnsafeNewWith n_ f
1246           gs <- M.basicUnsafeNewWith n_ g
1247           hs <- M.basicUnsafeNewWith n_ h
1248           return $ MV_8 n_ as bs cs ds es fs gs hs
1249   {-# INLINE basicUnsafeRead  #-}
1250   basicUnsafeRead (MV_8 n_ as bs cs ds es fs gs hs) i_
1251       = do
1252           a <- M.basicUnsafeRead as i_
1253           b <- M.basicUnsafeRead bs i_
1254           c <- M.basicUnsafeRead cs i_
1255           d <- M.basicUnsafeRead ds i_
1256           e <- M.basicUnsafeRead es i_
1257           f <- M.basicUnsafeRead fs i_
1258           g <- M.basicUnsafeRead gs i_
1259           h <- M.basicUnsafeRead hs i_
1260           return (a, b, c, d, e, f, g, h)
1261   {-# INLINE basicUnsafeWrite  #-}
1262   basicUnsafeWrite (MV_8 n_ as
1263                             bs
1264                             cs
1265                             ds
1266                             es
1267                             fs
1268                             gs
1269                             hs) i_ (a, b, c, d, e, f, g, h)
1270       = do
1271           M.basicUnsafeWrite as i_ a
1272           M.basicUnsafeWrite bs i_ b
1273           M.basicUnsafeWrite cs i_ c
1274           M.basicUnsafeWrite ds i_ d
1275           M.basicUnsafeWrite es i_ e
1276           M.basicUnsafeWrite fs i_ f
1277           M.basicUnsafeWrite gs i_ g
1278           M.basicUnsafeWrite hs i_ h
1279   {-# INLINE basicClear  #-}
1280   basicClear (MV_8 n_ as bs cs ds es fs gs hs)
1281       = do
1282           M.basicClear as
1283           M.basicClear bs
1284           M.basicClear cs
1285           M.basicClear ds
1286           M.basicClear es
1287           M.basicClear fs
1288           M.basicClear gs
1289           M.basicClear hs
1290   {-# INLINE basicSet  #-}
1291   basicSet (MV_8 n_ as bs cs ds es fs gs hs) (a, b, c, d, e, f, g, h)
1292       = do
1293           M.basicSet as a
1294           M.basicSet bs b
1295           M.basicSet cs c
1296           M.basicSet ds d
1297           M.basicSet es e
1298           M.basicSet fs f
1299           M.basicSet gs g
1300           M.basicSet hs h
1301   {-# INLINE basicUnsafeCopy  #-}
1302   basicUnsafeCopy (MV_8 n_1 as1
1303                             bs1
1304                             cs1
1305                             ds1
1306                             es1
1307                             fs1
1308                             gs1
1309                             hs1) (MV_8 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2)
1310       = do
1311           M.basicUnsafeCopy as1 as2
1312           M.basicUnsafeCopy bs1 bs2
1313           M.basicUnsafeCopy cs1 cs2
1314           M.basicUnsafeCopy ds1 ds2
1315           M.basicUnsafeCopy es1 es2
1316           M.basicUnsafeCopy fs1 fs2
1317           M.basicUnsafeCopy gs1 gs2
1318           M.basicUnsafeCopy hs1 hs2
1319   {-# INLINE basicUnsafeGrow  #-}
1320   basicUnsafeGrow (MV_8 n_ as bs cs ds es fs gs hs) m_
1321       = do
1322           M.basicUnsafeGrow as m_
1323           M.basicUnsafeGrow bs m_
1324           M.basicUnsafeGrow cs m_
1325           M.basicUnsafeGrow ds m_
1326           M.basicUnsafeGrow es m_
1327           M.basicUnsafeGrow fs m_
1328           M.basicUnsafeGrow gs m_
1329           M.basicUnsafeGrow hs m_
1330           return $ MV_8 (m_+n_) as bs cs ds es fs gs hs
1331 instance (Unbox a,
1332           Unbox b,
1333           Unbox c,
1334           Unbox d,
1335           Unbox e,
1336           Unbox f,
1337           Unbox g,
1338           Unbox h) => G.Vector Vector (a, b, c, d, e, f, g, h) where
1339   {-# INLINE unsafeFreeze  #-}
1340   unsafeFreeze (MV_8 n_ as bs cs ds es fs gs hs)
1341       = do
1342           as' <- G.unsafeFreeze as
1343           bs' <- G.unsafeFreeze bs
1344           cs' <- G.unsafeFreeze cs
1345           ds' <- G.unsafeFreeze ds
1346           es' <- G.unsafeFreeze es
1347           fs' <- G.unsafeFreeze fs
1348           gs' <- G.unsafeFreeze gs
1349           hs' <- G.unsafeFreeze hs
1350           return $ V_8 n_ as' bs' cs' ds' es' fs' gs' hs'
1351   {-# INLINE basicLength  #-}
1352   basicLength (V_8 n_ as bs cs ds es fs gs hs) = n_
1353   {-# INLINE basicUnsafeSlice  #-}
1354   basicUnsafeSlice (V_8 n_ as bs cs ds es fs gs hs) i_ m_
1355       = V_8 m_ (G.basicUnsafeSlice as i_ m_)
1356                (G.basicUnsafeSlice bs i_ m_)
1357                (G.basicUnsafeSlice cs i_ m_)
1358                (G.basicUnsafeSlice ds i_ m_)
1359                (G.basicUnsafeSlice es i_ m_)
1360                (G.basicUnsafeSlice fs i_ m_)
1361                (G.basicUnsafeSlice gs i_ m_)
1362                (G.basicUnsafeSlice hs i_ m_)
1363   {-# INLINE basicUnsafeIndexM  #-}
1364   basicUnsafeIndexM (V_8 n_ as bs cs ds es fs gs hs) i_
1365       = do
1366           a <- G.basicUnsafeIndexM as i_
1367           b <- G.basicUnsafeIndexM bs i_
1368           c <- G.basicUnsafeIndexM cs i_
1369           d <- G.basicUnsafeIndexM ds i_
1370           e <- G.basicUnsafeIndexM es i_
1371           f <- G.basicUnsafeIndexM fs i_
1372           g <- G.basicUnsafeIndexM gs i_
1373           h <- G.basicUnsafeIndexM hs i_
1374           return (a, b, c, d, e, f, g, h)
1375 #endif
1376 #ifdef DEFINE_MUTABLE
1377 zip8 :: (Unbox a,
1378          Unbox b,
1379          Unbox c,
1380          Unbox d,
1381          Unbox e,
1382          Unbox f,
1383          Unbox g,
1384          Unbox h) => MVector s a ->
1385                      MVector s b ->
1386                      MVector s c ->
1387                      MVector s d ->
1388                      MVector s e ->
1389                      MVector s f ->
1390                      MVector s g ->
1391                      MVector s h -> MVector s (a, b, c, d, e, f, g, h)
1392 {-# INLINE zip8 #-}
1393 zip8 as bs cs ds es fs gs hs = MV_8 len (unsafeSlice as 0 len)
1394                                         (unsafeSlice bs 0 len)
1395                                         (unsafeSlice cs 0 len)
1396                                         (unsafeSlice ds 0 len)
1397                                         (unsafeSlice es 0 len)
1398                                         (unsafeSlice fs 0 len)
1399                                         (unsafeSlice gs 0 len)
1400                                         (unsafeSlice hs 0 len)
1401   where
1402     len = length as `min`
1403           length bs `min`
1404           length cs `min`
1405           length ds `min`
1406           length es `min`
1407           length fs `min`
1408           length gs `min`
1409           length hs
1410 unzip8 :: (Unbox a,
1411            Unbox b,
1412            Unbox c,
1413            Unbox d,
1414            Unbox e,
1415            Unbox f,
1416            Unbox g,
1417            Unbox h) => MVector s (a, b, c, d, e, f, g, h) -> (MVector s a,
1418                                                               MVector s b,
1419                                                               MVector s c,
1420                                                               MVector s d,
1421                                                               MVector s e,
1422                                                               MVector s f,
1423                                                               MVector s g,
1424                                                               MVector s h)
1425 {-# INLINE unzip8 #-}
1426 unzip8 (MV_8 n_ as bs cs ds es fs gs hs) = (as,
1427                                             bs,
1428                                             cs,
1429                                             ds,
1430                                             es,
1431                                             fs,
1432                                             gs,
1433                                             hs)
1434 #endif
1435 #ifdef DEFINE_IMMUTABLE
1436 zip8 :: (Unbox a,
1437          Unbox b,
1438          Unbox c,
1439          Unbox d,
1440          Unbox e,
1441          Unbox f,
1442          Unbox g,
1443          Unbox h) => Vector a ->
1444                      Vector b ->
1445                      Vector c ->
1446                      Vector d ->
1447                      Vector e ->
1448                      Vector f ->
1449                      Vector g ->
1450                      Vector h -> Vector (a, b, c, d, e, f, g, h)
1451 {-# INLINE zip8 #-}
1452 zip8 as bs cs ds es fs gs hs = V_8 len (unsafeSlice as 0 len)
1453                                        (unsafeSlice bs 0 len)
1454                                        (unsafeSlice cs 0 len)
1455                                        (unsafeSlice ds 0 len)
1456                                        (unsafeSlice es 0 len)
1457                                        (unsafeSlice fs 0 len)
1458                                        (unsafeSlice gs 0 len)
1459                                        (unsafeSlice hs 0 len)
1460   where
1461     len = length as `min`
1462           length bs `min`
1463           length cs `min`
1464           length ds `min`
1465           length es `min`
1466           length fs `min`
1467           length gs `min`
1468           length hs
1469 unzip8 :: (Unbox a,
1470            Unbox b,
1471            Unbox c,
1472            Unbox d,
1473            Unbox e,
1474            Unbox f,
1475            Unbox g,
1476            Unbox h) => Vector (a, b, c, d, e, f, g, h) -> (Vector a,
1477                                                            Vector b,
1478                                                            Vector c,
1479                                                            Vector d,
1480                                                            Vector e,
1481                                                            Vector f,
1482                                                            Vector g,
1483                                                            Vector h)
1484 {-# INLINE unzip8 #-}
1485 unzip8 (V_8 n_ as bs cs ds es fs gs hs) = (as,
1486                                            bs,
1487                                            cs,
1488                                            ds,
1489                                            es,
1490                                            fs,
1491                                            gs,
1492                                            hs)
1493 #endif
1494 #ifdef DEFINE_INSTANCES
1495 data instance MVector s (a, b, c, d, e, f, g, h, i)
1496     = MV_9 {-# UNPACK #-} !Int (MVector s a)
1497                                (MVector s b)
1498                                (MVector s c)
1499                                (MVector s d)
1500                                (MVector s e)
1501                                (MVector s f)
1502                                (MVector s g)
1503                                (MVector s h)
1504                                (MVector s i)
1505 data instance Vector (a, b, c, d, e, f, g, h, i)
1506     = V_9 {-# UNPACK #-} !Int (Vector a)
1507                               (Vector b)
1508                               (Vector c)
1509                               (Vector d)
1510                               (Vector e)
1511                               (Vector f)
1512                               (Vector g)
1513                               (Vector h)
1514                               (Vector i)
1515 instance (Unbox a,
1516           Unbox b,
1517           Unbox c,
1518           Unbox d,
1519           Unbox e,
1520           Unbox f,
1521           Unbox g,
1522           Unbox h,
1523           Unbox i) => Unbox (a, b, c, d, e, f, g, h, i)
1524 instance (Unbox a,
1525           Unbox b,
1526           Unbox c,
1527           Unbox d,
1528           Unbox e,
1529           Unbox f,
1530           Unbox g,
1531           Unbox h,
1532           Unbox i) => M.MVector MVector (a, b, c, d, e, f, g, h, i) where
1533   {-# INLINE basicLength  #-}
1534   basicLength (MV_9 n_ as bs cs ds es fs gs hs is) = n_
1535   {-# INLINE basicUnsafeSlice  #-}
1536   basicUnsafeSlice (MV_9 n_ as bs cs ds es fs gs hs is) i_ m_
1537       = MV_9 m_ (M.basicUnsafeSlice as i_ m_)
1538                 (M.basicUnsafeSlice bs i_ m_)
1539                 (M.basicUnsafeSlice cs i_ m_)
1540                 (M.basicUnsafeSlice ds i_ m_)
1541                 (M.basicUnsafeSlice es i_ m_)
1542                 (M.basicUnsafeSlice fs i_ m_)
1543                 (M.basicUnsafeSlice gs i_ m_)
1544                 (M.basicUnsafeSlice hs i_ m_)
1545                 (M.basicUnsafeSlice is i_ m_)
1546   {-# INLINE basicOverlaps  #-}
1547   basicOverlaps (MV_9 n_1 as1
1548                           bs1
1549                           cs1
1550                           ds1
1551                           es1
1552                           fs1
1553                           gs1
1554                           hs1
1555                           is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
1556       = M.basicOverlaps as1 as2
1557         || M.basicOverlaps bs1 bs2
1558         || M.basicOverlaps cs1 cs2
1559         || M.basicOverlaps ds1 ds2
1560         || M.basicOverlaps es1 es2
1561         || M.basicOverlaps fs1 fs2
1562         || M.basicOverlaps gs1 gs2
1563         || M.basicOverlaps hs1 hs2
1564         || M.basicOverlaps is1 is2
1565   {-# INLINE basicUnsafeNew  #-}
1566   basicUnsafeNew n_
1567       = do
1568           as <- M.basicUnsafeNew n_
1569           bs <- M.basicUnsafeNew n_
1570           cs <- M.basicUnsafeNew n_
1571           ds <- M.basicUnsafeNew n_
1572           es <- M.basicUnsafeNew n_
1573           fs <- M.basicUnsafeNew n_
1574           gs <- M.basicUnsafeNew n_
1575           hs <- M.basicUnsafeNew n_
1576           is <- M.basicUnsafeNew n_
1577           return $ MV_9 n_ as bs cs ds es fs gs hs is
1578   {-# INLINE basicUnsafeNewWith  #-}
1579   basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i)
1580       = do
1581           as <- M.basicUnsafeNewWith n_ a
1582           bs <- M.basicUnsafeNewWith n_ b
1583           cs <- M.basicUnsafeNewWith n_ c
1584           ds <- M.basicUnsafeNewWith n_ d
1585           es <- M.basicUnsafeNewWith n_ e
1586           fs <- M.basicUnsafeNewWith n_ f
1587           gs <- M.basicUnsafeNewWith n_ g
1588           hs <- M.basicUnsafeNewWith n_ h
1589           is <- M.basicUnsafeNewWith n_ i
1590           return $ MV_9 n_ as bs cs ds es fs gs hs is
1591   {-# INLINE basicUnsafeRead  #-}
1592   basicUnsafeRead (MV_9 n_ as bs cs ds es fs gs hs is) i_
1593       = do
1594           a <- M.basicUnsafeRead as i_
1595           b <- M.basicUnsafeRead bs i_
1596           c <- M.basicUnsafeRead cs i_
1597           d <- M.basicUnsafeRead ds i_
1598           e <- M.basicUnsafeRead es i_
1599           f <- M.basicUnsafeRead fs i_
1600           g <- M.basicUnsafeRead gs i_
1601           h <- M.basicUnsafeRead hs i_
1602           i <- M.basicUnsafeRead is i_
1603           return (a, b, c, d, e, f, g, h, i)
1604   {-# INLINE basicUnsafeWrite  #-}
1605   basicUnsafeWrite (MV_9 n_ as
1606                             bs
1607                             cs
1608                             ds
1609                             es
1610                             fs
1611                             gs
1612                             hs
1613                             is) i_ (a, b, c, d, e, f, g, h, i)
1614       = do
1615           M.basicUnsafeWrite as i_ a
1616           M.basicUnsafeWrite bs i_ b
1617           M.basicUnsafeWrite cs i_ c
1618           M.basicUnsafeWrite ds i_ d
1619           M.basicUnsafeWrite es i_ e
1620           M.basicUnsafeWrite fs i_ f
1621           M.basicUnsafeWrite gs i_ g
1622           M.basicUnsafeWrite hs i_ h
1623           M.basicUnsafeWrite is i_ i
1624   {-# INLINE basicClear  #-}
1625   basicClear (MV_9 n_ as bs cs ds es fs gs hs is)
1626       = do
1627           M.basicClear as
1628           M.basicClear bs
1629           M.basicClear cs
1630           M.basicClear ds
1631           M.basicClear es
1632           M.basicClear fs
1633           M.basicClear gs
1634           M.basicClear hs
1635           M.basicClear is
1636   {-# INLINE basicSet  #-}
1637   basicSet (MV_9 n_ as
1638                     bs
1639                     cs
1640                     ds
1641                     es
1642                     fs
1643                     gs
1644                     hs
1645                     is) (a, b, c, d, e, f, g, h, i)
1646       = do
1647           M.basicSet as a
1648           M.basicSet bs b
1649           M.basicSet cs c
1650           M.basicSet ds d
1651           M.basicSet es e
1652           M.basicSet fs f
1653           M.basicSet gs g
1654           M.basicSet hs h
1655           M.basicSet is i
1656   {-# INLINE basicUnsafeCopy  #-}
1657   basicUnsafeCopy (MV_9 n_1 as1
1658                             bs1
1659                             cs1
1660                             ds1
1661                             es1
1662                             fs1
1663                             gs1
1664                             hs1
1665                             is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
1666       = do
1667           M.basicUnsafeCopy as1 as2
1668           M.basicUnsafeCopy bs1 bs2
1669           M.basicUnsafeCopy cs1 cs2
1670           M.basicUnsafeCopy ds1 ds2
1671           M.basicUnsafeCopy es1 es2
1672           M.basicUnsafeCopy fs1 fs2
1673           M.basicUnsafeCopy gs1 gs2
1674           M.basicUnsafeCopy hs1 hs2
1675           M.basicUnsafeCopy is1 is2
1676   {-# INLINE basicUnsafeGrow  #-}
1677   basicUnsafeGrow (MV_9 n_ as bs cs ds es fs gs hs is) m_
1678       = do
1679           M.basicUnsafeGrow as m_
1680           M.basicUnsafeGrow bs m_
1681           M.basicUnsafeGrow cs m_
1682           M.basicUnsafeGrow ds m_
1683           M.basicUnsafeGrow es m_
1684           M.basicUnsafeGrow fs m_
1685           M.basicUnsafeGrow gs m_
1686           M.basicUnsafeGrow hs m_
1687           M.basicUnsafeGrow is m_
1688           return $ MV_9 (m_+n_) as bs cs ds es fs gs hs is
1689 instance (Unbox a,
1690           Unbox b,
1691           Unbox c,
1692           Unbox d,
1693           Unbox e,
1694           Unbox f,
1695           Unbox g,
1696           Unbox h,
1697           Unbox i) => G.Vector Vector (a, b, c, d, e, f, g, h, i) where
1698   {-# INLINE unsafeFreeze  #-}
1699   unsafeFreeze (MV_9 n_ as bs cs ds es fs gs hs is)
1700       = do
1701           as' <- G.unsafeFreeze as
1702           bs' <- G.unsafeFreeze bs
1703           cs' <- G.unsafeFreeze cs
1704           ds' <- G.unsafeFreeze ds
1705           es' <- G.unsafeFreeze es
1706           fs' <- G.unsafeFreeze fs
1707           gs' <- G.unsafeFreeze gs
1708           hs' <- G.unsafeFreeze hs
1709           is' <- G.unsafeFreeze is
1710           return $ V_9 n_ as' bs' cs' ds' es' fs' gs' hs' is'
1711   {-# INLINE basicLength  #-}
1712   basicLength (V_9 n_ as bs cs ds es fs gs hs is) = n_
1713   {-# INLINE basicUnsafeSlice  #-}
1714   basicUnsafeSlice (V_9 n_ as bs cs ds es fs gs hs is) i_ m_
1715       = V_9 m_ (G.basicUnsafeSlice as i_ m_)
1716                (G.basicUnsafeSlice bs i_ m_)
1717                (G.basicUnsafeSlice cs i_ m_)
1718                (G.basicUnsafeSlice ds i_ m_)
1719                (G.basicUnsafeSlice es i_ m_)
1720                (G.basicUnsafeSlice fs i_ m_)
1721                (G.basicUnsafeSlice gs i_ m_)
1722                (G.basicUnsafeSlice hs i_ m_)
1723                (G.basicUnsafeSlice is i_ m_)
1724   {-# INLINE basicUnsafeIndexM  #-}
1725   basicUnsafeIndexM (V_9 n_ as bs cs ds es fs gs hs is) i_
1726       = do
1727           a <- G.basicUnsafeIndexM as i_
1728           b <- G.basicUnsafeIndexM bs i_
1729           c <- G.basicUnsafeIndexM cs i_
1730           d <- G.basicUnsafeIndexM ds i_
1731           e <- G.basicUnsafeIndexM es i_
1732           f <- G.basicUnsafeIndexM fs i_
1733           g <- G.basicUnsafeIndexM gs i_
1734           h <- G.basicUnsafeIndexM hs i_
1735           i <- G.basicUnsafeIndexM is i_
1736           return (a, b, c, d, e, f, g, h, i)
1737 #endif
1738 #ifdef DEFINE_MUTABLE
1739 zip9 :: (Unbox a,
1740          Unbox b,
1741          Unbox c,
1742          Unbox d,
1743          Unbox e,
1744          Unbox f,
1745          Unbox g,
1746          Unbox h,
1747          Unbox i) => MVector s a ->
1748                      MVector s b ->
1749                      MVector s c ->
1750                      MVector s d ->
1751                      MVector s e ->
1752                      MVector s f ->
1753                      MVector s g ->
1754                      MVector s h ->
1755                      MVector s i -> MVector s (a, b, c, d, e, f, g, h, i)
1756 {-# INLINE zip9 #-}
1757 zip9 as bs cs ds es fs gs hs is = MV_9 len (unsafeSlice as 0 len)
1758                                            (unsafeSlice bs 0 len)
1759                                            (unsafeSlice cs 0 len)
1760                                            (unsafeSlice ds 0 len)
1761                                            (unsafeSlice es 0 len)
1762                                            (unsafeSlice fs 0 len)
1763                                            (unsafeSlice gs 0 len)
1764                                            (unsafeSlice hs 0 len)
1765                                            (unsafeSlice is 0 len)
1766   where
1767     len = length as `min`
1768           length bs `min`
1769           length cs `min`
1770           length ds `min`
1771           length es `min`
1772           length fs `min`
1773           length gs `min`
1774           length hs `min`
1775           length is
1776 unzip9 :: (Unbox a,
1777            Unbox b,
1778            Unbox c,
1779            Unbox d,
1780            Unbox e,
1781            Unbox f,
1782            Unbox g,
1783            Unbox h,
1784            Unbox i) => MVector s (a, b, c, d, e, f, g, h, i) -> (MVector s a,
1785                                                                  MVector s b,
1786                                                                  MVector s c,
1787                                                                  MVector s d,
1788                                                                  MVector s e,
1789                                                                  MVector s f,
1790                                                                  MVector s g,
1791                                                                  MVector s h,
1792                                                                  MVector s i)
1793 {-# INLINE unzip9 #-}
1794 unzip9 (MV_9 n_ as bs cs ds es fs gs hs is) = (as,
1795                                                bs,
1796                                                cs,
1797                                                ds,
1798                                                es,
1799                                                fs,
1800                                                gs,
1801                                                hs,
1802                                                is)
1803 #endif
1804 #ifdef DEFINE_IMMUTABLE
1805 zip9 :: (Unbox a,
1806          Unbox b,
1807          Unbox c,
1808          Unbox d,
1809          Unbox e,
1810          Unbox f,
1811          Unbox g,
1812          Unbox h,
1813          Unbox i) => Vector a ->
1814                      Vector b ->
1815                      Vector c ->
1816                      Vector d ->
1817                      Vector e ->
1818                      Vector f ->
1819                      Vector g ->
1820                      Vector h ->
1821                      Vector i -> Vector (a, b, c, d, e, f, g, h, i)
1822 {-# INLINE zip9 #-}
1823 zip9 as bs cs ds es fs gs hs is = V_9 len (unsafeSlice as 0 len)
1824                                           (unsafeSlice bs 0 len)
1825                                           (unsafeSlice cs 0 len)
1826                                           (unsafeSlice ds 0 len)
1827                                           (unsafeSlice es 0 len)
1828                                           (unsafeSlice fs 0 len)
1829                                           (unsafeSlice gs 0 len)
1830                                           (unsafeSlice hs 0 len)
1831                                           (unsafeSlice is 0 len)
1832   where
1833     len = length as `min`
1834           length bs `min`
1835           length cs `min`
1836           length ds `min`
1837           length es `min`
1838           length fs `min`
1839           length gs `min`
1840           length hs `min`
1841           length is
1842 unzip9 :: (Unbox a,
1843            Unbox b,
1844            Unbox c,
1845            Unbox d,
1846            Unbox e,
1847            Unbox f,
1848            Unbox g,
1849            Unbox h,
1850            Unbox i) => Vector (a, b, c, d, e, f, g, h, i) -> (Vector a,
1851                                                               Vector b,
1852                                                               Vector c,
1853                                                               Vector d,
1854                                                               Vector e,
1855                                                               Vector f,
1856                                                               Vector g,
1857                                                               Vector h,
1858                                                               Vector i)
1859 {-# INLINE unzip9 #-}
1860 unzip9 (V_9 n_ as bs cs ds es fs gs hs is) = (as,
1861                                               bs,
1862                                               cs,
1863                                               ds,
1864                                               es,
1865                                               fs,
1866                                               gs,
1867                                               hs,
1868                                               is)
1869 #endif
1870 #ifdef DEFINE_INSTANCES
1871 data instance MVector s (a, b, c, d, e, f, g, h, i, j)
1872     = MV_10 {-# UNPACK #-} !Int (MVector s a)
1873                                 (MVector s b)
1874                                 (MVector s c)
1875                                 (MVector s d)
1876                                 (MVector s e)
1877                                 (MVector s f)
1878                                 (MVector s g)
1879                                 (MVector s h)
1880                                 (MVector s i)
1881                                 (MVector s j)
1882 data instance Vector (a, b, c, d, e, f, g, h, i, j)
1883     = V_10 {-# UNPACK #-} !Int (Vector a)
1884                                (Vector b)
1885                                (Vector c)
1886                                (Vector d)
1887                                (Vector e)
1888                                (Vector f)
1889                                (Vector g)
1890                                (Vector h)
1891                                (Vector i)
1892                                (Vector j)
1893 instance (Unbox a,
1894           Unbox b,
1895           Unbox c,
1896           Unbox d,
1897           Unbox e,
1898           Unbox f,
1899           Unbox g,
1900           Unbox h,
1901           Unbox i,
1902           Unbox j) => Unbox (a, b, c, d, e, f, g, h, i, j)
1903 instance (Unbox a,
1904           Unbox b,
1905           Unbox c,
1906           Unbox d,
1907           Unbox e,
1908           Unbox f,
1909           Unbox g,
1910           Unbox h,
1911           Unbox i,
1912           Unbox j) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j) where
1913   {-# INLINE basicLength  #-}
1914   basicLength (MV_10 n_ as bs cs ds es fs gs hs is js) = n_
1915   {-# INLINE basicUnsafeSlice  #-}
1916   basicUnsafeSlice (MV_10 n_ as bs cs ds es fs gs hs is js) i_ m_
1917       = MV_10 m_ (M.basicUnsafeSlice as i_ m_)
1918                  (M.basicUnsafeSlice bs i_ m_)
1919                  (M.basicUnsafeSlice cs i_ m_)
1920                  (M.basicUnsafeSlice ds i_ m_)
1921                  (M.basicUnsafeSlice es i_ m_)
1922                  (M.basicUnsafeSlice fs i_ m_)
1923                  (M.basicUnsafeSlice gs i_ m_)
1924                  (M.basicUnsafeSlice hs i_ m_)
1925                  (M.basicUnsafeSlice is i_ m_)
1926                  (M.basicUnsafeSlice js i_ m_)
1927   {-# INLINE basicOverlaps  #-}
1928   basicOverlaps (MV_10 n_1 as1
1929                            bs1
1930                            cs1
1931                            ds1
1932                            es1
1933                            fs1
1934                            gs1
1935                            hs1
1936                            is1
1937                            js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
1938       = M.basicOverlaps as1 as2
1939         || M.basicOverlaps bs1 bs2
1940         || M.basicOverlaps cs1 cs2
1941         || M.basicOverlaps ds1 ds2
1942         || M.basicOverlaps es1 es2
1943         || M.basicOverlaps fs1 fs2
1944         || M.basicOverlaps gs1 gs2
1945         || M.basicOverlaps hs1 hs2
1946         || M.basicOverlaps is1 is2
1947         || M.basicOverlaps js1 js2
1948   {-# INLINE basicUnsafeNew  #-}
1949   basicUnsafeNew n_
1950       = do
1951           as <- M.basicUnsafeNew n_
1952           bs <- M.basicUnsafeNew n_
1953           cs <- M.basicUnsafeNew n_
1954           ds <- M.basicUnsafeNew n_
1955           es <- M.basicUnsafeNew n_
1956           fs <- M.basicUnsafeNew n_
1957           gs <- M.basicUnsafeNew n_
1958           hs <- M.basicUnsafeNew n_
1959           is <- M.basicUnsafeNew n_
1960           js <- M.basicUnsafeNew n_
1961           return $ MV_10 n_ as bs cs ds es fs gs hs is js
1962   {-# INLINE basicUnsafeNewWith  #-}
1963   basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j)
1964       = do
1965           as <- M.basicUnsafeNewWith n_ a
1966           bs <- M.basicUnsafeNewWith n_ b
1967           cs <- M.basicUnsafeNewWith n_ c
1968           ds <- M.basicUnsafeNewWith n_ d
1969           es <- M.basicUnsafeNewWith n_ e
1970           fs <- M.basicUnsafeNewWith n_ f
1971           gs <- M.basicUnsafeNewWith n_ g
1972           hs <- M.basicUnsafeNewWith n_ h
1973           is <- M.basicUnsafeNewWith n_ i
1974           js <- M.basicUnsafeNewWith n_ j
1975           return $ MV_10 n_ as bs cs ds es fs gs hs is js
1976   {-# INLINE basicUnsafeRead  #-}
1977   basicUnsafeRead (MV_10 n_ as bs cs ds es fs gs hs is js) i_
1978       = do
1979           a <- M.basicUnsafeRead as i_
1980           b <- M.basicUnsafeRead bs i_
1981           c <- M.basicUnsafeRead cs i_
1982           d <- M.basicUnsafeRead ds i_
1983           e <- M.basicUnsafeRead es i_
1984           f <- M.basicUnsafeRead fs i_
1985           g <- M.basicUnsafeRead gs i_
1986           h <- M.basicUnsafeRead hs i_
1987           i <- M.basicUnsafeRead is i_
1988           j <- M.basicUnsafeRead js i_
1989           return (a, b, c, d, e, f, g, h, i, j)
1990   {-# INLINE basicUnsafeWrite  #-}
1991   basicUnsafeWrite (MV_10 n_ as
1992                              bs
1993                              cs
1994                              ds
1995                              es
1996                              fs
1997                              gs
1998                              hs
1999                              is
2000                              js) i_ (a, b, c, d, e, f, g, h, i, j)
2001       = do
2002           M.basicUnsafeWrite as i_ a
2003           M.basicUnsafeWrite bs i_ b
2004           M.basicUnsafeWrite cs i_ c
2005           M.basicUnsafeWrite ds i_ d
2006           M.basicUnsafeWrite es i_ e
2007           M.basicUnsafeWrite fs i_ f
2008           M.basicUnsafeWrite gs i_ g
2009           M.basicUnsafeWrite hs i_ h
2010           M.basicUnsafeWrite is i_ i
2011           M.basicUnsafeWrite js i_ j
2012   {-# INLINE basicClear  #-}
2013   basicClear (MV_10 n_ as bs cs ds es fs gs hs is js)
2014       = do
2015           M.basicClear as
2016           M.basicClear bs
2017           M.basicClear cs
2018           M.basicClear ds
2019           M.basicClear es
2020           M.basicClear fs
2021           M.basicClear gs
2022           M.basicClear hs
2023           M.basicClear is
2024           M.basicClear js
2025   {-# INLINE basicSet  #-}
2026   basicSet (MV_10 n_ as
2027                      bs
2028                      cs
2029                      ds
2030                      es
2031                      fs
2032                      gs
2033                      hs
2034                      is
2035                      js) (a, b, c, d, e, f, g, h, i, j)
2036       = do
2037           M.basicSet as a
2038           M.basicSet bs b
2039           M.basicSet cs c
2040           M.basicSet ds d
2041           M.basicSet es e
2042           M.basicSet fs f
2043           M.basicSet gs g
2044           M.basicSet hs h
2045           M.basicSet is i
2046           M.basicSet js j
2047   {-# INLINE basicUnsafeCopy  #-}
2048   basicUnsafeCopy (MV_10 n_1 as1
2049                              bs1
2050                              cs1
2051                              ds1
2052                              es1
2053                              fs1
2054                              gs1
2055                              hs1
2056                              is1
2057                              js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
2058       = do
2059           M.basicUnsafeCopy as1 as2
2060           M.basicUnsafeCopy bs1 bs2
2061           M.basicUnsafeCopy cs1 cs2
2062           M.basicUnsafeCopy ds1 ds2
2063           M.basicUnsafeCopy es1 es2
2064           M.basicUnsafeCopy fs1 fs2
2065           M.basicUnsafeCopy gs1 gs2
2066           M.basicUnsafeCopy hs1 hs2
2067           M.basicUnsafeCopy is1 is2
2068           M.basicUnsafeCopy js1 js2
2069   {-# INLINE basicUnsafeGrow  #-}
2070   basicUnsafeGrow (MV_10 n_ as bs cs ds es fs gs hs is js) m_
2071       = do
2072           M.basicUnsafeGrow as m_
2073           M.basicUnsafeGrow bs m_
2074           M.basicUnsafeGrow cs m_
2075           M.basicUnsafeGrow ds m_
2076           M.basicUnsafeGrow es m_
2077           M.basicUnsafeGrow fs m_
2078           M.basicUnsafeGrow gs m_
2079           M.basicUnsafeGrow hs m_
2080           M.basicUnsafeGrow is m_
2081           M.basicUnsafeGrow js m_
2082           return $ MV_10 (m_+n_) as bs cs ds es fs gs hs is js
2083 instance (Unbox a,
2084           Unbox b,
2085           Unbox c,
2086           Unbox d,
2087           Unbox e,
2088           Unbox f,
2089           Unbox g,
2090           Unbox h,
2091           Unbox i,
2092           Unbox j) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j) where
2093   {-# INLINE unsafeFreeze  #-}
2094   unsafeFreeze (MV_10 n_ as bs cs ds es fs gs hs is js)
2095       = do
2096           as' <- G.unsafeFreeze as
2097           bs' <- G.unsafeFreeze bs
2098           cs' <- G.unsafeFreeze cs
2099           ds' <- G.unsafeFreeze ds
2100           es' <- G.unsafeFreeze es
2101           fs' <- G.unsafeFreeze fs
2102           gs' <- G.unsafeFreeze gs
2103           hs' <- G.unsafeFreeze hs
2104           is' <- G.unsafeFreeze is
2105           js' <- G.unsafeFreeze js
2106           return $ V_10 n_ as' bs' cs' ds' es' fs' gs' hs' is' js'
2107   {-# INLINE basicLength  #-}
2108   basicLength (V_10 n_ as bs cs ds es fs gs hs is js) = n_
2109   {-# INLINE basicUnsafeSlice  #-}
2110   basicUnsafeSlice (V_10 n_ as bs cs ds es fs gs hs is js) i_ m_
2111       = V_10 m_ (G.basicUnsafeSlice as i_ m_)
2112                 (G.basicUnsafeSlice bs i_ m_)
2113                 (G.basicUnsafeSlice cs i_ m_)
2114                 (G.basicUnsafeSlice ds i_ m_)
2115                 (G.basicUnsafeSlice es i_ m_)
2116                 (G.basicUnsafeSlice fs i_ m_)
2117                 (G.basicUnsafeSlice gs i_ m_)
2118                 (G.basicUnsafeSlice hs i_ m_)
2119                 (G.basicUnsafeSlice is i_ m_)
2120                 (G.basicUnsafeSlice js i_ m_)
2121   {-# INLINE basicUnsafeIndexM  #-}
2122   basicUnsafeIndexM (V_10 n_ as bs cs ds es fs gs hs is js) i_
2123       = do
2124           a <- G.basicUnsafeIndexM as i_
2125           b <- G.basicUnsafeIndexM bs i_
2126           c <- G.basicUnsafeIndexM cs i_
2127           d <- G.basicUnsafeIndexM ds i_
2128           e <- G.basicUnsafeIndexM es i_
2129           f <- G.basicUnsafeIndexM fs i_
2130           g <- G.basicUnsafeIndexM gs i_
2131           h <- G.basicUnsafeIndexM hs i_
2132           i <- G.basicUnsafeIndexM is i_
2133           j <- G.basicUnsafeIndexM js i_
2134           return (a, b, c, d, e, f, g, h, i, j)
2135 #endif
2136 #ifdef DEFINE_MUTABLE
2137 zip10 :: (Unbox a,
2138           Unbox b,
2139           Unbox c,
2140           Unbox d,
2141           Unbox e,
2142           Unbox f,
2143           Unbox g,
2144           Unbox h,
2145           Unbox i,
2146           Unbox j) => MVector s a ->
2147                       MVector s b ->
2148                       MVector s c ->
2149                       MVector s d ->
2150                       MVector s e ->
2151                       MVector s f ->
2152                       MVector s g ->
2153                       MVector s h ->
2154                       MVector s i ->
2155                       MVector s j -> MVector s (a, b, c, d, e, f, g, h, i, j)
2156 {-# INLINE zip10 #-}
2157 zip10 as
2158       bs
2159       cs
2160       ds
2161       es
2162       fs
2163       gs
2164       hs
2165       is
2166       js = MV_10 len (unsafeSlice as 0 len)
2167                      (unsafeSlice bs 0 len)
2168                      (unsafeSlice cs 0 len)
2169                      (unsafeSlice ds 0 len)
2170                      (unsafeSlice es 0 len)
2171                      (unsafeSlice fs 0 len)
2172                      (unsafeSlice gs 0 len)
2173                      (unsafeSlice hs 0 len)
2174                      (unsafeSlice is 0 len)
2175                      (unsafeSlice js 0 len)
2176   where
2177     len = length as `min`
2178           length bs `min`
2179           length cs `min`
2180           length ds `min`
2181           length es `min`
2182           length fs `min`
2183           length gs `min`
2184           length hs `min`
2185           length is `min`
2186           length js
2187 unzip10 :: (Unbox a,
2188             Unbox b,
2189             Unbox c,
2190             Unbox d,
2191             Unbox e,
2192             Unbox f,
2193             Unbox g,
2194             Unbox h,
2195             Unbox i,
2196             Unbox j) => MVector s (a, b, c, d, e, f, g, h, i, j) -> (MVector s a,
2197                                                                      MVector s b,
2198                                                                      MVector s c,
2199                                                                      MVector s d,
2200                                                                      MVector s e,
2201                                                                      MVector s f,
2202                                                                      MVector s g,
2203                                                                      MVector s h,
2204                                                                      MVector s i,
2205                                                                      MVector s j)
2206 {-# INLINE unzip10 #-}
2207 unzip10 (MV_10 n_ as bs cs ds es fs gs hs is js) = (as,
2208                                                     bs,
2209                                                     cs,
2210                                                     ds,
2211                                                     es,
2212                                                     fs,
2213                                                     gs,
2214                                                     hs,
2215                                                     is,
2216                                                     js)
2217 #endif
2218 #ifdef DEFINE_IMMUTABLE
2219 zip10 :: (Unbox a,
2220           Unbox b,
2221           Unbox c,
2222           Unbox d,
2223           Unbox e,
2224           Unbox f,
2225           Unbox g,
2226           Unbox h,
2227           Unbox i,
2228           Unbox j) => Vector a ->
2229                       Vector b ->
2230                       Vector c ->
2231                       Vector d ->
2232                       Vector e ->
2233                       Vector f ->
2234                       Vector g ->
2235                       Vector h ->
2236                       Vector i ->
2237                       Vector j -> Vector (a, b, c, d, e, f, g, h, i, j)
2238 {-# INLINE zip10 #-}
2239 zip10 as
2240       bs
2241       cs
2242       ds
2243       es
2244       fs
2245       gs
2246       hs
2247       is
2248       js = V_10 len (unsafeSlice as 0 len)
2249                     (unsafeSlice bs 0 len)
2250                     (unsafeSlice cs 0 len)
2251                     (unsafeSlice ds 0 len)
2252                     (unsafeSlice es 0 len)
2253                     (unsafeSlice fs 0 len)
2254                     (unsafeSlice gs 0 len)
2255                     (unsafeSlice hs 0 len)
2256                     (unsafeSlice is 0 len)
2257                     (unsafeSlice js 0 len)
2258   where
2259     len = length as `min`
2260           length bs `min`
2261           length cs `min`
2262           length ds `min`
2263           length es `min`
2264           length fs `min`
2265           length gs `min`
2266           length hs `min`
2267           length is `min`
2268           length js
2269 unzip10 :: (Unbox a,
2270             Unbox b,
2271             Unbox c,
2272             Unbox d,
2273             Unbox e,
2274             Unbox f,
2275             Unbox g,
2276             Unbox h,
2277             Unbox i,
2278             Unbox j) => Vector (a, b, c, d, e, f, g, h, i, j) -> (Vector a,
2279                                                                   Vector b,
2280                                                                   Vector c,
2281                                                                   Vector d,
2282                                                                   Vector e,
2283                                                                   Vector f,
2284                                                                   Vector g,
2285                                                                   Vector h,
2286                                                                   Vector i,
2287                                                                   Vector j)
2288 {-# INLINE unzip10 #-}
2289 unzip10 (V_10 n_ as bs cs ds es fs gs hs is js) = (as,
2290                                                    bs,
2291                                                    cs,
2292                                                    ds,
2293                                                    es,
2294                                                    fs,
2295                                                    gs,
2296                                                    hs,
2297                                                    is,
2298                                                    js)
2299 #endif
2300 #ifdef DEFINE_INSTANCES
2301 data instance MVector s (a, b, c, d, e, f, g, h, i, j, k)
2302     = MV_11 {-# UNPACK #-} !Int (MVector s a)
2303                                 (MVector s b)
2304                                 (MVector s c)
2305                                 (MVector s d)
2306                                 (MVector s e)
2307                                 (MVector s f)
2308                                 (MVector s g)
2309                                 (MVector s h)
2310                                 (MVector s i)
2311                                 (MVector s j)
2312                                 (MVector s k)
2313 data instance Vector (a, b, c, d, e, f, g, h, i, j, k)
2314     = V_11 {-# UNPACK #-} !Int (Vector a)
2315                                (Vector b)
2316                                (Vector c)
2317                                (Vector d)
2318                                (Vector e)
2319                                (Vector f)
2320                                (Vector g)
2321                                (Vector h)
2322                                (Vector i)
2323                                (Vector j)
2324                                (Vector k)
2325 instance (Unbox a,
2326           Unbox b,
2327           Unbox c,
2328           Unbox d,
2329           Unbox e,
2330           Unbox f,
2331           Unbox g,
2332           Unbox h,
2333           Unbox i,
2334           Unbox j,
2335           Unbox k) => Unbox (a, b, c, d, e, f, g, h, i, j, k)
2336 instance (Unbox a,
2337           Unbox b,
2338           Unbox c,
2339           Unbox d,
2340           Unbox e,
2341           Unbox f,
2342           Unbox g,
2343           Unbox h,
2344           Unbox i,
2345           Unbox j,
2346           Unbox k) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k) where
2347   {-# INLINE basicLength  #-}
2348   basicLength (MV_11 n_ as bs cs ds es fs gs hs is js ks) = n_
2349   {-# INLINE basicUnsafeSlice  #-}
2350   basicUnsafeSlice (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
2351       = MV_11 m_ (M.basicUnsafeSlice as i_ m_)
2352                  (M.basicUnsafeSlice bs i_ m_)
2353                  (M.basicUnsafeSlice cs i_ m_)
2354                  (M.basicUnsafeSlice ds i_ m_)
2355                  (M.basicUnsafeSlice es i_ m_)
2356                  (M.basicUnsafeSlice fs i_ m_)
2357                  (M.basicUnsafeSlice gs i_ m_)
2358                  (M.basicUnsafeSlice hs i_ m_)
2359                  (M.basicUnsafeSlice is i_ m_)
2360                  (M.basicUnsafeSlice js i_ m_)
2361                  (M.basicUnsafeSlice ks i_ m_)
2362   {-# INLINE basicOverlaps  #-}
2363   basicOverlaps (MV_11 n_1 as1
2364                            bs1
2365                            cs1
2366                            ds1
2367                            es1
2368                            fs1
2369                            gs1
2370                            hs1
2371                            is1
2372                            js1
2373                            ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
2374       = M.basicOverlaps as1 as2
2375         || M.basicOverlaps bs1 bs2
2376         || M.basicOverlaps cs1 cs2
2377         || M.basicOverlaps ds1 ds2
2378         || M.basicOverlaps es1 es2
2379         || M.basicOverlaps fs1 fs2
2380         || M.basicOverlaps gs1 gs2
2381         || M.basicOverlaps hs1 hs2
2382         || M.basicOverlaps is1 is2
2383         || M.basicOverlaps js1 js2
2384         || M.basicOverlaps ks1 ks2
2385   {-# INLINE basicUnsafeNew  #-}
2386   basicUnsafeNew n_
2387       = do
2388           as <- M.basicUnsafeNew n_
2389           bs <- M.basicUnsafeNew n_
2390           cs <- M.basicUnsafeNew n_
2391           ds <- M.basicUnsafeNew n_
2392           es <- M.basicUnsafeNew n_
2393           fs <- M.basicUnsafeNew n_
2394           gs <- M.basicUnsafeNew n_
2395           hs <- M.basicUnsafeNew n_
2396           is <- M.basicUnsafeNew n_
2397           js <- M.basicUnsafeNew n_
2398           ks <- M.basicUnsafeNew n_
2399           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
2400   {-# INLINE basicUnsafeNewWith  #-}
2401   basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k)
2402       = do
2403           as <- M.basicUnsafeNewWith n_ a
2404           bs <- M.basicUnsafeNewWith n_ b
2405           cs <- M.basicUnsafeNewWith n_ c
2406           ds <- M.basicUnsafeNewWith n_ d
2407           es <- M.basicUnsafeNewWith n_ e
2408           fs <- M.basicUnsafeNewWith n_ f
2409           gs <- M.basicUnsafeNewWith n_ g
2410           hs <- M.basicUnsafeNewWith n_ h
2411           is <- M.basicUnsafeNewWith n_ i
2412           js <- M.basicUnsafeNewWith n_ j
2413           ks <- M.basicUnsafeNewWith n_ k
2414           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
2415   {-# INLINE basicUnsafeRead  #-}
2416   basicUnsafeRead (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_
2417       = do
2418           a <- M.basicUnsafeRead as i_
2419           b <- M.basicUnsafeRead bs i_
2420           c <- M.basicUnsafeRead cs i_
2421           d <- M.basicUnsafeRead ds i_
2422           e <- M.basicUnsafeRead es i_
2423           f <- M.basicUnsafeRead fs i_
2424           g <- M.basicUnsafeRead gs i_
2425           h <- M.basicUnsafeRead hs i_
2426           i <- M.basicUnsafeRead is i_
2427           j <- M.basicUnsafeRead js i_
2428           k <- M.basicUnsafeRead ks i_
2429           return (a, b, c, d, e, f, g, h, i, j, k)
2430   {-# INLINE basicUnsafeWrite  #-}
2431   basicUnsafeWrite (MV_11 n_ as
2432                              bs
2433                              cs
2434                              ds
2435                              es
2436                              fs
2437                              gs
2438                              hs
2439                              is
2440                              js
2441                              ks) i_ (a, b, c, d, e, f, g, h, i, j, k)
2442       = do
2443           M.basicUnsafeWrite as i_ a
2444           M.basicUnsafeWrite bs i_ b
2445           M.basicUnsafeWrite cs i_ c
2446           M.basicUnsafeWrite ds i_ d
2447           M.basicUnsafeWrite es i_ e
2448           M.basicUnsafeWrite fs i_ f
2449           M.basicUnsafeWrite gs i_ g
2450           M.basicUnsafeWrite hs i_ h
2451           M.basicUnsafeWrite is i_ i
2452           M.basicUnsafeWrite js i_ j
2453           M.basicUnsafeWrite ks i_ k
2454   {-# INLINE basicClear  #-}
2455   basicClear (MV_11 n_ as bs cs ds es fs gs hs is js ks)
2456       = do
2457           M.basicClear as
2458           M.basicClear bs
2459           M.basicClear cs
2460           M.basicClear ds
2461           M.basicClear es
2462           M.basicClear fs
2463           M.basicClear gs
2464           M.basicClear hs
2465           M.basicClear is
2466           M.basicClear js
2467           M.basicClear ks
2468   {-# INLINE basicSet  #-}
2469   basicSet (MV_11 n_ as
2470                      bs
2471                      cs
2472                      ds
2473                      es
2474                      fs
2475                      gs
2476                      hs
2477                      is
2478                      js
2479                      ks) (a, b, c, d, e, f, g, h, i, j, k)
2480       = do
2481           M.basicSet as a
2482           M.basicSet bs b
2483           M.basicSet cs c
2484           M.basicSet ds d
2485           M.basicSet es e
2486           M.basicSet fs f
2487           M.basicSet gs g
2488           M.basicSet hs h
2489           M.basicSet is i
2490           M.basicSet js j
2491           M.basicSet ks k
2492   {-# INLINE basicUnsafeCopy  #-}
2493   basicUnsafeCopy (MV_11 n_1 as1
2494                              bs1
2495                              cs1
2496                              ds1
2497                              es1
2498                              fs1
2499                              gs1
2500                              hs1
2501                              is1
2502                              js1
2503                              ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
2504       = do
2505           M.basicUnsafeCopy as1 as2
2506           M.basicUnsafeCopy bs1 bs2
2507           M.basicUnsafeCopy cs1 cs2
2508           M.basicUnsafeCopy ds1 ds2
2509           M.basicUnsafeCopy es1 es2
2510           M.basicUnsafeCopy fs1 fs2
2511           M.basicUnsafeCopy gs1 gs2
2512           M.basicUnsafeCopy hs1 hs2
2513           M.basicUnsafeCopy is1 is2
2514           M.basicUnsafeCopy js1 js2
2515           M.basicUnsafeCopy ks1 ks2
2516   {-# INLINE basicUnsafeGrow  #-}
2517   basicUnsafeGrow (MV_11 n_ as bs cs ds es fs gs hs is js ks) m_
2518       = do
2519           M.basicUnsafeGrow as m_
2520           M.basicUnsafeGrow bs m_
2521           M.basicUnsafeGrow cs m_
2522           M.basicUnsafeGrow ds m_
2523           M.basicUnsafeGrow es m_
2524           M.basicUnsafeGrow fs m_
2525           M.basicUnsafeGrow gs m_
2526           M.basicUnsafeGrow hs m_
2527           M.basicUnsafeGrow is m_
2528           M.basicUnsafeGrow js m_
2529           M.basicUnsafeGrow ks m_
2530           return $ MV_11 (m_+n_) as bs cs ds es fs gs hs is js ks
2531 instance (Unbox a,
2532           Unbox b,
2533           Unbox c,
2534           Unbox d,
2535           Unbox e,
2536           Unbox f,
2537           Unbox g,
2538           Unbox h,
2539           Unbox i,
2540           Unbox j,
2541           Unbox k) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k) where
2542   {-# INLINE unsafeFreeze  #-}
2543   unsafeFreeze (MV_11 n_ as bs cs ds es fs gs hs is js ks)
2544       = do
2545           as' <- G.unsafeFreeze as
2546           bs' <- G.unsafeFreeze bs
2547           cs' <- G.unsafeFreeze cs
2548           ds' <- G.unsafeFreeze ds
2549           es' <- G.unsafeFreeze es
2550           fs' <- G.unsafeFreeze fs
2551           gs' <- G.unsafeFreeze gs
2552           hs' <- G.unsafeFreeze hs
2553           is' <- G.unsafeFreeze is
2554           js' <- G.unsafeFreeze js
2555           ks' <- G.unsafeFreeze ks
2556           return $ V_11 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks'
2557   {-# INLINE basicLength  #-}
2558   basicLength (V_11 n_ as bs cs ds es fs gs hs is js ks) = n_
2559   {-# INLINE basicUnsafeSlice  #-}
2560   basicUnsafeSlice (V_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
2561       = V_11 m_ (G.basicUnsafeSlice as i_ m_)
2562                 (G.basicUnsafeSlice bs i_ m_)
2563                 (G.basicUnsafeSlice cs i_ m_)
2564                 (G.basicUnsafeSlice ds i_ m_)
2565                 (G.basicUnsafeSlice es i_ m_)
2566                 (G.basicUnsafeSlice fs i_ m_)
2567                 (G.basicUnsafeSlice gs i_ m_)
2568                 (G.basicUnsafeSlice hs i_ m_)
2569                 (G.basicUnsafeSlice is i_ m_)
2570                 (G.basicUnsafeSlice js i_ m_)
2571                 (G.basicUnsafeSlice ks i_ m_)
2572   {-# INLINE basicUnsafeIndexM  #-}
2573   basicUnsafeIndexM (V_11 n_ as bs cs ds es fs gs hs is js ks) i_
2574       = do
2575           a <- G.basicUnsafeIndexM as i_
2576           b <- G.basicUnsafeIndexM bs i_
2577           c <- G.basicUnsafeIndexM cs i_
2578           d <- G.basicUnsafeIndexM ds i_
2579           e <- G.basicUnsafeIndexM es i_
2580           f <- G.basicUnsafeIndexM fs i_
2581           g <- G.basicUnsafeIndexM gs i_
2582           h <- G.basicUnsafeIndexM hs i_
2583           i <- G.basicUnsafeIndexM is i_
2584           j <- G.basicUnsafeIndexM js i_
2585           k <- G.basicUnsafeIndexM ks i_
2586           return (a, b, c, d, e, f, g, h, i, j, k)
2587 #endif
2588 #ifdef DEFINE_MUTABLE
2589 zip11 :: (Unbox a,
2590           Unbox b,
2591           Unbox c,
2592           Unbox d,
2593           Unbox e,
2594           Unbox f,
2595           Unbox g,
2596           Unbox h,
2597           Unbox i,
2598           Unbox j,
2599           Unbox k) => MVector s a ->
2600                       MVector s b ->
2601                       MVector s c ->
2602                       MVector s d ->
2603                       MVector s e ->
2604                       MVector s f ->
2605                       MVector s g ->
2606                       MVector s h ->
2607                       MVector s i ->
2608                       MVector s j ->
2609                       MVector s k -> MVector s (a, b, c, d, e, f, g, h, i, j, k)
2610 {-# INLINE zip11 #-}
2611 zip11 as
2612       bs
2613       cs
2614       ds
2615       es
2616       fs
2617       gs
2618       hs
2619       is
2620       js
2621       ks = MV_11 len (unsafeSlice as 0 len)
2622                      (unsafeSlice bs 0 len)
2623                      (unsafeSlice cs 0 len)
2624                      (unsafeSlice ds 0 len)
2625                      (unsafeSlice es 0 len)
2626                      (unsafeSlice fs 0 len)
2627                      (unsafeSlice gs 0 len)
2628                      (unsafeSlice hs 0 len)
2629                      (unsafeSlice is 0 len)
2630                      (unsafeSlice js 0 len)
2631                      (unsafeSlice ks 0 len)
2632   where
2633     len = length as `min`
2634           length bs `min`
2635           length cs `min`
2636           length ds `min`
2637           length es `min`
2638           length fs `min`
2639           length gs `min`
2640           length hs `min`
2641           length is `min`
2642           length js `min`
2643           length ks
2644 unzip11 :: (Unbox a,
2645             Unbox b,
2646             Unbox c,
2647             Unbox d,
2648             Unbox e,
2649             Unbox f,
2650             Unbox g,
2651             Unbox h,
2652             Unbox i,
2653             Unbox j,
2654             Unbox k) => MVector s (a, b, c, d, e, f, g, h, i, j, k) -> (MVector s a,
2655                                                                         MVector s b,
2656                                                                         MVector s c,
2657                                                                         MVector s d,
2658                                                                         MVector s e,
2659                                                                         MVector s f,
2660                                                                         MVector s g,
2661                                                                         MVector s h,
2662                                                                         MVector s i,
2663                                                                         MVector s j,
2664                                                                         MVector s k)
2665 {-# INLINE unzip11 #-}
2666 unzip11 (MV_11 n_ as bs cs ds es fs gs hs is js ks) = (as,
2667                                                        bs,
2668                                                        cs,
2669                                                        ds,
2670                                                        es,
2671                                                        fs,
2672                                                        gs,
2673                                                        hs,
2674                                                        is,
2675                                                        js,
2676                                                        ks)
2677 #endif
2678 #ifdef DEFINE_IMMUTABLE
2679 zip11 :: (Unbox a,
2680           Unbox b,
2681           Unbox c,
2682           Unbox d,
2683           Unbox e,
2684           Unbox f,
2685           Unbox g,
2686           Unbox h,
2687           Unbox i,
2688           Unbox j,
2689           Unbox k) => Vector a ->
2690                       Vector b ->
2691                       Vector c ->
2692                       Vector d ->
2693                       Vector e ->
2694                       Vector f ->
2695                       Vector g ->
2696                       Vector h ->
2697                       Vector i ->
2698                       Vector j ->
2699                       Vector k -> Vector (a, b, c, d, e, f, g, h, i, j, k)
2700 {-# INLINE zip11 #-}
2701 zip11 as
2702       bs
2703       cs
2704       ds
2705       es
2706       fs
2707       gs
2708       hs
2709       is
2710       js
2711       ks = V_11 len (unsafeSlice as 0 len)
2712                     (unsafeSlice bs 0 len)
2713                     (unsafeSlice cs 0 len)
2714                     (unsafeSlice ds 0 len)
2715                     (unsafeSlice es 0 len)
2716                     (unsafeSlice fs 0 len)
2717                     (unsafeSlice gs 0 len)
2718                     (unsafeSlice hs 0 len)
2719                     (unsafeSlice is 0 len)
2720                     (unsafeSlice js 0 len)
2721                     (unsafeSlice ks 0 len)
2722   where
2723     len = length as `min`
2724           length bs `min`
2725           length cs `min`
2726           length ds `min`
2727           length es `min`
2728           length fs `min`
2729           length gs `min`
2730           length hs `min`
2731           length is `min`
2732           length js `min`
2733           length ks
2734 unzip11 :: (Unbox a,
2735             Unbox b,
2736             Unbox c,
2737             Unbox d,
2738             Unbox e,
2739             Unbox f,
2740             Unbox g,
2741             Unbox h,
2742             Unbox i,
2743             Unbox j,
2744             Unbox k) => Vector (a, b, c, d, e, f, g, h, i, j, k) -> (Vector a,
2745                                                                      Vector b,
2746                                                                      Vector c,
2747                                                                      Vector d,
2748                                                                      Vector e,
2749                                                                      Vector f,
2750                                                                      Vector g,
2751                                                                      Vector h,
2752                                                                      Vector i,
2753                                                                      Vector j,
2754                                                                      Vector k)
2755 {-# INLINE unzip11 #-}
2756 unzip11 (V_11 n_ as bs cs ds es fs gs hs is js ks) = (as,
2757                                                       bs,
2758                                                       cs,
2759                                                       ds,
2760                                                       es,
2761                                                       fs,
2762                                                       gs,
2763                                                       hs,
2764                                                       is,
2765                                                       js,
2766                                                       ks)
2767 #endif
2768 #ifdef DEFINE_INSTANCES
2769 data instance MVector s (a, b, c, d, e, f, g, h, i, j, k, l)
2770     = MV_12 {-# UNPACK #-} !Int (MVector s a)
2771                                 (MVector s b)
2772                                 (MVector s c)
2773                                 (MVector s d)
2774                                 (MVector s e)
2775                                 (MVector s f)
2776                                 (MVector s g)
2777                                 (MVector s h)
2778                                 (MVector s i)
2779                                 (MVector s j)
2780                                 (MVector s k)
2781                                 (MVector s l)
2782 data instance Vector (a, b, c, d, e, f, g, h, i, j, k, l)
2783     = V_12 {-# UNPACK #-} !Int (Vector a)
2784                                (Vector b)
2785                                (Vector c)
2786                                (Vector d)
2787                                (Vector e)
2788                                (Vector f)
2789                                (Vector g)
2790                                (Vector h)
2791                                (Vector i)
2792                                (Vector j)
2793                                (Vector k)
2794                                (Vector l)
2795 instance (Unbox a,
2796           Unbox b,
2797           Unbox c,
2798           Unbox d,
2799           Unbox e,
2800           Unbox f,
2801           Unbox g,
2802           Unbox h,
2803           Unbox i,
2804           Unbox j,
2805           Unbox k,
2806           Unbox l) => Unbox (a, b, c, d, e, f, g, h, i, j, k, l)
2807 instance (Unbox a,
2808           Unbox b,
2809           Unbox c,
2810           Unbox d,
2811           Unbox e,
2812           Unbox f,
2813           Unbox g,
2814           Unbox h,
2815           Unbox i,
2816           Unbox j,
2817           Unbox k,
2818           Unbox l) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k, l) where
2819   {-# INLINE basicLength  #-}
2820   basicLength (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
2821   {-# INLINE basicUnsafeSlice  #-}
2822   basicUnsafeSlice (MV_12 n_ as
2823                              bs
2824                              cs
2825                              ds
2826                              es
2827                              fs
2828                              gs
2829                              hs
2830                              is
2831                              js
2832                              ks
2833                              ls) i_ m_
2834       = MV_12 m_ (M.basicUnsafeSlice as i_ m_)
2835                  (M.basicUnsafeSlice bs i_ m_)
2836                  (M.basicUnsafeSlice cs i_ m_)
2837                  (M.basicUnsafeSlice ds i_ m_)
2838                  (M.basicUnsafeSlice es i_ m_)
2839                  (M.basicUnsafeSlice fs i_ m_)
2840                  (M.basicUnsafeSlice gs i_ m_)
2841                  (M.basicUnsafeSlice hs i_ m_)
2842                  (M.basicUnsafeSlice is i_ m_)
2843                  (M.basicUnsafeSlice js i_ m_)
2844                  (M.basicUnsafeSlice ks i_ m_)
2845                  (M.basicUnsafeSlice ls i_ m_)
2846   {-# INLINE basicOverlaps  #-}
2847   basicOverlaps (MV_12 n_1 as1
2848                            bs1
2849                            cs1
2850                            ds1
2851                            es1
2852                            fs1
2853                            gs1
2854                            hs1
2855                            is1
2856                            js1
2857                            ks1
2858                            ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
2859       = M.basicOverlaps as1 as2
2860         || M.basicOverlaps bs1 bs2
2861         || M.basicOverlaps cs1 cs2
2862         || M.basicOverlaps ds1 ds2
2863         || M.basicOverlaps es1 es2
2864         || M.basicOverlaps fs1 fs2
2865         || M.basicOverlaps gs1 gs2
2866         || M.basicOverlaps hs1 hs2
2867         || M.basicOverlaps is1 is2
2868         || M.basicOverlaps js1 js2
2869         || M.basicOverlaps ks1 ks2
2870         || M.basicOverlaps ls1 ls2
2871   {-# INLINE basicUnsafeNew  #-}
2872   basicUnsafeNew n_
2873       = do
2874           as <- M.basicUnsafeNew n_
2875           bs <- M.basicUnsafeNew n_
2876           cs <- M.basicUnsafeNew n_
2877           ds <- M.basicUnsafeNew n_
2878           es <- M.basicUnsafeNew n_
2879           fs <- M.basicUnsafeNew n_
2880           gs <- M.basicUnsafeNew n_
2881           hs <- M.basicUnsafeNew n_
2882           is <- M.basicUnsafeNew n_
2883           js <- M.basicUnsafeNew n_
2884           ks <- M.basicUnsafeNew n_
2885           ls <- M.basicUnsafeNew n_
2886           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
2887   {-# INLINE basicUnsafeNewWith  #-}
2888   basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k, l)
2889       = do
2890           as <- M.basicUnsafeNewWith n_ a
2891           bs <- M.basicUnsafeNewWith n_ b
2892           cs <- M.basicUnsafeNewWith n_ c
2893           ds <- M.basicUnsafeNewWith n_ d
2894           es <- M.basicUnsafeNewWith n_ e
2895           fs <- M.basicUnsafeNewWith n_ f
2896           gs <- M.basicUnsafeNewWith n_ g
2897           hs <- M.basicUnsafeNewWith n_ h
2898           is <- M.basicUnsafeNewWith n_ i
2899           js <- M.basicUnsafeNewWith n_ j
2900           ks <- M.basicUnsafeNewWith n_ k
2901           ls <- M.basicUnsafeNewWith n_ l
2902           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
2903   {-# INLINE basicUnsafeRead  #-}
2904   basicUnsafeRead (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
2905       = do
2906           a <- M.basicUnsafeRead as i_
2907           b <- M.basicUnsafeRead bs i_
2908           c <- M.basicUnsafeRead cs i_
2909           d <- M.basicUnsafeRead ds i_
2910           e <- M.basicUnsafeRead es i_
2911           f <- M.basicUnsafeRead fs i_
2912           g <- M.basicUnsafeRead gs i_
2913           h <- M.basicUnsafeRead hs i_
2914           i <- M.basicUnsafeRead is i_
2915           j <- M.basicUnsafeRead js i_
2916           k <- M.basicUnsafeRead ks i_
2917           l <- M.basicUnsafeRead ls i_
2918           return (a, b, c, d, e, f, g, h, i, j, k, l)
2919   {-# INLINE basicUnsafeWrite  #-}
2920   basicUnsafeWrite (MV_12 n_ as
2921                              bs
2922                              cs
2923                              ds
2924                              es
2925                              fs
2926                              gs
2927                              hs
2928                              is
2929                              js
2930                              ks
2931                              ls) i_ (a, b, c, d, e, f, g, h, i, j, k, l)
2932       = do
2933           M.basicUnsafeWrite as i_ a
2934           M.basicUnsafeWrite bs i_ b
2935           M.basicUnsafeWrite cs i_ c
2936           M.basicUnsafeWrite ds i_ d
2937           M.basicUnsafeWrite es i_ e
2938           M.basicUnsafeWrite fs i_ f
2939           M.basicUnsafeWrite gs i_ g
2940           M.basicUnsafeWrite hs i_ h
2941           M.basicUnsafeWrite is i_ i
2942           M.basicUnsafeWrite js i_ j
2943           M.basicUnsafeWrite ks i_ k
2944           M.basicUnsafeWrite ls i_ l
2945   {-# INLINE basicClear  #-}
2946   basicClear (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
2947       = do
2948           M.basicClear as
2949           M.basicClear bs
2950           M.basicClear cs
2951           M.basicClear ds
2952           M.basicClear es
2953           M.basicClear fs
2954           M.basicClear gs
2955           M.basicClear hs
2956           M.basicClear is
2957           M.basicClear js
2958           M.basicClear ks
2959           M.basicClear ls
2960   {-# INLINE basicSet  #-}
2961   basicSet (MV_12 n_ as
2962                      bs
2963                      cs
2964                      ds
2965                      es
2966                      fs
2967                      gs
2968                      hs
2969                      is
2970                      js
2971                      ks
2972                      ls) (a, b, c, d, e, f, g, h, i, j, k, l)
2973       = do
2974           M.basicSet as a
2975           M.basicSet bs b
2976           M.basicSet cs c
2977           M.basicSet ds d
2978           M.basicSet es e
2979           M.basicSet fs f
2980           M.basicSet gs g
2981           M.basicSet hs h
2982           M.basicSet is i
2983           M.basicSet js j
2984           M.basicSet ks k
2985           M.basicSet ls l
2986   {-# INLINE basicUnsafeCopy  #-}
2987   basicUnsafeCopy (MV_12 n_1 as1
2988                              bs1
2989                              cs1
2990                              ds1
2991                              es1
2992                              fs1
2993                              gs1
2994                              hs1
2995                              is1
2996                              js1
2997                              ks1
2998                              ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
2999       = do
3000           M.basicUnsafeCopy as1 as2
3001           M.basicUnsafeCopy bs1 bs2
3002           M.basicUnsafeCopy cs1 cs2
3003           M.basicUnsafeCopy ds1 ds2
3004           M.basicUnsafeCopy es1 es2
3005           M.basicUnsafeCopy fs1 fs2
3006           M.basicUnsafeCopy gs1 gs2
3007           M.basicUnsafeCopy hs1 hs2
3008           M.basicUnsafeCopy is1 is2
3009           M.basicUnsafeCopy js1 js2
3010           M.basicUnsafeCopy ks1 ks2
3011           M.basicUnsafeCopy ls1 ls2
3012   {-# INLINE basicUnsafeGrow  #-}
3013   basicUnsafeGrow (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) m_
3014       = do
3015           M.basicUnsafeGrow as m_
3016           M.basicUnsafeGrow bs m_
3017           M.basicUnsafeGrow cs m_
3018           M.basicUnsafeGrow ds m_
3019           M.basicUnsafeGrow es m_
3020           M.basicUnsafeGrow fs m_
3021           M.basicUnsafeGrow gs m_
3022           M.basicUnsafeGrow hs m_
3023           M.basicUnsafeGrow is m_
3024           M.basicUnsafeGrow js m_
3025           M.basicUnsafeGrow ks m_
3026           M.basicUnsafeGrow ls m_
3027           return $ MV_12 (m_+n_) as bs cs ds es fs gs hs is js ks ls
3028 instance (Unbox a,
3029           Unbox b,
3030           Unbox c,
3031           Unbox d,
3032           Unbox e,
3033           Unbox f,
3034           Unbox g,
3035           Unbox h,
3036           Unbox i,
3037           Unbox j,
3038           Unbox k,
3039           Unbox l) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k, l) where
3040   {-# INLINE unsafeFreeze  #-}
3041   unsafeFreeze (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
3042       = do
3043           as' <- G.unsafeFreeze as
3044           bs' <- G.unsafeFreeze bs
3045           cs' <- G.unsafeFreeze cs
3046           ds' <- G.unsafeFreeze ds
3047           es' <- G.unsafeFreeze es
3048           fs' <- G.unsafeFreeze fs
3049           gs' <- G.unsafeFreeze gs
3050           hs' <- G.unsafeFreeze hs
3051           is' <- G.unsafeFreeze is
3052           js' <- G.unsafeFreeze js
3053           ks' <- G.unsafeFreeze ks
3054           ls' <- G.unsafeFreeze ls
3055           return $ V_12 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks' ls'
3056   {-# INLINE basicLength  #-}
3057   basicLength (V_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
3058   {-# INLINE basicUnsafeSlice  #-}
3059   basicUnsafeSlice (V_12 n_ as
3060                             bs
3061                             cs
3062                             ds
3063                             es
3064                             fs
3065                             gs
3066                             hs
3067                             is
3068                             js
3069                             ks
3070                             ls) i_ m_
3071       = V_12 m_ (G.basicUnsafeSlice as i_ m_)
3072                 (G.basicUnsafeSlice bs i_ m_)
3073                 (G.basicUnsafeSlice cs i_ m_)
3074                 (G.basicUnsafeSlice ds i_ m_)
3075                 (G.basicUnsafeSlice es i_ m_)
3076                 (G.basicUnsafeSlice fs i_ m_)
3077                 (G.basicUnsafeSlice gs i_ m_)
3078                 (G.basicUnsafeSlice hs i_ m_)
3079                 (G.basicUnsafeSlice is i_ m_)
3080                 (G.basicUnsafeSlice js i_ m_)
3081                 (G.basicUnsafeSlice ks i_ m_)
3082                 (G.basicUnsafeSlice ls i_ m_)
3083   {-# INLINE basicUnsafeIndexM  #-}
3084   basicUnsafeIndexM (V_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
3085       = do
3086           a <- G.basicUnsafeIndexM as i_
3087           b <- G.basicUnsafeIndexM bs i_
3088           c <- G.basicUnsafeIndexM cs i_
3089           d <- G.basicUnsafeIndexM ds i_
3090           e <- G.basicUnsafeIndexM es i_
3091           f <- G.basicUnsafeIndexM fs i_
3092           g <- G.basicUnsafeIndexM gs i_
3093           h <- G.basicUnsafeIndexM hs i_
3094           i <- G.basicUnsafeIndexM is i_
3095           j <- G.basicUnsafeIndexM js i_
3096           k <- G.basicUnsafeIndexM ks i_
3097           l <- G.basicUnsafeIndexM ls i_
3098           return (a, b, c, d, e, f, g, h, i, j, k, l)
3099 #endif
3100 #ifdef DEFINE_MUTABLE
3101 zip12 :: (Unbox a,
3102           Unbox b,
3103           Unbox c,
3104           Unbox d,
3105           Unbox e,
3106           Unbox f,
3107           Unbox g,
3108           Unbox h,
3109           Unbox i,
3110           Unbox j,
3111           Unbox k,
3112           Unbox l) => MVector s a ->
3113                       MVector s b ->
3114                       MVector s c ->
3115                       MVector s d ->
3116                       MVector s e ->
3117                       MVector s f ->
3118                       MVector s g ->
3119                       MVector s h ->
3120                       MVector s i ->
3121                       MVector s j ->
3122                       MVector s k ->
3123                       MVector s l -> MVector s (a, b, c, d, e, f, g, h, i, j, k, l)
3124 {-# INLINE zip12 #-}
3125 zip12 as
3126       bs
3127       cs
3128       ds
3129       es
3130       fs
3131       gs
3132       hs
3133       is
3134       js
3135       ks
3136       ls = MV_12 len (unsafeSlice as 0 len)
3137                      (unsafeSlice bs 0 len)
3138                      (unsafeSlice cs 0 len)
3139                      (unsafeSlice ds 0 len)
3140                      (unsafeSlice es 0 len)
3141                      (unsafeSlice fs 0 len)
3142                      (unsafeSlice gs 0 len)
3143                      (unsafeSlice hs 0 len)
3144                      (unsafeSlice is 0 len)
3145                      (unsafeSlice js 0 len)
3146                      (unsafeSlice ks 0 len)
3147                      (unsafeSlice ls 0 len)
3148   where
3149     len = length as `min`
3150           length bs `min`
3151           length cs `min`
3152           length ds `min`
3153           length es `min`
3154           length fs `min`
3155           length gs `min`
3156           length hs `min`
3157           length is `min`
3158           length js `min`
3159           length ks `min`
3160           length ls
3161 unzip12 :: (Unbox a,
3162             Unbox b,
3163             Unbox c,
3164             Unbox d,
3165             Unbox e,
3166             Unbox f,
3167             Unbox g,
3168             Unbox h,
3169             Unbox i,
3170             Unbox j,
3171             Unbox k,
3172             Unbox l) => MVector s (a, b, c, d, e, f, g, h, i, j, k, l) -> (MVector s a,
3173                                                                            MVector s b,
3174                                                                            MVector s c,
3175                                                                            MVector s d,
3176                                                                            MVector s e,
3177                                                                            MVector s f,
3178                                                                            MVector s g,
3179                                                                            MVector s h,
3180                                                                            MVector s i,
3181                                                                            MVector s j,
3182                                                                            MVector s k,
3183                                                                            MVector s l)
3184 {-# INLINE unzip12 #-}
3185 unzip12 (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = (as,
3186                                                           bs,
3187                                                           cs,
3188                                                           ds,
3189                                                           es,
3190                                                           fs,
3191                                                           gs,
3192                                                           hs,
3193                                                           is,
3194                                                           js,
3195                                                           ks,
3196                                                           ls)
3197 #endif
3198 #ifdef DEFINE_IMMUTABLE
3199 zip12 :: (Unbox a,
3200           Unbox b,
3201           Unbox c,
3202           Unbox d,
3203           Unbox e,
3204           Unbox f,
3205           Unbox g,
3206           Unbox h,
3207           Unbox i,
3208           Unbox j,
3209           Unbox k,
3210           Unbox l) => Vector a ->
3211                       Vector b ->
3212                       Vector c ->
3213                       Vector d ->
3214                       Vector e ->
3215                       Vector f ->
3216                       Vector g ->
3217                       Vector h ->
3218                       Vector i ->
3219                       Vector j ->
3220                       Vector k ->
3221                       Vector l -> Vector (a, b, c, d, e, f, g, h, i, j, k, l)
3222 {-# INLINE zip12 #-}
3223 zip12 as
3224       bs
3225       cs
3226       ds
3227       es
3228       fs
3229       gs
3230       hs
3231       is
3232       js
3233       ks
3234       ls = V_12 len (unsafeSlice as 0 len)
3235                     (unsafeSlice bs 0 len)
3236                     (unsafeSlice cs 0 len)
3237                     (unsafeSlice ds 0 len)
3238                     (unsafeSlice es 0 len)
3239                     (unsafeSlice fs 0 len)
3240                     (unsafeSlice gs 0 len)
3241                     (unsafeSlice hs 0 len)
3242                     (unsafeSlice is 0 len)
3243                     (unsafeSlice js 0 len)
3244                     (unsafeSlice ks 0 len)
3245                     (unsafeSlice ls 0 len)
3246   where
3247     len = length as `min`