Untuk i = 0, mengapa (i + = i ++) sama dengan 0?

Ambil kode berikut (dapat digunakan sebagai Aplikasi Konsol):

static void Main(string[] args)
{
    int i = 0;
    i += i++;
    Console.WriteLine(i);
    Console.ReadLine();
}

Hasilnya iadalah 0. Saya mengharapkan 2 (seperti yang dilakukan beberapa rekan saya). Mungkin kompiler membuat semacam struktur yang menghasilkan inol.

Alasan saya mengharapkan 2 adalah bahwa, di garis pemikiran saya, pernyataan tangan kanan akan dievaluasi terlebih dahulu, menambah i dengan 1. Daripada ditambahkan ke i. Karena saya sudah 1, itu menambahkan 1 ke 1. Jadi 1 + 1 = 2. Jelas ini bukan yang terjadi.

Bisakah Anda menjelaskan apa yang dilakukan kompiler atau apa yang terjadi pada saat runtime? Mengapa hasilnya nol?

Semacam penyangkalan: Saya sangat sadar Anda tidak akan (dan mungkin tidak seharusnya) menggunakan kode ini. Saya tahu saya tidak akan pernah. Namun demikian, saya merasa menarik untuk mengetahui mengapa itu bertindak sedemikian rupa dan apa yang sebenarnya terjadi.

Ini:

int i = 0;
i += i++

Dapat dilihat seperti yang Anda lakukan (berikut ini adalah penyederhanaan berlebih):

int i = 0;
i = i + i; // i=0 because the ++ is a postfix operator and hasn't been executed
i + 1; // Note that you are discarding the calculation result

Apa yang sebenarnya terjadi adalah lebih terlibat dari itu - lihatlah pada MSDN, 7.5.9 Peningkatan dan penurunan operator postfix :

Pemrosesan run-time dari operasi kenaikan atau penurunan postfix dari bentuk x ++ atau x-- terdiri dari langkah-langkah berikut:

• Jika x diklasifikasikan sebagai variabel:

  • x dievaluasi untuk menghasilkan variabel.
  • Nilai x disimpan.
  • Operator yang dipilih dipanggil dengan nilai x yang disimpan sebagai argumennya.
  • Nilai yang dikembalikan oleh operator disimpan di lokasi yang diberikan oleh evaluasi x.
  • Nilai x yang disimpan menjadi hasil operasi.

Perhatikan bahwa karena urutan prioritas , postfix ++terjadi sebelumnya += , tetapi hasilnya akhirnya tidak digunakan (seperti nilai sebelumnya iyang digunakan).

Dekomposisi yang lebih teliti dari i += i++bagian-bagian yang dibuatnya mengharuskan seseorang untuk mengetahui bahwa keduanya +=dan ++bukan atom (yaitu, tidak satu pun adalah operasi tunggal), bahkan jika mereka terlihat seperti itu. Cara ini diterapkan melibatkan variabel sementara, salinan isebelum operasi berlangsung - satu untuk setiap operasi. (Saya akan menggunakan nama iAdddan iAssignuntuk variabel sementara yang digunakan untuk ++dan +=masing - masing).

Jadi, perkiraan yang lebih dekat dengan apa yang terjadi adalah:

int i = 0;
int iAdd = i; // Copy of the current value of i, for ++
int iAssign = i; // Copy of the current value of i, for +=

i = i + 1; // i++ - Happens before += due to order of precedence
i = iAdd + iAssign;

Pembongkaran kode yang sedang berjalan:

int i = 0;
  xor         edx, edx
  mov         dword ptr i, edx         // set i = 0
i += i++;
  mov         eax, dword ptr i         // set eax = i (=0)
  mov         dword ptr tempVar1, eax  // set tempVar1 = eax (=0)
  mov         eax, dword ptr i         // set eax = 0 ( again... why??? =\ )
  mov         dword ptr tempVar2, eax  // set tempVar2 = eax (=0)
  inc         dword ptr i              // set i = i+1 (=1)
  mov         eax, dword ptr tempVar1  // set eax = tempVar1 (=0)
  add         eax, dword ptr tempVar2  // set eax = eax+tempVar2 (=0)
  mov         dword ptr i, eax         // set i = eax (=0)

Kode Setara

Ini mengkompilasi ke kode yang sama dengan kode berikut:

