void pango_layout_set_text (PangoLayout *layout, const char *text, int length);

#include <string.h>
#include <stdlib.h>
#include <dlfcn.h>
 
#define UNREGISTERED "[UNREGISTERED] "
 
static void *libpango;
static void (*pango_layout_set_text_orig)(void *, const char *, int);
 
__attribute__((__constructor__)) void pango_hook_init() {
	libpango = dlopen("libpango-1.0.so", RTLD_LOCAL  | RTLD_LAZY);
	pango_layout_set_text_orig = dlsym(libpango, "pango_layout_set_text");
}
 
void pango_layout_set_text(void *layout, const char *text, int length) {
	char *p = text ? strstr(text, UNREGISTERED) : 0;
	if (__builtin_expect((long)p, 0)) {
		int len = length >= 0 ? length : strlen(text);
		memmove(p, p + sizeof(UNREGISTERED) - 1,
			(len -= sizeof(UNREGISTERED) - 1) - (p - text)
			);
		if (length >= 0) length = len;
	}
	pango_layout_set_text_orig(layout, text, length);
}

#!/bin/dash
RAINLENDAR_PATH='/opt/rainlendar2'
export LD_PRELOAD="$RAINLENDAR_PATH/libpango_hook.so"
exec $RAINLENDAR_PATH/rainlendar2

sysctl -w vm.oom_kill_allocating_task = 1

sysctl -w vm.overcommit_memory = 2

#define _GNU_SOURCE 1
 
#include <unistd .h>
#include <stdio .h>
#include <stdlib .h>
#include <err .h>
#include <errno .h>
#include <string .h>
 
#define errexit(status, info) fprintf(stderr, "%s: %s\n", program_invocation_name, info), exit(status);
 
FILE *fp_meminfo;
 
void set_overcommitted_limit(int value)
{
	char new_value[32];
	int old_len = 0;
	FILE *fp_overcommit_ratio;
 
	if (!(fp_overcommit_ratio = fopen("/proc/sys/vm/overcommit_ratio", "w")))
		err(-4, "can't write /proc/sys/vm/overcommit_ratio");
	fprintf(fp_overcommit_ratio, "%d", value);
 
	fclose(fp_overcommit_ratio);
}
 
int main(int argc, char const* argv[])
{
	char item_name[32];
	int item_value;
 
	int mem_free, mem_total, committed_as, buffers, cached, item_count, i;
 
	char essential_names[][32] = {"MemTotal", "MemFree", "Committed_AS", "Cached"};
	int essential_values[sizeof(essential_names) / sizeof(essential_names[0])];
 
	for(;;sleep(1)) {
		if (!(fp_meminfo = fopen("/proc/meminfo", "r")))
			err(-2, "can't read /proc/meminfo");
 
		for (memset(essential_values, -1, sizeof(essential_values)),
				item_count = sizeof(essential_values) / sizeof(essential_values[0]);
				item_count; ) {
 
			if (feof(fp_meminfo)) errexit(-3, "can't read all essential information");
 
			fscanf(fp_meminfo, " %31[^:]%*[^ ]%d%*[^\n]", item_name, &item_value);
 
			for(i = 0; i < sizeof(essential_values) / sizeof(essential_values[0]); i++) {
				if (essential_values[i] == -1 && 
					strcmp(essential_names[i], item_name) == 0) {
					essential_values[i] = item_value;
					--item_count;
					break;
				}
			}
		}
 
		set_overcommitted_limit(
			(essential_values[1] + essential_values[2] + essential_values[3] / 3)
			* 100 / essential_values[0] + 1);
 
		fclose(fp_meminfo);
	}
 
	return 0;
}

#include <stdio .h>
 
const int N = 4;
const int N2 = N * N;
const int M = N - 1;
const int S = (1 + N2) * N / 2 - N;
 
int a[N][N];
int u[N2];
 
int d;
 
bool updated(int d) {
    if (d < 0 || d >= N2 || u[d]) return false;
    if (::d >= 0) {
        return (::d == d);
    } else {
        ::d = d;
        return true;
    }
}
 
