diff --git a/src/site/apt/examples/exclude-project-jar.apt b/src/site/apt/examples/exclude-project-jar.apt
index 2a98b47..cb9e7cf 100644
--- a/src/site/apt/examples/exclude-project-jar.apt
+++ b/src/site/apt/examples/exclude-project-jar.apt
@@ -7,19 +7,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
diff --git a/src/site/apt/examples/include-extra-files.apt b/src/site/apt/examples/include-extra-files.apt
index e415ac8..1e92e7a 100644
--- a/src/site/apt/examples/include-extra-files.apt
+++ b/src/site/apt/examples/include-extra-files.apt
@@ -6,19 +6,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
diff --git a/src/site/apt/examples/manifest.apt b/src/site/apt/examples/manifest.apt
index eb54321..d9a55e3 100644
--- a/src/site/apt/examples/manifest.apt
+++ b/src/site/apt/examples/manifest.apt
@@ -6,19 +6,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
diff --git a/src/site/apt/examples/ra-custom-location.apt b/src/site/apt/examples/ra-custom-location.apt
index 89bf2d0..5196d35 100644
--- a/src/site/apt/examples/ra-custom-location.apt
+++ b/src/site/apt/examples/ra-custom-location.apt
@@ -7,19 +7,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
diff --git a/src/site/apt/index.apt b/src/site/apt/index.apt
index e935439..f22e6a4 100644
--- a/src/site/apt/index.apt
+++ b/src/site/apt/index.apt
@@ -6,19 +6,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
diff --git a/src/site/apt/usage.apt b/src/site/apt/usage.apt
index 1b24bf6..d128734 100644
--- a/src/site/apt/usage.apt
+++ b/src/site/apt/usage.apt
@@ -6,19 +6,22 @@
   July 2006
   ------
 
-~~ Copyright 2006 The Apache Software Foundation.
-~~
-~~ Licensed under the Apache License, Version 2.0 (the "License");
-~~ you may not use this file except in compliance with the License.
-~~ You may obtain a copy of the License at
-~~
-~~      http://www.apache.org/licenses/LICENSE-2.0
-~~
-~~ Unless required by applicable law or agreed to in writing, software
-~~ distributed under the License is distributed on an "AS IS" BASIS,
-~~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-~~ See the License for the specific language governing permissions and
-~~ limitations under the License.
+~~ Licensed to the Apache Software Foundation (ASF) under one                                                                                                      
+~~ or more contributor license agreements.  See the NOTICE file                                                                                                    
+~~ distributed with this work for additional information                                                                                                           
+~~ regarding copyright ownership.  The ASF licenses this file                                                                                                      
+~~ to you under the Apache License, Version 2.0 (the                                                                                                               
+~~ "License"); you may not use this file except in compliance                                                                                                      
+~~ with the License.  You may obtain a copy of the License at                                                                                                      
+~~                                                                                                                                                                 
+~~   http://www.apache.org/licenses/LICENSE-2.0                                                                                                                    
+~~                                                                                                                                                                 
+~~ Unless required by applicable law or agreed to in writing,                                                                                                      
+~~ software distributed under the License is distributed on an                                                                                                     
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY                                                                                                          
+~~ KIND, either express or implied.  See the License for the                                                                                                       
+~~ specific language governing permissions and limitations                                                                                                         
+~~ under the License.               
 
 ~~ NOTE: For help with the syntax of this file, see:
 ~~ http://maven.apache.org/guides/mini/guide-apt-format.html