int i, tempVar1, tempVar2;
i = 0;
tempVar1 = i; // created due to postfix ++ operator
tempVar2 = i; // created due to += operator
++i;
i = tempVar1 + tempVar2;

Pembongkaran kode kedua (hanya untuk membuktikan bahwa mereka sama)

int i, tempVar1, tempVar2;
i = 0;
    xor         edx, edx
    mov         dword ptr i, edx
tempVar1 = i; // created due to postfix ++ operator
    mov         eax, dword ptr i
    mov         dword ptr tempVar1, eax
tempVar2 = i; // created due to += operator
    mov         eax, dword ptr i
    mov         dword ptr tempVar2, eax
++i;
    inc         dword ptr i
i = tempVar1 + tempVar2;
    mov         eax, dword ptr tempVar1
    add         eax, dword ptr tempVar2
    mov         dword ptr i, eax

Membuka jendela pembongkaran

Kebanyakan orang tidak tahu, atau bahkan tidak ingat, bahwa mereka dapat melihat kode perakitan di-memori akhir, menggunakan jendela Visual Studio Disassembly . Ini menunjukkan kode mesin yang sedang dieksekusi, itu bukan CIL.

Gunakan ini saat men-debug:

Debug (menu) -> Windows (submenu) -> Disassembly

Jadi apa yang terjadi dengan postfix ++?

Postfix ++ memberi tahu bahwa kami ingin menambah nilai operan setelah evaluasi ... yang semua orang tahu ... yang sedikit membingungkan adalah arti dari "setelah evaluasi" .

Jadi, apa artinya "setelah evaluasi" :

• penggunaan lain dari operan, pada baris kode yang sama harus terpengaruh:
  • a = i++ + i yang kedua saya dipengaruhi oleh kenaikan tersebut
  • Func(i++, i) yang kedua saya terpengaruh
• penggunaan lain pada saluran yang sama menghormati operator hubungan pendek seperti ||dan &&:
  • (false && i++ != i) || i == 0 yang ketiga saya tidak terpengaruh oleh i ++ karena tidak dievaluasi

Jadi apa arti dari: i += i++;?

Itu sama dengan i = i + i++;

Urutan evaluasi adalah:

1. Simpan i + i (yaitu 0 + 0)
2. Kenaikan i (i menjadi 1)
3. Tetapkan nilai langkah 1 ke i (i menjadi 0)

Bukan berarti kenaikan itu dibuang.

Apa arti dari: i = i++ + i;?

Ini tidak sama dengan contoh sebelumnya. Yang ke-3 idipengaruhi oleh kenaikan tersebut.

Urutan evaluasi adalah:

1. Store i (yaitu 0)
2. Kenaikan i (i menjadi 1)
3. Simpan nilai langkah 1 + i (yaitu 0 + 1)
4. Tetapkan nilai langkah 3 ke i (i menjadi 1)

int i = 0;
i += i++;

dievaluasi sebagai berikut:

Stack<int> stack = new Stack<int>();
int i;

// int i = 0;
stack.Push(0);                   // push 0
i = stack.Pop();                 // pop 0 --> i == 0

// i += i++;
stack.Push(i);                   // push 0
stack.Push(i);                   // push 0
stack.Push(i);                   // push 0
stack.Push(1);                   // push 1
i = stack.Pop() + stack.Pop();   // pop 0 and 1 --> i == 1
i = stack.Pop() + stack.Pop();   // pop 0 and 0 --> i == 0

yaitu idiubah dua kali: sekali oleh i++ekspresi dan sekali oleh +=pernyataan.

Tetapi operan dari +=pernyataan itu adalah

• nilai isebelum evaluasi i++(sisi kiri +=) dan
• nilai isebelum evaluasi i++(sisi kanan +=).

Pertama, i++pengembalian 0. Kemudian iditambahkan oleh 1. Terakhir idiatur ke nilai awal iyaitu 0 ditambah nilai yang i++dikembalikan, yang juga nol. 0 + 0 = 0.

Ini hanya dari kiri ke kanan, evaluasi bottom-up dari pohon sintaksis abstrak. Secara konseptual, pohon ekspresi berjalan dari atas ke bawah, tetapi evaluasi terbuka ketika rekursi muncul kembali ke atas pohon dari bawah.

// source code
i += i++;

