Code:

char decode_A(bool b)
{
    if (b) return 'a';
    else return 'A'; 
}
...
char decode_Z(bool b)
{
    if (b) return 'z';
    else return 'Z'; 
}

Code:

public partial class Form1 : Form
    {
        const ulong maxDateValue = 6071500800;

        ulong yearOffset = 0;
        ulong dayOffset = 0;
        ulong hourOffset = 0;
        ulong minuteOffset = 0;

        public Form1() {
            InitializeComponent();

            this.dateTimePicker1.Value = new DateTime(1900, 10, 1, 1, 1, 1);
            this.dateTimePicker2.Value = new DateTime(1900, 10, 2, 1, 1, 1);


            yearOffset = 366 * 24 * 60 * 60;
            dayOffset = 24 * 60 * 60;
            hourOffset = 60 * 60;
            minuteOffset = 60;
        }


        private ulong PairDates(DateTime d1, DateTime d2) {

            ulong x = ConvertDate(d1);
            ulong y = ConvertDate(d2);

            ulong n = maxDateValue;
            ulong m = n - x + 2;
            ulong pos = 0;

            if (m > n) {
                pos = (ulong)(maxDateValue - y + 1);
            }
            else {
                pos = (ulong)((n - m + 1) * (n + m)) / 2 + (maxDateValue - y + 1);
            }

            return pos;
        }

        private ulong ConvertDate(DateTime d) {
            return  (ulong)(d.Year - 1900) * yearOffset + (ulong)d.DayOfYear * dayOffset + (ulong)d.Hour * hourOffset + (ulong)d.Minute * minuteOffset + (ulong)d.Second;
        }

        private void UnpairDates(ulong pairDate, out DateTime d1, out DateTime d2)
        {
            bool search = true;
            ulong sum = 0;
            ulong total = 0;
            ulong stepen = 1;

            while (search) {           

                stepen = stepen << 1;                
                total += stepen;
                sum = Sum(maxDateValue, maxDateValue - total + 1);

                if (sum >= pairDate)
                {                    
                    total -= stepen;

                    stepen = 1;                 
                    total += stepen;

                    sum = Sum(maxDateValue, maxDateValue - total + 1);                    

                    if (sum >= pairDate) {
                        break;
                    }                  
                }                
            }

            ulong ud1 = total;
            sum = Sum(maxDateValue, maxDateValue - total + 2);
            ulong ud2 = maxDateValue - (pairDate - sum) + 1;


            d1 = GetDate(ud1);
            d2 = GetDate(ud2);
        }


        private DateTime GetDate(ulong pos) {
            
            ulong year = pos / yearOffset;
            ulong day = (pos - year * yearOffset) / dayOffset;

            ulong hour = (pos - year * yearOffset - day * dayOffset) / hourOffset;
            ulong minute = (pos - year * yearOffset - day * dayOffset - hour * hourOffset) / minuteOffset;
            ulong second = pos - year * yearOffset - day * dayOffset - hour * hourOffset - minute * minuteOffset;            

            DateTime d = new DateTime(1900 + (int)year, 1, 1);
            DateTime d2 = d.AddDays(day - 1);
            

            return new DateTime(d2.Year, d2.Month, d2.Day, (int)hour, (int)minute, (int)second);
        }

        private ulong Sum(ulong n, ulong m)
        {
            return ((n - m + 1) * (n + m)) / 2;
        }

        private void button1_Click(object sender, EventArgs e) {
                   
            ulong res = PairDates(dateTimePicker1.Value, dateTimePicker2.Value);

            DateTime d1;
            DateTime d2;
            
            UnpairDates(res, out d1, out d2);

            dateTimePicker3.Value = d1;
            dateTimePicker4.Value = d2;
            
            textBox1.Text = res.ToString();
            
        }
    }

