diff --git a/Circular_kernel_2/include/CGAL/Filtered_hexagon_circular_kernel_2/hexagon_primitives.h b/Circular_kernel_2/include/CGAL/Filtered_hexagon_circular_kernel_2/hexagon_primitives.h
index 0f5680992a7..2a4c1273781 100644
--- a/Circular_kernel_2/include/CGAL/Filtered_hexagon_circular_kernel_2/hexagon_primitives.h
+++ b/Circular_kernel_2/include/CGAL/Filtered_hexagon_circular_kernel_2/hexagon_primitives.h
@@ -510,7 +510,7 @@ template < class CK, class Hexagon>
       Conv cnv;
       static const bool Protection = true;
       try{return CGALi::construct_bounding_hexagons_2<CK2>(cnv(a),res);}
-      catch (Interval_nt_advanced::unsafe_comparison)
+      catch (Uncertain_conversion_exception)
       {
          CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
          return CGALi::construct_bounding_hexagons_2<CK>(a,res);
@@ -523,7 +523,7 @@ template < class CK, class Hexagon>
       Conv cnv;
       static const bool Protection = true;
       try{return CGALi::construct_bounding_hexagon_for_line_arc_2<CK2>(cnv(a));}
-      catch (Interval_nt_advanced::unsafe_comparison)
+      catch (Uncertain_conversion_exception)
       {
          CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
          return CGALi::construct_bounding_hexagon_for_line_arc_2<CK>(a);
@@ -548,7 +548,7 @@ template < class CK, class Hexagon>
     { 
       static const bool Protection = true;      
       try{return CGALi::construct_bounding_hexagons_2<typename CK::AK>(a.approx(),res);}
-      catch (Interval_nt_advanced::unsafe_comparison)
+      catch (Uncertain_conversion_exception)
       {
          CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
          return CGALi::construct_bounding_hexagons_2<typename CK::EK>(a.exact(),res);
@@ -560,7 +560,7 @@ template < class CK, class Hexagon>
     { 
       static const bool Protection = true;
       try{return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::AK>(a.approx());}
-      catch (Interval_nt_advanced::unsafe_comparison)
+      catch (Uncertain_conversion_exception)
       {
          CGAL::Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
          return CGALi::construct_bounding_hexagon_for_line_arc_2<typename CK::EK>(a.exact());
diff --git a/Circular_kernel_2/include/CGAL/Lazy_circular_kernel_constructions.h b/Circular_kernel_2/include/CGAL/Lazy_circular_kernel_constructions.h
index bd976536284..59bce6bd2ff 100644
--- a/Circular_kernel_2/include/CGAL/Lazy_circular_kernel_constructions.h
+++ b/Circular_kernel_2/include/CGAL/Lazy_circular_kernel_constructions.h
@@ -130,7 +130,7 @@ public:
 	}
       }
       
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       // TODO: Instead of using a vector, write an iterator adapter
@@ -198,7 +198,7 @@ public:
 	}
       }
       
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       // TODO: Instead of using a vector, write an iterator adapter
@@ -267,7 +267,7 @@ public:
 	}
       }
       
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       // TODO: Instead of using a vector, write an iterator adapter
@@ -350,7 +350,7 @@ template <typename L1>
         else {
 	std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl;
       }
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       ET eto = ec(CGAL::exact(l1));
@@ -401,7 +401,7 @@ template <typename L1>
         else {
 	std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's" << std::endl;
       }
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       ET eto = ec(CGAL::exact(l1), CGAL::exact(l2));
diff --git a/Filtered_kernel/include/CGAL/Filtered_predicate.h b/Filtered_kernel/include/CGAL/Filtered_predicate.h
index 8f629844afa..d7525ad6568 100644
--- a/Filtered_kernel/include/CGAL/Filtered_predicate.h
+++ b/Filtered_kernel/include/CGAL/Filtered_predicate.h
@@ -161,7 +161,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(args)...);
@@ -183,7 +183,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1));
@@ -203,7 +203,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ")+ std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2));
@@ -223,7 +223,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3));
@@ -243,7 +243,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4));
@@ -264,7 +264,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5));
@@ -285,7 +285,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6));
@@ -308,7 +308,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7));
@@ -331,7 +331,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
@@ -356,7 +356,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
@@ -381,7 +381,7 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
       if (is_certain(res))
         return get_certain(res);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
