What's (currently) your favourite snippet of code?

template <class T>
static T& Instance(){
   static T t;
   return t;
}

_titleLabel->SetFrame([&]() -> RN::Rect {
	RN::Rect rect = _titleLabel->GetFrame();
	
	rect.x = 5.0f;
	rect.y = 5.0f;
	
	return rect;
}());

10 PRINT "A"
20 GOTO 10

RN::Rect rect = _titleLabel->GetFrame();

rect.x = 5.0f;
rect.y = 5.0f;

_titleLabel->SetFrame(rect);

// Why does rect have to still be visible here?!

static Singleton& Instance(){
       static Singleton s;
       return s;
}

class Initializer
{
public:
	typedef void (*Callback)();
	
	Initializer(Callback ctor, Callback dtor) :
		_dtor(dtor)
	{
		if(ctor) ctor();
	}
	
	~Initializer()
	{
		if(_dtor) _dtor();
	}
	
private:
	Callback _dtor;
};

#define RN_REGISTER_INITIALIZER(name, body) \
	namespace { \
		static void __RNGlobalInit##name##Callback() { body; } \
		static RN::Initializer __RNGlobalInit##name (__RNGlobalInit##name##Callback, nullptr); \
	}
#define RN_REGISTER_DESTRUCTOR(name, body) \
	namespace { \
		static void __RNGlobalDestructor##name##Callback() { body; } \
		static RN::Initializer __RNGlobalDestructor##name (nullptr, __RNGlobalDestructor##name##Callback); \
	}

my.pan = your.pan + random(360);

titleLabel.Frame = new Rect(5f, 5f);// C# style

// Does it occur on target date?
if ((this.pattern.weekdays & p.date.get.dotw(h.target)))
{
    // How many week has it been since this appointment started?
    var weeksSinceStart = p.date.get.weeksBetween(h.current, h.target);

    // Skip this week?
    if (weeksSinceStart % this.pattern.periodicity)
    {
        return null;
    }

    // How many blind occurrences are there?
    // e.g. appointment starts on a WED but the pattern is MO/_WED_/TH/SU = 1 blind (MO)
    var blind_occurrences = 0;

    // Avoid loop with clever switch
    switch ((this.pattern.weekdays & p.date.get.dotw(this.start)))
    {
        // INTENTIONAL FALL-THROUGHS!!! //                                                                                                                    
        case FLAG_SUNDAY:
            (this.pattern.weekdays & FLAG_SATURDAY) && blind_occurrences++;
        case FLAG_SATURDAY:
            (this.pattern.weekdays & FLAG_FRIDAY) && blind_occurrences++;
        case FLAG_FRIDAY:
            (this.pattern.weekdays & FLAG_THURSDAY) && blind_occurrences++;
        case FLAG_THURSDAY:
            (this.pattern.weekdays & FLAG_WEDNESDAY) && blind_occurrences++;
        case FLAG_WEDNESDAY:
            (this.pattern.weekdays & FLAG_TUESDAY) && blind_occurrences++;
        case FLAG_TUESDAY:
            (this.pattern.weekdays & FLAG_MONDAY) && blind_occurrences++;
    }

    // How often has it already occurred *this* week?
    var occurrenceIndexThisWeek = -blind_occurrences;

    // Avoid loop with clever switch
    switch ((this.pattern.weekdays & p.date.get.dotw(h.target)))
    {
        // INTENTIONAL FALL-THROUGHS!!! //                                                                                                                     
        case FLAG_SUNDAY:
            (this.pattern.weekdays & FLAG_SATURDAY) && occurrenceIndexThisWeek++;
        case FLAG_SATURDAY:
            (this.pattern.weekdays & FLAG_FRIDAY) && occurrenceIndexThisWeek++;
        case FLAG_FRIDAY:
            (this.pattern.weekdays & FLAG_THURSDAY) && occurrenceIndexThisWeek++;
        case FLAG_THURSDAY:
            (this.pattern.weekdays & FLAG_WEDNESDAY) && occurrenceIndexThisWeek++;
        case FLAG_WEDNESDAY:
            (this.pattern.weekdays & FLAG_TUESDAY) && occurrenceIndexThisWeek++;
        case FLAG_TUESDAY:
            (this.pattern.weekdays & FLAG_MONDAY) && occurrenceIndexThisWeek++;
    }

    // Set index
    var index = (weeksSinceStart * this.occurrencesPerWeek / this.pattern.periodicity) + occurrenceIndexThisWeek;

namespace RN
{
	class ScopeGuard
	{
	public:
		template<typename F>
		explicit ScopeGuard(F &&rollback) :
			_committed(false),
			_rollback(std::move(rollback))
		{}
		
		ScopeGuard(ScopeGuard &&other) :
			_committed(other._committed),
			_rollback(std::move(other._rollback))
		{}
		
		ScopeGuard &operator=(ScopeGuard &&other)
		{
			_rollback = std::move(other._rollback);
			_committed = other._committed;
			
			return *this;
		}
		
		~ScopeGuard()
		{
			if(!_committed)
				_rollback();
		}
		
		
		void Commit()
		{
			_committed = true;
		}
		
	private:
		bool _committed;
		Function _rollback;
	};
}

void foo()
{
	FILE *file = fopen(...);

	RN::ScopeGuard guard([&]() {
		fclose(file); // Close the file descriptor
	});

	bar(file); // In this case, bar can throw an exception. 
	// Either way, exception or normal exit, once the scope guard goes out of scope, the file is closed.
}

list.RemoveAll((client) => !client.Update());

void magicFunc(char *d, const char *s) {
    while(*d++ = *s++);
}

RAC(createButton, enabled) = [RACSignal 
    combineLatest:@[ RACObserve(self, password), RACObserve(self, passwordConfirmation) ] 
    reduce:^(NSString *password, NSString *passwordConfirm) {
        return @([passwordConfirm isEqualToString:password]);
    }];

public String getTypeOfDayWithSwitchStatement(String dayOfWeekArg) {

    String typeOfDay;
    
    switch (dayOfWeekArg) {
    
        case "Monday":      typeOfDay = "Start of work week";
                            break;
    
        case "Tuesday":
        case "Wednesday":
        case "Thursday":    typeOfDay = "Midweek";
                            break;
    
        case "Friday":      typeOfDay = "End of work week";
                            break;
    
        case "Saturday":
        case "Sunday":      typeOfDay = "Weekend";
                            break;
    
        default:            throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeekArg);
    }
    
    return typeOfDay;
}

