Một chương trình in các chương trình


13

Thử thách

Mục tiêu của bạn là viết một chương trình in một chương trình khác. Chương trình in đó sẽ in một chương trình khác và chương trình mới sẽ in một chương trình khác cho đến khi kết thúc.

Quy tắc

  1. Mỗi chương trình phải ít hơn 256 byte. (Nếu điều này cần phải thay đổi, hãy để lại nhận xét)
  2. Chương trình cuối cùng phải là một chương trình trống.
  3. Phải có một số lượng chương trình hữu hạn, vì vậy chương trình không thể là một quine.
  4. Tất cả các chương trình phải chạy trong cùng một ngôn ngữ.
  5. Không có đầu vào được cho phép.
  6. Chương trình chiến thắng là chương trình in càng nhiều chương trình càng tốt, tính chính nó.

Chúc may mắn!


Điểm tối đa là 2^2048, hoặc 3.2317e616.
orlp

Để làm cho nó dễ dàng hơn để so sánh điểm số lớn, xin vui lòng bao gồm một xấp xỉ đến điểm số của bạn theo hình thức a*10^bnơi 1<=a<10blà một số tự nhiên.
flawr

2
Trên thực tế, tính toán trước đây của tôi là sai. Giả sử chương trình phải tính bằng byte thì điểm tối đa có thể là <số quá dài để bình luận> hoặc 1.2673e614.
orlp

Câu trả lời:


20

CJam, 4,56 × 10 526 chương trình

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

Điểm chính xác: 254 219 + 254 192 + 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 3

Tất cả các chương trình phải được lưu bằng mã hóa ISO-8859-1 để tuân thủ giới hạn kích thước tệp.

Cảm ơn @ChrisDrost , người đã chỉ ra một lỗi và đề xuất phương pháp lồng nhau.

Hãy thử trực tuyến trong trình thông dịch CJam .

254 219 + 2 ≈ 4,56 × 10 526 chương trình

Chia sẻ dòng điểm có thể đạt được bằng cách sau đây, chương trình 1 đơn giản hơn nhiều .

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

Chạy chương trình này tạo ra chương trình

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

và sau 254 219 - 1 lần lặp nữa, chương trình

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

Chương trình không trống cuối cùng này thoát với lỗi 2 và không in gì (chương trình trống).

Làm thế nào nó hoạt động

Giả sử chuỗi đã có trên ngăn xếp.

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

254 192 5,35 × 10 461 chương trình khác

Đây là nơi mọi thứ trở nên hơi điên rồ.

Chương trình đầu tiên có khả năng nén cao. Bằng cách viết một chương trình tương tự, thay vì chương trình trống, cuối cùng tạo ra chương trình đầu tiên từ phần trên, chúng ta có thể cải thiện điểm số bằng 254 192 chương trình 3 .

Chương trình

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

tương tự như chương trình đầu tiên của phần trước, và chạy phần trước và đầu ra của nó cho 254 192 lần lặp tạo ra phần sau.

Giả sử chuỗi đã có trên ngăn xếp:

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

Chương trình Moar

Chương trình đầu tiên của phần trước vẫn có khả năng nén cao, vì vậy chúng ta có thể áp dụng một phương pháp tương tự và viết một chương trình, sau 254 166 lần lặp, tạo ra chương trình đã nói ở trên.

Lặp đi lặp lại kỹ thuật này nhiều lần cho đến khi đạt đến giới hạn 255 byte, chúng ta có thể thêm tổng cộng 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 38 + 254 13 + 1 1.59 × 10 399 chương trình vào những phần trước


1 dòng mới được thêm vào cho rõ ràng.
2 Theo sự đồng thuận trên Meta , điều này được cho phép theo mặc định.
3 hoặc 0,0000000000000000000000000000000000000000000000000000000000000000000012%



5

JavaScript, 1000 chương trình

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

Điều này có hợp lệ hay không phụ thuộc vào cách hiểu chính xác quy tắc thứ ba.


Về mặt kỹ thuật, đây không phải là một vấn đề, vì nó in ra một phiên bản sửa đổi của mã nguồn của chính nó chứ không phải là một bản sao giống hệt nhau. Nó sử dụng các kỹ thuật giống như quine, rõ ràng. Tôi nghĩ chúng ta sẽ cần làm rõ từ @TheTurtle.
JohnE

5
@JohnE và Ypnypn Đây là một cái gì đó giống như tôi đã hình dung. Những công việc này.
Rùa

6
Bạn vẫn còn dưới giới hạn chiều dài mã. Tại sao bạn không đổi 999 thành một cái gì đó lớn hơn?
DankMeme

4

Ruby, 1.628 × 10 ^ 237 chương trình

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

Cách tiếp cận tương tự như câu trả lời Perl của tôi, nhưng vì Ruby đã xử lý các số nguyên lớn, nên việc lưu trữ dưới dạng hex dễ dàng hơn.


Chương trình Ruby, 9.277 × 10 ^ 90

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

Vì vậy, nỗ lực này là một biến thể hơi khác so với kiểu quine trước đó, nhưng vì tất cả các chức năng bổ sung, tôi không nhận được số ở bất cứ đâu cao gần như khác ... Thật thú vị khi thử một cách tiếp cận khác!


4

Các chương trình Python 2, 9.7 * 10 ^ 229

O=0
if len(hex(O))<191:print"O=0x%x"%(O+1)+open(__file__).read()[-68:]

Đẹp, không nghĩ về sự lặp lại chuỗi!
Dom Hastings