void printout() {
    puts("-----");
    for (int j = 0; j < N; j++) {
        for (int k = 0; k < N; k++) printf("%d ", a[j][k] + 1);
        putchar('\n');
    }
}
 
void f(int y, int x) {
    d = -1;
 
    if (y == M - 1) {
        if (x == 1) {
            int q = a[M - 1][0];
            for (int j = 0; j < M - 1; j++)
                q += a[j][0] - a[j][M - j];
            if (!updated(q)) return;
        } else if (x == M - 1) {
            int q = S;
            for (int j = 0; j < M - 1; j++)
                q -= -a[j][M] + a[j][j] + a[M - 1][j];
            if (q & 1) return;
            if (!updated(q / 2)) return;
        }
    } else if (y == M) {
        int q = S;
        for (int j = 0; j < M; j++) q -= a[j][x];
        if (!updated(q)) return;
        if (x == M) {
            a[M][M] = q;
            printout();
            return;
        }
    }
 
    if (x == M) {
        int q = S;
        for (int j = 0; j < M; j++) q -= a[y][j];
        if (!updated(q)) return;
    }
 
    int i = d;
    if (i >= 0) {
        u[i] = 1;
        a[y][x] = i;
        if (x == M) f(y + 1, 0);
        else f(y, x + 1);
        u[i] = 0;
    } else {
		for (i = 0; i < N2; i++) {
            if (!u[i]) {
                u[i] = 1;
                a[y][x] = i;
                if (x == M) f(y + 1, 0);
                else f(y, x + 1);
                u[i] = 0;
            }
        }
	}
}
 
int main() {
    f(0, 0);
    return 0;
}

#include < stdio.h >
#include < string.h >
#include < algorithm >
#include < vector >
 
 
using namespace std;
 
const int N = 5;
const int N2 = N * N;
const int M = N - 1;
const int H = N / 2;
const int S = (1 + N2) * N / 2 - N;
 
int a[N][N];
int u[N2];
 
template< int T >
class Row {
    int a_[T];
public:
 
    Row() {
    }
 
    Row(const int a[]) {
        for (int i = 0; i < N; i++) a_[i] = a[i];
    }
 
    void set(int index, int value) {
        a_[index] = value;
    }
 
    int get(int index) {
        return a_[index];
    }
 
    bool operator<(const Row<T>& that) const {
        for (int i = 0; i < T; i++)
            if (a_[i] < that.a_[i]) return true;
            else if (a_[i] > that.a_[i]) return false;
        return false;
    }
 
    bool operator ==(const Row< t >& that) const {
        for (int i = 0; i < T; i++)
            if (a_[i] != that.a_[i]) return false;
        return true;
    }
 
    bool match(const int a[], const int l) const {
        for (int i = 0; i < l; i++) {
            if (a_[i] != a[i]) return false;
        }
        return true;
    }
};
 
vector< Row< N > > t;
int h[N];
int rl, rr;
 
void printout() {
    puts("-----");
    for (int j = 0; j < N; j++) {
        for (int k = 0; k < N; k++) printf("%d ", a[j][k] + 1);
        putchar('\n');
    }
}
 
