diff --git a/src/site/apt/release.apt b/src/site/apt/release.apt
index a934381..6071b8e 100644
--- a/src/site/apt/release.apt
+++ b/src/site/apt/release.apt
@@ -44,12 +44,14 @@
 $ svn co https://svn.apache.org/repos/asf/vxquery/site
 ---
 
+  * create a code signing key with the Apache {{{http://www.apache.org/dev/openpgp.html#generate-key}instructions}} and example settings
+
   * add your key to the <<<KEYS>>> file
 
     Change into the <<<dist>>> directory and run
 
 ---
-(gpg --list-sigs <your name> && gpg2 --armor --export <your name>) >> KEYS
+(gpg2 --list-sigs <your name> && gpg2 --armor --export <your name>) >> KEYS
 ---
 
     and then check the new <<<KEYS>>> file into svn
@@ -69,21 +71,29 @@
     * for the upload to the nexus repository
 
 ---
+<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
+                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
+...
   <servers>
+    ...
     <!-- To publish a snapshot of some part of Maven -->
     <server>
       <id>apache.snapshots.https</id>
       <username>[YOUR APACHE LDAP USERNAME]</username>
-      <password>[YOUR APACHE LDAP PASSWORD] (encrypted)</password>
+      <password>[YOUR APACHE LDAP PASSWORD (encrypted)]</password>
     </server>
     <!-- To stage a release of some part of Maven -->
     <server>
       <id>apache.releases.https</id>
       <username>[YOUR APACHE LDAP USERNAME]</username>
-      <password>[YOUR APACHE LDAP PASSWORD] (encrypted)</password>
+      <password>[YOUR APACHE LDAP PASSWORD (encrypted)]</password>
     </server>
    ...
   </servers>
+...
+</settings>
 ---
 
     * to sign the artifacts
@@ -101,6 +111,10 @@
 ---
 
   * Download Apache Rat from {{{https://creadur.apache.org/rat/download_rat.cgi}https://creadur.apache.org/rat/download_rat.cgi}}.
+  
+  * Add your ssh key to {{{https://id.apache.org}id.apache.org}} (required to create a website on {{{https://people.apache.org}people.apache.org}}).
+
+    * Login and update your profile details. 
 
 * Each time steps
 
@@ -143,6 +157,8 @@
 
   * send out <<<[VOTE]>>> e-mail on dev@vxquery.apache.org
 
+    * {{{http://mail-archives.apache.org/mod_mbox/vxquery-dev/201409.mbox/%3CCAGZxfJUZDczuZR5jQResE4B7%2Bv4QQgwMpAd%2B-_Kt-U_RjCyReA%40mail.gmail.com%3E}example e-mail}} 
+
   * after successful vote promote staging repository {{{https://repository.apache.org/}https://repository.apache.org/}}
 
   * add new source artifacts (archive + signature + hashes) to svn {{{https://dist.apache.org/repos/dist/release/vxquery}https://dist.apache.org/repos/dist/release/vxquery}} and remove old release dirctory
@@ -169,6 +185,8 @@
   * wait a few days for the mirroring of the release artifacts
 
   * send <<<[ANNOUNCE]>>> e-mail to announce@apache.org and dev@vxquery.apache.org
+  
+    * {{{http://mail-archives.apache.org/mod_mbox/www-announce/201405.mbox/%3C537AD473.9080505@apache.org%3E}example e-mail}}
 
 * References
 
diff --git a/src/site/site.xml b/src/site/site.xml
index 9f41540..78e6651 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -78,7 +78,7 @@
                 name="Eclipse Setup"
                 href="development_eclipse_setup.html" />
             <item
-                name="Release steps"
+                name="Release Steps"
                 href="release.html" />
             <item
                 name="Update Local Git XQTS Results"
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_sensor.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_sensor.xq
index 1e8e312..3418d32 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_sensor.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_sensor.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Count all the weather sensor readings available.                           :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_station.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_station.xq
index fe6ec8f..bd63bb2 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_station.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/count_station.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Count all the weather stations available.                                  :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q00.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q00.xq
index 09c5b79..ac23dba 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q00.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q00.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: 
 XQuery Filter Query
 -------------------
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q01.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q01.xq
index 39d7e20..019d738 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q01.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q01.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Filter Query :)
 (: Find all reading for hurricane force wind warning or extreme wind warning. :)
 (: The warnings occur when the wind speed (AWND) exceeds 110 mph (49.1744     :)
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q02.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q02.xq
index 3fb0975..b0ec839 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q02.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q02.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (:
 XQuery Aggregate Query
 ----------------------
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q03.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q03.xq
index cda344a..57981f9 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q03.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q03.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Aggregate Query :)
 (: Find the highest recorded temperature (TMAX) in Celsius.                   :)
 fn:max(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_sensor.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_sensor.xq
index 6c927a4..828c239 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_sensor.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_sensor.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Count all the weather sensor readings on 1976-07-04.                       :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_station.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_station.xq
index 957aec0..4230cd8 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_station.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q04_count_station.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Count all the weather stations for King county.                            :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_sensor.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_sensor.xq
index 4ac353b..2287c22 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_sensor.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_sensor.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Aggregate Query :)
 (: Count all sensor readings for TMIN in 2001.                                :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_station.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_station.xq
index 4349805..0fa8e30 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_station.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q05_count_station.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Aggregate Query :)
 (: Count all stations in the state of Oregon.                                 :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_sensor.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_sensor.xq
index 5ca3329..9539f4b 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_sensor.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_sensor.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 count(
     let $sensor_collection := "../../../../../../../weather_data/dataset-tiny-local/data_links/local_speed_up/d0_p1_i0/sensors/?select=*.xml;recurse=yes"
     for $r in collection($sensor_collection)/root/dataCollection/data
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_station.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_station.xq
index ef1e732..ee2511f 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_station.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q06_count_station.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 count(
     let $station_collection := "../../../../../../../weather_data/dataset-tiny-local/data_links/local_speed_up/d0_p1_i0/stations/?select=*.xml;recurse=yes"
     for $s in collection($station_collection)/root/stationCollection/station
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07.xq
index 35e5ea2..49b95bf 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Aggregate Query :)
 (: Self join with all sensor readings after the year 2000.                    :)
 fn:avg(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmax.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmax.xq
index 3245746..1b5ce16 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmax.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmax.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Find the all the records for TMAX.                                         :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmin.xq b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmin.xq
index 6fcd276..0af9cad 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmin.xq
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/other_systems/saxon/q07_count_tmin.xq
@@ -1,3 +1,20 @@
+(: 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. :)
+
 (: XQuery Join Query :)
 (: Find the all the records for TMIN.                                         :)
 count(
diff --git a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/scripts/benchmark_logging.properties b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/scripts/benchmark_logging.properties
index 2745a12..ca3c79a 100644
--- a/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/scripts/benchmark_logging.properties
+++ b/vxquery-benchmark/src/main/resources/noaa-ghcn-daily/scripts/benchmark_logging.properties
@@ -1,42 +1,32 @@
-# Properties file which configures the operation of the JDK 
-# logging facility.
+# 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. :)
 
-# The system will look for this config file, first using 
-# a System property specified at startup: 
-# 
-# >java -Djava.util.logging.config.file=myLoggingConfigFilePath 
-# 
-# If this property is not specified, then the config file is 
-# retrieved from its default location at: 
-# 
-# JDK_HOME/jre/lib/logging.properties
+# This properties file sets the logging output for the benchmark tests.
 
-# Global logging properties. 
-# ------------------------------------------ 
-# The set of handlers to be loaded upon startup. 
-# Comma-separated list of class names. 
-# (? LogManager docs say no comma here, but JDK example has comma.) 
+# Global Settings
 handlers=java.util.logging.ConsoleHandler
-
-# Default global logging level. 
-# Loggers and Handlers may override this level 
 .level=WARNING
 
 # Loggers 
-# ------------------------------------------ 
-# Loggers are usually attached to packages. 
-# Here, the level for each package is specified. 
-# The global level is used by default, so levels 
-# specified here simply act as an override. 
-#edu.uci.ics.hyracks.dataflow.std.join.level=ALL
 edu.uci.ics.hyracks.dataflow.std.join.OptimizedHybridHashJoinOperatorDescriptor.level=ALL
 
 
 # Handlers 
-# -----------------------------------------
 
 # --- ConsoleHandler --- 
-# Override of global logging level 
 java.util.logging.ConsoleHandler.level=SEVERE
-#java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
 