2

Chương trình C, 2.2 * 10 ^ 177

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

Nó không hoàn hảo, nhưng khá tốt. Ý tôi là nó chính xác là 255byte dài và tạo ra các chương trình có cùng độ dài. Bạn có thể có thể tìm hiểu thêm một số chương trình để có thêm một số chương trình, nhưng tôi sẽ để nó như bây giờ.

Chương trình này dựa trên một quine C đơn giản. Ngoài ra, có một thuật toán đếm khá đơn giản, đếm qua tất cả các giá trị có thể có của mảng char n. Chúng tôi có nhiều chương trình như hoán vị của chuỗi n.

Phạm vi char được giới hạn trong phạm vi từ #(= 35) đến [= (91). Đó là bởi vì tôi không muốn bất kỳ "hoặc \trong chuỗi, bởi vì chúng cần phải được thoát.

Việc tạo chương trình kết thúc khi tất cả các giá trị trong mảng char n[. Sau đó, nó đưa ra một chương trình giả đơn giản main(){}, mà chính nó không tạo ra gì.

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

Như một minh chứng rằng nó sẽ hoạt động, tôi chỉ thay đổi các giới hạn, do đó, chỉ các ký tự giữa ASCII-Code 3536được sử dụng và chỉ có 4 phần tử mảng.

Các chương trình kết quả là

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

Điều này đầu ra 2^4 + 1 = 17các chương trình khác nhau.

Vì vậy, chương trình trên xuất ra ((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177các chương trình khác nhau. Tôi không chắc chắn nếu điều này được tính, hoặc nếu tính toán của tôi thậm chí là chính xác


1
Bạn có thể vui lòng bao gồm rằng đây là về 2.2 * 10^177(cho những người muốn so sánh)?
flawr

Không biết làm thế nào để tính toán cái này, nhưng tôi đã bao gồm nó ;-)
MarcDefiant


1

Perl, 1 × 10 ^ 163

Mặt khác, đây là một quine khá cơ bản, được thu nhỏ lại càng ít ký tự càng tốt, nó chỉ chạy trong khi bộ đếm thì không 0.

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e

1

Lisp thường gặp, 10 113 -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))
  • Có 113 dây.
  • Chương trình tiếp theo có 112 số theo sau là 8
  • Chương trình tiếp theo có 112 số theo sau là 7
  • ...

Số lượng dây được giới hạn bởi kích thước tối đa của mã, 256, có tính đến các khoảng trắng được máy in giới thiệu.


1

Perl, 1,4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

Cách tiếp cận tương tự với trăn; cùng một kết quả!


0

> <> , 65534 (?) Chương trình

Tôi đã thêm một dấu hỏi bên cạnh 65533 vì tôi chưa xác minh rằng nó có thể in 65533 (mặc dù tôi có lý do để tin rằng nó nên). Khi tôi có thêm một chút thời gian, tôi sẽ tìm ra cách để kiểm tra nó.

":?!;1-r00gol?!;a0.�

Bạn có thể thử trực tuyến ở đây .

Điểm chính của chương trình này là nó thay đổi đầu ra của ký tự ở cuối và sau đó giảm giá trị số của nó trước khi in. Tôi đã nhận được 65534 chương trình vì giá trị ascii của ký tự ở cuối mã là 65533, vì vậy đếm chương trình đầu tiên chúng tôi có 65534 (nếu bạn tính chương trình trống 65535, tôi đoán vậy). Chương trình cuối cùng "trở về" là không có gì; nó chỉ đơn giản kết thúc khi giá trị ký tự bằng 0.

Tôi khá chắc chắn rằng nó sẽ có thể in một ký tự cho tất cả các lần lặp: Tôi không thể tìm thấy một nguồn chính xác cho bao nhiêu ký tự> <> có thể in, nhưng có các ký tự ngay dưới 65533, bằng số.

Hãy cho tôi biết nếu có bất kỳ vấn đề với việc thực hiện này; Tôi hơi không chắc chắn về tính hợp lệ của mục nhập của tôi.


Giải trình

Tôi đã xấu hổ đánh cắp ý tưởng sử dụng một dấu ngoặc kép duy nhất để tạo ra một giả giả từ> <> wiki và một nhận xét tôi đã thấy ở đây một lần.

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop 

Những gì nó làm là phân tích mọi thứ sau dấu ngoặc kép dưới dạng ký tự, sau đó giảm giá trị cuối cùng. Từ đó, nó chỉ đảo ngược ngăn xếp (để in theo đúng thứ tự), đẩy một dấu ngoặc kép lên ngăn xếp, và sau đó in cho đến khi ngăn xếp trống.


0

Chương trình Python, 1 × 10 ^ 194

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

Điều này phải được chạy từ một tập tin, không phải là một thay thế tương tác. Nó không phải là một câu đố.

Cảm ơn @The Rùa đã giúp tôi tiết kiệm 3 byte, nhiều chỗ hơn cho số tiền phạt!
Cảm ơn @poke đã giúp tôi tiết kiệm 2 byte, nhiều chỗ hơn cho số tiền phạt!


@ Người yêu phô mai if n!=0là dư thừa. Bạn chỉ có thể viết if n.
Rùa

Bạn có thể thoát khỏi hai không gian quá; sau if n:và giữa các replaceđối số.
chọc

0

Bash, 52 chương trình

Hoàn toàn không mệt mỏi, và (hy vọng) vững chắc ở vị trí cuối cùng.

echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.