Code:
        static ulong Encode2DT(DateTime start, DateTime stop)
        {
            unchecked
            {
                ulong max = getMaximumSpan();
                // skloni detalje implementacije jezika, vazno je da dobijemo broj sekundi od 1.1.1900/0:0:0
                ulong startSpan = getSeconds(start);
                ulong stopSpan = getSeconds(stop);
                // validacija opsega
                System.Diagnostics.Debug.Assert(startSpan < max);
                System.Diagnostics.Debug.Assert(stopSpan < max);

                // osiguraj da je stop>=start
                sortSpans(ref startSpan, ref stopSpan);
                ulong totalSpan = stopSpan - startSpan;

                // ok, encoding
                ulong blob = 0;
                for (ulong cnt = 1; cnt <= startSpan; cnt++) blob += (max - cnt + 1);
                blob += totalSpan;
                return blob;
            }
        }

        static void Decode2DT(ulong blob, out DateTime start, out DateTime stop)
        {
            unchecked
            {
                ulong max = getMaximumSpan();
                // validacija opsega
                System.Diagnostics.Debug.Assert(blob < getMaximumBlob());

                // decoding
                ulong startSpan = 0;
                for (ulong cnt = 1; cnt <= max; cnt++)
                    if (blob >= (max - cnt + 1)) blob -= (max - cnt + 1);
                    else { startSpan = cnt - 1; break; }

                start = getDateFromSeconds(startSpan);
                stop = getDateFromSeconds(startSpan + blob);
            }
        }

Code:

#include <iostream>

using namespace std;

// Compiler depended code. This is definition of unsigned 64-bit integer.
// This code can be compiled using GNU C++ compiler and MinGW C++ compiler.

typedef unsigned long long int UInt64;

// March is the first month in the modified calendar (number 0).
// January and February belong to the previous year.
// March = 0, April = 1, May = 2, June = 3, July = 4, August = 5,
// September = 6, October = 7, November = 8, December = 9, January = 10, February = 11
int days_in_month[12] = {31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28};

// Converts datetime to 64-bit unsigned integer.
UInt64 to_num(int year, int month, int day, int hour, int minute, int second) {
    UInt64 result = 0;
    
    // Conversion from standard calendar to the modified calendar.
    
    if (month < 3) {
        month += 9;
        year = year - 1;
    } else
        month -= 3;
    
    // Number of days in 400 years is 365.2425*400 = 146097.
    result = result + (year/400) * 146097;
    year = year % 400;
    // Number of days in 100 years (of the rest <400 years) is 365.25*100 = 36525.
    result = result + (year/100) * 36525;
    year = year % 100;
    // Number of days in 4 years (of the rest <100 years) is 365.25*4 = 1461.
    result = result + (year/4) * 1461;
    year = year % 4;
    // Number of days in one year (of the rest <4 years) is 365.
    result = result + year * 365;
    
    // Add the number of days in previous months.
    
    for (int m = 0; m < month; m = m + 1) {
        result += days_in_month[m];
    }
    
    // Add the number of previous days in month.
    
    result = result + day - 1;
    
    // Switch to seconds
    
    result = result * (24*60*60);
    
    // Add the number of previous seconds in the day.
    
    result = result + (60*60)*hour + 60*minute + second;
    
    return result;
}

void to_datetime(UInt64 number, int &year, int &month, int &day, int &hour, int &minute, int &second) {
    // Conversion from seconds since epoch to days and seconds in day;
    
    int days = number / (24*60*60);
    int seconds = number - days * (24*60*60);
    
    int year400 = days / 146097;
    year = 400 * year400;
    days = days - year400 * 146097;
    int year100 = days / 36525;
    year = year + 100 * year100;
    days = days - year100 * 36525;
    int year4 = days / 1461;
    year = year + 4 * year4;
    days = days - year4 * 1461;
    int year1 = days / 365;
    year += year1;
    days = days - year1 * 365;
    
    int m;
    
    for (m = 0; days >= days_in_month[m]; m = m + 1) {
        days = days - days_in_month[m];
    }
    
    month = m;
    day = days + 1;
    
    hour = seconds / (60*60);
    seconds = seconds - hour * (60*60);
    minute = seconds / 60;
    seconds = seconds - minute * 60;
    second = seconds;
    
    // Conversion from modified calendar to standard calendar.
    
    if (month < 10) {
        month = month + 3;
    } else {
        month = month - 9;
        year = year + 1;
    }
}

