diff --git a/apps/echo/init.c b/apps/echo/init.c
index bcb9adf..a281d35 100644
--- a/apps/echo/init.c
+++ b/apps/echo/init.c
@@ -1,5 +1,5 @@
 #include "minilibc.h"
-
+long write(int fd, void *buf, unsigned long count);
 int main(void)
 {
 	char wmsg[]   = "Welcome to Echo program (written in C)!\n";
@@ -7,29 +7,31 @@ int main(void)
 	char token[512];
 	char key[2];
 	int i, p;
-
-	_printf(wmsg);
-	_printf(prompt);
+	write(1,wmsg,sizeof(wmsg));
+	write(1,prompt,sizeof(prompt));
 	p = 0;
 	while (1) {
 		/* Read a key */
-		if (read(0, key, 1) > 0) {
+		if(read(0,key,1)>0){
 			switch (key[0]) {
 				case '\r':
 				case '\n':
 					token[p] = '\0';
-					_printf("Echo: %s\n", token);
-					_printf(prompt);
+					int j = 0;
+					while (token[j] != '\0' && j < p) {
+						write(1, &token[j], 1);
+						j++;
+					}
+					write(1,&"\n",1);
+					write(1,prompt,sizeof(prompt));
 					p = 0;
 					break;
-
 				default:
 					token[p++] = key[0];
 			}
 		}
 	}
 
-	for(;;);
 	return 0;
 }
 
diff --git a/apps/echo/stdlib.c b/apps/echo/stdlib.c
index f4013b2..5a70344 100644
--- a/apps/echo/stdlib.c
+++ b/apps/echo/stdlib.c
@@ -27,30 +27,19 @@
 
 int atoi(const char *nptr)
 {
-	char *nstr = (char *)nptr;
-	char isneg = 0;
-	int sum    = 0;
-	int mult   = 1;
+    int res = 0; 
 
-	if(*nstr == '-') {
-		isneg = 1;
-		nstr++;
-	}
+    int sign = 1; 
 
-	while(*nstr++) {
-		if(*nstr && !isdigit(*nstr))
-			return(0);
-	}
+    int i = 0; 
 
-	nstr--;
-	while(nstr-- != (nptr + isneg)) {
-		sum  += (*nstr - '0') * mult;
-		mult *= 10;
-	}
+    if (nptr[0] == '-') { 
+        sign = -1; 
+        i++; 
+    } 
 
-	if(isneg)
-		return(sum * -1);
-	else
-		return(sum);
+    for (; nptr[i] != '\0'; ++i) 
+        res = res * 10 + nptr[i] - '0'; 
+    return sign * res;
 }
 
diff --git a/kernel/kernel/sched.c b/kernel/kernel/sched.c
index 4069981..0e1e25f 100644
--- a/kernel/kernel/sched.c
+++ b/kernel/kernel/sched.c
@@ -1,105 +1,311 @@
-/*
- * Copyright (C) 2009 Renê de Souza Pinto
- * Tempos - Tempos is an Educational and multi purpose Operating System
- *
- * File: sched.c
- * Desc: The TempOS scheduler
- *
- * This file is part of TempOS.
- *
- * TempOS is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- * 
- * TempOS is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include <tempos/sched.h>
-#include <tempos/kernel.h>
-#include <tempos/timer.h>
-#include <tempos/jiffies.h>
-
-/** Scheduler Quantum */
-static uint32_t scheduler_quantum = (HZ / 100); /* 10 ms */
-
-/** Scheduler time counter */
-static size_t sched_cnt;
-
-/** Linked list of all tasks */
-c_llist *tasks = NULL;
-
-/** Element of list that points to current task */
-c_llist *cur_task = NULL;
-
-/**
- * Initialize the scheduler. This function creates the circular
- * linked list and call architecture specific code to initialize
- * the scheduler.
- */
-void init_scheduler(void (*start_routine)(void*))
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct node /* process node information */
+{
+    char name[20];     /* The name of the process */
+    int priority;          /* priority of the process */
+    int quantum;         /* allocate CPU time slice */
+    int exectime;       /*CPU execution time*/
+    int needtime;      /* time required for process execution*/
+    char state;        /* state of the process, W - ready state, R - execution state, F - completion state */
+    int executions;         /* record the number of executions */
+    struct node *nextNode; /* linked list pointer */
+} ProcessControlBlock;
+
+typedef struct Queue /* multi-level ready queue node information */
 {
-	/* Create circular linked list */
-	c_llist_create(&tasks);
+    ProcessControlBlock *ProcessPointer;       /* Process queue pointer in the ready queue */
+    int priority;           /* priority of this ready queue*/
+    int quantum;          /* time slice allocated by this ready queue*/
+    struct Queue *nextNode; /* Pointer pointer to the next ready queue */
+} ReadyQueue;
 
-	/* Start scheduler time counter */
-	sched_cnt = jiffies + scheduler_quantum;
+ProcessControlBlock *run = NULL, *finish = NULL;             /* defines three queues, ready queue, execution queue and completion queue */
+ReadyQueue *Head = NULL;                     /* defines the first ready queue */
+int num;                                     /* number of processes */
+int ReadyNum;                                /* Ready queue number */
+void Output();                               /*Process information output function*/
+void InsertFinish(ProcessControlBlock *in);                  /* Insert the process into the end of the completion queue*/
+void InsertReady(ReadyQueue *in);             /*Create a ready queue, specifying the smaller the priority number, the lower the priority */
+void CreateReadyQueue();                           /*Create ready queue input function*/
+void GetFirst(ReadyQueue *queue);            /*Get the head process in a ready queue*/
+void InsertLast(ProcessControlBlock *in, ReadyQueue *queue); /*Inserts the process to the end of the ready queue*/
+void ProcessCreate();                        /*Process creation function */
+void RoundRobin(ReadyQueue *timechip);         /* Time slice rotation scheduling algorithm */
+void Scheduling();                             /*Multi-level scheduling algorithm, one time slice per execution*/
 
-	/* Architecture dependent */
-	arch_init_scheduler(start_routine);
+int main(void)
+{
+    CreateReadyQueue();    /*Create ready queue*/
+    ProcessCreate(); /*Create a ready process queue*/
+    Scheduling(); /* algorithm starts*/
+    Output();        /* Output the final dispatch sequence */
+    return 0;
 }
 
+void Output() /*Process information output function*/
+{
+    ReadyQueue *tempReady = Head;
+    ProcessControlBlock *PCB;
+    printf(" -------------------------------------------------------------------------------------------------------------\n");
+    printf("| %7s\t | %6s\t | %8s\t | %8s\t | %9s\t | %7s\t | %10s |\n", "pname", "status", "priority","cpu time","need time", "quantum","executions");
+    printf(" -------------------------------------------------------------------------------------------------------------\n");
+    while (tempReady)
+    {
+        if (tempReady->ProcessPointer != NULL)
+        {
+            PCB = tempReady->ProcessPointer;
+            while (PCB)
+            {
+                printf("| %7s\t | %6c\t | %8d\t | %8d\t | %9d\t | %6d\t | %6d     |\n", PCB->name, PCB->state, PCB->priority, PCB->exectime, PCB->needtime, PCB->quantum, PCB->executions);
+                PCB = PCB->nextNode;
+            }
+        }
+        tempReady = tempReady->nextNode;
+    }
+    PCB = finish;
+    while (PCB != NULL)
+    {
+        printf("| %7s\t | %6c\t | %8d\t | %8d\t | %9d\t | %6d\t | %6d     |\n", PCB->name, PCB->state, PCB->priority, PCB->exectime, PCB->needtime, PCB->quantum, PCB->executions);
+        PCB = PCB->nextNode;
+    }
+    PCB = run;
+    while (PCB != NULL)
+    {
+        printf("| %7s\t | %6c\t | %8d\t | %8d\t | %9d\t | %6d\t | %6d     |\n", PCB->name, PCB->state, PCB->priority, PCB->exectime, PCB->needtime, PCB->quantum, PCB->executions);
+        PCB = PCB->nextNode;
+    }
+    printf(" ---------------------------------------------------------------------------------------------------------------\n");
 
-/**
- * Check if scheduler quantum is expired and
- * make a context switch if necessary.
- * \note This function is executed on each IRQ0 interrupt.
- */
-void do_schedule(pt_regs *regs)
+}
+void InsertFinish(ProcessControlBlock *in) /* Inserts the process into the end of the completion queue */
 {
-	/* Check if the quantum has exceeded */
-	if( !time_after(jiffies, sched_cnt) ) {
-		return;
-	} else {
-		sched_cnt = jiffies + scheduler_quantum;
-		schedule();
-	}
+    ProcessControlBlock *fst;
+    fst = finish;
+
+    if (finish == NULL)
+    {
+        in->nextNode = finish;
+        finish = in;
+    }
+    else
+    {
+        while (fst->nextNode != NULL)
+        {
+            fst = fst->nextNode;
+        }
+        in->nextNode = fst->nextNode;
+        fst->nextNode = in;
+    }
 }
 
+void InsertReady(ReadyQueue *in) /*Creates a ready queue, specifying that the smaller the priority number, the lower the priority*/
+{
+    ReadyQueue *fst, *nxt;
+    fst = nxt = Head;
+
+    if (Head == NULL) /* If there is no queue, it is the first element */
+    {
+        in->nextNode = Head;
+        Head = in;
+    }
+    else /*find the right place to insert */
+    {
+        if (in->priority >= fst->priority) /* is bigger than the first one, it is inserted into the team head */
+        {
+            in->nextNode = Head;
+            Head = in;
+        }
+        else
+        {
+            while (fst->nextNode != NULL) /* Move the pointer to find the position of the first individual small element to insert */
+            {
+                nxt = fst;
+                fst = fst->nextNode;
+            }
 
-/**
- * Decides what task to run and make the task switch.
- *
- * TempOS scheduler uses a round robin policy.
- */
-void schedule(void)
+            if (fst->nextNode == NULL) /* has searched for the end of the team, its priority is the smallest, insert it into the end of the team */
+            {
+                in->nextNode = fst->nextNode;
+                fst->nextNode = in;
+            }
+            else /* is inserted into the queue */
+            {
+                nxt = in;
+                in->nextNode = fst;
+            }
+        }
+    }
+}
+
+void CreateReadyQueue() /*Create ready queue input function */
+{
+    ReadyQueue *tmp;
+    int i;
+
+    printf("[?] Input : Enter Number of ready queues: ");
+    scanf("%d", &ReadyNum);
+
+    for (i = 0; i < ReadyNum; i++)
+    {
+        printf("[?] Input : Enter the CPU time slice for ready queue %d: ", (i+1));
+        if ((tmp = (ReadyQueue *)malloc(sizeof(ReadyQueue))) == NULL)
+        {
+            perror("[-] Malloc : Failed to Allocate Memory !!");
+            exit(1);
+        }
+        scanf("%d", &(tmp->quantum));  /*Enter the CPU time slice allocated to each process in this ready queue*/
+        tmp->priority = 50 - tmp->quantum; /* set its priority, the higher the time slice, the lower its priority */
+        tmp->ProcessPointer = NULL;         /* Initialize the queue of its connected process is empty */
+        tmp->nextNode = NULL;
+        InsertReady(tmp); /*Create multiple ready queues by priority from high to low*/
+    }
+}
+
+void GetFirst(ReadyQueue *queue) /*Get the queue process in a ready queue*/
 {
-	task_t *c_task;
-	c_llist *tmp, *head;
-
-	if (cur_task == NULL) {
-		return;
-	}
-
-	/* do schedule */
-	tmp = head = cur_task;
-	do {
-		tmp = tmp->next;
-		c_task = GET_TASK(tmp);
-		if (c_task->state == TASK_RUNNING || 
-				c_task->state == TASK_READY_TO_RUN) {
-			switch_to(tmp);
-			break;
-		} else {
-			continue;
-		}
-	} while(tmp == head);
+    run = queue->ProcessPointer;
+
+    if (queue->ProcessPointer != NULL)
+    {
+        run->state = 'R';
+        queue->ProcessPointer = queue->ProcessPointer->nextNode;
+        run->nextNode = NULL;
+    }
 }
 
+void InsertLast(ProcessControlBlock *in, ReadyQueue *queue) /*Inserts the process to the end of the ready queue*/
+{
+    ProcessControlBlock *fst;
+    fst = queue->ProcessPointer;
+
+    if (queue->ProcessPointer == NULL)
+    {
+        in->nextNode = queue->ProcessPointer;
+        queue->ProcessPointer = in;
+    }
+    else
+    {
+        while (fst->nextNode != NULL)
+        {
+            fst = fst->nextNode;
+        }
+        in->nextNode = fst->nextNode;
+        fst->nextNode = in;
+    }
+}
+
+void ProcessCreate() /*Process creation function */
+{
+    ProcessControlBlock *tmp;
+    int i;
+
+    printf("[?] Input : Enter number of input processes : ");
+    scanf("%d", &num);
+    for (i = 0; i < num; i++)
+    {
+        printf("[?] Input : Enter process name and process time %d: ", (i+1));
+        if ((tmp = (ProcessControlBlock *)malloc(sizeof(ProcessControlBlock))) == NULL)
+        {
+            perror("[-] Malloc : Failed to Allocate Memory !!");
+            exit(1);
+        }
+        scanf("%s", tmp->name);
+        getchar(); /* absorb the carriage return symbol*/
+        scanf("%d", &(tmp->needtime));
+        tmp->exectime = 0;
+        tmp->state = 'W';
+        tmp->priority = 50 - tmp->needtime; /* set its priority, the more time it takes, the lower the priority */
+        tmp->quantum = Head->quantum;
+        tmp->executions = 0;
+        InsertLast(tmp, Head); /* is inserted into the ready queue according to the priority from high to low*/
+    }
+}
+
+void RoundRobin(ReadyQueue *timechip) /* Time slice rotation scheduling algorithm */
+{
+    int flag = 1;
+
+    GetFirst(timechip);
+    while (run != NULL)
+    {
+        while (flag)
+        {
+            run->executions++;
+            run->exectime++;
+            run->needtime--;
+            if (run->needtime == 0) /*The process is completed*/
+            {
+                run->state = 'F';
+                InsertFinish(run);
+                flag = 0;
+            }
+            else if (run->executions == timechip->quantum) /*time slice is exhausted*/
+            {
+                run->state = 'W';
+                run->executions = 0; /*The counter is cleared to prepare for the next time*/
+                InsertLast(run, timechip);
+                flag = 0;
+            }
+        }
+        flag = 1;
+        GetFirst(timechip);
+        Output();
+    }
+}
+
+void Scheduling() /* Multi-level scheduling algorithm, one time slice per execution*/
+{
+    int flag = 1;
+    int k = 0;
+
+    ReadyQueue *point;
+    point = Head;
+
+    GetFirst(point);
+    while (run != NULL)
+    {
+        Output();
+        if (Head->ProcessPointer != NULL)
+            point = Head;
+        while (flag)
+        {
+            run->executions++;
+            run->exectime++;
+            run->needtime--;
+            if (run->needtime == 0) /*The process is completed*/
+            {
+                run->state = 'F';
+                InsertFinish(run);
+                flag = 0;
+            }
+            else if (run->executions == run->quantum) /*time slice runs out*/
+            {
+                run->state = 'W';
+                run->executions = 0; /*The counter is cleared to prepare for the nextNode time*/
+                if (point->nextNode != NULL)
+                {
+                    run->quantum = point->nextNode->quantum; /*Set the time slice to be the time slice of the next ready queue*/
+                    InsertLast(run, point->nextNode);    /*Inserts the process into the next ready queue*/
+                    flag = 0;
+                }
+                else
+                {
+                    RoundRobin(point); /* If the last ready queue is called, the time slice rotation algorithm */
+                    break;
+                }
+            }
+        }
+        flag = 1;
+        if (point->ProcessPointer == NULL) /*Ready queue pointer down */
+            point = point->nextNode;
+        if (point->nextNode == NULL)
+        {
+            RoundRobin(point);
+            break;
+        }
+        GetFirst(point);
+    }
+}