bzoj2757

非常神的数位dp，我调了几乎一天
首先和bzoj3131类似，乘积是可以预处理出来的，注意这里乘积有一个表示的技巧
因为这里质因数只有2,3,5,7，所以我们可以表示成2^a*3^b*5^c*7^d，也就是v[a,b,c,d]这个数组
这样也非常方便进行除法，乘法的状态转移，转移和要维护的东西比较多，我就直接在程序里注释了
这里维护转移的核心思想是算每一位对编号和的贡献，乘积为0和非0分开计算

const mo=20120427;
      lim=1000000000000000000;
      q:array[1..9,1..4] of longint=((0,0,0,0),(1,0,0,0),(0,1,0,0),(2,0,0,0),(0,0,1,0),
                                     (1,1,0,0),(0,0,0,1),(3,0,0,0),(0,2,0,0));
//1~9对乘积的影响
var v:array[0..60,0..38,0..30,0..22] of longint;
    f,s:array[0..20,0..70010] of longint;
    p,r,g,h:array[0..20] of longint;
    pp:array[0..20] of int64;
    n,a,b,c,d,i,j,t,m,k:longint;
    x,y,w:int64;

procedure up(var a:longint; b:longint);
  begin
    a:=(a+b+mo) mod mo;
  end;

procedure pre;
  var i,j,k,p:int64;
      a,b,c,d:longint;
  begin
    i:=1;
    a:=0;
    while i<=lim do
    begin
      j:=i; b:=0;
      while j<=lim do
      begin
        k:=j; c:=0;
        while k<=lim do
        begin
          p:=k; d:=0;
          while p<=lim do
          begin
            inc(t);
            v[a,b,c,d]:=t;
            p:=p*7;
            inc(d);
          end;
          k:=k*5;
          inc(c);
        end;
        j:=j*3;
        inc(b);
      end;
      i:=i*2;
      inc(a);
    end;
  end;

procedure work;
  var a,b,c,d,i,j:longint;
  begin
    f[0,1]:=1;
    for i:=1 to 18 do
      for a:=0 to 60 do for b:=0 to 38 do for c:=0 to 26 do for d:=0 to 22 do
        if (v[a,b,c,d]>0) and (f[i-1,v[a,b,c,d]]>0) then
        begin
          for j:=1 to 9 do
          begin
            up(f[i,v[a+q[j,1],b+q[j,2],c+q[j,3],d+q[j,4]]],f[i-1,v[a,b,c,d]]);
//f[i,S]表示i位数乘积为S的数的个数
            up(s[i,v[a+q[j,1],b+q[j,2],c+q[j,3],d+q[j,4]]],s[i-1,v[a,b,c,d]]+int64(f[i-1,v[a,b,c,d]])*int64(j)*int64(p[i]) mod mo);
//s[i,S]表示i位数乘积为S的数的和，转移就是算当前第i位对和的贡献，显然是j(第i位的数)*p[i](位权)*f[i-1,S/j]
          end;
        end
        else if v[a,b,c,d]=0 then break;
    h[0]:=1;
    for i:=1 to 18 do
    begin
      h[i]:=h[i-1]*9 mod mo;  //i位数不含0的个数
      g[i]:=(g[i-1]*9+45*int64(p[i])*int64(h[i-1]) mod mo) mod mo;  //i位数不含0的数的和，45=1+..+9
    end;
  end;

procedure get(x:int64);
  begin
    m:=0;
    while x>0 do
    begin
      inc(m);
      r[m]:=x mod 10;
      x:=x div 10;
    end;
  end;

function can(x:int64):boolean;
  begin
    a:=0; b:=0; c:=0; d:=0;  //拆分成2^a*3^b*5^c*7^d
    while x mod 2=0 do
    begin
      inc(a);
      x:=x div 2;
    end;
    while x mod 3=0 do
    begin
      inc(b);
      x:=x div 3;
    end;
    while x mod 5=0 do
    begin
      inc(c);
      x:=x div 5;
    end;
    while x mod 7=0 do
    begin
      inc(d);
      x:=x div 7;
    end;
    if x=1 then exit(true) else exit(false);
  end;

function sum(a:int64):longint;  //防止爆int64的计算
  var b:int64;
  begin
    b:=a-1;
    if a mod 2=0 then a:=a div 2
    else b:=b div 2;
    a:=a mod mo;
    b:=b mod mo;
    exit(a*b mod mo);
  end;

function count(x,k:int64):longint;
  var i,j,pre,a1,b1,c1,d1,ans:longint;
      now:int64;
  begin
    if not can(k) then exit(0);  //k不存在
    get(x);
    ans:=0;
    for i:=1 to m-1 do  //统计1~m-1位数乘积为k数的和
      up(ans,s[i,v[a,b,c,d]]);
    now:=1;
    pre:=0;  //pre=∑(r[i]*p[i])
    for i:=m downto 1 do
    begin
      now:=now*int64(r[i]); 
      if r[i]=0 then break; //显然
      for j:=1 to r[i]-1 do
      begin
        a1:=a-q[j,1]; b1:=b-q[j,2]; c1:=c-q[j,3]; d1:=d-q[j,4];
        if (a1<0) or (b1<0) or (c1<0) or (d1<0) then continue;
        up(ans,s[i-1,v[a1,b1,c1,d1]]+int64(pre+j*p[i])*int64(f[i-1,v[a1,b1,c1,d1]]) mod mo);
//和与处理的转移类似
      end;
      a:=a-q[r[i],1]; b:=b-q[r[i],2]; c:=c-q[r[i],3]; d:=d-q[r[i],4];
      up(pre,r[i]*p[i] mod mo);
      if (a<0) or (b<0) or (c<0) or (d<0) then break;
    end;
    if now=k then up(ans,x mod mo);  //判断x
    exit(ans);
  end;

function calc(x:int64):longint;  //乘积为0的转移要复杂，容易出错
  var i,j,pre,ans,e:longint;
  begin
    get(x);
    ans:=sum(p[m]) mod mo;  //先求1~m-1乘积为0的数和，我们可以用补集的思想，总和-不含0的数和
    for i:=1 to m-1 do
      up(ans,-g[i]);
    pre:=0;
    for i:=m downto 1 do
    begin
      if r[i]=0 then
      begin
        up(ans,int64(pre)*int64(x mod pp[i] mod mo+1) mod mo+sum(x mod pp[i]+1));
//当前为0，后面对答案的贡献可以直接算出来
        break;
      end;
      if i<m then up(ans,int64(pre)*int64(p[i]) mod mo+sum(pp[i]));
//否则m位数且小于等于x的数当前位可以是0，计算贡献
      if i=1 then e:=r[i] else e:=r[i]-1;
      for j:=1 to e do
        up(ans,sum(pp[i])-g[i-1]+int64(pre+j*p[i])*int64((p[i]-h[i-1]+mo) mod mo) mod mo);
//这里还是运用到补集的思想，和之前算乘积不为0类似
      up(pre,r[i]*p[i] mod mo);
    end;
    exit(ans);
  end;

begin
  readln(n);
  p[1]:=1;
  pp[1]:=1;
  for i:=2 to 18 do
  begin
    p[i]:=p[i-1]*10 mod mo;  //位权
    pp[i]:=pp[i-1]*10;
  end;
  pre;
  work;
  for i:=1 to n do
  begin
    readln(x,y,w);
    if w=0 then writeln((calc(y)-calc(x-1)+mo) mod mo)
    else writeln((count(y,w)-count(x-1,w)+mo) mod mo);
  end;
end.