UInt64 epoch = to_num(1901, 1, 1, 0, 0, 0);

struct DateTime {
    int year;
    int month;
    int day;
    int hour;
    int minute;
    int second;
};

UInt64 to_num(DateTime datetime) {
    UInt64 result = to_num(datetime.year, datetime.month, datetime.day,
                           datetime.hour, datetime.minute, datetime.second);
    
    result = result - epoch;
    
    return result;
}

DateTime to_datetime(UInt64 number) {
    DateTime result;
    
    number = number + epoch;
    to_datetime(number, result.year, result.month, result.day,
                        result.hour, result.minute, result.second);
    
    return result;
}

struct Time_interval {
    DateTime from;
    DateTime to;
};

// Returns n*(n+1)/2.
UInt64 binomial(UInt64 n) {
// Computing without overflow
    
    if (n % 2 == 0)
        return (n/2) * (n+1);
    else
        return n * ((n+1)/2);
}

UInt64 encode(Time_interval interval) {
    UInt64 from = to_num(interval.from);
    UInt64 to = to_num(interval.to);
    
    return binomial(to) + from;
}

Time_interval decode(UInt64 code) {
    UInt64 min = 0;
    // Computing constant 6,074,000,999 without overflow.
    // This is the greatest integer n such that n*(n+1)/2 < 2^64. 
    UInt64 max = 6074001;
    max = max * 1000;
    max = max - 1;
    
    // Binary search of the greatest number n such that n*(n+1)/2 <= code.
    while (min +1 < max) {
        UInt64 middle = (min + max) / 2;
        
        if (binomial(middle) > code)
            max = middle;
        else
            min = middle;
    }
    
    Time_interval result;
    
    result.to = to_datetime(min);
    result.from = to_datetime(code - binomial(min));
    
    return result;
}

ostream& operator<<(ostream &ostr, DateTime datetime) {
    ostr << datetime.year
         << "-" << datetime.month
         << "-" << datetime.day
         << " " << datetime.hour
         << ":" << datetime.minute
         << ":" << datetime.second;
    
    return ostr;
}

ostream& operator<<(ostream &ostr, Time_interval interval) {
    ostr << interval.from << " " << interval.to;
    
    return ostr;
}

istream& operator>>(istream &istr, DateTime &datetime) {
    char ch;
    
    istr >> datetime.year;
    istr >> ch;
    istr >> datetime.month;
    istr >> ch;
    istr >> datetime.day;
    istr >> datetime.hour;
    istr >> ch;
    istr >> datetime.minute;
    istr >> ch;
    istr >> datetime.second;
    
    return istr;
}

istream& operator>>(istream &istr, Time_interval &interval) {
    istr >> interval.from;
    istr >> interval.to;
    
    return istr;
}

int main() {
    cout << "Enter the time interval (from-to) in the format yyyy-mm-dd hh:mm:ss yyyy-mm-dd hh:mm:ss" << endl;
    Time_interval interval;
    cin >> interval;
    UInt64 code = encode(interval);
    cout << "It's 64-bit code is " << code << " (decimal)" << endl;
    Time_interval check = decode(code);
    cout << "Decoded interval is\n" << check << endl;
    
    return 0;
}

Code:

const uint64_t maxDateValue = 6074000999ull;

uint64_t encodeDate(uint64_t start, uint64_t stop)
{
    uint64_t rc;
    if(stop-start>maxDateValue/2)
        rc = (maxDateValue/2-start)*maxDateValue+stop;
    else
        rc = (stop-start)*maxDateValue+start;
    return rc;
}

void decodeDate(uint64_t blob, uint64_t* start, uint64_t* stop)
{
    uint64_t s1 = blob/maxDateValue;
    uint64_t s2 = blob%maxDateValue;
    if(s1 + s2 >= maxDateValue)
    {
        *start = maxDateValue/2-s1;
        *stop = s2;
    }
    else
    {
        *start = s2;
        *stop = s1+s2;
    }
}