diff --git a/Filtered_kernel/include/CGAL/Lazy.h b/Filtered_kernel/include/CGAL/Lazy.h
index 68c56de5f68..a78c85e6c17 100644
--- a/Filtered_kernel/include/CGAL/Lazy.h
+++ b/Filtered_kernel/include/CGAL/Lazy.h
@@ -1184,7 +1184,7 @@ struct Lazy_construction_bbox
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return ac(CGAL::approx(l1));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return ec(CGAL::exact(l1));
@@ -1214,7 +1214,7 @@ struct Lazy_construction_nt {
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return new Lazy_rep_1<AC, EC, To_interval<ET>, L1>(ac, ec, l1);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1)));
@@ -1228,7 +1228,7 @@ struct Lazy_construction_nt {
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return new Lazy_rep_2<AC, EC, To_interval<ET>, L1,L2>(ac, ec, l1,l2);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2)));
@@ -1242,7 +1242,7 @@ struct Lazy_construction_nt {
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return new Lazy_rep_3<AC, EC, To_interval<ET>, L1,L2,L3>(ac, ec, l1,l2,l3);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3)));
@@ -1256,7 +1256,7 @@ struct Lazy_construction_nt {
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return new Lazy_rep_4<AC, EC, To_interval<ET>, L1,L2,L3,L4>(ac, ec, l1,l2,l3,l4);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4)));
@@ -1270,7 +1270,7 @@ struct Lazy_construction_nt {
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return new Lazy_rep_5<AC, EC, To_interval<ET>, L1,L2,L3,L4,L5>(ac, ec, l1,l2,l3,l4,l5);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return new Lazy_rep_0<AT,ET,To_interval<ET> >(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5)));
@@ -1429,7 +1429,7 @@ public:
       Protect_FPU_rounding<Protection> P;
       // we suppose that R1 is a Lazy<Something>
       r1 = R1(new Lazy_rep_2_1<AC, EC, E2A, L1, L2, R1>(ac, ec, l1, l2));
-    } catch(Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       typename R1::ET et;
@@ -1497,7 +1497,7 @@ public:
       // lv->approx() is a std::pair<R1::AT, R2::AT>;
       r1 = R1(new Lazy_rep_1<First<std::pair<typename R1::AT, typename R2::AT> >, First<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(First<std::pair<typename R1::AT, typename R2::AT> >(), First<std::pair<typename R1::ET, typename R2::ET> >(), lv));
       r2 = R2(new Lazy_rep_1<Second<std::pair<typename R1::AT, typename R2::AT> >, Second<std::pair<typename R1::ET, typename R2::ET> >, E2A, Lazy_pair>(Second<std::pair<typename R1::AT, typename R2::AT> >(), Second<std::pair<typename R1::ET, typename R2::ET> >(), lv));
-    } catch(Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       typename R1::ET et1, et2;
@@ -1554,7 +1554,7 @@ public:
         std::cerr << "we need  more casts" << std::endl;
       }
 
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       // TODO: Instead of using a vector, write an iterator adapter
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
@@ -1633,7 +1633,7 @@ public:
       std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl;
       std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl;
 
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       ET eto = ec(CGAL::exact(l1));
@@ -1666,7 +1666,7 @@ public:
       std::cerr << "object_cast inside Lazy_construction_rep::operator() failed. It needs more else if's (#1)" << std::endl;
       std::cerr << "dynamic type of the Object : " << lo.approx().type().name() << std::endl;
 
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       ET eto = ec(CGAL::exact(l1), CGAL::exact(l2));
@@ -1715,7 +1715,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return  Handle(new Lazy_rep_1<AC, EC, E2A, L1>(ac, ec, l1));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1))));
@@ -1730,7 +1730,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_2<AC, EC, E2A, L1, L2>(ac, ec, l1, l2));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2))));
@@ -1745,7 +1745,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_3<AC, EC, E2A, L1, L2, L3>(ac, ec, l1, l2, l3));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3))));
@@ -1760,7 +1760,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_4<AC, EC, E2A, L1, L2, L3, L4>(ac, ec, l1, l2, l3, l4));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4))));
@@ -1775,7 +1775,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_5<AC, EC, E2A, L1, L2, L3, L4, L5>(ac, ec, l1, l2, l3, l4, l5));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5))));
@@ -1790,7 +1790,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_6<AC, EC, E2A, L1, L2, L3, L4, L5, L6>(ac, ec, l1, l2, l3, l4, l5, l6));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6))));
@@ -1805,7 +1805,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_7<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7>(ac, ec, l1, l2, l3, l4, l5, l6, l7));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7))));
@@ -1820,7 +1820,7 @@ public:
       CGAL_PROFILER(std::string("calls to    : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<Protection> P;
       return Handle(new Lazy_rep_8<AC, EC, E2A, L1, L2, L3, L4, L5, L6, L7, L8>(ac, ec, l1, l2, l3, l4, l5, l6, l7, l8));
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       CGAL_PROFILER(std::string("failures of : ") + std::string(CGAL_PRETTY_FUNCTION));
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return Handle(new Lazy_rep_0<AT,ET,E2A>(ec(CGAL::exact(l1), CGAL::exact(l2), CGAL::exact(l3), CGAL::exact(l4), CGAL::exact(l5), CGAL::exact(l6), CGAL::exact(l7), CGAL::exact(l8))));
diff --git a/Nef_2/include/CGAL/Filtered_extended_homogeneous.h b/Nef_2/include/CGAL/Filtered_extended_homogeneous.h
index e92fa9674ba..903834122d7 100644
--- a/Nef_2/include/CGAL/Filtered_extended_homogeneous.h
+++ b/Nef_2/include/CGAL/Filtered_extended_homogeneous.h
@@ -393,7 +393,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or2);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or2);
     res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -405,7 +405,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or1);
     res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -417,7 +417,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or0);
     res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -442,7 +442,7 @@ int compare_x(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx1);
     res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
   }
   if ( res != 0 ) return res; 
