.reg .pred p; // declare p a predicate register.
setp.lt.s32 p, i, n; // p = (i < n)
@p add.s32 i, i, 1; // i++
	    

.reg .pred p; // declare p a predicate register.
setp.lt.s32 p, i, n; // p = (i < n)
@p add.s32 i, i, 1; // if (p) i++
@!p add.s32 n, n, 1; // if (!p) n++
	    

async function loadStuff() {
    let someFirstThing = await loadThatFirstThing();
}
	    

async fn loadStuff() {
    let someFirstThing = await loadThatFirstThing();
    let someOtherThing = await loadThatOtherThing();
}
	    

#include <atomic>

template<class T>
class Locked{
public:
    Locked(T t): locked_(t), mutex_(false) {}
    T& ExclusivelyAccess() {
        bool f = false;
        while(!mutex_.compare_exchange_strong(f, true));
        return locked_;
    }
    void EndExclusiveAccess() {
        mutex_ = false;	
    }
    bool IsHeld() { return !mutex_; }
private:
    std::atomic<bool> mutex_;
    T locked_;
};
	    

;suppose %rdi is the address of white_base[0][0], %rbx = amuro, and %rcx = ray
movq %rdx, (%rdi, %rbx, 8)
mov %al, (%rdx, %rcx)
;now aznable is in %al
            

;suppose %rdi is the address of white_base[0][0], %rbx = amuro, and %rcx = ray
mult %rbx, %rbx, 8
add %rdi, %rdi, %rbx
load %rdx, %rdi
add %rdx, %rcx
load %al, %rdx
;now aznable is in %al
            

#define CACHE_LINE_SIZE 1024
char probe[CACHE_LINE_SIZE * 256];	      
char should_not_be_accessed = *pointer_into_kernel_memory;
char* for_cache = &probe[should_not_be_accessed * CACHE_LINE_SIZE];
            

COPY some-procedure IN some-library REPLACING ==:TAG:== BY ==some-example==
	    

public class Point3D {
  private int x, y, z;

  Point3D(int x, int y, int z) {
    this.x = x;
    this.y = y;
    this.z = z;
  }

  //Drumroll please...
  public int getX(){ return x; }
  public void setX(int x){ this.x = x; }
  public int getY(){ return y; }
  public void setY(int y){ this.y = y; }
  public int getZ(){ return z; }
  public void setZ(int z){ this.z = z; }
}
	    

#define SQUARE(x) x*x

double vecNorm2D(Vec2D* v) {
  return sqrt(SQUARE(v->x) + SQUARE(v->y));
}
	    

