diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-applications.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-applications.apt
index 87ef0ef..12e5cb2 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-applications.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-applications.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 Hyracks Applications
 
   The Hyracks platform provides users the ability to execute jobs on a cluster. Jobs in Hyracks are expressed as a DAG of Operators and Connectors. Prior to being able to execute jobs on a Hyracks cluster, the code that implements the operators and connectors used in the jobs must be installed on the nodes of the cluster. The unit of deployment of code onto the cluster is called an application. Once an application containing the required code is created, multiple jobs can be executed against it until it is destroyed. A Hyracks cluster can have multiple applications installed simultaneously.
diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-terminology.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-terminology.apt
index b39440e..4e3b9cb 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-terminology.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-concepts-terminology.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 Terminology
 
   [Operator Descriptor] An Operator Descriptor is a node in a Hyracks Job DAG. An Operator Descriptor has zero or more inputs and produces zero or more outputs.
diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-commands.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-commands.apt
index 6ddd162..18cfccb 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-commands.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-commands.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 Hyracks CLI Commands
 
   * Connecting to a Hyracks Cluster Controller
diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-running.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-running.apt
index aa16d9d..d93dc41 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-running.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-hyrackscli-running.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 Running Hyracks CLI
 
   The Hyracks CLI is contained in the hyracks-cli subproject under the Hyracks source tree. The Hyracks CLI binary distribution contains the scripts to start the CLI in the bin folder.
diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-overview.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-overview.apt
index f35b7e4..9e097a8 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-overview.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-overview.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 Hyracks Overview
 
   Hyracks employs a client-server architecture. On the server side, the software module that is responsible for interacting with clients, keeping track of and dispatching work
diff --git a/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-whatis.apt b/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-whatis.apt
index e3a659e..88f5b49 100644
--- a/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-whatis.apt
+++ b/hyracks/hyracks-documentation/src/books/user-guide/sec-introduction-whatis.apt
@@ -1,3 +1,16 @@
+~~Copyright 2009-2013 by The Regents of the University of California
+~~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 from
+~~
+~~     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.
+
 What is Hyracks?
 
   Hyracks is a partitioned-parallel platform for running data-intensive computation on a shared-nothing cluster of commodity machines.