float Q_rsqrt( float number )
{
	long i;
	float x2, y;
	const float threehalfs = 1.5F;
 
	x2 = number * 0.5F;
	y  = number;
	i  = * ( long * ) &y;                       // evil floating point bit level hacking
	i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
	y  = * ( float * ) &i;
	y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//      y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed
 
	return y;
}

Object = { new = function (self)
  local o = {}
  setmetatable(o, self)
  self.__index = self
  return o
end }

"".GetType()

for( v=0; v<TEXTURESIZE; v++ ) {
	SDL_GetRGB(getPixel(texture,u,v),screen->format,&b,&g,&r);
	color = SDL_MapRGB(screen->format,r,g,b);
	while( texelcount<=max(1.0,texelsize) && y<camera->winy+camera->winh ) {
		if( y>=camera->winy ) {
			*(Uint32 *)((Uint8 *)p + scanline)=color; // draw pixel
			scanline += scanwidth;
		}
		y++;
		texelcount+=min(texelsize,1.0);
	}
	texelcount -= max(1.0,texelsize);
	if( y>=camera->winh+camera->winy )
		break;
}

fld fnum
fistp inum

#include <acknex.h>
#include <windows.h>

typedef int HKEY;
typedef int REGSAM;

long WINAPI RegEnumKeyEx(
	HKEY hKey,
	DWORD dwIndex,
	char *lpName, 
	long *lpcName,
	long *lpReserved, 
	char *lpClass, 
	long *lpcClass, 
	FILETIME *lpftLastWriteTime);
	
long WINAPI RegOpenKeyEx(HKEY hKey, char *lpSubKey, DWORD ulOptions, REGSAM samDesired, HKEY *phkResult);

long WINAPI RegCloseKey(HKEY hKey);

function main()
{
	HKEY hTestKey;
	if(RegOpenKeyEx(HKEY_CURRENT_USER,
		"SOFTWARE\\Unity Technologies",
		0,
		KEY_READ,
		&hTestKey) == ERROR_SUCCESS )
	{
		error("Traitor!");
		RegCloseKey(hTestKey);
	}
	else
	{
		error("All fine!");
	}
   
}

template<class T, size_t Size>
class lock_free_ring_buffer
{
public:
	lock_free_ring_buffer() :
		_head(0),
		_tail(0)
	{}
	
	bool push(const T &val)
	{
		size_t tail = _tail.load(std::memory_order_relaxed);
		size_t next = (index + 1) % capacity;
		
		if(next != _head.load(std::memory_order_acquire))
		{
			_buffer[tail] = val;
			_tail.store(next, std::memory_order_release);
			
			return true;
		}
		
		return false;
	}
	
	bool pop(T &val)
	{
		size_t head = _head.load(std::memory_order_relaxed);
		
		if(head != _tail.load(std::memory_order_acquire))
		{
			val = std::move(_buffer[head]);
			_head.store((index + 1) % capacity, std::memory_order_release);
			
			return true;
		}
		
		return false;
	}
	
	bool was_empty() const
	{
		return (_head.load() == _tail.load());
	}
	
private:
	enum { capacity = Size + 1 };
	
	std::atomic<size_t> _head;
	std::atomic<size_t> _tail;
	
	std::array<T, capacity> _buffer;
};

Object *Object::Retain()
{
	_refCount.fetch_add(1, std::memory_order_relaxed);
	return this;
}

void Object::Release()
{
	if(_refCount.fetch_sub(1, std::memory_order_release) == 1)
	{
		std::atomic_thread_fence(std::memory_order_acquire); // Synchronize all accesses to this object before deleting it

		CleanUp();
		delete this;
	}
}