// abstract syntax tree

     +=
    /  \
   i    ++ (post)
         \
         i

Evaluasi dimulai dengan mempertimbangkan simpul akar +=. Itu adalah konstituen utama dari ekspresi. Operan kiri +=harus dievaluasi untuk menentukan tempat kami menyimpan variabel, dan untuk mendapatkan nilai sebelumnya yang nol. Selanjutnya, sisi kanan harus dievaluasi.

Sisi kanan adalah ++operator pasca kenaikan . Ini memiliki satu operan, iyang dievaluasi baik sebagai sumber nilai, dan sebagai tempat menyimpan nilai. Operator mengevaluasi i, menemukan 0, dan akibatnya menyimpan a 1ke lokasi itu. Ini mengembalikan nilai sebelumnya,, 0sesuai dengan semantik mengembalikan nilai sebelumnya.

Sekarang kontrol kembali ke +=operator. Sekarang memiliki semua info untuk menyelesaikan operasinya. Ia tahu tempat menyimpan hasil (lokasi penyimpanan i) serta nilai sebelumnya, dan memiliki nilai untuk ditambahkan ke nilai sebelumnya, yaitu 0. Jadi, iberakhir dengan nol.

Seperti Java, C # telah membersihkan aspek yang sangat tidak jelas dari bahasa C dengan memperbaiki urutan evaluasi. Kiri-ke-kanan, bawah-ke-atas: urutan paling jelas yang mungkin diharapkan oleh pembuat kode.

Karena i++pertama mengembalikan nilai, lalu menambahkannya. Tetapi setelah saya diatur ke 1, Anda mengaturnya kembali ke 0.

Metode post-increment terlihat seperti ini

int ++(ref int i)
{
    int c = i;
    i = i + 1;
    return c;
}

Jadi pada dasarnya ketika Anda menelepon i++, iadalah kenaikan tetapi nilai asli dikembalikan dalam kasus Anda 0 dikembalikan.

Jawaban sederhana

int i = 0;
i += i++;
// Translates to:
i = i + 0; // because post increment returns the current value 0 of i
// Before the above operation is set, i will be incremented to 1
// Now i gets set after the increment,
// so the original returned value of i will be taken.
i = 0;

i ++ berarti: mengembalikan nilai i THEN increment it.

i + = i ++ berarti: Ambil nilai i saat ini. Tambahkan hasil i ++.

Sekarang, mari kita tambahkan i = 0 sebagai kondisi awal. i + = i ++ sekarang dievaluasi seperti ini:

1. Berapa nilai saya saat ini? Ini 0. Simpan sehingga kita dapat menambahkan hasil i ++ ke dalamnya.
2. Mengevaluasi i ++ (mengevaluasi ke 0 karena itulah nilai saat ini dari i)
3. Muat nilai yang disimpan dan tambahkan hasil langkah 2 ke dalamnya. (tambahkan 0 hingga 0)

Catatan: Pada akhir langkah 2, nilai i sebenarnya adalah 1. Namun, pada langkah 3, Anda membuangnya dengan memuat nilai i sebelum ditambahkan.

Berbeda dengan i ++, ++ i mengembalikan nilai yang ditambahkan.

Karena itu, i + = ++ saya akan memberi Anda 1.

Operator kenaikan pos perbaikan ++,, memberikan variabel nilai dalam ekspresi dan kemudian melakukan kenaikan yang Anda tetapkan mengembalikan nol (0) nilai untuk ilagi yang menimpa yang bertambah satu (1) , sehingga Anda mendapatkan nol. Anda dapat membaca lebih lanjut tentang operator kenaikan di ++ Operator (MSDN).

i += i++;akan sama dengan nol, karena ia melakukan ++sesudahnya.

i += ++i; akan melakukannya sebelumnya

++ postfix mengevaluasi isebelum menambahkannya, dan +=hanya mengevaluasi isekali.

Oleh karena itu, 0 + 0 = 0, seperti iyang dievaluasi dan digunakan sebelum ditambahkan, sebagai format postfix ++digunakan. Untuk mendapatkan ipeningkatan terlebih dahulu, gunakan formulir awalan ( ++i).

(Juga, hanya sebuah catatan: Anda hanya akan mendapatkan 1, karena 0 + (0 + 1) = 1)

