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