clock置換演算法

⑴ 頁面置換演算法的常見的置換演算法

最簡單的頁面置換演算法是先入先出（FIFO）法。這種演算法的實質是，總是選擇在主存中停留時間最長（即最老）的一頁置換，即先進入內存的頁，先退出內存。理由是：最早調入內存的頁，其不再被使用的可能性比剛調入內存的可能性大。建立一個FIFO隊列，收容所有在內存中的頁。被置換頁面總是在隊列頭上進行。當一個頁面被放入內存時，就把它插在隊尾上。
這種演算法只是在按線性順序訪問地址空間 時才是理想的，否則效率不高。因為那些常被訪問的頁，往往在主存中也停留得最久，結果它們因變「老」而不得不被置換出去。
FIFO的另一個缺點是，它有一種異常現象，即在增加存儲塊的情況下，反而使缺頁中斷率增加了。當然，導致這種異常現象的頁面走向實際上是很少見的。
FIFO演算法和OPT演算法之間的主要差別是，FIFO演算法利用頁面進入內存後的時間長短作為置換依據，而OPT演算法的依據是將來使用頁面的時間。如果以最近的過去作為不久將來的近似，那麼就可以把過去最長一段時間里不曾被使用的頁面置換掉。它的實質是，當需要置換一頁時，選擇在之前一段時間里最久沒有使用過的頁面予以置換。這種演算法就稱為最久未使用演算法（Least Recently Used，LRU）。
LRU演算法是與每個頁面最後使用的時間有關的。當必須置換一個頁面時，LRU演算法選擇過去一段時間里最久未被使用的頁面。
LRU演算法是經常採用的頁面置換演算法，並被認為是相當好的，但是存在如何實現它的問題。LRU演算法需要實際硬體的支持。其問題是怎麼確定最後使用時間的順序，對此有兩種可行的辦法：
1.計數器。最簡單的情況是使每個頁表項對應一個使用時間欄位，並給CPU增加一個邏輯時鍾或計數器。每次存儲訪問，該時鍾都加1。每當訪問一個頁面時，時鍾寄存器的內容就被復制到相應頁表項的使用時間欄位中。這樣我們就可以始終保留著每個頁面最後訪問的「時間」。在置換頁面時，選擇該時間值最小的頁面。這樣做， 不僅要查頁表，而且當頁表改變時（因CPU調度）要 維護這個頁表中的時間，還要考慮到時鍾值溢出的問題。
2.棧。用一個棧保留頁號。每當訪問一個頁面時，就把它從棧中取出放在棧頂上。這樣一來，棧頂總是放有目前使用最多的頁，而棧底放著目前最少使用的頁。由於要從棧的中間移走一項，所以要用具有頭尾指針的雙向鏈連起來。在最壞的情況下，移走一頁並把它放在棧頂上需要改動6個指針。每次修改都要有開銷，但需要置換哪個頁面卻可直接得到，用不著查找，因為尾指針指向棧底，其中有被置換頁。
因實現LRU演算法必須有大量硬體支持，還需要一定的軟體開銷。所以實際實現的都是一種簡單有效的LRU近似演算法。
一種LRU近似演算法是最近未使用演算法（Not Recently Used，NUR）。它在存儲分塊表的每一表項中增加一個引用位，操作系統定期地將它們置為0。當某一頁被訪問時，由硬體將該位置1。過一段時間後，通過檢查這些位可以確定哪些頁使用過，哪些頁自上次置0後還未使用過。就可把該位是0的頁淘汰出去，因為在之前最近一段時間里它未被訪問過。
4）Clock置換演算法（LRU演算法的近似實現）
5）最少使用（LFU）置換演算法
在採用最少使用置換演算法時，應為在內存中的每個頁面設置一個移位寄存器，用來記錄該頁面被訪問的頻率。該置換演算法選擇在之前時期使用最少的頁面作為淘汰頁。由於存儲器具有較高的訪問速度，例如100 ns，在1 ms時間內可能對某頁面連續訪 問成千上萬次，因此，通常不能直接利用計數器來記錄某頁被訪問的次數，而是採用移位寄存器方式。每次訪問某頁時，便將該移位寄存器的最高位置1，再每隔一定時間(例如100 ns)右移一次。這樣，在最近一段時間使用最少的頁面將是∑Ri最小的頁。
LFU置換演算法的頁面訪問圖與LRU置換演算法的訪問圖完全相同；或者說，利用這樣一套硬體既可實現LRU演算法，又可實現LFU演算法。應該指出，LFU演算法並不能真正反映出頁面的使用情況，因為在每一時間間隔內，只是用寄存器的一位來記錄頁的使用情況，因此，訪問一次和訪問10 000次是等效的。
6）工作集演算法
7）工作集時鍾演算法
8）老化演算法（非常類似LRU的有效演算法）
9）NRU(最近未使用）演算法
10）第二次機會演算法
第二次機會演算法的基本思想是與FIFO相同的，但是有所改進，避免把經常使用的頁面置換出去。當選擇置換頁面時，檢查它的訪問位。如果是 0，就淘汰這頁；如果訪問位是1，就給它第二次機會，並選擇下一個FIFO頁面。當一個頁面得到第二次機會時，它的訪問位就清為0，它的到達時間就置為當前時間。如果該頁在此期間被訪問過，則訪問位置1。這樣給了第二次機會的頁面將不被淘汰，直至所有其他頁面被淘汰過（或者也給了第二次機會）。因此，如果一個頁面經常使用，它的訪問位總保持為1，它就從來不會被淘汰出去。
第二次機會演算法可視為一個環形隊列。用一個指針指示哪一頁是下面要淘汰的。當需要一個 存儲塊時，指針就前進，直至找到訪問位是0的頁。隨著指針的前進，把訪問位就清為0。在最壞的情況下，所有的訪問位都是1，指針要通過整個隊列一周，每個頁都給第二次機會。這時就退化成FIFO演算法了。

⑵ 頁面訪問序列怎麼求

一般採用以下幾種演算法
1、最佳置換演算法
2、先進先出置換演算法
3、最近最久未使用置換演算法
4、改進型Clock置換演算法
5、頁面緩沖置換演算法
例如
已知頁面大小為100，則可分成第1頁：0-100，第2頁：100-200.。。。第5頁：400-500
根據已知進程訪問序列，可知10在第1頁內，11在第1頁內，以此類推得出頁面訪問序列：
1,1,2,2,1,4，2,3,3,5,5,4
頁面訪問的序列串是一個整數序列，需要我們編寫函數生成，要求整數的取值范圍為0-N-1。頁面訪問序列串中的每個元素p表示對頁面p的一次訪問。1.確定虛擬內存的尺寸N，工作集的起始位置p，工作集中包含的頁數e，工作集移動率m（每處理m個頁面訪問則將起始位置p +1），以及一個范圍在0和1之間的值t；2.生成m個取值范圍在p和p + e間的隨機數，並記錄到頁面訪問序列串中； 3.生成一個隨機數r，0 ≤ r ≤ 1；4.如果r < t，則為p生成一個新值，否則p = (p + 1) mod N； 5.如果想繼續加大頁面訪問序列串的長度，請返回第2步，否則結束。

⑶ 誰能給個詳細的clock置換演算法

教材是王道。說白了就是如果訪問位是1就置零，繼續掃，如果是零就換出。改進的需要考慮修改位

⑷ nru演算法----改進型"clock"演算法

CLOCK演算法的性能比較接近LRU，而通過增加使用的位數目，可以使得 CLOCK演算法更加高效。在使用位的基礎上再增加一個修改位，則得到改進型的 CLOCK置換演算法。這樣，每一幀都處於以下四種情況之一：
1）最近未被訪問，也未被修改（u=0，m=0）
2）最近被訪問，但未被修改（u=1，m=0）。
3）最近未被訪問，但被修改（u=0，m=1）
4）最近被訪問，被修改（u=1，m=1）
演算法執行如下操作步驟：
1）從指針的當前位置開始，掃描幀緩沖區。在這次掃描過程中，對使用位不做任何修改。選擇遇到的第一個幀（u=0，m=0）用於替換。
2）如果第1）步失敗，則重新掃描，查找（u=0，m=1）的幀。選擇遇到的第一個這樣的幀用於替換。在這個掃描過程中，對每個跳過的幀，把它的使用位設置成0。

3）如果第2）步失敗，指針將回到它的最初位置，並且集合中所有幀的使用位均為0。重復第1步，並且如果有必要，重復第2步。這樣將可以找到供替換的幀。
改進型的 CLOCK演算法優於簡單CLOC演算法之處在於替換時首選沒有變化的頁。由於修改過的頁在被替換之前必須寫回，因而這樣做會節省時間。

⑸ 進程/作業/頁面調度演算法

進程已獲得除CPU之外的所有必須資源,只等待操作系統利用CPU調度演算法將CPU分配給該進程以便執行。

進程等待某一特定事件的出現。如[I/O操作,在該過程中,進程依舊位於內存內,且佔有CPU資源。

（1）靜態優先數法：
一開始創建的時候就確定他的優先數，並在運行時保持不變。確定優先數時可以讓外設的進程優先，或者操作時間長的優先....

（2）動態優先數法：
克服無法修改優先數的問題。CPU佔用時間過長優先數下降，進程等待時間過長，優先數提高。

時間片太短切換開銷太大不劃算，太長又變成了FCFS。

引入多個就緒隊列，在時間片輪轉基礎上改進

最高優先順序隊列運行一個時間片，次高兩個，低優先順序四個。當該進程用完所分配時間片仍未執行完時，需要調入下一級隊列，下一級隊列只有在上一級隊列為空時才有機會執行。如果進程執行時有新進程進入上級優先順序渣燃返的隊列，則會中斷該進程並放入原隊列的隊尾然後執行新進程。

非搶占式的先來先服務（First Come First Severd, FCFS）演算法了。

顧名思義，先來後到，每次從就緒隊列選擇最先進入隊列的進程，然後一直運行，直到進程退出或被阻塞，才會繼續從隊列中選擇第一個進程接著運行。

這似乎很公平，但是當一個長作業先運行了，那麼後面的短作業等待的時間就會很長，不利於短作業。

最短作業優先（Shortest Job First, SJF）調度演算法同樣也是顧名思義，它會優先選擇運行時間最短的進程來運行，這有助於提高系統的吞吐量。

這顯然對長作業不利，很容易造成一種極端現象。

高響應比優先 （Highest Response Ratio Next, HRRN）調度演算法主要是權衡了短作業和長作業。

每次進行進程調度時，先計算「響應比優先順序」，然後把「響應比優先順序」最高的進程投入運行，「響應比優先順序」的計算公式：

最古老、最簡單、最公平且使用最廣的演算法就是時間片輪轉（Round Robin, RR）調度演算法。

時間片的長度就是一個很關鍵的點：

如果時間片設得太短會導致過多的進程上下文切換，降低了 CPU 效率；如果設得太長又可能引起對短作業進程的響應時間變長。

靜態優先順序：創建進程時候，就已經確定了優先順序了，然後整個運行時間優先順序都不會變化；

動態優先順序：根據進程的動態變化調整優先順序，比如如果進程運行時間增加，則降低其優先順序，如果進程等待時間（就緒隊列的等待時間）增加，則升高其優先順序，也就是隨著時間的推移增加等待進程的優先順序。

（1）非搶占式：當就緒隊列中出現優先順序高的進程，運行完當前進程，再選擇優先順序高的進程。
（2）搶占式：當就緒隊列中出現優先順序高的進程，當前進程掛起，調度優先順序高的進程運行。

但是依然有缺點，可能會導致低優先順序的進程永遠不會運行。

設置了多個隊列，賦予每個隊列不同的優先順序，每個隊列優先順序從高到低，同時優先順序越高時間片越短；

新的進程會被放入到第一級隊列的末尾，按先來先服務的原則排隊等待被調度，如果在第一級隊列規定的時間片沒運行完成，則將其轉入到第二級隊列的末尾，段談以此類推，直至完成；

當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程運行。如果進程運行時，有新進程進入較高優先順序的隊列，則停止當前運行的進程並將其移入到原隊列末尾，接著讓較高優先順序的進程運行。

對於短作業可能可以在第一級隊列很快被處理完。對於長作如飢業，如果在第一級隊列處理不完，可以移入下次隊列等待被執行，雖然等待的時間變長了，但是運行時間也會更長了，所以該演算法很好的兼顧了長短作業，同時有較好的響應時間。

每次選擇淘汰的頁面將是以後永不使用，或者在最長時間內不再被訪問的頁面，這樣可以保證最低的缺頁率。

最佳置換演算法可以保證最低的缺頁率，但是實際上，只有進程執行的過程中才能知道接下來會訪問到的是哪個頁面。操作系統無法提前預判頁面的訪問序列。因此，最佳置換演算法是無法實現的。

演算法思想：每次選擇淘汰的頁面是最早進入內存的頁面。

該演算法很簡單，每次淘汰最在內存中待時間最久的各個，下面分別給出系統為進程分為配三個內存塊和四個內存塊的執行情況圖。訪問序列為3,2,1,0,3,2,4,3,2,1,0,4

演算法思想：每次淘汰的頁面是最近最久未使用的頁面。

實現方法：賦予每個頁面對應的頁表項中，用訪問欄位記錄該頁面自上次被訪問以來所經歷的時間t。當需要淘汰一個頁面時，選擇現有頁面中t最大的頁面，即最近最久未使用。

最佳置換演算法性能最好，但無法實現。先進先出置換演算法實現簡單，但是演算法性能差。最近最久未使用置換演算法性能好，是最接近OPT演算法性能的，但是實現起來需要專門的硬體支持，演算法開銷大。時鍾置換演算法是一種性能和開銷均平衡的演算法。又稱CLOCK演算法，或最近未用演算法（NRU，Not Recently Used）

簡單CLOCK演算法演算法思想：為每個頁面設置一個訪問位，再將內存中的頁面都通過鏈接指針鏈接成一個循環隊列。當某個頁被訪問時，其訪問位置1.當需要淘汰一個頁面時，只需檢查頁的訪問位。如果是0，就選擇該頁換出；如果是1，暫不換出，將訪問位改為0，繼續檢查下一個頁面，若第一輪掃描中所有的頁面都是1，則將這些頁面的訪問位一次置為0後，再進行第二輪掃描（第二輪掃描中一定會有訪問位為0的頁面，因此簡單的CLOCK演算法選擇一個淘汰頁面最多會經過兩輪掃描）。

除了考慮一個頁面最近有沒有被訪問過之外，操作系統還需要考慮頁面有沒有被修改過。

改進型時鍾置換演算法的演算法思想：在其他在條件相同時，應該優先淘汰沒有被修改過的頁面，從而來避免I/O操作。

⑹ 操作系統CLOCK置換演算法的題目，急求解！！

因為一個目錄文件最多可以由4個磁碟塊組成，讀目錄和下級目錄的時候，在最好的情況下，總能在第一個磁碟塊上就能找到所需的下級目錄信息，所以ADKQ四個目錄讀四次就可以了，此後是讀文件，理想情況下所需頁面可以通過前10個索引直接找到，此時只需再讀一次就能讀到所需頁了，結果最少共用5次

最壞情況下，每個目錄都存放在4個磁碟塊的最後一個上，因此每個目錄都得讀四次，一共4*4=16次，而找到文件後，所需頁面又得通過2級索引去找，這樣一來2級索引表讀一次，1級索引表又讀一次，頁面本身內容再讀一次，又需2+1=3次，所以最壞情況就是16+3=19次

⑺ 對於問題小孩這門課所學所識有什麼啟發

我做了這么多年幼師，一直在想幼兒園的小孩是否全部都是天真快樂呢？是否全部都能友好相處呢？這些問題一直縈繞在我的心中，直到我讀了《幼兒園里的「問題小孩」》,我這個疑惑的雲朵才被撥開。

對於《幼兒園里的「問題小孩」》這一本書的總體評價，我認為這是一本基於作者理論學養於實踐經驗的原創之作，站在一個幼師的角度，我認為要以身作則，去在現實中發現書中存在的「問題」小孩，學會更多的專業知識去輔導孩子的心理，引導他們積極向上，懂得生活的美好。

在書中，論述圍繞幼兒園課程的課程價值，分析了幼兒園教學內容有別於其他階段的特質，從課程與教學的視角，澄清了長期以來幼兒園教育設計中諸多群體性、無意識的錯誤做法。語言淺白通俗又不失學理思考，雖脫胎於日常的授課講義，又從讀者的閱讀心理出發設計了靈動的閱讀結構，為職前、職後的幼兒園教師提供了有價值的學習與指導。

書中描述的一個很典型的現象就是幼兒的「隱蔽性」說謊，是指幼兒在特定環境下因為某種原因而隱蔽地說謊，這對剛處在萌芽階段的幼兒有很不利的影響。由於幼兒「心靈的純潔」，他們在真實的偽裝下說謊時，往往會顯得很不自然，對他們心靈的摧殘也是顯而易見的，因此，教導幼兒學會真誠，多和幼兒熟悉，多聽他們的心事，也是我讀完這本書的一個很大的感悟。

書中描述的幼兒園中存在的問題小孩主要有下面這八個問題：磨蹭、倔強、叛逆、暴力、吹牛、撒謊、孤僻，這些都是一個人成長中起阻礙的消極面，書中主要描寫了從行為規范、心理健康、培養個性、解決叛逆等問題入手，以幼兒園和家長的雙角度去更好地描述這本書的主題思想，帶給普世大眾對幼兒園教育中的解決。其中，書中展現的「榜樣模範」也是讓我記憶尤深的，一個好的集體需要好的帶領人，在幼兒中建立榜樣模範，可以讓幼兒培養良好的習慣，汲取優秀的品質從而培養真誠善良的性格，良好的學習升高習慣，有益於幼兒集體的發展。

總之，幼兒園里的孩子作為稚嫩的花朵，必然需要社會上人們的關懷，作為幼兒園老師和家長，我們要學會用愛去鼓勵孩子，去呵護每一個嬌嫩的花朵，使他們尋回自信和堅強，讓他們能以更好的姿態去迎接生活中的困難，去呵護每一個幼兒園孩子，培養他們優良的品格，成為國家未來的中流砥柱.

⑻ 實現虛擬存儲器最常用的演算法是哪個

頁式虛擬存儲器的頁面置換演算法一般有：
最佳置換演算法（OPT），先進先出置換演算法（FIFO），最近最久未使用置換演算法（LRU），Clock置換演算法，最少使用置換演算法（拆困LFU），頁面緩存演算法（PBA）等。
先進先出（FIFO）置換演算法是最直觀的置換演算法，由於它可能是性能最差的演算法，故實際應攜簡用極少。（摘錄自湯旅隱念的教材）

⑼ 計算機操作系統中頁面置換的三種方式

常見的置換演算法有：
1．最佳置換演算法（OPT）（理想置換演算法）
2．先進先出置換演算法（FIFO）：
3．最近最久未使用（LRU）演算法
4．Clock置換演算法改御（LRU演算法的近似實現坦陪）核信岩
5．最少使用（LFU）置換演算法
6．工作集演算法
7 . 工作集時鍾演算法
8. 老化演算法（非常類似LRU的有效演算法）
9. NRU(最近未使用）演算法
10. 第二次機會演算法

⑽ C++編程，clock置換演算法

#include<iostream>
#include<stdlib.h>
#include<time.h>
#define N 20 //虛擬內存尺寸
using namespace std;

int P;
int const blockCount=3 ;//內存中的物理塊數
int count = 0;
int block[blockCount];
int const PageCount=15;//總的頁面數
int Page[PageCount];
int state[blockCount];//clock置換演算法中，內存中的每個頁面號對應的狀態
int state2[blockCount][2];// 二維數組，第一行第一列為訪問位，第一行的第二列為修改位
double lost= 0.0;

void generate_list(int *list,int e,int m,int t)
{
int i,j=0,q=P,r;
srand((unsigned)time(NULL));
while(j<e)
{
for(i=j;i<j+m;i++)
{
if(i==e)
break;
list[i]=(q+rand()%e)%N; //保證在虛擬內存的頁號內
}
j=i;
r=rand()%100;
if(r<t)
q=rand()%N;
else
q=(q+1)%N;
}
}

//隨機生產是否被修改的情況，prop(0……100),prop/100的概率為被修改
void generate_modify(int *mo,int e,int prop)
{
int i,t;
for(i=0;i<e;i++)
{
t=rand()%100;
if(t>prop)
mo[i]=0;
else
mo[i]=1;
}
}

//檢測頁號是否在內存中
bool inblock(int num)
{
for(int i=0; i<blockCount;i++)
{
if(block[i] == Page[num])
{
state[i] = 1;
return true;
}
}
return false;
}

//判斷頁面是否已經被修改
bool change()
{
if((rand()%2+1) == 1 )
{
printf("該頁面被修改!\n");
return true;
}
else
return false;
}

//用於改進型clock置換演算法，檢測頁號是否在內存中並把訪問位和修改位置1
bool inblock2(int num)
{
for(int i=0;i<blockCount;i++){
if(block[i] == Page[num]){
if(change()){
state2[i][0] = 1;
state2[i][1] = 1;
}
else{
state2[i][0] = 1;
}
return true;
}
}
return false;
}

//用於改進型clock置換演算法，判斷內存中第幾個需要被置換
int whichpage(){

int j;

for(j=0;j<blockCount;j++)
{
if(state2[j][0] == 0&&state2[j][1] == 0)
{
return j;
}
}
for(j=0;j<blockCount;j++ )
{
if(state2[j][0] == 0&&state2[j][1] == 1)
{
return j;
}
state2[j][0] = 0 ;
}
for(j=0;j<blockCount;j++ )
{
state2[j][0] =0 ;
}
return whichpage();
}

//簡單Clock置換演算法
void CLOCK(int num)
{
int j;

if(inblock(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block [i]);
}
else
if(count == blockCount)
{
//lost++;
for(j=0;j<blockCount; )
{
if(state[j] == 0)
{
break;
}
else{
state[j] = 0;
}
j++;
j = j%3;
}
block[j] = Page[num];
state[j] = 1;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block[i]);
}
}

//改進型clock置換演算法
void LCLOCK(int num)
{
int j;

if(inblock2(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block[i]);
}
else
if(count == blockCount)
{
//lost++;
j = whichpage();
block[j] = Page[num];
state2[j][0] = 1;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理塊%d#中內容:%d\n",i,block[i]);
}
}

int main()
{
int a[N];
int mo[N];
int A=10;
int e,m,prop,t,j;
printf("頁面走向為：");
generate_list(a, e,m,t);
generate_modify(mo,e,prop);

for(int i = 0;i<PageCount;i++)
{

Page[i] =rand()%9 + 1;
printf("%d ",Page[i]);
}
char ch ;
printf("\n");
printf("\t\t1 Clock置換演算法\n");
printf("\t\t2 改進型Clock置換演算法\n");
printf("\t\t3 退出!\n\n");
printf("請輸入演算法序號:\t\n");
while(1){
scanf("%c",&ch);
switch(ch){
case '1':{
lost=0;
count=0;
for(int m=0;m<blockCount;m++)
{
state[m] = 0;
}
for(int j=0;j<blockCount;j++)
{
block[j]=0;
}
for(int i=0;i<PageCount;i++)
{
printf("讀入Page[%d]\n",i);
CLOCK(i);
}
printf("頁面訪問次數: %d\n缺頁次數: %0.lf\n",PageCount,PageCount-lost);
printf("缺頁率為:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n請輸入演算法序號:\t");
}break;
case '2':{
lost = 0;
count = 0;
for(int m = 0; m < blockCount; m++)
{
for(int n = 0; n < 2;n++)
state2[m][n] = 0;
}
for(int j = 0; j < blockCount; j++)
{
block[j] = 0;
}
for(int i = 0; i < PageCount; i++)
{
printf("讀入Page[%d]\n",i);
LCLOCK(i);
}
printf("頁面訪問次數: %d\n缺頁次數: %0.lf\n",PageCount,PageCount-lost);
printf("缺頁率為:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n請輸入演算法序號:\t");
}break;
case '3':{
exit(0);
}
}
}
return 0;
}