void f(int n, int d) {
    if (n == N) {
        //check '\'
        int s = 0;
        for (int i = 0; i < N; i++) s += a[i][i];
        if (s == S) printout();
        return;
    }
    int h[N];
    switch (d) {
        case 0:
            // Direction: Hor --
            for (int i = 0; i < N; i++) h[i] = i >= n ? 0 : a[n][i];
 
            for (vector< Row< N > >::iterator l = lower_bound(t.begin(), t.end(), Row< N > (h));
                    l != t.end() && l -> match(h, n); l++) {
                //check unused
                bool flag = true;
                for (int i = n; i < N; i++) {
                    if (u[l->get(i)]) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    //try it
                    for (int i = n; i < N; i++) u[a[n][i] = l -> get(i)] = 1;
                    //check /
                    if ((N & 1) && n == H) {
                        int s = 0;
                        for (int k = 0; k < N; k++) s += a[M - k][k];
                        flag = (s == S);
                    }
 
                    if (flag) f(n + 1, 1);
                    for (int i = n; i < N; i++) u[l -> get(i)] = 0;
                }
            }
            break;
        case 1:
            // Direction: Ver |
            for (int i = 0; i < N; i++) h[i] = i >= n ? 0 : a[i][n - 1];
 
            for (vector< Row< N > >::iterator l = lower_bound(t.begin(), t.end(), Row< N > (h));
                    l != t.end() && l->match(h, n); l++) {
                //check unused
                bool flag = true;
                for (int i = n; i < N; i++) {
                    if (u[l -> get(i)]) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    //try it
                    for (int i = n; i < N; i++)
                        u[a[i][n - 1] = l -> get(i)] = 1;
                    //check /
                    if (!(N & 1) && n == H) {
                        int s = 0;
                        for (int k = 0; k < N; k++) s += a[M - k][k];
                        flag = (s == S);
                    }
                    if (flag) f(n, 0);
 
                    for (int i = n; i < N; i++)
                        u[l -> get(i)] = 0;
                }
            }
    }
}
 
void gen(int i, int l) {
    if (i == M) {
        if (l >= 0 && l < N2 && !u[l]) {
            h[M] = l;
            t.push_back(Row< N > (h));
        }
    } else {
        for (int j = 0; j < N2; j++) {
            if (!u[j]) {
                if (l >= j) {
                    u[j] = 1;
                    if (i >= 0) h[i] = j;
                    gen(i + 1, l - j);
                    u[j] = 0;
                }
            }
        }
    }
}
 
int main() {
    gen(0, S);
    f(0, 0);
    return 0;
}

program magic_square;
{$APPTYPE CONSOLE}
 
const debug=1;
      MAX_PERMUTATION_ELEMENTS_COUNT=20;
      MAX_PERMUTATION_COUNT=50000;
type
     TInt=longword;
     TPermutation=array [1..MAX_PERMUTATION_ELEMENTS_COUNT] of word;
     TLink=record prev,next:TInt; end;
     ECompare=(Bigger,Smaller,Equal);
var
  Pers:packed array [1..MAX_PERMUTATION_COUNT] of TPermutation;
  PersIndex:packed array [1..MAX_PERMUTATION_COUNT] of TInt;
  PersCount:TInt;
 
  PerTemp:TPermutation;
  {PersLinkTable:array [0..MAX_PERMUTATION_COUNT] of TLink;}
 
  {
   Data struct:
     PersLinkTable[i].next  : (Element Pers[i])'s next element's index, 0 : Tail
                     .prev  : (Element Pers[i])'s previous element's index, 0 : Tail
     PersLinkTable[0].next  : Head index
     ->Use binary search, not use PersLinkTable
  }
 
//Permutation functions//////////////////////////
{
procedure PersLinkTableInit;
begin
  PersCount:=0;
  fillchar(PersLinkTable,sizeof(PersLinkTable),0);
  PersLinkTable[0].next:=1;
end;
}
 
function PersCompare(var a,b:TPermutation):ECompare;
var i:TInt;
begin
  for i:=1 to MAX_PERMUTATION_ELEMENTS_COUNT do
    if a[i] > b[i] then begin result:=Bigger;exit end else
    if a[i] < b[i] then begin result:=Smaller;exit end;
  Result:=Equal;
end;
 
function PersBinarySearch(var a:TPermutation):TInt;
var l,r,m:TInt;
begin
  l:=1;r:=PersCount;
  while l<=r do begin
    m:=(l+r) div 2;
    case PersCompare(a,Pers[PersIndex[m]]) of
    Equal:
      //本应该返回mid, 但是直接处理掉重复，返回0
      begin result:=0;exit;end;
    Bigger:
      l:=m+1;
    Smaller:
      r:=m-1;
    end;
  end;
  //此时，l= (>a的第一个元素)
  Result:=l;
end;
 
