xlc

#include <iostream>
#include <typeinfo>
#include <type_traits>
#include <functional>
#include <tuple>

using namespace std;

int TestCount = 0;

xlc

struct Point3D {
    var x: Int
    var y: Int
    var z: Int
}

protocol Point3DGenerator {
    mutating func next() -> Point3D
}

xlc

import Cocoa

class A : NSObject {
    
    init() { }
    
}

class B : A {

xlc

class Wrapper<T> {
    let _val: T[]
    
    init(_ v: T) {
        _val = [v]
    }
    
    func __conversion() -> T {
        return _val[0]
    }

xlc

#include <cassert>
#include <deque>
#include <functional>
#include <algorithm>
#include <memory>

template <class TArg, class TFriend = void>
class Event {
    friend TFriend;

xlc

#import "AppDelegate.h"

#import <objc/runtime.h>
#import <objc/message.h>

@interface Test : NSObject


@end

xlc

#include <vector>
#include <iostream>
#include <utility>
#include <functional>
#include <type_traits>
#include <memory>

namespace xlc
{
    template <class TIterator, class TSelectFunc>

xlc

func someCondition(_: Int) -> Bool {
    return true
}

func foo() {
    func loop(_ index: Int) {
        if (index < 100) {
            if someCondition(index) {
                return loop(index + 3)
            } else {

xlc

Keybase proof

I hereby claim:

• I am xlc on github.
• I am bryan_chen (https://keybase.io/bryan_chen) on keybase.
• I have a public key ASAbgVm-oIEZQcWvGB7nOL-wwFoe-jSG3LcGJj7JGY8pRgo

To claim this, I am signing this object:

xlc

const mh = require('multihashes')
const crypto = require('libp2p-crypto')
const secp256k1factory = require('libp2p-crypto-secp256k1')
const { Secp256k1PrivateKey } = secp256k1factory(crypto.keys.keysPBM, crypto.randomBytes)

const input = '0000000000000000000000000000000000000000000000000000000000000001'

const key = Buffer.from(input, 'hex')

 const sk = new Secp256k1PrivateKey(key)