Referensi: http://msdn.microsoft.com/en-us/library/sa7629ew.aspx (+ =)
http://msdn.microsoft.com/en-us/library/36x43w8w.aspx (++)

Apa yang dilakukan C #, dan "mengapa" kebingungan itu

Saya juga mengharapkan nilainya menjadi 1 ... tetapi beberapa eksplorasi tentang hal itu mengklarifikasi beberapa poin.

Karena metode berikut:

    static int SetSum(ref int a, int b) { return a += b; }

    static int Inc(ref int a) { return a++; }

Saya berharap itu i += i++sama dengan SetSum(ref i, Inc(ref i)). Nilai i setelah pernyataan ini adalah 1 :

int i = 0;
SetSum(ref i, Inc(ref i));
Console.WriteLine(i); // i is 1

Tapi kemudian saya sampai pada kesimpulan lain ... i += i++sebenarnya sama dengan i = i + i++... jadi saya telah membuat contoh serupa lainnya, menggunakan fungsi-fungsi ini:

    static int Sum(int a, int b) { return a + b; }

    static int Set(ref int a, int b) { return a = b; }

Setelah memanggil ini Set(ref i, Sum(i, Inc(ref i)))nilai i adalah 0 :

int i = 0;
Set(ref i, Sum(i, Inc(ref i)));
Console.WriteLine(i); // i is 0

Ini tidak hanya menjelaskan apa yang dilakukan C # ... tetapi juga mengapa banyak orang bingung dengan hal itu ... termasuk saya.

Mnemonik yang baik yang selalu saya ingat tentang ini adalah sebagai berikut:

Jika ++berdiri setelah ekspresi, itu mengembalikan nilai seperti sebelumnya . Jadi kode berikut

int a = 1;
int b = a++;

adalah 1, karena aitu 1 sebelum naik setelah++ berdiri . Orang-orang menyebut notasi perbaikan pos ini . Ada juga notasi pre fix, di mana semuanya justru sebaliknya: jika berdiri sebelumnya , ekspresi mengembalikan nilai setelah operasi: a++

int a = 1;
int b = ++a;

b ada dua di sini.

Jadi untuk kode Anda, ini artinya

int i = 0;
i += (i++);

i++mengembalikan 0 (seperti dijelaskan di atas), jadi 0 + 0 = 0.

i += (++i); // Here 'i' would become two

Scott Meyers menjelaskan perbedaan antara kedua notasi dalam "pemrograman C ++ Efektif". Secara internal, i++(postfix) mengingat nilai itadi, dan memanggil awalan-notasi ( ++i) dan mengembalikan nilai yang lama i,. Inilah sebabnya mengapa Anda harus allways menggunakan ++idi forloop (meskipun saya pikir semua kompiler modern menerjemahkan i++ke ++idalam forloop).

Satu-satunya jawaban untuk pertanyaan Anda yang benar adalah: Karena itu tidak terdefinisi.

Ok, sebelum kalian semua membakar aku ..

Anda semua menjawab mengapa i+=i++boleh dan logis untuk menghasilkan i=0.

Saya tergoda untuk memberikan suara untuk setiap 1 dari jawaban Anda tetapi reputasi yang saya hitung akan terlalu tinggi ..

Kenapa aku sangat marah pada kalian? bukan karena apa jawaban Anda menjelaskan ..
Maksud saya, setiap jawaban yang saya baca telah melakukan upaya luar biasa untuk menjelaskan yang tidak mungkin, saya Tepuk Tangan!

Tapi apa hasilnya ?? apakah ini hasil yang intuitif - apakah ini hasil yang dapat diterima ??

Anda masing-masing melihat "raja telanjang" dan entah bagaimana menerimanya sebagai raja yang rasional.

Anda semua salah!

i+=i++; menghasilkan 0 tidak terdefinisi.

bug dalam mekanisme evaluasi bahasa jika Anda mau .. atau lebih buruk lagi! bug dalam desain.

ingin bukti? tentu saja kamu mau!

int t=0; int i=0; t+=i++; //t=0; i=1

Sekarang ini ... adalah hasil yang intuitif! karena kami pertama kali mengevaluasit memberinya nilai dan hanya setelah evaluasi dan penugasan kami memiliki operasi pasca terjadi - rasional bukan?

apakah itu rasional: i=i++dan i=imenghasilkan hasil yang sama untuki ?