{-# LANGUAGE DataKinds, KindSignatures, GADTs,
  TypeFamilies, PolyKinds #-}
-- DataKinds lets us define our own kinds (types of types)
-- KindSignatures allows the * -> * sort of notation,
-- TypeFamilies let us express functions on our kinds,
-- PolyKinds lets us express functions about our kinds,
-- and GADTs adds... well, GADTs.

-- A kind for natural numbers. ZNat is 0, SNat is the next one.
data Nat :: * where
  ZNat :: Nat
  SNat :: Nat -> Nat

-- A fixed length vector. 
-- This takes the length as the second parameter.
-- The property of Cons producing a vector one longer is key.
data FixedVec :: * -> Nat -> * where
  Empty :: FixedVec a ZNat
  Cons :: a -> FixedVec a n -> FixedVec a (SNat n)
	      

-- Small complaint: it was hard to find the right syntax.
type family Plus (x :: Nat) (y :: Nat) :: Nat
type instance Plus ZNat     m = m
type instance Plus (SNat n) m = SNat (Plus n m)

-- GHC just figures this out.
fconcat :: FixedVec a n -> FixedVec a m -> FixedVec a (Plus n m)
fconcat Empty       ys = ys
fconcat (Cons x xs) ys = Cons x $ fconcat xs ys
	      

-- Brings in the :~: type-level equality
import Data.Type.Equality
		
-- Brings the Nat kind into the type universe.
data ReifyNat (n :: Nat) where
  Zeify :: ReifyNat ZNat
  Seify :: ReifyNat n -> ReifyNat (SNat n)

-- Brings the vector lenghts into the type universe.
reifyVecLen :: FixedVec a n -> ReifyNat n
reifyVecLen Empty       = Zeify
reifyVecLen (Cons _ xs) = Seify $ reifyVecLen xs

-- The proof of 1 + (x + y) = x + (y + 1).
-- Base case: 1 + (0 + 0) = 0 + (0 + 1)
sumSuccRight :: ReifyNat x -> ReifyNat y
  -> (SNat (Plus x y)) :~: (Plus x (SNat y))
sumSuccRight Zeify     Zeify     = Refl
sumSuccRight (Seify n) Zeify     = apply Refl
  $ sumSuccRight n Zeify
sumSuccRight Zeify     (Seify n) = apply Refl
  $ sumSuccRight Zeify n
sumSuccRight (Seify m) (Seify n) = apply Refl
  $ sumSuccRight m (Seify n)

-- GHC needs that (1 + (x + y)) = (x + (y + 1)).
-- You'll note that that's not how we defined +.
fdup :: FixedVec a n -> FixedVec a (Plus n n)
fdup Empty       = Empty
fdup (Cons x xs) = case
  sumSuccRight (reifyVecLen xs) (reifyVecLen xs) of
    Refl -> Cons x (Cons x (fdup xs))
	      

Hyena ed;
if (be_prepared()) {
  ed = banzai;
} else {
  ed = shenzi;
}
	    

#include <atomic>

template <class T>
class Locked {
 public:
  class HeldValue {
   public:
    HeldValue(T* h, std::atomic<bool>* m) {
      bool f = false;
      while (!m->compare_exchange_strong(f, true));
      held_ = h;
      mutex_ = m;
    }

    // For more on this, see below
    HeldValue(HeldValue&& other)
        : held_(std::exchange(other.held_, nullptr)),
          mutex_(std::exchange(other.mutex_, nullptr)) {}
    HeldValue operator=(HeldValue&& rhs) {
      if (this != &rhs) {
        held_ = std::exchange(rhs.held_, nullptr);
        mutex_ = std::exchange(rhs.mutex_, nullptr);
      }
      return std::move(*this);
    }

    T& operator*() { return *held_; }
    T* operator->() { return held_; }
    ~HeldValue() { *mutex_ = false; }

   private:
    T* held_;
    std::atomic<bool>* mutex_;

    // We will only move and construct with 2 params.
    HeldValue operator=(const HeldValue& rhs) = delete;
    HeldValue(const HeldValue& h) = delete;
    HeldValue() = delete;
  };

  Locked(T t) : locked_(t), mutex_(false) {}
  HeldValue Lock() { return HeldValue(&locked_, &mutex_); }
  bool IsHeld() { return !mutex_; }

 private:
  std::atomic<bool> mutex_;
  T locked_;
};

void useLockedThingy(Locked<int>* p) {
  Locked<int>::HeldValue grabbed = p->Lock();
  (*grabbed)++;
}
	    

useLockedThingy(Locked<int>*):
        mov     BYTE PTR [rsp-1], 0
        mov     edx, 1
.L3:
        movzx   eax, BYTE PTR [rsp-1]
        lock cmpxchg BYTE PTR [rdi], dl
        je      .L4
        mov     BYTE PTR [rsp-1], al
        jmp     .L3
.L4:
        add     DWORD PTR [rdi+4], 1
        xor     eax, eax
        xchg    al, BYTE PTR [rdi]
        ret
	    

struct Basic {
  int x;

  // constructors, 
  Basic() { x = 0; }
  Basic(int x_) : x(x_) {}
  Basic(const Basic& other) { x = other.x; }
  Basic(Basic&& other) { x = other.x; }

  // assignment operators, 
  Basic operator=(const Basic& other) {
    x = other.x;
    return *this;
  }
  Basic operator=(Basic&& other) {
    x = other.x;
    return *this;
  }

  // and a destructor.
  ~Basic() {}
};
	    

#include <string>

class Slide {
public:
  virtual std::string GetText() = 0;
  virtual ~Slide();
};

class LongSlide : public Slide {
public:
  std::string GetText() override;
  int GetScrollLevel();
};
	    

#include <concepts>

template <typename F, typename RT, typename... Args>
concept Function = requires (RT r, Args... a) {
  {F{}(a...)} -> std::convertible_to<RT>;
  std::copy_constructible<F>;
};

// Technically useless, but this is what C++17 (sorta) had as its std::function
template <typename F, typename RT, typename... Args>
requires Function<F, RT, Args...>
class MyStdFunction {
public:
  MyStdFunction(F f) : f_(f) {}
  RT operator()(Args... a) {
      f_(a...);
  }
private:
  F f_;
};
	    

template <typename It>
concept IteratorForFind = requires(It i) {
  typename It::value_type;
  { *i } -> std::convertible_to<typename It::value_type>;
  { i++ } -> std::convertible_to<It>;
};
	    

#include <concepts>

template <typename F, typename RT, typename... Args>
concept Function = requires (RT r, Args... a) {
  {F{}(a...)} -> std::convertible_to<RT>;
  std::copy_constructible<F>;
};

template <typename It>
concept IteratorForFind = requires(It i) {
  typename It::value_type;
  { *i } -> std::convertible_to<typename It::value_type>;
  { i++ } -> std::convertible_to<It>;
};
	    

template <typename It, typename Comp>
requires IteratorForFind<It> && Function<Comp, bool, typename It::value_type>
It my_find_if(It begin, It end, Comp c) {
  for(; begin != end && !c(*begin); begin++);
  return begin;
}

int * find_int(int n, int* arr, int key) {
    return my_find_if(arr, arr + n, [key](int i) { return i == key;});
}
	    

#include <concepts>

template <typename F, typename RT, typename... Args>
concept Function = requires (RT r, Args... a) {
  {F{}(a...)} -> std::convertible_to<RT>;
  std::copy_constructible<F>;
};

template <typename It, typename T>
concept IteratorForFind = requires(It i) {
  { *i } -> std::convertible_to<T>;
  { i++ } -> std::convertible_to<It>;
  std::equality_comparable_with<It, It>;
};

template <typename T, typename It, typename Comp>
requires IteratorForFind<It, T> && Function<Comp, bool, T>
It my_find_if(It begin, It end, Comp c) {
  for(; begin != end && !c(*begin); begin++);
  return begin;
}

int * find_int(int n, int* arr, int key) {
    return my_find_if<int>(arr, arr + n, [key](int i) { return i == key;});
}
	    

#include <concepts>
#include <iterator>

template <std::forward_iterator It, typename Comp>
requires std::predicate<Comp, typename std::iterator_traits<It>::value_type>
It my_find_if(It begin, It end, Comp c) {
  for (; begin != end && !c(*begin); begin++);
  return begin;
}

int* find_int(int n, int* arr, int key) {
  return my_find_if(arr, arr + n, [key](int i) { return i == key; });
}