@@ -450,7 +450,7 @@ int compare_x(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx0);
     res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
   }
   return res;  
@@ -467,7 +467,7 @@ int compare_y(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy1);
     res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
   }
   if ( res != 0 ) return res; 
@@ -475,7 +475,7 @@ int compare_y(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy0);
     res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
   }
   return res;  
@@ -612,7 +612,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd2);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd2);
     res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -626,7 +626,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd1);
     res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -640,7 +640,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd0);
     res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -876,7 +876,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord2);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord2);
     res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -889,7 +889,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord1);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord1);
     res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -901,7 +901,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord0);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord0);
     res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
diff --git a/Nef_2/noweb/Filtered_extended_kernel.lw b/Nef_2/noweb/Filtered_extended_kernel.lw
index 9e764f1a83c..22ad61564d3 100644
--- a/Nef_2/noweb/Filtered_extended_kernel.lw
+++ b/Nef_2/noweb/Filtered_extended_kernel.lw
@@ -508,7 +508,7 @@ DEFCOUNTER(or2)
 Now the final orientation predicate consists of three |try|-|catch|
 blocks. Each |try| block contains the filtered coefficient evaluation.
 If the sign evaluation is not defined (the resulting interval contains
-zero) then the |unsafe_comparison| exception is thrown. The |catch|
+zero) then the |Uncertain_conversion_exception| exception is thrown. The |catch|
 block evaluates the expression with |RT| arithmetic. Note again the
 protection of the rounding mode with the |Protect_FPU_rounding<true>|
 class declaration. The macros |INCTOTAL()| and |INCEXCEPTION()| are
@@ -525,7 +525,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or2);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or2);
     res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -537,7 +537,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or1);
     res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -549,7 +549,7 @@ int orientation(const Extended_point<RT>& p1,
                              p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                              p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(or0);
     res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                              p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                              p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw());
@@ -582,7 +582,7 @@ int compare_x(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpx1); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx1);
     res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw());
   }
   if ( res != 0 ) return res; 
@@ -590,7 +590,7 @@ int compare_x(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpx0); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpx0);
     res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw());
   }
   return res;  
@@ -607,7 +607,7 @@ int compare_y(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpy1); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy1);
     res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw());
   }
   if ( res != 0 ) return res; 
