Split this tuple into two tuples of degree 2 and 4.
15417
public final Tuple2<Tuple2<T1, T2>, Tuple4<T3, T4, T5, T6>> split2() {
        return new Tuple2<>(limit2(), skip2());
    }
556165
public final Tuple4<T10, T11, T12, T13> skip9() {
        return new Tuple4<>(v10, v11, v12, v13);
    }
119183
public final Tuple2<Tuple0, Tuple4<T1, T2, T3, T4>> split0() {
        return new Tuple2<>(limit0(), skip0());
    }
774074
def _divide(self, x1, x2, out):
        """"""
        self.tspace._divide(x1.tensor, x2.tensor, out.tensor)
1363093
public final Tuple2<Tuple3<T1, T2, T3>, Tuple9<T4, T5, T6, T7, T8, T9, T10, T11, T12>> split3() {
        return new Tuple2<>(limit3(), skip3());
    }
297680
public final <U3> Tuple4<T1, T2, U3, T4> map3(Function<? super T3, ? extends U3> function) {
        return Tuple.tuple(v1, v2, function.apply(v3), v4);
    }
246757
public final Tuple4<T13, T14, T15, T16> skip12() {
        return new Tuple4<>(v13, v14, v15, v16);
    }
1174107
public final Tuple2<Tuple2<T1, T2>, Tuple10<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> split2() {
        return new Tuple2<>(limit2(), skip2());
    }
1060723
def split(self):
        
        # Sets temp_k1, temp_k2 = HKDF(ck, b'', 2).
        temp_k1, temp_k2 = self.noise_protocol.hkdf(self.ck, b'', 2)

        # If HASHLEN is 64, then truncates temp_k1 and temp_k2 to 32 bytes.
        if self.noise_protocol.hash_fn.hashlen == 64:
            temp_k1 = temp_k1[:32]
            temp_k2 = temp_k2[:32]

        # Creates two new CipherState objects c1 and c2.
        # Calls c1.InitializeKey(temp_k1) and c2.InitializeKey(temp_k2).
        c1, c2 = CipherState(self.noise_protocol), CipherState(self.noise_protocol)
        c1.initialize_key(temp_k1)
        c2.initialize_key(temp_k2)
        if self.noise_protocol.handshake_state.initiator:
            self.noise_protocol.cipher_state_encrypt = c1
            self.noise_protocol.cipher_state_decrypt = c2
        else:
            self.noise_protocol.cipher_state_encrypt = c2
            self.noise_protocol.cipher_state_decrypt = c1

        self.noise_protocol.handshake_done()

        # Returns the pair (c1, c2).
        return c1, c2
1324057
public final <U2> Tuple4<T1, U2, T3, T4> map2(Function<? super T2, ? extends U2> function) {
        return Tuple.tuple(v1, function.apply(v2), v3, v4);
    }
1097821
public final <T2, T3> Tuple3<T1, T2, T3> concat(Tuple2<T2, T3> tuple) {
        return new Tuple3<>(v1, tuple.v1, tuple.v2);
    }
856447
public Tuple2<A, S> run(S s) {
        return stateFn.apply(s).into(HList::tuple);
    }
810812
def squash(self, a, b):
        

        return ((''.join(x) if isinstance(x, tuple) else x) for x in itertools.product(a, b))
231945
public final static <T> Tuple2<Stream<T>, Stream<T>> partition(final Stream<T> stream, final Predicate<? super T> splitter) {
        final Tuple2<Stream<T>, Stream<T>> Tuple2 = duplicate(stream);
        return Tuple.tuple(
                          Tuple2._1().filter(splitter), Tuple2._2().filter(splitter.negate()));
    }
348359
def sub(v1, v2):
    '''
    '''
    return tuple(a - b for a, b in zip(v1, v2))
487371
public final Tuple2<Tuple6<T1, T2, T3, T4, T5, T6>, Tuple6<T7, T8, T9, T10, T11, T12>> split6() {
        return new Tuple2<>(limit6(), skip6());
    }
1206245
public final Tuple4<T5, T6, T7, T8> skip4() {
        return new Tuple4<>(v5, v6, v7, v8);
    }