procedure PersInsert(var a:TPermutation);
var i,p:TInt;
begin
  p:=PersBinarySearch(a);
  if p>0 then begin
    if PersCount>=MAX_PERMUTATION_COUNT then begin
       writeln('Over flow!');
       readln;
       halt;
    end;
 
    //Move Pers[p..PersCount] to Pers[p+1..PersCount+1]
    inc(PersCount);
    if PersCount mod 1000=0 then writeln('  Count: ',PersCount);
    Move(PersIndex[p],PersIndex[p+1],(PersCount-p)*sizeof(PersCount));
 
    Pers[PersCount]:=a;
    PersIndex[p]:=PersCount;
  end;
 
end;
 
procedure PersCreat(var a:TPermutation;ProvidedLength:Word;Content:array of Word);
var i:word;
begin
     for i:=1 to MAX_PERMUTATION_ELEMENTS_COUNT do a[i]:=i;
     //注意:Content array 下标从0开始
     for i:=0 to ProvidedLength-1 do
         a[Content[i]]:=Content[ProvidedLength+i];
end;
 
procedure PersMultiply(var MulResult,a,b:TPermutation);
var i:word;
begin
     for i:=1 to MAX_PERMUTATION_ELEMENTS_COUNT do
         MulResult[i]:=b[a[i]];
end;
/////////////////////////////////////////////////
 
var
    LastPersCount:TInt;
    i,j,k:word;
begin
  PersCount:=0;
  LastPersCount:=PersCount;
{
                 +--------+
                 |13 14 15|
                 |16    17|
                 |18 19 20|
         +-------+--------+
         |9    10|
         |       |
         |11   12|
 +-------+-------+
 |1  2  3|
 |4     5|
 |6  7  8|
 +-------+
 注意:每个面的面心固定住，
 因为无论怎么转，都可得到本质相同的情况（考虑一步即可）
}
  PersCreat(PerTemp,8,
  [1,2,3,4,5,6,7,8,
   3,5,8,2,7,1,4,6]);PersInsert(PerTemp); //Front side
 
  PersCreat(PerTemp,8,
  [13,14,15,16,17,18,19,20,
   15,17,20,14,19,13,16,18]);PersInsert(PerTemp); //Back side
 
  PersCreat(PerTemp,8,
  [1,9,13,4,16,6,11,18,
   13,16,18,9,11,1,4,6]);PersInsert(PerTemp); //Left side
 
  PersCreat(PerTemp,8,
  [3,10,15,5,17,8,12,20,
  15,17,20,10,12,3,5,8]);PersInsert(PerTemp); //Right side
 
  PersCreat(PerTemp,8,
  [1,2,3,9,10,13,14,15,
  3,10,15,2,14,1,9,13]);PersInsert(PerTemp); //Top side
 
  PersCreat(PerTemp,8,
  [6,7,8,11,12,18,19,20,
  8,12,20,7,19,6,11,18]);PersInsert(PerTemp); //Bottom side
 
  for i:=1 to 10 do begin
      writeln('#',i,':');
      LastPersCount:=PersCount;
      for j:=1 to LastPersCount do for k:=1 to LastPersCount do begin
          PersMultiply(PerTemp,Pers[j],Pers[k]);
          PersInsert(PerTemp);
      end;
      writeln('Now Count: ',Perscount);
      readln;
  end;
 
  if debug=1 then readln;
end.

string IPsec_v9(string a) {
        while (a.size() % 32 != 0)
                a += "IPsecV9";
        string ret = "";
        for (int i = 0; i < 32; i++) {
                unsigned v = 0;
                for (int j = i; j < a.size(); j += 32)
                        v = (v * 7 + a[j]) % 26;
                ret += v + 'A';
        }
        reverse(ret.begin(),ret.end());
        return ret;
}

main(){puts("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");}

b=32;main(){while(b--)putchar("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"[b]);}