sementara t=i++dan t=imemiliki hasil berbeda untuki .

Operasi pos adalah sesuatu yang harus terjadi setelah evaluasi pernyataan.
Karena itu:

int i=0;
i+=i++;

Seharusnya sama jika kita menulis:

int i=0;
i = i + i ++;

dan karena itu sama dengan:

int i=0;
i= i + i;
i ++;

dan karena itu sama dengan:

int i=0;
i = i + i;
i = i + 1;

Hasil apa pun yang tidak 1 menunjukkan bug dalam kompilator atau bug dalam desain bahasa jika kita menggunakan pemikiran rasional - namun MSDN dan banyak sumber lain memberi tahu kita "hei - ini tidak terdefinisi!"

Sekarang, sebelum saya melanjutkan, bahkan set contoh yang saya berikan ini tidak didukung atau diakui oleh siapa pun .. Namun inilah yang menurut cara intuitif dan rasional seharusnya hasilnya.

Pembuat kode harus tidak memiliki pengetahuan tentang bagaimana majelis sedang ditulis atau diterjemahkan!

Jika ditulis dengan cara yang tidak akan menghormati definisi bahasa - itu adalah bug!

Dan untuk menyelesaikannya, saya menyalin ini dari Wikipedia, operator increment dan decrement :
Karena operator increment / decrement memodifikasi operandnya, penggunaan operan semacam itu lebih dari sekali dalam ekspresi yang sama dapat menghasilkan hasil yang tidak ditentukan . Misalnya, dalam ekspresi seperti x - ++ x, tidak jelas dalam urutan apa operator pengurangan dan penambahan harus dilakukan. Situasi seperti ini menjadi lebih buruk ketika optimasi diterapkan oleh kompiler, yang dapat mengakibatkan urutan pelaksanaan operasi menjadi berbeda dari apa yang diinginkan oleh programmer.

Dan oleh karena itu.

Jawaban yang benar adalah bahwa ini TIDAK HARUS DIGUNAKAN! (karena itu TIDAK DITETAPKAN!)

Ya .. - Ini memiliki hasil yang tidak dapat diprediksi bahkan jika C # complier mencoba menormalkannya.

Saya tidak menemukan dokumentasi C # yang menjelaskan perilaku yang Anda semua dokumentasikan sebagai perilaku bahasa yang normal atau terdefinisi dengan baik. Apa yang saya temukan justru sebaliknya!

[ disalin dari dokumentasi MSDN untuk Operator Peningkatan dan Penurunan Postfix: ++ dan - ]

Ketika operator postfix diterapkan ke argumen fungsi, nilai argumen tidak dijamin akan bertambah atau dikurangi sebelum diteruskan ke fungsi. Lihat bagian 1.9.17 dalam standar C ++ untuk informasi lebih lanjut.

Perhatikan kata-kata itu tidak dijamin ...

Maafkan saya jika jawaban itu tampak sombong - saya bukan orang yang sombong. Saya hanya mempertimbangkan bahwa ribuan orang datang ke sini untuk belajar dan jawaban yang saya baca akan menyesatkan mereka dan akan merusak logika dan pemahaman mereka tentang subjek tersebut.

Operator ++ setelah variabel membuatnya menjadi kenaikan postfix. Penambahan terjadi setelah semua hal lain dalam pernyataan, penambahan dan penugasan. Jika sebaliknya, Anda meletakkan ++ sebelum variabel, itu akan terjadi sebelum nilai i dievaluasi, dan memberi Anda jawaban yang diharapkan.

Langkah-langkah dalam perhitungan adalah:

1. int i=0 // Diinisialisasi ke 0
2. i+=i++ //Persamaan
3. i=i+i++ // setelah menyederhanakan persamaan dengan kompiler
4. i=0+i++ // saya menghargai substitusi
5. i=0+0 // i ++ adalah 0 seperti yang dijelaskan di bawah ini
6. i=0 // Hasil akhir i = 0

Di sini, awalnya nilai iadalah 0. WKT, i++tidak lain adalah: pertama-tama gunakan inilai dan kemudian tambahkan inilainya dengan 1. Jadi menggunakan inilainya, 0, saat menghitung i++dan kemudian menambahkannya dengan 1. Jadi menghasilkan nilai dari 0.

