diff --git a/previous-releases.php b/previous-releases.php
index 684b779..08480d9 100644
--- a/previous-releases.php
+++ b/previous-releases.php
@@ -16,6 +16,7 @@
 	$pageAuthor		= "Igor Vinnykov";
 	
 	$sidebar = file_get_contents($_SERVER['DOCUMENT_ROOT'] . "/subversive/sidebars/download.php");	
+	$notes = file_get_contents($_SERVER['DOCUMENT_ROOT'] . "/subversive/include/installation-notes.php");	
 	
 	// 	# Paste your HTML content between the EOHTML markers!
 $html = <<<EOHTML
@@ -25,13 +26,7 @@
 		<p>
 			Here you can find a list of Subversive build for previous Eclipse Simultaneous Releases.
 		</p>
-		<h2>Subversive Distribution and Installation Notes</h2>
-		<p>
-			The Subversive installation consists of two parts: Subversive plug-in and Subversive SVN Connectors. Both parts are required to be installed in order to use Subversive. Subversive plug-in is developed as an official Eclipse project and is available for installation on this page under the terms and conditions of the Eclipse Public License Version 1.0 ("EPL"). Subversive SVN Connectors are external libraries (used by Subversive to communicate with SVN) with their own licenses. Subversive SVN Connectors are developed as an open-source project on <a href="http://www.polarion.com/products/svn/subversive/download.php?utm_source=eclipse.org&utm_medium=link&utm_campaign=subversive">polarion.com</a> and are distributed separately.
-		</p>
-		<p>
-			In order to install Subversive, you should install Subversive plug-in and at least one of Subversive SVN Connectors. Subversive plug-in and Subversive SVN Connectors are distributed from different update sites, located on different servers. At the first step you need to install Subversive plug-in, using information on this page. After Subversive plug-in installation you will be prompted to select Subversive SVN Connectors, that will be installed automatically from another server. For more information please refer <a href="/subversive/installation-instructions.php">Installation Instructions</a>.
-		</p>
+		$notes
 		<h2>Indigo (Eclipse 3.7) Release</h2>
 		<p>
 			This is the Subversive plug-in release, that is a part of Eclipse Indigo Simultaneous Release. Subversive plug-in is included into Indigo Update Site, so you can install Subversive directly from Eclipse Indigo.
