diff --git a/src/threads/synch.c b/src/threads/synch.c
index 2431494..387f060 100644
--- a/src/threads/synch.c
+++ b/src/threads/synch.c
@@ -114,22 +114,13 @@ sema_up (struct semaphore *sema)
   ASSERT (sema != NULL);
 
   old_level = intr_disable ();
-
-  /* Wake up (unblock) the highest priority thread from the waiters list */
-  struct thread *t = NULL;
-  if (!list_empty (&sema->waiters))
-    {
-      t = list_entry (list_pop_front (&sema->waiters), struct thread, elem);
-      thread_unblock (t);
-    }
-
+  if (!list_empty (&sema->waiters)) 
+    thread_unblock (list_entry (list_pop_front (&sema->waiters),
+                                struct thread, elem));
   sema->value++;
   intr_set_level (old_level);
 
-  /* If the unblocked thread has higher priority than the current running thread
-     then yield the CPU to the unblocked thread */
-  if (!intr_context() && t != NULL && t->priority > thread_get_priority ())
-    thread_yield ();
+  thread_yield ();
 }
 
 static void sema_test_helper (void *sema_);
@@ -355,14 +346,7 @@ cond_wait (struct condition *cond, struct lock *lock)
   ASSERT (lock_held_by_current_thread (lock));
   
   sema_init (&waiter.semaphore, 0);
-
-  /* Insert the semaphore_elem into the waiters list in order of priority.
-     We pass the priority of the current thread as aux to sema_priority_more
-     because the thread has not been sema'd down yet (See sema_priority_more) */
-  int priority = thread_current ()->priority;
-  list_insert_ordered (&cond->waiters, &waiter.elem, sema_priority_more,
-                       &priority);
-
+  list_push_back (&cond->waiters, &waiter.elem);
   lock_release (lock);
   sema_down (&waiter.semaphore);
   lock_acquire (lock);
diff --git a/src/threads/thread.c b/src/threads/thread.c
index 67d08d1..e587626 100644
--- a/src/threads/thread.c
+++ b/src/threads/thread.c
@@ -219,10 +219,7 @@ thread_create (const char *name, int priority,
 
   /* Add to run queue. */
   thread_unblock (t);
-
-  /* Yield if the new thread has a higher priority than the current thread. */
-  if (priority > thread_get_priority ())
-    thread_yield ();
+  thread_yield ();
 
   return tid;
 }
@@ -335,7 +332,7 @@ thread_yield (void)
   old_level = intr_disable ();
 
   /* Insert the thread back into the ready list in priority order. */
-  if (cur != idle_thread) 
+  if (cur != idle_thread)
     list_insert_ordered(&ready_list, &cur->elem, priority_more, NULL);
 
   cur->status = THREAD_READY;
@@ -386,31 +383,8 @@ thread_set_priority (int new_priority)
 
   thread_current ()->priority = new_priority;
 
-  enum intr_level old_level = intr_disable ();
-
-  /* If the thread is in the ready list, the list must be reordered to maintain
-    the priority order. */
-  if (thread_current ()->status == THREAD_READY) {
-    /* Remove from the ready list and reinsert it in priority order. */
-    list_remove (&thread_current ()->elem);
-    list_insert_ordered (&ready_list, &thread_current ()->elem, priority_more,
-                         NULL);
-  }
-
-  if (new_priority < old_priority && !list_empty (&ready_list)) {
-    /* If the new priority is lower than the old priority, check if the current
-       thread no longer has the highest priority. If it doesn't, yield the CPU.
-     */
-
-    struct thread *next_thread =
-      list_entry (list_front (&ready_list), struct thread, elem);
-
-    if (next_thread->priority > new_priority) {
-      thread_yield();
-    }
-  }
-
-  intr_set_level (old_level);
+  if (new_priority < old_priority)
+    thread_yield ();
 }
 
 /* Returns the current thread's priority. */
diff --git a/src/threads/thread.h b/src/threads/thread.h
index 1cde088..a4a2439 100644
--- a/src/threads/thread.h
+++ b/src/threads/thread.h
@@ -141,4 +141,7 @@ void thread_set_nice (int);
 int thread_get_recent_cpu (void);
 int thread_get_load_avg (void);
 
+/* Returns true iff the priority of the first list element's thread is greater
+   than that of the second list element's thread. */
+list_less_func thread_priority_greater;
 #endif /* threads/thread.h */