char s[]="$!(#f#(%{{q(zR(%{{g#zp#(%{{](zz4#%{{S#zzH#%{{SzzR)#%{{S47fAp#%{{I(*#5-H#I#f%{{I#*+ (+>#+*(+f%{{I#*!4+>#!>+#\\%{{I$*!$*+>#(!*$+f%{{S*!U*K(5f%{{S*K(A(_f%{{S# $A$A$K$#p(%{{S#*(}-$5z%{{S#*#!$i$I#z(%{{I(*I$A$g$z(%{{5(>{{!$p(%{{!(>{{I$p(%{q(H#{{Sz(%{g(H#${{Sz (%{](R7({!(]27'z #(%{S(\\.S$7.{+.-z*(%{SR{+#{g$-z*%{I#>#${+#{{$z*#%{?(H{?#{{!-z*%{?>#${{{S-z*%{?>{I({{+-z*(%{(#R{I#{{+-z*-%{f{I#{{+-z4#%{f{I#{{+-z4#%{$#R{I${{+-z*#$%{+(#(!*#({{{I(#z4$%{U($*#({+#{g(-!z $#%+(}K($>({{gA$f$7(%+}i($H{{SK($(*($U(%+}}($>#({{5_(.s%+$}}#($*#${{!($}}2%?}}#($*{{(-!}}7%+(}}7(!*{I(->!}}7%+}}K($42g(-\\!}}$%+$}}K!zz4!}_$%?$}}7!zz4!}K$%g$}s'R-8-z!$}-$%{5.#(}${{?\"('$U.%",b[]="x `:'\n  _.X";i,t;main(){for(;i<640;s[++i]-=32)for(t=s[i]/10;t--+1;)putchar(b[s[i]%10]);}

c,n,m,s;
q(){n&&q(n/=2,s+=(n&1)+s);}
p(){c--&&p(puts(s^m?"NO":"YES"),q(),s=0,m=n,scanf("%d",&n));}
main(){scanf("%d",&c),p();}

char s[120],n[120],r[]="dbbdwmmwpq2569WM";
l,i,t,c,k;
main() {
  while(gets(s)) {
    n[l=strlen(s)]=0;
    for(t=i=0;t<l;i=++t*2){
      c=s[t];
      for(k=0;!(k&1)&&k<15;k+=2)
        c=(c==r[k]?r[++k]:c);
      n[i<=l?i-l|1:i]=c;
    }
    puts(n);
  }
}

class{public:void*mult(int(a),int(b)){cout<<a*b<<endl;}}typedef(multiply);

#define __CONCAT(x,y)   x ## y

#include<iostream>
using namespace std;
unsigned x;
unsigned f1(unsigned a,unsigned b){
        return !(a&b)?a^b:f1(a^b,(a&b)<<1);
}
unsigned f2(unsigned a,unsigned b){
        return a>=b?((b==0)?a:f2(a-1,b-1)):f2(a,0);
}
unsigned f3(unsigned a,unsigned b){
        return !a?-1:~f2(f1(~(f3(a>>1,b)<<1),-(~a&1)),b);
}
unsigned f4(unsigned a,unsigned b,unsigned c){
        return (!((min(a,b)-c)&1))?(~((!c)?(max(a,b)):((((f3(a,c)&~x)==~x)&((f3(b,c)&~x)==~x))?c:f4(a,b,c-1)))):
((!c)?(max(a,b)):((((f3(a,c)&~x)==~x)&((f3(b,c)&~x)==~x))?c:f4(a,b,c-1)));
}
unsigned f5(unsigned a,unsigned b,unsigned c){
        unsigned x=f4(a,c,c);
        return c?(((x>~x)?~x:x)<=b?f5(a,b,c-1)+1:f5(a,b,c-1)):0;
}
unsigned f6(unsigned a,unsigned b){
        return f5(a,b,a);
}
int main(){
        unsigned a,b;
        while(cin>>a>>b){
                cout<<f6(a,b)<<endl;
        }
}

g(a,b){return b?g(b,a%b):a;}
f(a,b,c){return c?f(a,b,c-1)+(g(a,c)<=b):0;}
main(a,b){while(scanf("%d%d",&a,&b)+1)printf("%d\n",f(a,b,a));}

g(a,b){return b?g(b,a%b):a;}
main(a,b,i,s){while(scanf("%d%d",&a,&b)+1){for(i=a,s=0;i;i--)s+=g(a,i)<=b;printf("%d\n",s);}}