Ada dua opsi:

Opsi pertama: jika kompiler membaca pernyataan sebagai berikut,

i++;
i+=i;

maka hasilnya adalah 2.

Untuk

else if
i+=0;
i++;

hasilnya 1.

Berhati-hatilah: baca FAQ C : apa yang Anda coba lakukan (mencampur tugas dan ++variabel yang sama) tidak hanya tidak ditentukan, tetapi juga tidak ditentukan (artinya kompiler dapat melakukan apa saja saat mengevaluasi !, tidak hanya memberi hasil "masuk akal").

Silakan baca, bagian 3 . Seluruh bagian ini layak dibaca! Terutama 3.9, yang menjelaskan implikasi yang tidak ditentukan. Bagian 3.3 memberi Anda ringkasan singkat tentang apa yang Anda bisa, dan tidak bisa lakukan, dengan "i ++" dan sejenisnya.

Bergantung pada internal kompiler, Anda mungkin mendapatkan 0, atau 2, atau 1, atau bahkan yang lainnya! Dan karena tidak terdefinisi, tidak apa-apa bagi mereka untuk melakukannya.

Ada banyak alasan bagus dalam jawaban di atas, saya hanya melakukan tes kecil dan ingin berbagi dengan Anda

int i = 0;
i+ = i++;

Di sini hasil saya menunjukkan hasil 0. Sekarang pertimbangkan kasus di bawah ini:

Kasus 1:

i = i++ + i; //Answer 1

sebelumnya saya pikir kode di atas menyerupai ini sehingga pada awalnya terlihat jawaban adalah 1, dan jawaban saya untuk yang ini adalah 1.

Kasus 2:

i = i + i++; //Answer 0 this resembles the question code.

di sini operator kenaikan tidak datang di jalur eksekusi, tidak seperti kasus sebelumnya di mana i ++ memiliki kesempatan untuk mengeksekusi sebelum penambahan.

Saya harap ini sedikit membantu. Terima kasih

Berharap untuk menjawab ini dari tipe pemrograman C 101 perspektif.

Sepertinya ini terjadi dalam urutan ini:

1. idievaluasi sebagai 0, menghasilkan i = 0 + 0operasi kenaikan i++"antri", tetapi penugasan 0 untuk ibelum terjadi juga.
2. Peningkatan i++terjadi
3. Penugasan i = 0dari atas terjadi, secara efektif menimpa apa pun yang # 2 (setelah kenaikan) akan dilakukan.

Sekarang, # 2 mungkin tidak pernah benar-benar terjadi (mungkin tidak?) Karena kompiler mungkin menyadari itu tidak akan ada gunanya, tetapi ini bisa jadi tergantung kompiler. Bagaimanapun, jawaban lain yang lebih luas menunjukkan bahwa hasilnya benar dan sesuai dengan standar C #, tetapi tidak ditentukan apa yang terjadi di sini untuk C / C ++.

Bagaimana dan mengapa di luar keahlian saya, tetapi kenyataan bahwa penugasan sisi kanan yang sebelumnya dievaluasi terjadi setelah kenaikan pasca mungkin yang membingungkan di sini.

Selanjutnya, Anda tidak akan mengharapkan hasilnya menjadi 2 terlepas kecuali Anda melakukannya, ++ibukan i++saya percaya.

Sederhananya,

i ++, akan menambahkan 1 ke "i" setelah operator "+ =" selesai.

Yang Anda inginkan adalah ++ i, sehingga akan menambahkan 1 ke "i" sebelum operator "+ =" dieksekusi.

i=0

i+=i

i=i+1

i=0;

Kemudian angka 1 ditambahkan ke i.

i + = i ++

Jadi sebelum menambahkan 1 ke i, iambil nilai 0. Hanya jika kita menambahkan 1 sebelumnya, idapatkan nilai 0.

i+=++i

i=2

Jawabannya adalah iakan1 .

Mari kita lihat caranya:

Mulanya i=0; .

Kemudian sambil menghitung i +=i++;sesuai dengan nilai kita akan memiliki sesuatu seperti 0 +=0++;, jadi menurut operator diutamakan 0+=0akan tampil pertama dan hasilnya akan0 .

Kemudian operator kenaikan akan diterapkan sebagaimana 0++, sebagaimana 0+1dan nilai iakan 1.