@@ -615,7 +615,7 @@ int compare_y(const Extended_point<RT>& p1,
   try { INCTOTAL(cmpy0); Protect_FPU_rounding<true> Protection;
     res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmpy0);
     res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw());
   }
   return res;  
@@ -752,7 +752,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd2);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd2);
     res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -766,7 +766,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd1);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd1);
     res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -780,7 +780,7 @@ int compare_pair_dist(
                        p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                        p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
   }
-  catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd0);
+  catch (Uncertain_conversion_exception) { INCEXCEPTION(cmppd0);
     res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                        p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                        p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -1124,7 +1124,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord2);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord2);
     res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -1137,7 +1137,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord1);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord1);
     res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
@@ -1149,7 +1149,7 @@ int orientation(const Extended_direction<RT>& d1,
                      p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(),
                      p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(),
                      p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD());
-  } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord0);
+  } catch (Uncertain_conversion_exception) { INCEXCEPTION(ord0);
     res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(),
                      p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(),
                      p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(),
diff --git a/Number_types/doc_tex/NumberTypeSupport_ref/Interval_nt.tex b/Number_types/doc_tex/NumberTypeSupport_ref/Interval_nt.tex
index 266b8453939..da88fade6c2 100644
--- a/Number_types/doc_tex/NumberTypeSupport_ref/Interval_nt.tex
+++ b/Number_types/doc_tex/NumberTypeSupport_ref/Interval_nt.tex
@@ -58,11 +58,9 @@ doing any computations with the interval class.
 
 \ccTypes
 The class \ccc{Interval_nt} defines the following types:
-%Three{typedef std::exception unsafe_comparison;}{Tetrahedronxxxxx}{}
-%ThreeToTwo
 \ccTypedef{typedef double value_type;}{The type of the bounds of the interval.}
 \ccGlue
-\ccTypedef{typedef std::exception unsafe_comparison;}{The type of the
+\ccTypedef{typedef Uncertain_conversion_exception unsafe_comparison;}{The type of the
 exceptions raised when uncertain comparisons are performed.}
 \ccGlue
 \ccNestedType{Protector}{A type whose default constructor and destructor allow
diff --git a/Number_types/include/CGAL/Interval_nt.h b/Number_types/include/CGAL/Interval_nt.h
index c41a9e6d580..adfcf6e5531 100644
--- a/Number_types/include/CGAL/Interval_nt.h
+++ b/Number_types/include/CGAL/Interval_nt.h
@@ -51,7 +51,7 @@ public:
 
   typedef double      value_type;
 
-  typedef Uncertain<bool>::Uncertain_conversion_exception  unsafe_comparison;
+  typedef Uncertain_conversion_exception            unsafe_comparison;
   typedef Checked_protect_FPU_rounding<Protected>   Internal_protector;
   typedef Protect_FPU_rounding<!Protected>          Protector;
 
diff --git a/Segment_Delaunay_graph_2/include/CGAL/Filtered_construction.h b/Segment_Delaunay_graph_2/include/CGAL/Filtered_construction.h
index da09fef3fe3..814b7a4843c 100644
--- a/Segment_Delaunay_graph_2/include/CGAL/Filtered_construction.h
+++ b/Segment_Delaunay_graph_2/include/CGAL/Filtered_construction.h
@@ -59,7 +59,7 @@ public:
       Protect_FPU_rounding<Protection> P;
       return From_Filtered( Filter_construction(To_Filtered(a1)) );
     }
-    catch (Interval_nt_advanced::unsafe_comparison)
+    catch (Uncertain_conversion_exception)
     {
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return From_Exact( Exact_construction(To_Exact(a1)) );
@@ -75,7 +75,7 @@ public:
       return From_Filtered( Filter_construction(To_Filtered(a1),
 						To_Filtered(a2)) );
     }
-    catch (Interval_nt_advanced::unsafe_comparison)
+    catch (Uncertain_conversion_exception)
     {
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return From_Exact( Exact_construction(To_Exact(a1),
@@ -94,7 +94,7 @@ public:
 						To_Filtered(a2),
 						To_Filtered(a3)) );
     }
-    catch (Interval_nt_advanced::unsafe_comparison)
+    catch (Uncertain_conversion_exception)
     {
       Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
       return From_Exact( Exact_construction(To_Exact(a1),
diff --git a/Skin_surface_3/include/CGAL/Skin_surface_base_3.h b/Skin_surface_3/include/CGAL/Skin_surface_base_3.h
index ac083835f4d..c5fc3d83afb 100644
--- a/Skin_surface_3/include/CGAL/Skin_surface_base_3.h
+++ b/Skin_surface_3/include/CGAL/Skin_surface_base_3.h
@@ -303,7 +303,7 @@ sign(TMC_Vertex_handle vit) const {
       if (is_certain(result))
         return result;
     }
-  catch (Interval_nt_advanced::unsafe_comparison) {}
+  catch (Uncertain_conversion_exception) {}
   CGAL_PROFILER(std::string("NGHK: failures of : ") + 
                 std::string(CGAL_PRETTY_FUNCTION));
   Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@@ -341,7 +341,7 @@ sign(const Bare_point &p, const Cell_info &info) const {
       if (is_certain(result))
         return result;
     }
-  catch (Interval_nt_advanced::unsafe_comparison) {}
+  catch (Uncertain_conversion_exception) {}
   CGAL_PROFILER(std::string("NGHK: failures of : ") + 
                 std::string(CGAL_PRETTY_FUNCTION));
   Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@@ -634,7 +634,7 @@ compare(Cell_info &info1,
       if (is_certain(result))
         return result;
     }
-  catch (Interval_nt_advanced::unsafe_comparison) {}
+  catch (Uncertain_conversion_exception) {}
   CGAL_PROFILER(std::string("NGHK: failures of : ") + 
                 std::string(CGAL_PRETTY_FUNCTION));
   Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
@@ -698,7 +698,7 @@ locate_in_tmc(const Bare_point &p0,
       Protect_FPU_rounding<true> P;
 
       o = TMC_Geom_traits().orientation_3_object()(*pts[0], *pts[1], *pts[2], *pts[3]);
-    } catch (Interval_nt_advanced::unsafe_comparison) {
+    } catch (Uncertain_conversion_exception) {
       Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
       typedef Exact_predicates_exact_constructions_kernel EK;
       Cartesian_converter<typename Geometric_traits::Bare_point::R, EK> converter_ek;
diff --git a/Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h b/Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h
index d4a3a699d3d..fee372df4da 100644
--- a/Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h
+++ b/Skin_surface_3/include/CGAL/triangulate_mixed_complex_3.h
@@ -1265,7 +1265,7 @@ orientation(Tmc_Cell_handle ch) {
     // filtered kernel
     o = _tmc.geom_traits().orientation_3_object()(pts[0], pts[1], 
                                                   pts[2], pts[3]);
-  } catch (Interval_nt_advanced::unsafe_comparison) {
+  } catch (Uncertain_conversion_exception) {
     Protect_FPU_rounding<false> P(CGAL_FE_TONEAREST);
     typedef Exact_predicates_exact_constructions_kernel EK;
     typedef Cartesian_converter<EK, Tmc_traits>         Exact_converter;
diff --git a/Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h b/Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h
index 10810a9b584..31a505b7e5b 100644
--- a/Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h
+++ b/Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_traits_2_aux.h
@@ -121,7 +121,7 @@ public:
       if ( fr )
         return From_Filtered(fr);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
 
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     EC_result_type er = Exact_construction(To_Exact(a1)) ;
@@ -139,7 +139,7 @@ public:
       if ( fr )
         return From_Filtered(fr);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2)) ;
@@ -157,7 +157,7 @@ public:
       if ( fr )
         return From_Filtered(fr);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3)) ;
@@ -176,7 +176,7 @@ public:
       if ( fr )
         return From_Filtered(fr);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)) ;
@@ -195,7 +195,7 @@ public:
       if ( fr )
         return From_Filtered(fr);
     }
-    catch (Interval_nt_advanced::unsafe_comparison) {}
+    catch (Uncertain_conversion_exception) {}
     
     Protect_FPU_rounding<!Protection> P(CGAL_FE_TONEAREST);
     EC_result_type er = Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)) ;