numru-units 1.7.0 → 1.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9aa6ff8758cccbbc3bac5299c946c1cafd1de45
+  data.tar.gz: dffe312aefd1531fc4e2a4a355b1e1c572b35d07
+SHA512:
+  metadata.gz: e065c34277db2b4a6913a45b9107503e4be0e4777945e264fe384e65c7ce60f42ebad84794dc0b9af44c06ec7ac30f1db88db1966aa86c95bedc52e5f0a8b0d8
+  data.tar.gz: 2bac48e91ab581506aa81e8b90413d0b676595cd7442acc020596b779e5e2e259e510e15c9a32703df5866d1d33bcf8957fb24cdf15a9902b0efe5f30eab0c86

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/ChangeLog

@@ -1,3 +1,34 @@
+Tue Feb 17 2015   T Horinouchi
+	* version 1.9 released ((cvs) tag: numru-units-1_9)
+Fri Jan 23  2015   T Horinouchi
+	* dcunits.txt
+	  * added a description as comments at the beginning of the file
+	  * added units: cd, candela
+	  * changed the mode of the following units
+	    * S to N: kg, %, permil, d
+	    * S to P: percent
+	  * added a meteorological unit gpm (mode: N, definition: m).
+	* LICENSE.txt: updated (years)
+	* src/version.rb: added
+	* src/Makefile: updated to use version.rb
+Tue Jan 20  2015   T Horinouchi
+	* src/lex.rb: Regexp changed: UTC --> (UTC|Z)
+Mon Jan 12  2015   T Horinouchi
+	* version 1.8 released ((cvs) tag: numru-units-1_8)
+Mon Jan 12  2015   T Horinouchi <-- S Nishizawa [dennou-ruby:003805] and
+	T Koshiro [dennou-ruby:003806] (files to patch was corrected, though)
+	* src/rules.rb: Update to support ruby 2.1 or later
+	  (l.10: origin_exp { yyaccept; } --> origin_exp { val[0] })
+	  and a cleaner treatment of the NumRu:: wrapper
+	  (l.1: class Units --> class NumRu::Units).
+	* src/test.rb: updated (handling of "" and numeric expressions:
+	  float --> rational)
+	* src/Makefile: updated in response to the change in rule.rb
+	* install.rb: updated (ruby 1.6 support abondoned)
+	* src/units.racc, src/units.rb, lib/numru/units.rb: regenreated
+
+Fri Mar 14  2014   T Koshiro < M Nakano [dennou-ruby:003646]
+	* install.rb: for Ruby 2.x
 Thu Aug  4  2011  T Horinouchi
 	* version 1.7 released ((cvs) tag: numru-units-1_7)
 	* LICENSE.txt: added (BSD 2-clause)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in numru-units.gemspec
+gemspec

data/LICENSE.txt

@@ -1,7 +1,7 @@
-NumRu::Units is copyrighted free software by Takeshi Horinouchi and
+NumRu::Units is copyrighted free software by 
 GFD Dennou Club (http://www.gfd-dennou.org/).
 
-Copyright 2011 (C) Takeshi Horinouchi and GFD Dennou Club
+Copyright 2004-2015 (C) GFD Dennou Club
 (http://www.gfd-dennou.org/) All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.rdoc

@@ -0,0 +1,232 @@
+=begin
+=class NumRu::Units
+
+* ((<Overview>))
+* ((<Installation>))
+* ((<Usage Examples>))
+* ((<Class Methods>))
+* ((<Instance Methods>))
+* ((<Supported units|URL:http://ruby.gfd-dennou.org/products/numru-units/doc/dcunits.txt>))  (Plural form allowed if the second field is "P")
+
+==Overview
+
+A class of units of physical quantities.
+
+This class covers most functionality of UNIDATA's 
+((<UDUNITS Library|URL:http://www.unidata.ucar.edu/packages/udunits/>)), 
+however, with a more sophisticated handling of string expressions. 
+
+UDUNITS always decomposes units into the four base units and discards
+the original string expressions. Therefore, 'hPa' always becomes
+'100 kg.m-1.sec-1', and 'day' always becomes '86400 sec'. On the other 
+hand, this library tries to keep the original expressions as much as
+possible by default, while allowing partial to complete decompositions
+if needed.
+
+==Installation
+
+Move to the top directly of this library (where you find
+the file install.rb). Then, type in the following:
+
+  % ruby install.rb
+
+==Usage Examples
+
+Here is an example using the "irb" interactive shell ("(('%'))" is the
+command prompt, and "(('>>'))" is the irb prompt -- Type in those after it
+to test.  "(('=>'))" shows the result.):
+
+  % irb --simple-prompt
+  >> require "numru/units"
+  => true
+  >> un1 = NumRu::Units.new('kg.m2/s')
+  => Units{kg.m2/s}
+  >> un2 = NumRu::Units.new('g.m')
+  => Units{g.m}
+  >> un3 = un1 / un2
+  => Units[Multi[Pow[Name[g], Number[-1]], Name[kg], Pow[Name[m], Number[1]], Pow[Name[s], Number[-1]]]]
+  >> un1.to_s
+  => "kg.m2/s"
+  >> un2.to_s
+  => "g.m"
+  >> un3.to_s
+  => "g-1 kg.m1 s-1"
+  >> un3.reduce5
+  => Units[Multi[Number[1000], Pow[Name[m], Number[1]], Pow[Name[s], Number[-1]]]]
+  >> un3.to_s
+  => "1000 m1 s-1"
+
+Note the difference between the results of (('un3.to_s')) 
+before and after (('un3.reduce5')),
+where the former retains the literal expression
+of each atomic unit, while the latter does the maximum reduction.
+You can change the default behavior by using the class method 
+(('reduce_level=')):
+
+  >> NumRu::Units.reduce_level = 5
+  => :reduce5
+  >> un3.to_s
+  => "1000 m1 s-1"
+
+Note that you can eliminate the prefix (('NumRu::')) by "including"
+it:
+
+  >> require "numru/units"
+  => true
+  >> include NumRu
+  => Object
+  >> un1 = Units.new('kg.m2/s')
+  => Units{kg.m2/s}
+  >> Units.reduce_level = 5
+  => :reduce5
+
+==Class Methods
+
+In what follows, the prefix (('NumRu::')) is omitted for conciseness.
+See ((<Usage Examples>)) on this issue.
+
+---Units.new(string)
+    Constructor.
+
+    ARGUMENTS
+    * string (String): string expression of the units. 
+      [factor] units; [factor] time units [since ...] (see EXAMPLES below)
+
+    RETURN VALUE
+    * a Units
+
+    EXAMPLE
+
+      units = Units.new('kg.m2/s')
+      units = Units.new('100 m')
+      units = Units.new('g/kg')
+      units = Units.new('hour since 2003-10-01 00:00:0 +0:00')
+      units = Units.new('hour since 2003-10-01')   # same as above
+      units = Units.new('minutes since 2003-10-01 03:15:22.5 -6:00')
+
+---Units[string]
+
+    Same as ((<Units.new>))
+
+---Units.reduce_level=(n) 
+    Set the reduction level before ((<to_s>)) is applied.
+
+    ARGUMENTS
+    * n (Integer): the reduction level. The default value is 4.
+      Use 5 if you want a full reduction. Levels lower than 4 
+      will not be needed.
+
+==Instance Methods
+
+---to_s
+    Returns a string expression of the units.
+
+---*(other)
+    Multiplies self with another units. 
+    Applies ((<reduce4>)) to format the string expression of the result.
+
+    ARGUMENTS
+    * other [Units]: the other units
+
+    RETURN VALUE
+    * a Units
+
+---/(other)
+    Divides self with another units.
+    Applies ((<reduce4>)) to format the string expression of the result.
+
+    ARGUMENTS
+    * other [Units]: the other units
+
+    RETURN VALUE
+    * a Units
+
+---**(pow)
+    Power.
+    Applies ((<reduce4>)) to format the string expression of the result.
+
+    ARGUMENTS
+    * pow [Numeric -- Integer, Rational, or Float]
+
+    RETURN VALUE
+    * a Units
+
+---==(other)
+    Whether the two units are the same. 
+    ('m/s' and 'm.s-1' are the same, for instance.)
+
+---===(other)
+    Same as ((<==>)).
+
+---=~(other)
+    Whether the two units are compatible (i.e., with the same dimensionality).
+    ('m/s' and '10 m.s-1' are compatible, for instance.)
+
+---reduce4
+    Moderately reduces the string expression of the units (destructive method).
+    This method preserves string expression of atomic units. 
+    See also ((<reduce5>)).
+
+    RETURN VALUE
+    * self
+
+    EXAMPLE
+      Untis.new('hour/hour').reduce4.to_s
+        # => "1"
+      Units.new('mm/m').reduce4.to_s
+        # => "mm.m-1"
+
+---reduce5
+    Aggressively reduces the string expression of the units (destructive method).
+    See also ((<reduce4>)).
+
+    RETURN VALUE
+    * self
+
+    EXAMPLE
+      Units.new('hour/hour').reduce4.to_s
+        # => "1"
+      Units.new('mm/m').reduce5.to_s
+        # => "0.001"
+
+---convert(numeric, to_units)
+    Converts a numeric of the current units (=self) to ((|to_units|)).
+
+    ARGUMENTS
+    * numeric [Numeric]: the numeric to convert
+    * to_units [Units]: the units converted into
+
+    RETURN VALUE
+    * a Numeric
+
+    EXCEPTIONS
+    * ((|self|)) and ((|to_units|)) are incompatible.
+
+---convert2(val, to_units)
+    Like ((<convert>)), but (1) accpets any Numeric-like objects, and (2)
+    does not raise an exception even if the two units are incompatible -- 
+    in this case, simply returns ((|val|)) (warned).
+
+    ARGUMENTS
+    * val [a Numeric-like class, for which (('*')) and (('+')) are defined]:
+      the value to convert
+    * to_units [Units]: the units converted into
+
+    RETURN VALUE
+    * an object with the same class as ((|val|)).
+
+---factor_and_offset(to_units)
+    Returns the factor and offset to convert from ((|self|)) to ((|to_units|)).
+    The conversion is done as  (('scale_factor * operand + add_offset')).
+
+    ARGUMENTS
+    * to_units [Units]: the units to be converted into
+
+    RETURN VALUE
+    * [ scale_factor, add_offset ] (a 2-element Array, where both are Numeric)
+
+    EXAMPLE
+      scale_factor, add_offset = from_units.factor_and_offset(to_units)
+      to = scale_factor * from + add_offset
+
+=end

data/Rakefile

@@ -1,39 +1,2 @@
-require 'rake/gempackagetask'
+require "bundler/gem_tasks"
 
-NAME = 'numru-units'
-VER = '1.7.0'
-
-PKG_FILES = FileList[
-  '**',
-  'lib/**/*',
-  'doc/**/*',
-  'src/**/*'
-]
-
-spec = Gem::Specification.new do |s|
-  s.name             = NAME
-  s.version          = VER
-  s.authors           = ["Eizi Toyoda","Takeshi Horinouchi"]
-  s.email            = ['eriko@gfd-dennou.org']
-  s.homepage         = 'http://www.gfd-dennou.org/arch/ruby/products/numru-units/'
-  s.licenses         = ["Takeshi Horinouchi", "GFD Dennou Club"]
-  s.platform         = Gem::Platform::RUBY
-  s.summary          = %q{Class to handle units of physical quantities}
-  s.description      = %q{This is a class to handle units of physical quantities. It covers most functionality of UNIDATA's UDUNITS Library, however, with a more sophisticated handling of string expressions. See the documentation for more infomation.}
-
-  s.files            = PKG_FILES.to_a
-  s.require_paths    = ['lib']
-  #s.test_files = Dir.glob("test/*")
-  #s.has_rdoc         = true
-  s.required_ruby_version = Gem::Requirement.new(">= 1.6")
-  #s.add_runtime_dependency(%q<narray>, [">= 0"])
-  #s.add_runtime_dependency(%q<narray_miss>, [">= 0"])
-  #s.extra_rdoc_files = ['README']
-
-  #s.extensions << "install.rb"
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-  pkg.need_tar = true
-end

data/install.rb

@@ -1,27 +1,8 @@
 require 'rbconfig'
 require 'find'
-include Config
+include RbConfig
 
-if CONFIG["MINOR"].to_i > 6 then $rb_18 = true else $rb_18 = false end
-if $rb_18
-  require 'fileutils'
-else
-  require 'ftools'
-end
-
-=begin
-$version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
-$libdir = File.join(CONFIG["libdir"], "ruby", $version)
-# $archdir = File.join($libdir, CONFIG["arch"])
-$site_libdir = $:.find {|x| x =~ /site_ruby$/}
-if !$site_libdir
-  $site_libdir = File.join($libdir, "site_ruby")
-elsif Regexp.compile($site_libdir) !~ Regexp.quote($version)
-  $site_libdir = File.join($site_libdir, $version)
-end
-
-default_destdir = $site_libdir
-=end
+require 'fileutils'
 
 default_destdir = CONFIG["sitelibdir"]
 
@@ -40,20 +21,12 @@ def install_rb(srcdir, destdir)
   for f in dir
     next if f == "."
     next if f == "CVS"
-    if $rb_18
-      FileUtils.makedirs(File.join(destdir, f))
-    else
-      File::makedirs(File.join(destdir, f))
-    end
+    FileUtils.makedirs(File.join(destdir, f))
   end
   for f in path
     next if (/\~$/ =~ f)
     next if (/^\./ =~ File.basename(f))
-    if $rb_18
-      FileUtils.install(File.join("lib", f), File.join(destdir, f), {:mode => 0644, :verbose => true})
-    else
-      File::install(File.join("lib", f), File.join(destdir, f), 0644, true)
-    end
+    FileUtils.install(File.join("lib", f), File.join(destdir, f), {:mode => 0644, :verbose => true})
   end
 end
 

data/lib/numru/units.rb

@@ -1,3505 +1,2 @@
-#
-# DO NOT MODIFY!!!!
-# This file is automatically generated by racc 1.4.5
-# from racc grammer file "units.racc".
-#
-#
-# tmp.rb: generated by racc (runtime embedded)
-#
-###### racc/parser.rb begin
-unless $".index 'racc/parser.rb'
-$".push 'racc/parser.rb'
-
-#
-# $Id: units.rb,v 1.19 2011-08-03 09:16:07 horinout Exp $
-#
-# Copyright (c) 1999-2005 Minero Aoki
-#
-# This program is free software.
-# You can distribute/modify this program under the same terms of ruby.
-#
-# As a special exception, when this code is copied by Racc
-# into a Racc output file, you may use that output file
-# without restriction.
-#
-
-unless defined?(NotImplementedError)
-  NotImplementedError = NotImplementError
-end
-
-module Racc
-  class ParseError < StandardError; end
-end
-unless defined?(::ParseError)
-  ParseError = Racc::ParseError
-end
-
-module Racc
-
-  unless defined?(Racc_No_Extentions)
-    Racc_No_Extentions = false
-  end
-
-  class Parser
-
-    Racc_Runtime_Version = '1.4.5'
-    Racc_Runtime_Revision = '$Revision: 1.19 $'.split[1]
-
-    Racc_Runtime_Core_Version_R = '1.4.5'
-    Racc_Runtime_Core_Revision_R = '$Revision: 1.19 $'.split[1]
-    begin
-      require 'racc/cparse'
-    # Racc_Runtime_Core_Version_C  = (defined in extention)
-      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2]
-      unless new.respond_to?(:_racc_do_parse_c, true)
-        raise LoadError, 'old cparse.so'
-      end
-      if Racc_No_Extentions
-        raise LoadError, 'selecting ruby version of racc runtime core'
-      end
-
-      Racc_Main_Parsing_Routine    = :_racc_do_parse_c
-      Racc_YY_Parse_Method         = :_racc_yyparse_c
-      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
-      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
-      Racc_Runtime_Type            = 'c'
-    rescue LoadError
-      Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
-      Racc_YY_Parse_Method         = :_racc_yyparse_rb
-      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_R
-      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_R
-      Racc_Runtime_Type            = 'ruby'
-    end
-
-    def Parser.racc_runtime_type
-      Racc_Runtime_Type
-    end
-
-    private
-
-    def _racc_setup
-      @yydebug = false unless self.class::Racc_debug_parser
-      @yydebug = false unless defined?(@yydebug)
-      if @yydebug
-        @racc_debug_out = $stderr unless defined?(@racc_debug_out)
-        @racc_debug_out ||= $stderr
-      end
-      arg = self.class::Racc_arg
-      arg[13] = true if arg.size < 14
-      arg
-    end
-
-    def _racc_init_sysvars
-      @racc_state  = [0]
-      @racc_tstack = []
-      @racc_vstack = []
-
-      @racc_t = nil
-      @racc_val = nil
-
-      @racc_read_next = true
-
-      @racc_user_yyerror = false
-      @racc_error_status = 0
-    end
-
-    ###
-    ### do_parse
-    ###
-
-    def do_parse
-      __send__(Racc_Main_Parsing_Routine, _racc_setup(), false)
-    end
-
-    def next_token
-      raise NotImplementedError, "#{self.class}\#next_token is not defined"
-    end
-
-    def _racc_do_parse_rb(arg, in_debug)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-
-      _racc_init_sysvars
-      tok = act = i = nil
-      nerr = 0
-
-      catch(:racc_end_parse) {
-        while true
-          if i = action_pointer[@racc_state[-1]]
-            if @racc_read_next
-              if @racc_t != 0   # not EOF
-                tok, @racc_val = next_token()
-                unless tok      # EOF
-                  @racc_t = 0
-                else
-                  @racc_t = (token_table[tok] or 1)   # error token
-                end
-                racc_read_token(@racc_t, tok, @racc_val) if @yydebug
-                @racc_read_next = false
-              end
-            end
-            i += @racc_t
-            unless i >= 0 and
-                   act = action_table[i] and
-                   action_check[i] == @racc_state[-1]
-              act = action_default[@racc_state[-1]]
-            end
-          else
-            act = action_default[@racc_state[-1]]
-          end
-          while act = _racc_evalact(act, arg)
-            ;
-          end
-        end
-      }
-    end
-
-    ###
-    ### yyparse
-    ###
-
-    def yyparse(recv, mid)
-      __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), true)
-    end
-
-    def _racc_yyparse_rb(recv, mid, arg, c_debug)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-
-      _racc_init_sysvars
-      tok = nil
-      act = nil
-      i = nil
-      nerr = 0
-
-      catch(:racc_end_parse) {
-        until i = action_pointer[@racc_state[-1]]
-          while act = _racc_evalact(action_default[@racc_state[-1]], arg)
-            ;
-          end
-        end
-        recv.__send__(mid) do |tok, val|
-          unless tok
-            @racc_t = 0
-          else
-            @racc_t = (token_table[tok] or 1)   # error token
-          end
-          @racc_val = val
-          @racc_read_next = false
-
-          i += @racc_t
-          unless i >= 0 and
-                 act = action_table[i] and
-                 action_check[i] == @racc_state[-1]
-            act = action_default[@racc_state[-1]]
-          end
-          while act = _racc_evalact(act, arg)
-            ;
-          end
-
-          while not (i = action_pointer[@racc_state[-1]]) or
-                not @racc_read_next or
-                @racc_t == 0   # $
-            unless i and i += @racc_t and
-                   i >= 0 and
-                   act = action_table[i] and
-                   action_check[i] == @racc_state[-1]
-              act = action_default[@racc_state[-1]]
-            end
-            while act = _racc_evalact(act, arg)
-              ;
-            end
-          end
-        end
-      }
-    end
-
-    ###
-    ### common
-    ###
-
-    def _racc_evalact(act, arg)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-      nerr = 0   # tmp
-
-      if act > 0 and act < shift_n
-        #
-        # shift
-        #
-        if @racc_error_status > 0
-          @racc_error_status -= 1 unless @racc_t == 1   # error token
-        end
-        @racc_vstack.push @racc_val
-        @racc_state.push act
-        @racc_read_next = true
-        if @yydebug
-          @racc_tstack.push @racc_t
-          racc_shift @racc_t, @racc_tstack, @racc_vstack
-        end
-
-      elsif act < 0 and act > -reduce_n
-        #
-        # reduce
-        #
-        code = catch(:racc_jump) {
-          @racc_state.push _racc_do_reduce(arg, act)
-          false
-        }
-        if code
-          case code
-          when 1 # yyerror
-            @racc_user_yyerror = true   # user_yyerror
-            return -reduce_n
-          when 2 # yyaccept
-            return shift_n
-          else
-            raise '[Racc Bug] unknown jump code'
-          end
-        end
-
-      elsif act == shift_n
-        #
-        # accept
-        #
-        racc_accept if @yydebug
-        throw :racc_end_parse, @racc_vstack[0]
-
-      elsif act == -reduce_n
-        #
-        # error
-        #
-        case @racc_error_status
-        when 0
-          unless arg[21]    # user_yyerror
-            nerr += 1
-            on_error @racc_t, @racc_val, @racc_vstack
-          end
-        when 3
-          if @racc_t == 0   # is $
-            throw :racc_end_parse, nil
-          end
-          @racc_read_next = true
-        end
-        @racc_user_yyerror = false
-        @racc_error_status = 3
-        while true
-          if i = action_pointer[@racc_state[-1]]
-            i += 1   # error token
-            if  i >= 0 and
-                (act = action_table[i]) and
-                action_check[i] == @racc_state[-1]
-              break
-            end
-          end
-          throw :racc_end_parse, nil if @racc_state.size <= 1
-          @racc_state.pop
-          @racc_vstack.pop
-          if @yydebug
-            @racc_tstack.pop
-            racc_e_pop @racc_state, @racc_tstack, @racc_vstack
-          end
-        end
-        return act
-
-      else
-        raise "[Racc Bug] unknown action #{act.inspect}"
-      end
-
-      racc_next_state(@racc_state[-1], @racc_state) if @yydebug
-
-      nil
-    end
-
-    def _racc_do_reduce(arg, act)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-      state = @racc_state
-      vstack = @racc_vstack
-      tstack = @racc_tstack
-
-      i = act * -3
-      len       = reduce_table[i]
-      reduce_to = reduce_table[i+1]
-      method_id = reduce_table[i+2]
-      void_array = []
-
-      tmp_t = tstack[-len, len] if @yydebug
-      tmp_v = vstack[-len, len]
-      tstack[-len, len] = void_array if @yydebug
-      vstack[-len, len] = void_array
-      state[-len, len]  = void_array
-
-      # tstack must be updated AFTER method call
-      if use_result
-        vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
-      else
-        vstack.push __send__(method_id, tmp_v, vstack)
-      end
-      tstack.push reduce_to
-
-      racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug
-
-      k1 = reduce_to - nt_base
-      if i = goto_pointer[k1]
-        i += state[-1]
-        if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
-          return curstate
-        end
-      end
-      goto_default[k1]
-    end
-
-    def on_error(t, val, vstack)
-      raise ParseError, sprintf("\nparse error on value %s (%s)",
-                                val.inspect, token_to_str(t) || '?')
-    end
-
-    def yyerror
-      throw :racc_jump, 1
-    end
-
-    def yyaccept
-      throw :racc_jump, 2
-    end
-
-    def yyerrok
-      @racc_error_status = 0
-    end
-
-    #
-    # for debugging output
-    #
-
-    def racc_read_token(t, tok, val)
-      @racc_debug_out.print 'read    '
-      @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
-      @racc_debug_out.puts val.inspect
-      @racc_debug_out.puts
-    end
-
-    def racc_shift(tok, tstack, vstack)
-      @racc_debug_out.puts "shift   #{racc_token2str tok}"
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
-
-    def racc_reduce(toks, sim, tstack, vstack)
-      out = @racc_debug_out
-      out.print 'reduce '
-      if toks.empty?
-        out.print ' <none>'
-      else
-        toks.each {|t| out.print ' ', racc_token2str(t) }
-      end
-      out.puts " --> #{racc_token2str(sim)}"
-          
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
-
-    def racc_accept
-      @racc_debug_out.puts 'accept'
-      @racc_debug_out.puts
-    end
-
-    def racc_e_pop(state, tstack, vstack)
-      @racc_debug_out.puts 'error recovering mode: pop token'
-      racc_print_states state
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
-
-    def racc_next_state(curstate, state)
-      @racc_debug_out.puts  "goto    #{curstate}"
-      racc_print_states state
-      @racc_debug_out.puts
-    end
-
-    def racc_print_stacks(t, v)
-      out = @racc_debug_out
-      out.print '        ['
-      t.each_index do |i|
-        out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
-      end
-      out.puts ' ]'
-    end
-
-    def racc_print_states(s)
-      out = @racc_debug_out
-      out.print '        ['
-      s.each {|st| out.print ' ', st }
-      out.puts ' ]'
-    end
-
-    def racc_token2str(tok)
-      self.class::Racc_token_to_s_table[tok] or
-          raise "[Racc Bug] can't convert token #{tok} to string"
-    end
-
-    def token_to_str(t)
-      self.class::Racc_token_to_s_table[t]
-    end
-
-  end
-
-end
-end
-###### racc/parser.rb end
-
-
-
-require 'date'
-
-
-module NumRu
-class Units < Racc::Parser
-
-
-=begin
-= class Node
-Node is a parent class for classes of parse tree node.
-This is not expected to be instanciated directly.
-=end
-
-class Node
-
-    def initialize(*args)
-	raise "#{self.class} is virtual."
-    end
-
-    def to_s(*args)
-	raise "#{self.class}#to_s is virtual."
-    end
-
-=begin
---- pow other
-    simply constructs a PowNode object.
-    No reduction is performed.
-=end
-
-    def pow(other)
-	PowNode.new(self, other)
-    end
-
-=begin
---- mul other
-    simply constructs a MulNode object.
-    No reduction is performed.
-=end
-
-    def mul(other)
-	other = NumberNode.new(other) if Numeric === other
-	MulNode.new(self, other)
-    end
-
-=begin
---- divide other
-    simply constructs a MulNode object.
-    No reduction is performed.
-=end
-
-    def divide(other)
-	MulNode.new(self, PowNode.new(other, NumberNode.new(-1)))
-    end
-
-=begin
---- shift other
-    simply constructs a ShiftNode object.
-    No reduction is performed.
-=end
-
-    def shift(other)
-	ShiftNode.new(self, other)
-    end
-
-=begin
---- pow_eval other
-    similar to ((<pow other>)), but reduces PowNode[PowNode[...]] into
-    single PowNode[...], so overriden at PowNode class.
-=end
-
-    def pow_eval(other)
-	pow(other)
-    end
-
-=begin
---- inspect
-=end
-
-    def inspect2;  "#{self.class}[#{to_s}]";  end
-
-    def inspect;  inspect2.gsub(/Units::/, '').gsub(/NumRu::/, '').gsub(/Node\[/, '[');  end
-
-=begin
---- trim
-    in most subclasses, "trim" is redirected into "trim2".
-=end
-
-    def trim
-	trim2
-    end
-
-=begin
---- flatten
-    in most subclasses, "flatten" is redirected into "flatten2".
-=end
-
-    def flatten
-	flatten2
-    end
-
-=begin
---- sort
-=end
-
-    def sort
-	raise "#{self.class}#sort is virtual: call after flatten"
-    end
-
-=begin
---- reduce1
---- reduce2
---- reduce3
---- reduce4
---- reduce5
-=end
-
-    def reduce1
-	self
-    end
-
-    def reduce2
-	trim
-    end
-
-    def reduce3
-	trim.flatten
-    end
-
-    def reduce4
-	# unalias(Hash.new).trim.flatten.sort
-	foldnumber(nil).trim.flatten.sort
-    end
-
-    def reduce5
-	expand(Hash.new).trim.flatten.sort
-    end
-
-=begin
---- ref
-    to be overriden at ShiftNode
---- deref
-    to be overriden at ShiftNode
-=end
-
-    def ref
-	NumberNode::ZERO
-    end
-
-    def deref
-	self
-    end
-
-end
-
-class ErrorNode < Node
-
-    def initialize(string)
-	@a = string
-    end
-
-    def to_s;  @a;  end
-
-end
-
-class ContainerNode < Node
-
-    def trim2
-	x = []
-	for child in self
-	    x.push child.trim2
-	end
-	self.class.new(*x)
-    end
-
-    def inspect2
-	a = []
-	for child in self
-	    a.push child.inspect2
-	end
-      	"#{self.class}[#{a.join(', ')}]"
-    end
-
-end
-
-module BinaryNode
-
-    def each
-	yield @lhs
-	yield @rhs
-    end
-
-    def expand(stopper)
-	self.class.new(@lhs.expand(stopper), @rhs.expand(stopper))
-    end
-
-    def unalias(stopper)
-	self.class.new(@lhs.unalias(stopper), @rhs.unalias(stopper))
-    end
-
-    def foldnumber(stopper)
-	self.class.new(@lhs.foldnumber(stopper), @rhs.foldnumber(stopper))
-    end
-
-end
-
-class TerminalNode < Node
-
-    def trim2;  self;  end
-    def flatten2;  self;  end
-
-    def expand(stopper);  self;  end
-    alias :unalias :expand
-    alias :foldnumber :expand
-
-    def sort;  self;  end
-
-end
-class NameNode < TerminalNode
-
-    def initialize(string)
-	@a = string
-    end
-
-    def to_s;  @a;  end
-
-    alias :name :to_s
-
-    def power;  NumberNode::UNITY;  end
-
-    def mul_eval(another)
-	raise "internal error (#{name}, #{another.name})" if name != another.name
-	PowNode.new(self, self.power.add_eval(another.power))
-    end
-
-    def expand(stopper) 
-	raise "circular dependency for #{@a}" if stopper[@a]
-	return self if basic?
-	return CACHE[@a] if CACHE.include?(@a)
-	CACHE[@a] = expand2(stopper)
-    end
-
-    def expand2(stopper)
-	newstopper = stopper.dup
-	newstopper[@a] = true
-	if UDEFS.include?(@a) then
-	    Units.new(UDEFS[@a]).ptree.expand(newstopper)
-	else
-	    p, n = UALIASES[@a]
-	    u = Units.new(UDEFS[n] || n).ptree.expand(newstopper)
-	    MulNode.new(u, PowNode.new(NumberNode.new(10), NumberNode.new(p)))
-	end
-    end
-
-    def unalias(stopper)
-	raise "circular dependency for #{@a}" if stopper[@a]
-	return self unless UALIASES.include?(@a)
-	p, n = UALIASES[@a]
-	u = NameNode.new(n)
-	q = PowNode.new(NumberNode.new(10), NumberNode.new(p))
-	MulNode.new(u, q)
-    end
-
-    def foldnumber(stopper)
-	return self unless UPLURALS.include?(@a)
-	n = UPLURALS[@a]
-	NameNode.new(n)
-    end
-
-    def basic?
-	not (UDEFS.include?(@a) or UALIASES.include?(@a))
-    end
-
-    CACHE = {}
-
-    def factor
-	1
-    end
-
-end
-
-class NameNode
-UDEFS = {
-  "%" => "1e-2",  "Au" => "astronomical_unit",  "Bq" => "s-1",
-  "C" => "A.s",  "Celsius" => "K @ 273.15",  "F" => "C/V",
-  "Fahrenheit" => "degree_F",  "G" => "gauss",  "Gal" => "cm s-2",
-  "Gy" => "J.kg-1",  "H" => "Wb.A-1",  "Hg" => "mercury",
-  "Hz" => "1/s",  "J" => "N.m",  "Julian_year" => "365.25 day",
-  "L" => "litre",  "N" => "kg.m.s-2",  "P" => "poise",  "Pa" => "N.m-2",
-  "Pascal" => "Pa",  "S" => "A/V",  "St" => "stokes",  "Sv" => "J.kg-1",
-  "T" => "Wb.m-2",  "V" => "J/C",  "W" => "J/s",  "Wb" => "V.s",
-  "a" => "are",  "ac" => "acre",  "acre" => "10 chain2",
-  "ampere" => "A",  "angstrom" => "1.0e-10 m",
-  "angular_degree" => "degree",  "angular_minute" => "minute_angle",
-  "angular_second" => "second_angle",  "are" => "100 m2",
-  "astronomical_unit" => "1.49597870e11 m",
-  "astronomical_units" => "1.49597870e11 m",  "atm" => "atmosphere",
-  "atmosphere" => "101325 Pa",  "bar" => "1e6 dyn.cm-2",
-  "cal" => "calorie",  "calorie" => "4.18605 J",
-  "celsius" => "K @ 273.15",  "centigrade" => "K @ 273.15",
-  "century" => "100 year",  "chain" => "22 yard",
-  "common_year" => "365 day",
-  "conventional_mercury" => "gravity 13595.10 kg/m3",  "coulomb" => "C",
-  "d" => "24 hour",  "day" => "24 hour",  "degC" => "K @ 273.15",
-  "degF" => "degree_F",  "degK" => "K",  "deg_C" => "K @ 273.15",
-  "deg_F" => "degree_F",  "deg_K" => "K",  "degree" => "pi.rad/180",
-  "degreeC" => "K @ 273.15",  "degreeF" => "degree_F",
-  "degreeK" => "K",  "degree_C" => "K @ 273.15",
-  "degree_E" => "degree",  "degree_F" => "degree_R @ 459.67",
-  "degree_N" => "degree",  "degree_R" => "K / 1.8",
-  "degree_S" => "degree",  "degree_W" => "degree",
-  "degree_c" => "K @ 273.15",  "degree_east" => "degree_E",
-  "degree_f" => "degree_R @ 459.67",  "degree_north" => "degree_N",
-  "degree_south" => "degree_S",  "degree_west" => "degree_W",
-  "degrees_east" => "degree_E",  "degrees_north" => "degree_N",
-  "degrees_south" => "degree_S",  "degrees_west" => "degree_W",
-  "dyn" => "g.cm.s-2",  "dyne" => "g.cm.s-2",  "erg" => "dyn cm",
-  "fahrenheit" => "degree_F",  "farad" => "coulomb/volt",
-  "feet" => "foot",  "fermi" => "1.0e-15 m",  "foot" => "12 inch",
-  "force" => "9.80665 m.s-2",  "ft" => "foot",  "g" => "kg/1000",
-  "gal" => "cm s-2",  "gauss" => "T / 10000",  "gram" => "kg/1000",
-  "gravity" => "9.806650 meter/second2",  "h" => "60 min",
-  "hectare" => "100 are",  "hertz" => "Hz",  "hg" => "mercury",
-  "horse_power" => "75 m kilogram-force / s",  "hour" => "60 min",
-  "hr" => "60 min",  "in" => "inch",  "inch" => "2.54 cm",
-  "joule" => "J",  "kelvin" => "K",  "kgf" => "kilogram-force",
-  "kilogram" => "kg",  "knot" => "nautical_mile / hour",
-  "kph" => "km / hour",  "lb" => "pound",
-  "light_speed" => "299792458 m/s",  "light_year" => "9.46e15 m",
-  "light_years" => "9.46e15 m",  "litre" => "1.0e-3 m3",
-  "lm" => "cd.sr",  "lx" => "lm.m-2",  "ly" => "light_year",
-  "mb" => "bar / 1000",  "mercury" => "conventional_mercury",
-  "meter" => "metre",  "metre" => "m",  "mgal" => "cm s-2 / 1000",
-  "micron" => "1.0e-6 m",  "mile" => "1760 yard",
-  "millibar" => "bar / 1000",  "min" => "60 s",  "minute" => "60 s",
-  "minute_angle" => "pi.rad/180/60",  "mole" => "mol",
-  "mon" => "month",  "month" => "6 pentad",  "mph" => "mile / hour",
-  "nautical_mile" => "1852 m",  "nautical_miles" => "1852 m",
-  "newton" => "N",  "ohm" => "V/A",  "ounce" => "pound / 16",
-  "oz" => "ounce",  "parsec" => "3.0857e16 m",  "pascal" => "Pa",
-  "pc" => "parsec",  "percent" => "1e-2",  "permil" => "1e-3",
-  "pi" => "3.141592653589793238462",  "poise" => "dyn s / cm2",
-  "pound" => "453.6 g",  "psi" => "pound-force / inch2",
-  "radian" => "rad",  "second" => "s",
-  "second_angle" => "pi.rad/180/60/60",  "steradian" => "sr",
-  "stokes" => "cm2 / s",  "t" => "ton",  "tesla" => "Wb.m-2",
-  "ton" => "1000 kg",  "tonne" => "ton",  "torr" => "133.322 Pa",
-  "volt" => "V",  "watt" => "W",  "weber" => "Wb",  "yard" => "6 feet",
-  "yd" => "yard",  "year" => "12 month",  "yr" => "year",
-}
-UALIASES = {
-  "Celsiuses" => [0, "Celsius"],  "E%" => [18, "%"],  "EA" => [18, "A"],
-  "EAu" => [18, "Au"],  "EBq" => [18, "Bq"],  "EC" => [18, "C"],
-  "EF" => [18, "F"],  "EG" => [18, "G"],  "EGal" => [18, "Gal"],
-  "EGy" => [18, "Gy"],  "EH" => [18, "H"],  "EHg" => [18, "Hg"],
-  "EHz" => [18, "Hz"],  "EJ" => [18, "J"],  "EK" => [18, "K"],
-  "EL" => [18, "L"],  "EN" => [18, "N"],  "EP" => [18, "P"],
-  "EPa" => [18, "Pa"],  "ES" => [18, "S"],  "ESt" => [18, "St"],
-  "ESv" => [18, "Sv"],  "ET" => [18, "T"],  "EV" => [18, "V"],
-  "EW" => [18, "W"],  "EWb" => [18, "Wb"],  "Ea" => [18, "a"],
-  "Eac" => [18, "ac"],  "Eatm" => [18, "atm"],  "Ebar" => [18, "bar"],
-  "Ecal" => [18, "cal"],
-  "Econventional_mercury" => [18, "conventional_mercury"],
-  "Ed" => [18, "d"],  "EdegC" => [18, "degC"],  "EdegF" => [18, "degF"],
-  "Edeg_C" => [18, "deg_C"],  "Edeg_F" => [18, "deg_F"],
-  "EdegreeC" => [18, "degreeC"],  "EdegreeF" => [18, "degreeF"],
-  "Edegree_C" => [18, "degree_C"],  "Edegree_E" => [18, "degree_E"],
-  "Edegree_F" => [18, "degree_F"],  "Edegree_N" => [18, "degree_N"],
-  "Edegree_R" => [18, "degree_R"],  "Edegree_S" => [18, "degree_S"],
-  "Edegree_W" => [18, "degree_W"],  "Edegree_c" => [18, "degree_c"],
-  "Edegree_east" => [18, "degree_east"],
-  "Edegree_f" => [18, "degree_f"],
-  "Edegree_north" => [18, "degree_north"],
-  "Edegree_south" => [18, "degree_south"],
-  "Edegree_west" => [18, "degree_west"],
-  "Edegrees_east" => [18, "degrees_east"],
-  "Edegrees_north" => [18, "degrees_north"],
-  "Edegrees_south" => [18, "degrees_south"],
-  "Edegrees_west" => [18, "degrees_west"],  "Edyn" => [18, "dyn"],
-  "Eerg" => [18, "erg"],  "Eforce" => [18, "force"],  "Eg" => [18, "g"],
-  "Egravity" => [18, "gravity"],  "Eh" => [18, "h"],
-  "Ehg" => [18, "hg"],  "Ehr" => [18, "hr"],  "Ein" => [18, "in"],
-  "Ekg" => [18, "kg"],  "Ekgf" => [18, "kgf"],  "Ekph" => [18, "kph"],
-  "Elb" => [18, "lb"],  "Elm" => [18, "lm"],  "Elx" => [18, "lx"],
-  "Ely" => [18, "ly"],  "Em" => [18, "m"],  "Emb" => [18, "mb"],
-  "Emercury" => [18, "mercury"],  "Emgal" => [18, "mgal"],
-  "Emin" => [18, "min"],  "Emol" => [18, "mol"],  "Emon" => [18, "mon"],
-  "Emph" => [18, "mph"],  "Eohm" => [18, "ohm"],  "Eoz" => [18, "oz"],
-  "Epc" => [18, "pc"],  "Epercent" => [18, "percent"],
-  "Epermil" => [18, "permil"],  "Epsi" => [18, "psi"],
-  "Erad" => [18, "rad"],  "Es" => [18, "s"],  "Esr" => [18, "sr"],
-  "Et" => [18, "t"],  "Eyr" => [18, "yr"],
-  "Fahrenheits" => [0, "Fahrenheit"],  "G%" => [9, "%"],
-  "GA" => [9, "A"],  "GAu" => [9, "Au"],  "GBq" => [9, "Bq"],
-  "GC" => [9, "C"],  "GF" => [9, "F"],  "GG" => [9, "G"],
-  "GGal" => [9, "Gal"],  "GGy" => [9, "Gy"],  "GH" => [9, "H"],
-  "GHg" => [9, "Hg"],  "GHz" => [9, "Hz"],  "GJ" => [9, "J"],
-  "GK" => [9, "K"],  "GL" => [9, "L"],  "GN" => [9, "N"],
-  "GP" => [9, "P"],  "GPa" => [9, "Pa"],  "GS" => [9, "S"],
-  "GSt" => [9, "St"],  "GSv" => [9, "Sv"],  "GT" => [9, "T"],
-  "GV" => [9, "V"],  "GW" => [9, "W"],  "GWb" => [9, "Wb"],
-  "Ga" => [9, "a"],  "Gac" => [9, "ac"],  "Gatm" => [9, "atm"],
-  "Gbar" => [9, "bar"],  "Gcal" => [9, "cal"],
-  "Gconventional_mercury" => [9, "conventional_mercury"],
-  "Gd" => [9, "d"],  "GdegC" => [9, "degC"],  "GdegF" => [9, "degF"],
-  "Gdeg_C" => [9, "deg_C"],  "Gdeg_F" => [9, "deg_F"],
-  "GdegreeC" => [9, "degreeC"],  "GdegreeF" => [9, "degreeF"],
-  "Gdegree_C" => [9, "degree_C"],  "Gdegree_E" => [9, "degree_E"],
-  "Gdegree_F" => [9, "degree_F"],  "Gdegree_N" => [9, "degree_N"],
-  "Gdegree_R" => [9, "degree_R"],  "Gdegree_S" => [9, "degree_S"],
-  "Gdegree_W" => [9, "degree_W"],  "Gdegree_c" => [9, "degree_c"],
-  "Gdegree_east" => [9, "degree_east"],  "Gdegree_f" => [9, "degree_f"],
-  "Gdegree_north" => [9, "degree_north"],
-  "Gdegree_south" => [9, "degree_south"],
-  "Gdegree_west" => [9, "degree_west"],
-  "Gdegrees_east" => [9, "degrees_east"],
-  "Gdegrees_north" => [9, "degrees_north"],
-  "Gdegrees_south" => [9, "degrees_south"],
-  "Gdegrees_west" => [9, "degrees_west"],  "Gdyn" => [9, "dyn"],
-  "Gerg" => [9, "erg"],  "Gforce" => [9, "force"],  "Gg" => [9, "g"],
-  "Ggravity" => [9, "gravity"],  "Gh" => [9, "h"],  "Ghg" => [9, "hg"],
-  "Ghr" => [9, "hr"],  "Gin" => [9, "in"],  "Gkg" => [9, "kg"],
-  "Gkgf" => [9, "kgf"],  "Gkph" => [9, "kph"],  "Glb" => [9, "lb"],
-  "Glm" => [9, "lm"],  "Glx" => [9, "lx"],  "Gly" => [9, "ly"],
-  "Gm" => [9, "m"],  "Gmb" => [9, "mb"],  "Gmercury" => [9, "mercury"],
-  "Gmgal" => [9, "mgal"],  "Gmin" => [9, "min"],  "Gmol" => [9, "mol"],
-  "Gmon" => [9, "mon"],  "Gmph" => [9, "mph"],  "Gohm" => [9, "ohm"],
-  "Goz" => [9, "oz"],  "Gpc" => [9, "pc"],
-  "Gpercent" => [9, "percent"],  "Gpermil" => [9, "permil"],
-  "Gpsi" => [9, "psi"],  "Grad" => [9, "rad"],  "Gs" => [9, "s"],
-  "Gsr" => [9, "sr"],  "Gt" => [9, "t"],  "Gyr" => [9, "yr"],
-  "Julians_year" => [0, "Julian_year"],  "M%" => [6, "%"],
-  "MA" => [6, "A"],  "MAu" => [6, "Au"],  "MBq" => [6, "Bq"],
-  "MC" => [6, "C"],  "MF" => [6, "F"],  "MG" => [6, "G"],
-  "MGal" => [6, "Gal"],  "MGy" => [6, "Gy"],  "MH" => [6, "H"],
-  "MHg" => [6, "Hg"],  "MHz" => [6, "Hz"],  "MJ" => [6, "J"],
-  "MK" => [6, "K"],  "ML" => [6, "L"],  "MN" => [6, "N"],
-  "MP" => [6, "P"],  "MPa" => [6, "Pa"],  "MS" => [6, "S"],
-  "MSt" => [6, "St"],  "MSv" => [6, "Sv"],  "MT" => [6, "T"],
-  "MV" => [6, "V"],  "MW" => [6, "W"],  "MWb" => [6, "Wb"],
-  "Ma" => [6, "a"],  "Mac" => [6, "ac"],  "Matm" => [6, "atm"],
-  "Mbar" => [6, "bar"],  "Mcal" => [6, "cal"],
-  "Mconventional_mercury" => [6, "conventional_mercury"],
-  "Md" => [6, "d"],  "MdegC" => [6, "degC"],  "MdegF" => [6, "degF"],
-  "Mdeg_C" => [6, "deg_C"],  "Mdeg_F" => [6, "deg_F"],
-  "MdegreeC" => [6, "degreeC"],  "MdegreeF" => [6, "degreeF"],
-  "Mdegree_C" => [6, "degree_C"],  "Mdegree_E" => [6, "degree_E"],
-  "Mdegree_F" => [6, "degree_F"],  "Mdegree_N" => [6, "degree_N"],
-  "Mdegree_R" => [6, "degree_R"],  "Mdegree_S" => [6, "degree_S"],
-  "Mdegree_W" => [6, "degree_W"],  "Mdegree_c" => [6, "degree_c"],
-  "Mdegree_east" => [6, "degree_east"],  "Mdegree_f" => [6, "degree_f"],
-  "Mdegree_north" => [6, "degree_north"],
-  "Mdegree_south" => [6, "degree_south"],
-  "Mdegree_west" => [6, "degree_west"],
-  "Mdegrees_east" => [6, "degrees_east"],
-  "Mdegrees_north" => [6, "degrees_north"],
-  "Mdegrees_south" => [6, "degrees_south"],
-  "Mdegrees_west" => [6, "degrees_west"],  "Mdyn" => [6, "dyn"],
-  "Merg" => [6, "erg"],  "Mforce" => [6, "force"],  "Mg" => [6, "g"],
-  "Mgravity" => [6, "gravity"],  "Mh" => [6, "h"],  "Mhg" => [6, "hg"],
-  "Mhr" => [6, "hr"],  "Min" => [6, "in"],  "Mkg" => [6, "kg"],
-  "Mkgf" => [6, "kgf"],  "Mkph" => [6, "kph"],  "Mlb" => [6, "lb"],
-  "Mlm" => [6, "lm"],  "Mlx" => [6, "lx"],  "Mly" => [6, "ly"],
-  "Mm" => [6, "m"],  "Mmb" => [6, "mb"],  "Mmercury" => [6, "mercury"],
-  "Mmgal" => [6, "mgal"],  "Mmin" => [6, "min"],  "Mmol" => [6, "mol"],
-  "Mmon" => [6, "mon"],  "Mmph" => [6, "mph"],  "Mohm" => [6, "ohm"],
-  "Moz" => [6, "oz"],  "Mpc" => [6, "pc"],
-  "Mpercent" => [6, "percent"],  "Mpermil" => [6, "permil"],
-  "Mpsi" => [6, "psi"],  "Mrad" => [6, "rad"],  "Ms" => [6, "s"],
-  "Msr" => [6, "sr"],  "Mt" => [6, "t"],  "Myr" => [6, "yr"],
-  "P%" => [15, "%"],  "PA" => [15, "A"],  "PAu" => [15, "Au"],
-  "PBq" => [15, "Bq"],  "PC" => [15, "C"],  "PF" => [15, "F"],
-  "PG" => [15, "G"],  "PGal" => [15, "Gal"],  "PGy" => [15, "Gy"],
-  "PH" => [15, "H"],  "PHg" => [15, "Hg"],  "PHz" => [15, "Hz"],
-  "PJ" => [15, "J"],  "PK" => [15, "K"],  "PL" => [15, "L"],
-  "PN" => [15, "N"],  "PP" => [15, "P"],  "PPa" => [15, "Pa"],
-  "PS" => [15, "S"],  "PSt" => [15, "St"],  "PSv" => [15, "Sv"],
-  "PT" => [15, "T"],  "PV" => [15, "V"],  "PW" => [15, "W"],
-  "PWb" => [15, "Wb"],  "Pa" => [15, "a"],  "Pac" => [15, "ac"],
-  "Pascals" => [0, "Pascal"],  "Patm" => [15, "atm"],
-  "Pbar" => [15, "bar"],  "Pcal" => [15, "cal"],
-  "Pconventional_mercury" => [15, "conventional_mercury"],
-  "Pd" => [15, "d"],  "PdegC" => [15, "degC"],  "PdegF" => [15, "degF"],
-  "Pdeg_C" => [15, "deg_C"],  "Pdeg_F" => [15, "deg_F"],
-  "PdegreeC" => [15, "degreeC"],  "PdegreeF" => [15, "degreeF"],
-  "Pdegree_C" => [15, "degree_C"],  "Pdegree_E" => [15, "degree_E"],
-  "Pdegree_F" => [15, "degree_F"],  "Pdegree_N" => [15, "degree_N"],
-  "Pdegree_R" => [15, "degree_R"],  "Pdegree_S" => [15, "degree_S"],
-  "Pdegree_W" => [15, "degree_W"],  "Pdegree_c" => [15, "degree_c"],
-  "Pdegree_east" => [15, "degree_east"],
-  "Pdegree_f" => [15, "degree_f"],
-  "Pdegree_north" => [15, "degree_north"],
-  "Pdegree_south" => [15, "degree_south"],
-  "Pdegree_west" => [15, "degree_west"],
-  "Pdegrees_east" => [15, "degrees_east"],
-  "Pdegrees_north" => [15, "degrees_north"],
-  "Pdegrees_south" => [15, "degrees_south"],
-  "Pdegrees_west" => [15, "degrees_west"],  "Pdyn" => [15, "dyn"],
-  "Perg" => [15, "erg"],  "Pforce" => [15, "force"],  "Pg" => [15, "g"],
-  "Pgravity" => [15, "gravity"],  "Ph" => [15, "h"],
-  "Phg" => [15, "hg"],  "Phr" => [15, "hr"],  "Pin" => [15, "in"],
-  "Pkg" => [15, "kg"],  "Pkgf" => [15, "kgf"],  "Pkph" => [15, "kph"],
-  "Plb" => [15, "lb"],  "Plm" => [15, "lm"],  "Plx" => [15, "lx"],
-  "Ply" => [15, "ly"],  "Pm" => [15, "m"],  "Pmb" => [15, "mb"],
-  "Pmercury" => [15, "mercury"],  "Pmgal" => [15, "mgal"],
-  "Pmin" => [15, "min"],  "Pmol" => [15, "mol"],  "Pmon" => [15, "mon"],
-  "Pmph" => [15, "mph"],  "Pohm" => [15, "ohm"],  "Poz" => [15, "oz"],
-  "Ppc" => [15, "pc"],  "Ppercent" => [15, "percent"],
-  "Ppermil" => [15, "permil"],  "Ppsi" => [15, "psi"],
-  "Prad" => [15, "rad"],  "Ps" => [15, "s"],  "Psr" => [15, "sr"],
-  "Pt" => [15, "t"],  "Pyr" => [15, "yr"],  "T%" => [12, "%"],
-  "TA" => [12, "A"],  "TAu" => [12, "Au"],  "TBq" => [12, "Bq"],
-  "TC" => [12, "C"],  "TF" => [12, "F"],  "TG" => [12, "G"],
-  "TGal" => [12, "Gal"],  "TGy" => [12, "Gy"],  "TH" => [12, "H"],
-  "THg" => [12, "Hg"],  "THz" => [12, "Hz"],  "TJ" => [12, "J"],
-  "TK" => [12, "K"],  "TL" => [12, "L"],  "TN" => [12, "N"],
-  "TP" => [12, "P"],  "TPa" => [12, "Pa"],  "TS" => [12, "S"],
-  "TSt" => [12, "St"],  "TSv" => [12, "Sv"],  "TT" => [12, "T"],
-  "TV" => [12, "V"],  "TW" => [12, "W"],  "TWb" => [12, "Wb"],
-  "Ta" => [12, "a"],  "Tac" => [12, "ac"],  "Tatm" => [12, "atm"],
-  "Tbar" => [12, "bar"],  "Tcal" => [12, "cal"],
-  "Tconventional_mercury" => [12, "conventional_mercury"],
-  "Td" => [12, "d"],  "TdegC" => [12, "degC"],  "TdegF" => [12, "degF"],
-  "Tdeg_C" => [12, "deg_C"],  "Tdeg_F" => [12, "deg_F"],
-  "TdegreeC" => [12, "degreeC"],  "TdegreeF" => [12, "degreeF"],
-  "Tdegree_C" => [12, "degree_C"],  "Tdegree_E" => [12, "degree_E"],
-  "Tdegree_F" => [12, "degree_F"],  "Tdegree_N" => [12, "degree_N"],
-  "Tdegree_R" => [12, "degree_R"],  "Tdegree_S" => [12, "degree_S"],
-  "Tdegree_W" => [12, "degree_W"],  "Tdegree_c" => [12, "degree_c"],
-  "Tdegree_east" => [12, "degree_east"],
-  "Tdegree_f" => [12, "degree_f"],
-  "Tdegree_north" => [12, "degree_north"],
-  "Tdegree_south" => [12, "degree_south"],
-  "Tdegree_west" => [12, "degree_west"],
-  "Tdegrees_east" => [12, "degrees_east"],
-  "Tdegrees_north" => [12, "degrees_north"],
-  "Tdegrees_south" => [12, "degrees_south"],
-  "Tdegrees_west" => [12, "degrees_west"],  "Tdyn" => [12, "dyn"],
-  "Terg" => [12, "erg"],  "Tforce" => [12, "force"],  "Tg" => [12, "g"],
-  "Tgravity" => [12, "gravity"],  "Th" => [12, "h"],
-  "Thg" => [12, "hg"],  "Thr" => [12, "hr"],  "Tin" => [12, "in"],
-  "Tkg" => [12, "kg"],  "Tkgf" => [12, "kgf"],  "Tkph" => [12, "kph"],
-  "Tlb" => [12, "lb"],  "Tlm" => [12, "lm"],  "Tlx" => [12, "lx"],
-  "Tly" => [12, "ly"],  "Tm" => [12, "m"],  "Tmb" => [12, "mb"],
-  "Tmercury" => [12, "mercury"],  "Tmgal" => [12, "mgal"],
-  "Tmin" => [12, "min"],  "Tmol" => [12, "mol"],  "Tmon" => [12, "mon"],
-  "Tmph" => [12, "mph"],  "Tohm" => [12, "ohm"],  "Toz" => [12, "oz"],
-  "Tpc" => [12, "pc"],  "Tpercent" => [12, "percent"],
-  "Tpermil" => [12, "permil"],  "Tpsi" => [12, "psi"],
-  "Trad" => [12, "rad"],  "Ts" => [12, "s"],  "Tsr" => [12, "sr"],
-  "Tt" => [12, "t"],  "Tyr" => [12, "yr"],  "a%" => [-18, "%"],
-  "aA" => [-18, "A"],  "aAu" => [-18, "Au"],  "aBq" => [-18, "Bq"],
-  "aC" => [-18, "C"],  "aF" => [-18, "F"],  "aG" => [-18, "G"],
-  "aGal" => [-18, "Gal"],  "aGy" => [-18, "Gy"],  "aH" => [-18, "H"],
-  "aHg" => [-18, "Hg"],  "aHz" => [-18, "Hz"],  "aJ" => [-18, "J"],
-  "aK" => [-18, "K"],  "aL" => [-18, "L"],  "aN" => [-18, "N"],
-  "aP" => [-18, "P"],  "aPa" => [-18, "Pa"],  "aS" => [-18, "S"],
-  "aSt" => [-18, "St"],  "aSv" => [-18, "Sv"],  "aT" => [-18, "T"],
-  "aV" => [-18, "V"],  "aW" => [-18, "W"],  "aWb" => [-18, "Wb"],
-  "aa" => [-18, "a"],  "aac" => [-18, "ac"],  "aatm" => [-18, "atm"],
-  "abar" => [-18, "bar"],  "acal" => [-18, "cal"],
-  "aconventional_mercury" => [-18, "conventional_mercury"],
-  "acres" => [0, "acre"],  "ad" => [-18, "d"],
-  "adegC" => [-18, "degC"],  "adegF" => [-18, "degF"],
-  "adeg_C" => [-18, "deg_C"],  "adeg_F" => [-18, "deg_F"],
-  "adegreeC" => [-18, "degreeC"],  "adegreeF" => [-18, "degreeF"],
-  "adegree_C" => [-18, "degree_C"],  "adegree_E" => [-18, "degree_E"],
-  "adegree_F" => [-18, "degree_F"],  "adegree_N" => [-18, "degree_N"],
-  "adegree_R" => [-18, "degree_R"],  "adegree_S" => [-18, "degree_S"],
-  "adegree_W" => [-18, "degree_W"],  "adegree_c" => [-18, "degree_c"],
-  "adegree_east" => [-18, "degree_east"],
-  "adegree_f" => [-18, "degree_f"],
-  "adegree_north" => [-18, "degree_north"],
-  "adegree_south" => [-18, "degree_south"],
-  "adegree_west" => [-18, "degree_west"],
-  "adegrees_east" => [-18, "degrees_east"],
-  "adegrees_north" => [-18, "degrees_north"],
-  "adegrees_south" => [-18, "degrees_south"],
-  "adegrees_west" => [-18, "degrees_west"],  "adyn" => [-18, "dyn"],
-  "aerg" => [-18, "erg"],  "aforce" => [-18, "force"],
-  "ag" => [-18, "g"],  "agravity" => [-18, "gravity"],
-  "ah" => [-18, "h"],  "ahg" => [-18, "hg"],  "ahr" => [-18, "hr"],
-  "ain" => [-18, "in"],  "akg" => [-18, "kg"],  "akgf" => [-18, "kgf"],
-  "akph" => [-18, "kph"],  "alb" => [-18, "lb"],  "alm" => [-18, "lm"],
-  "alx" => [-18, "lx"],  "aly" => [-18, "ly"],  "am" => [-18, "m"],
-  "amb" => [-18, "mb"],  "amercury" => [-18, "mercury"],
-  "amgal" => [-18, "mgal"],  "amin" => [-18, "min"],
-  "amol" => [-18, "mol"],  "amon" => [-18, "mon"],
-  "amperes" => [0, "ampere"],  "amph" => [-18, "mph"],
-  "angstroms" => [0, "angstrom"],
-  "angulars_degree" => [0, "angular_degree"],
-  "angulars_minute" => [0, "angular_minute"],
-  "angulars_second" => [0, "angular_second"],  "aohm" => [-18, "ohm"],
-  "aoz" => [-18, "oz"],  "apc" => [-18, "pc"],
-  "apercent" => [-18, "percent"],  "apermil" => [-18, "permil"],
-  "apsi" => [-18, "psi"],  "arad" => [-18, "rad"],
-  "ares" => [0, "are"],  "as" => [-18, "s"],  "asr" => [-18, "sr"],
-  "at" => [-18, "t"],  "atmospheres" => [0, "atmosphere"],
-  "attoCelsius" => [-18, "Celsius"],
-  "attoFahrenheit" => [-18, "Fahrenheit"],
-  "attoJulian_year" => [-18, "Julian_year"],
-  "attoPascal" => [-18, "Pascal"],  "attoacre" => [-18, "acre"],
-  "attoampere" => [-18, "ampere"],  "attoangstrom" => [-18, "angstrom"],
-  "attoangular_degree" => [-18, "angular_degree"],
-  "attoangular_minute" => [-18, "angular_minute"],
-  "attoangular_second" => [-18, "angular_second"],
-  "attoare" => [-18, "are"],  "attoatmosphere" => [-18, "atmosphere"],
-  "attocalorie" => [-18, "calorie"],  "attocelsius" => [-18, "celsius"],
-  "attocentigrade" => [-18, "centigrade"],
-  "attocentury" => [-18, "century"],  "attochain" => [-18, "chain"],
-  "attocommon_year" => [-18, "common_year"],
-  "attocoulomb" => [-18, "coulomb"],  "attoday" => [-18, "day"],
-  "attodegK" => [-18, "degK"],  "attodeg_K" => [-18, "deg_K"],
-  "attodegree" => [-18, "degree"],  "attodegreeK" => [-18, "degreeK"],
-  "attodyne" => [-18, "dyne"],  "attoerg" => [-18, "erg"],
-  "attofahrenheit" => [-18, "fahrenheit"],
-  "attofarad" => [-18, "farad"],  "attofermi" => [-18, "fermi"],
-  "attogal" => [-18, "gal"],  "attogauss" => [-18, "gauss"],
-  "attogram" => [-18, "gram"],  "attohectare" => [-18, "hectare"],
-  "attohertz" => [-18, "hertz"],  "attohour" => [-18, "hour"],
-  "attoinch" => [-18, "inch"],  "attojoule" => [-18, "joule"],
-  "attokelvin" => [-18, "kelvin"],  "attokilogram" => [-18, "kilogram"],
-  "attoknot" => [-18, "knot"],  "attolitre" => [-18, "litre"],
-  "attometer" => [-18, "meter"],  "attometre" => [-18, "metre"],
-  "attomicron" => [-18, "micron"],  "attomile" => [-18, "mile"],
-  "attomillibar" => [-18, "millibar"],  "attominute" => [-18, "minute"],
-  "attominute_angle" => [-18, "minute_angle"],
-  "attomole" => [-18, "mole"],  "attomonth" => [-18, "month"],
-  "attonewton" => [-18, "newton"],  "attoounce" => [-18, "ounce"],
-  "attoparsec" => [-18, "parsec"],  "attopascal" => [-18, "pascal"],
-  "attopentad" => [-18, "pentad"],  "attopoise" => [-18, "poise"],
-  "attopound" => [-18, "pound"],  "attoradian" => [-18, "radian"],
-  "attosecond" => [-18, "second"],
-  "attosecond_angle" => [-18, "second_angle"],
-  "attosteradian" => [-18, "steradian"],
-  "attostokes" => [-18, "stokes"],  "attotesla" => [-18, "tesla"],
-  "attoton" => [-18, "ton"],  "attotonne" => [-18, "tonne"],
-  "attotorr" => [-18, "torr"],  "attovolt" => [-18, "volt"],
-  "attowatt" => [-18, "watt"],  "attoweber" => [-18, "weber"],
-  "attoyard" => [-18, "yard"],  "attoyd" => [-18, "yd"],
-  "attoyear" => [-18, "year"],  "ayr" => [-18, "yr"],
-  "c%" => [-2, "%"],  "cA" => [-2, "A"],  "cAu" => [-2, "Au"],
-  "cBq" => [-2, "Bq"],  "cC" => [-2, "C"],  "cF" => [-2, "F"],
-  "cG" => [-2, "G"],  "cGal" => [-2, "Gal"],  "cGy" => [-2, "Gy"],
-  "cH" => [-2, "H"],  "cHg" => [-2, "Hg"],  "cHz" => [-2, "Hz"],
-  "cJ" => [-2, "J"],  "cK" => [-2, "K"],  "cL" => [-2, "L"],
-  "cN" => [-2, "N"],  "cP" => [-2, "P"],  "cPa" => [-2, "Pa"],
-  "cS" => [-2, "S"],  "cSt" => [-2, "St"],  "cSv" => [-2, "Sv"],
-  "cT" => [-2, "T"],  "cV" => [-2, "V"],  "cW" => [-2, "W"],
-  "cWb" => [-2, "Wb"],  "ca" => [-2, "a"],  "cac" => [-2, "ac"],
-  "calories" => [0, "calorie"],  "catm" => [-2, "atm"],
-  "cbar" => [-2, "bar"],  "ccal" => [-2, "cal"],
-  "cconventional_mercury" => [-2, "conventional_mercury"],
-  "cd" => [-2, "d"],  "cdegC" => [-2, "degC"],  "cdegF" => [-2, "degF"],
-  "cdeg_C" => [-2, "deg_C"],  "cdeg_F" => [-2, "deg_F"],
-  "cdegreeC" => [-2, "degreeC"],  "cdegreeF" => [-2, "degreeF"],
-  "cdegree_C" => [-2, "degree_C"],  "cdegree_E" => [-2, "degree_E"],
-  "cdegree_F" => [-2, "degree_F"],  "cdegree_N" => [-2, "degree_N"],
-  "cdegree_R" => [-2, "degree_R"],  "cdegree_S" => [-2, "degree_S"],
-  "cdegree_W" => [-2, "degree_W"],  "cdegree_c" => [-2, "degree_c"],
-  "cdegree_east" => [-2, "degree_east"],
-  "cdegree_f" => [-2, "degree_f"],
-  "cdegree_north" => [-2, "degree_north"],
-  "cdegree_south" => [-2, "degree_south"],
-  "cdegree_west" => [-2, "degree_west"],
-  "cdegrees_east" => [-2, "degrees_east"],
-  "cdegrees_north" => [-2, "degrees_north"],
-  "cdegrees_south" => [-2, "degrees_south"],
-  "cdegrees_west" => [-2, "degrees_west"],  "cdyn" => [-2, "dyn"],
-  "celsiuses" => [0, "celsius"],  "centiCelsius" => [-2, "Celsius"],
-  "centiFahrenheit" => [-2, "Fahrenheit"],
-  "centiJulian_year" => [-2, "Julian_year"],
-  "centiPascal" => [-2, "Pascal"],  "centiacre" => [-2, "acre"],
-  "centiampere" => [-2, "ampere"],  "centiangstrom" => [-2, "angstrom"],
-  "centiangular_degree" => [-2, "angular_degree"],
-  "centiangular_minute" => [-2, "angular_minute"],
-  "centiangular_second" => [-2, "angular_second"],
-  "centiare" => [-2, "are"],  "centiatmosphere" => [-2, "atmosphere"],
-  "centicalorie" => [-2, "calorie"],  "centicelsius" => [-2, "celsius"],
-  "centicentigrade" => [-2, "centigrade"],
-  "centicentury" => [-2, "century"],  "centichain" => [-2, "chain"],
-  "centicommon_year" => [-2, "common_year"],
-  "centicoulomb" => [-2, "coulomb"],  "centiday" => [-2, "day"],
-  "centidegK" => [-2, "degK"],  "centideg_K" => [-2, "deg_K"],
-  "centidegree" => [-2, "degree"],  "centidegreeK" => [-2, "degreeK"],
-  "centidyne" => [-2, "dyne"],  "centierg" => [-2, "erg"],
-  "centifahrenheit" => [-2, "fahrenheit"],
-  "centifarad" => [-2, "farad"],  "centifermi" => [-2, "fermi"],
-  "centigal" => [-2, "gal"],  "centigauss" => [-2, "gauss"],
-  "centigrades" => [0, "centigrade"],  "centigram" => [-2, "gram"],
-  "centihectare" => [-2, "hectare"],  "centihertz" => [-2, "hertz"],
-  "centihour" => [-2, "hour"],  "centiinch" => [-2, "inch"],
-  "centijoule" => [-2, "joule"],  "centikelvin" => [-2, "kelvin"],
-  "centikilogram" => [-2, "kilogram"],  "centiknot" => [-2, "knot"],
-  "centilitre" => [-2, "litre"],  "centimeter" => [-2, "meter"],
-  "centimetre" => [-2, "metre"],  "centimicron" => [-2, "micron"],
-  "centimile" => [-2, "mile"],  "centimillibar" => [-2, "millibar"],
-  "centiminute" => [-2, "minute"],
-  "centiminute_angle" => [-2, "minute_angle"],
-  "centimole" => [-2, "mole"],  "centimonth" => [-2, "month"],
-  "centinewton" => [-2, "newton"],  "centiounce" => [-2, "ounce"],
-  "centiparsec" => [-2, "parsec"],  "centipascal" => [-2, "pascal"],
-  "centipentad" => [-2, "pentad"],  "centipoise" => [-2, "poise"],
-  "centipound" => [-2, "pound"],  "centiradian" => [-2, "radian"],
-  "centisecond" => [-2, "second"],
-  "centisecond_angle" => [-2, "second_angle"],
-  "centisteradian" => [-2, "steradian"],
-  "centistokes" => [-2, "stokes"],  "centitesla" => [-2, "tesla"],
-  "centiton" => [-2, "ton"],  "centitonne" => [-2, "tonne"],
-  "centitorr" => [-2, "torr"],  "centivolt" => [-2, "volt"],
-  "centiwatt" => [-2, "watt"],  "centiweber" => [-2, "weber"],
-  "centiyard" => [-2, "yard"],  "centiyd" => [-2, "yd"],
-  "centiyear" => [-2, "year"],  "centuries" => [0, "century"],
-  "cerg" => [-2, "erg"],  "cforce" => [-2, "force"],  "cg" => [-2, "g"],
-  "cgravity" => [-2, "gravity"],  "ch" => [-2, "h"],
-  "chains" => [0, "chain"],  "chg" => [-2, "hg"],  "chr" => [-2, "hr"],
-  "cin" => [-2, "in"],  "ckg" => [-2, "kg"],  "ckgf" => [-2, "kgf"],
-  "ckph" => [-2, "kph"],  "clb" => [-2, "lb"],  "clm" => [-2, "lm"],
-  "clx" => [-2, "lx"],  "cly" => [-2, "ly"],  "cm" => [-2, "m"],
-  "cmb" => [-2, "mb"],  "cmercury" => [-2, "mercury"],
-  "cmgal" => [-2, "mgal"],  "cmin" => [-2, "min"],
-  "cmol" => [-2, "mol"],  "cmon" => [-2, "mon"],  "cmph" => [-2, "mph"],
-  "cohm" => [-2, "ohm"],  "commons_year" => [0, "common_year"],
-  "coulombs" => [0, "coulomb"],  "coz" => [-2, "oz"],
-  "cpc" => [-2, "pc"],  "cpercent" => [-2, "percent"],
-  "cpermil" => [-2, "permil"],  "cpsi" => [-2, "psi"],
-  "crad" => [-2, "rad"],  "cs" => [-2, "s"],  "csr" => [-2, "sr"],
-  "ct" => [-2, "t"],  "cyr" => [-2, "yr"],  "d%" => [-1, "%"],
-  "dA" => [-1, "A"],  "dAu" => [-1, "Au"],  "dBq" => [-1, "Bq"],
-  "dC" => [-1, "C"],  "dF" => [-1, "F"],  "dG" => [-1, "G"],
-  "dGal" => [-1, "Gal"],  "dGy" => [-1, "Gy"],  "dH" => [-1, "H"],
-  "dHg" => [-1, "Hg"],  "dHz" => [-1, "Hz"],  "dJ" => [-1, "J"],
-  "dK" => [-1, "K"],  "dL" => [-1, "L"],  "dN" => [-1, "N"],
-  "dP" => [-1, "P"],  "dPa" => [-1, "Pa"],  "dS" => [-1, "S"],
-  "dSt" => [-1, "St"],  "dSv" => [-1, "Sv"],  "dT" => [-1, "T"],
-  "dV" => [-1, "V"],  "dW" => [-1, "W"],  "dWb" => [-1, "Wb"],
-  "da" => [-1, "a"],  "da%" => [1, "%"],  "daA" => [1, "A"],
-  "daAu" => [1, "Au"],  "daBq" => [1, "Bq"],  "daC" => [1, "C"],
-  "daF" => [1, "F"],  "daG" => [1, "G"],  "daGal" => [1, "Gal"],
-  "daGy" => [1, "Gy"],  "daH" => [1, "H"],  "daHg" => [1, "Hg"],
-  "daHz" => [1, "Hz"],  "daJ" => [1, "J"],  "daK" => [1, "K"],
-  "daL" => [1, "L"],  "daN" => [1, "N"],  "daP" => [1, "P"],
-  "daPa" => [1, "Pa"],  "daS" => [1, "S"],  "daSt" => [1, "St"],
-  "daSv" => [1, "Sv"],  "daT" => [1, "T"],  "daV" => [1, "V"],
-  "daW" => [1, "W"],  "daWb" => [1, "Wb"],  "daa" => [1, "a"],
-  "daac" => [1, "ac"],  "daatm" => [1, "atm"],  "dabar" => [1, "bar"],
-  "dac" => [-1, "ac"],  "dacal" => [1, "cal"],
-  "daconventional_mercury" => [1, "conventional_mercury"],
-  "dad" => [1, "d"],  "dadegC" => [1, "degC"],  "dadegF" => [1, "degF"],
-  "dadeg_C" => [1, "deg_C"],  "dadeg_F" => [1, "deg_F"],
-  "dadegreeC" => [1, "degreeC"],  "dadegreeF" => [1, "degreeF"],
-  "dadegree_C" => [1, "degree_C"],  "dadegree_E" => [1, "degree_E"],
-  "dadegree_F" => [1, "degree_F"],  "dadegree_N" => [1, "degree_N"],
-  "dadegree_R" => [1, "degree_R"],  "dadegree_S" => [1, "degree_S"],
-  "dadegree_W" => [1, "degree_W"],  "dadegree_c" => [1, "degree_c"],
-  "dadegree_east" => [1, "degree_east"],
-  "dadegree_f" => [1, "degree_f"],
-  "dadegree_north" => [1, "degree_north"],
-  "dadegree_south" => [1, "degree_south"],
-  "dadegree_west" => [1, "degree_west"],
-  "dadegrees_east" => [1, "degrees_east"],
-  "dadegrees_north" => [1, "degrees_north"],
-  "dadegrees_south" => [1, "degrees_south"],
-  "dadegrees_west" => [1, "degrees_west"],  "dadyn" => [1, "dyn"],
-  "daerg" => [1, "erg"],  "daforce" => [1, "force"],  "dag" => [1, "g"],
-  "dagravity" => [1, "gravity"],  "dah" => [1, "h"],
-  "dahg" => [1, "hg"],  "dahr" => [1, "hr"],  "dain" => [1, "in"],
-  "dakg" => [1, "kg"],  "dakgf" => [1, "kgf"],  "dakph" => [1, "kph"],
-  "dalb" => [1, "lb"],  "dalm" => [1, "lm"],  "dalx" => [1, "lx"],
-  "daly" => [1, "ly"],  "dam" => [1, "m"],  "damb" => [1, "mb"],
-  "damercury" => [1, "mercury"],  "damgal" => [1, "mgal"],
-  "damin" => [1, "min"],  "damol" => [1, "mol"],  "damon" => [1, "mon"],
-  "damph" => [1, "mph"],  "daohm" => [1, "ohm"],  "daoz" => [1, "oz"],
-  "dapc" => [1, "pc"],  "dapercent" => [1, "percent"],
-  "dapermil" => [1, "permil"],  "dapsi" => [1, "psi"],
-  "darad" => [1, "rad"],  "das" => [1, "s"],  "dasr" => [1, "sr"],
-  "dat" => [1, "t"],  "datm" => [-1, "atm"],  "dayr" => [1, "yr"],
-  "days" => [0, "day"],  "dbar" => [-1, "bar"],  "dcal" => [-1, "cal"],
-  "dconventional_mercury" => [-1, "conventional_mercury"],
-  "dd" => [-1, "d"],  "ddegC" => [-1, "degC"],  "ddegF" => [-1, "degF"],
-  "ddeg_C" => [-1, "deg_C"],  "ddeg_F" => [-1, "deg_F"],
-  "ddegreeC" => [-1, "degreeC"],  "ddegreeF" => [-1, "degreeF"],
-  "ddegree_C" => [-1, "degree_C"],  "ddegree_E" => [-1, "degree_E"],
-  "ddegree_F" => [-1, "degree_F"],  "ddegree_N" => [-1, "degree_N"],
-  "ddegree_R" => [-1, "degree_R"],  "ddegree_S" => [-1, "degree_S"],
-  "ddegree_W" => [-1, "degree_W"],  "ddegree_c" => [-1, "degree_c"],
-  "ddegree_east" => [-1, "degree_east"],
-  "ddegree_f" => [-1, "degree_f"],
-  "ddegree_north" => [-1, "degree_north"],
-  "ddegree_south" => [-1, "degree_south"],
-  "ddegree_west" => [-1, "degree_west"],
-  "ddegrees_east" => [-1, "degrees_east"],
-  "ddegrees_north" => [-1, "degrees_north"],
-  "ddegrees_south" => [-1, "degrees_south"],
-  "ddegrees_west" => [-1, "degrees_west"],  "ddyn" => [-1, "dyn"],
-  "decaCelsius" => [1, "Celsius"],
-  "decaFahrenheit" => [1, "Fahrenheit"],
-  "decaJulian_year" => [1, "Julian_year"],
-  "decaPascal" => [1, "Pascal"],  "decaacre" => [1, "acre"],
-  "decaampere" => [1, "ampere"],  "decaangstrom" => [1, "angstrom"],
-  "decaangular_degree" => [1, "angular_degree"],
-  "decaangular_minute" => [1, "angular_minute"],
-  "decaangular_second" => [1, "angular_second"],
-  "decaare" => [1, "are"],  "decaatmosphere" => [1, "atmosphere"],
-  "decacalorie" => [1, "calorie"],  "decacelsius" => [1, "celsius"],
-  "decacentigrade" => [1, "centigrade"],
-  "decacentury" => [1, "century"],  "decachain" => [1, "chain"],
-  "decacommon_year" => [1, "common_year"],
-  "decacoulomb" => [1, "coulomb"],  "decaday" => [1, "day"],
-  "decadegK" => [1, "degK"],  "decadeg_K" => [1, "deg_K"],
-  "decadegree" => [1, "degree"],  "decadegreeK" => [1, "degreeK"],
-  "decadyne" => [1, "dyne"],  "decaerg" => [1, "erg"],
-  "decafahrenheit" => [1, "fahrenheit"],  "decafarad" => [1, "farad"],
-  "decafermi" => [1, "fermi"],  "decagal" => [1, "gal"],
-  "decagauss" => [1, "gauss"],  "decagram" => [1, "gram"],
-  "decahectare" => [1, "hectare"],  "decahertz" => [1, "hertz"],
-  "decahour" => [1, "hour"],  "decainch" => [1, "inch"],
-  "decajoule" => [1, "joule"],  "decakelvin" => [1, "kelvin"],
-  "decakilogram" => [1, "kilogram"],  "decaknot" => [1, "knot"],
-  "decalitre" => [1, "litre"],  "decameter" => [1, "meter"],
-  "decametre" => [1, "metre"],  "decamicron" => [1, "micron"],
-  "decamile" => [1, "mile"],  "decamillibar" => [1, "millibar"],
-  "decaminute" => [1, "minute"],
-  "decaminute_angle" => [1, "minute_angle"],  "decamole" => [1, "mole"],
-  "decamonth" => [1, "month"],  "decanewton" => [1, "newton"],
-  "decaounce" => [1, "ounce"],  "decaparsec" => [1, "parsec"],
-  "decapascal" => [1, "pascal"],  "decapentad" => [1, "pentad"],
-  "decapoise" => [1, "poise"],  "decapound" => [1, "pound"],
-  "decaradian" => [1, "radian"],  "decasecond" => [1, "second"],
-  "decasecond_angle" => [1, "second_angle"],
-  "decasteradian" => [1, "steradian"],  "decastokes" => [1, "stokes"],
-  "decatesla" => [1, "tesla"],  "decaton" => [1, "ton"],
-  "decatonne" => [1, "tonne"],  "decatorr" => [1, "torr"],
-  "decavolt" => [1, "volt"],  "decawatt" => [1, "watt"],
-  "decaweber" => [1, "weber"],  "decayard" => [1, "yard"],
-  "decayd" => [1, "yd"],  "decayear" => [1, "year"],
-  "deciCelsius" => [-1, "Celsius"],
-  "deciFahrenheit" => [-1, "Fahrenheit"],
-  "deciJulian_year" => [-1, "Julian_year"],
-  "deciPascal" => [-1, "Pascal"],  "deciacre" => [-1, "acre"],
-  "deciampere" => [-1, "ampere"],  "deciangstrom" => [-1, "angstrom"],
-  "deciangular_degree" => [-1, "angular_degree"],
-  "deciangular_minute" => [-1, "angular_minute"],
-  "deciangular_second" => [-1, "angular_second"],
-  "deciare" => [-1, "are"],  "deciatmosphere" => [-1, "atmosphere"],
-  "decicalorie" => [-1, "calorie"],  "decicelsius" => [-1, "celsius"],
-  "decicentigrade" => [-1, "centigrade"],
-  "decicentury" => [-1, "century"],  "decichain" => [-1, "chain"],
-  "decicommon_year" => [-1, "common_year"],
-  "decicoulomb" => [-1, "coulomb"],  "deciday" => [-1, "day"],
-  "decidegK" => [-1, "degK"],  "decideg_K" => [-1, "deg_K"],
-  "decidegree" => [-1, "degree"],  "decidegreeK" => [-1, "degreeK"],
-  "decidyne" => [-1, "dyne"],  "decierg" => [-1, "erg"],
-  "decifahrenheit" => [-1, "fahrenheit"],  "decifarad" => [-1, "farad"],
-  "decifermi" => [-1, "fermi"],  "decigal" => [-1, "gal"],
-  "decigauss" => [-1, "gauss"],  "decigram" => [-1, "gram"],
-  "decihectare" => [-1, "hectare"],  "decihertz" => [-1, "hertz"],
-  "decihour" => [-1, "hour"],  "deciinch" => [-1, "inch"],
-  "decijoule" => [-1, "joule"],  "decikelvin" => [-1, "kelvin"],
-  "decikilogram" => [-1, "kilogram"],  "deciknot" => [-1, "knot"],
-  "decilitre" => [-1, "litre"],  "decimeter" => [-1, "meter"],
-  "decimetre" => [-1, "metre"],  "decimicron" => [-1, "micron"],
-  "decimile" => [-1, "mile"],  "decimillibar" => [-1, "millibar"],
-  "deciminute" => [-1, "minute"],
-  "deciminute_angle" => [-1, "minute_angle"],
-  "decimole" => [-1, "mole"],  "decimonth" => [-1, "month"],
-  "decinewton" => [-1, "newton"],  "deciounce" => [-1, "ounce"],
-  "deciparsec" => [-1, "parsec"],  "decipascal" => [-1, "pascal"],
-  "decipentad" => [-1, "pentad"],  "decipoise" => [-1, "poise"],
-  "decipound" => [-1, "pound"],  "deciradian" => [-1, "radian"],
-  "decisecond" => [-1, "second"],
-  "decisecond_angle" => [-1, "second_angle"],
-  "decisteradian" => [-1, "steradian"],  "decistokes" => [-1, "stokes"],
-  "decitesla" => [-1, "tesla"],  "deciton" => [-1, "ton"],
-  "decitonne" => [-1, "tonne"],  "decitorr" => [-1, "torr"],
-  "decivolt" => [-1, "volt"],  "deciwatt" => [-1, "watt"],
-  "deciweber" => [-1, "weber"],  "deciyard" => [-1, "yard"],
-  "deciyd" => [-1, "yd"],  "deciyear" => [-1, "year"],
-  "degKs" => [0, "degK"],  "degreeKs" => [0, "degreeK"],
-  "degrees" => [0, "degree"],  "degs_K" => [0, "deg_K"],
-  "derg" => [-1, "erg"],  "dforce" => [-1, "force"],  "dg" => [-1, "g"],
-  "dgravity" => [-1, "gravity"],  "dh" => [-1, "h"],
-  "dhg" => [-1, "hg"],  "dhr" => [-1, "hr"],  "din" => [-1, "in"],
-  "dkg" => [-1, "kg"],  "dkgf" => [-1, "kgf"],  "dkph" => [-1, "kph"],
-  "dlb" => [-1, "lb"],  "dlm" => [-1, "lm"],  "dlx" => [-1, "lx"],
-  "dly" => [-1, "ly"],  "dm" => [-1, "m"],  "dmb" => [-1, "mb"],
-  "dmercury" => [-1, "mercury"],  "dmgal" => [-1, "mgal"],
-  "dmin" => [-1, "min"],  "dmol" => [-1, "mol"],  "dmon" => [-1, "mon"],
-  "dmph" => [-1, "mph"],  "dohm" => [-1, "ohm"],  "doz" => [-1, "oz"],
-  "dpc" => [-1, "pc"],  "dpercent" => [-1, "percent"],
-  "dpermil" => [-1, "permil"],  "dpsi" => [-1, "psi"],
-  "drad" => [-1, "rad"],  "ds" => [-1, "s"],  "dsr" => [-1, "sr"],
-  "dt" => [-1, "t"],  "dynes" => [0, "dyne"],  "dyr" => [-1, "yr"],
-  "ergs" => [0, "erg"],  "exaCelsius" => [18, "Celsius"],
-  "exaFahrenheit" => [18, "Fahrenheit"],
-  "exaJulian_year" => [18, "Julian_year"],
-  "exaPascal" => [18, "Pascal"],  "exaacre" => [18, "acre"],
-  "exaampere" => [18, "ampere"],  "exaangstrom" => [18, "angstrom"],
-  "exaangular_degree" => [18, "angular_degree"],
-  "exaangular_minute" => [18, "angular_minute"],
-  "exaangular_second" => [18, "angular_second"],
-  "exaare" => [18, "are"],  "exaatmosphere" => [18, "atmosphere"],
-  "exacalorie" => [18, "calorie"],  "exacelsius" => [18, "celsius"],
-  "exacentigrade" => [18, "centigrade"],
-  "exacentury" => [18, "century"],  "exachain" => [18, "chain"],
-  "exacommon_year" => [18, "common_year"],
-  "exacoulomb" => [18, "coulomb"],  "exaday" => [18, "day"],
-  "exadegK" => [18, "degK"],  "exadeg_K" => [18, "deg_K"],
-  "exadegree" => [18, "degree"],  "exadegreeK" => [18, "degreeK"],
-  "exadyne" => [18, "dyne"],  "exaerg" => [18, "erg"],
-  "exafahrenheit" => [18, "fahrenheit"],  "exafarad" => [18, "farad"],
-  "exafermi" => [18, "fermi"],  "exagal" => [18, "gal"],
-  "exagauss" => [18, "gauss"],  "exagram" => [18, "gram"],
-  "exahectare" => [18, "hectare"],  "exahertz" => [18, "hertz"],
-  "exahour" => [18, "hour"],  "exainch" => [18, "inch"],
-  "exajoule" => [18, "joule"],  "exakelvin" => [18, "kelvin"],
-  "exakilogram" => [18, "kilogram"],  "exaknot" => [18, "knot"],
-  "exalitre" => [18, "litre"],  "exameter" => [18, "meter"],
-  "exametre" => [18, "metre"],  "examicron" => [18, "micron"],
-  "examile" => [18, "mile"],  "examillibar" => [18, "millibar"],
-  "examinute" => [18, "minute"],
-  "examinute_angle" => [18, "minute_angle"],  "examole" => [18, "mole"],
-  "examonth" => [18, "month"],  "exanewton" => [18, "newton"],
-  "exaounce" => [18, "ounce"],  "exaparsec" => [18, "parsec"],
-  "exapascal" => [18, "pascal"],  "exapentad" => [18, "pentad"],
-  "exapoise" => [18, "poise"],  "exapound" => [18, "pound"],
-  "exaradian" => [18, "radian"],  "exasecond" => [18, "second"],
-  "exasecond_angle" => [18, "second_angle"],
-  "exasteradian" => [18, "steradian"],  "exastokes" => [18, "stokes"],
-  "exatesla" => [18, "tesla"],  "exaton" => [18, "ton"],
-  "exatonne" => [18, "tonne"],  "exatorr" => [18, "torr"],
-  "exavolt" => [18, "volt"],  "exawatt" => [18, "watt"],
-  "exaweber" => [18, "weber"],  "exayard" => [18, "yard"],
-  "exayd" => [18, "yd"],  "exayear" => [18, "year"],
-  "f%" => [-15, "%"],  "fA" => [-15, "A"],  "fAu" => [-15, "Au"],
-  "fBq" => [-15, "Bq"],  "fC" => [-15, "C"],  "fF" => [-15, "F"],
-  "fG" => [-15, "G"],  "fGal" => [-15, "Gal"],  "fGy" => [-15, "Gy"],
-  "fH" => [-15, "H"],  "fHg" => [-15, "Hg"],  "fHz" => [-15, "Hz"],
-  "fJ" => [-15, "J"],  "fK" => [-15, "K"],  "fL" => [-15, "L"],
-  "fN" => [-15, "N"],  "fP" => [-15, "P"],  "fPa" => [-15, "Pa"],
-  "fS" => [-15, "S"],  "fSt" => [-15, "St"],  "fSv" => [-15, "Sv"],
-  "fT" => [-15, "T"],  "fV" => [-15, "V"],  "fW" => [-15, "W"],
-  "fWb" => [-15, "Wb"],  "fa" => [-15, "a"],  "fac" => [-15, "ac"],
-  "fahrenheits" => [0, "fahrenheit"],  "farads" => [0, "farad"],
-  "fatm" => [-15, "atm"],  "fbar" => [-15, "bar"],
-  "fcal" => [-15, "cal"],
-  "fconventional_mercury" => [-15, "conventional_mercury"],
-  "fd" => [-15, "d"],  "fdegC" => [-15, "degC"],
-  "fdegF" => [-15, "degF"],  "fdeg_C" => [-15, "deg_C"],
-  "fdeg_F" => [-15, "deg_F"],  "fdegreeC" => [-15, "degreeC"],
-  "fdegreeF" => [-15, "degreeF"],  "fdegree_C" => [-15, "degree_C"],
-  "fdegree_E" => [-15, "degree_E"],  "fdegree_F" => [-15, "degree_F"],
-  "fdegree_N" => [-15, "degree_N"],  "fdegree_R" => [-15, "degree_R"],
-  "fdegree_S" => [-15, "degree_S"],  "fdegree_W" => [-15, "degree_W"],
-  "fdegree_c" => [-15, "degree_c"],
-  "fdegree_east" => [-15, "degree_east"],
-  "fdegree_f" => [-15, "degree_f"],
-  "fdegree_north" => [-15, "degree_north"],
-  "fdegree_south" => [-15, "degree_south"],
-  "fdegree_west" => [-15, "degree_west"],
-  "fdegrees_east" => [-15, "degrees_east"],
-  "fdegrees_north" => [-15, "degrees_north"],
-  "fdegrees_south" => [-15, "degrees_south"],
-  "fdegrees_west" => [-15, "degrees_west"],  "fdyn" => [-15, "dyn"],
-  "femtoCelsius" => [-15, "Celsius"],
-  "femtoFahrenheit" => [-15, "Fahrenheit"],
-  "femtoJulian_year" => [-15, "Julian_year"],
-  "femtoPascal" => [-15, "Pascal"],  "femtoacre" => [-15, "acre"],
-  "femtoampere" => [-15, "ampere"],
-  "femtoangstrom" => [-15, "angstrom"],
-  "femtoangular_degree" => [-15, "angular_degree"],
-  "femtoangular_minute" => [-15, "angular_minute"],
-  "femtoangular_second" => [-15, "angular_second"],
-  "femtoare" => [-15, "are"],  "femtoatmosphere" => [-15, "atmosphere"],
-  "femtocalorie" => [-15, "calorie"],
-  "femtocelsius" => [-15, "celsius"],
-  "femtocentigrade" => [-15, "centigrade"],
-  "femtocentury" => [-15, "century"],  "femtochain" => [-15, "chain"],
-  "femtocommon_year" => [-15, "common_year"],
-  "femtocoulomb" => [-15, "coulomb"],  "femtoday" => [-15, "day"],
-  "femtodegK" => [-15, "degK"],  "femtodeg_K" => [-15, "deg_K"],
-  "femtodegree" => [-15, "degree"],  "femtodegreeK" => [-15, "degreeK"],
-  "femtodyne" => [-15, "dyne"],  "femtoerg" => [-15, "erg"],
-  "femtofahrenheit" => [-15, "fahrenheit"],
-  "femtofarad" => [-15, "farad"],  "femtofermi" => [-15, "fermi"],
-  "femtogal" => [-15, "gal"],  "femtogauss" => [-15, "gauss"],
-  "femtogram" => [-15, "gram"],  "femtohectare" => [-15, "hectare"],
-  "femtohertz" => [-15, "hertz"],  "femtohour" => [-15, "hour"],
-  "femtoinch" => [-15, "inch"],  "femtojoule" => [-15, "joule"],
-  "femtokelvin" => [-15, "kelvin"],
-  "femtokilogram" => [-15, "kilogram"],  "femtoknot" => [-15, "knot"],
-  "femtolitre" => [-15, "litre"],  "femtometer" => [-15, "meter"],
-  "femtometre" => [-15, "metre"],  "femtomicron" => [-15, "micron"],
-  "femtomile" => [-15, "mile"],  "femtomillibar" => [-15, "millibar"],
-  "femtominute" => [-15, "minute"],
-  "femtominute_angle" => [-15, "minute_angle"],
-  "femtomole" => [-15, "mole"],  "femtomonth" => [-15, "month"],
-  "femtonewton" => [-15, "newton"],  "femtoounce" => [-15, "ounce"],
-  "femtoparsec" => [-15, "parsec"],  "femtopascal" => [-15, "pascal"],
-  "femtopentad" => [-15, "pentad"],  "femtopoise" => [-15, "poise"],
-  "femtopound" => [-15, "pound"],  "femtoradian" => [-15, "radian"],
-  "femtosecond" => [-15, "second"],
-  "femtosecond_angle" => [-15, "second_angle"],
-  "femtosteradian" => [-15, "steradian"],
-  "femtostokes" => [-15, "stokes"],  "femtotesla" => [-15, "tesla"],
-  "femtoton" => [-15, "ton"],  "femtotonne" => [-15, "tonne"],
-  "femtotorr" => [-15, "torr"],  "femtovolt" => [-15, "volt"],
-  "femtowatt" => [-15, "watt"],  "femtoweber" => [-15, "weber"],
-  "femtoyard" => [-15, "yard"],  "femtoyd" => [-15, "yd"],
-  "femtoyear" => [-15, "year"],  "ferg" => [-15, "erg"],
-  "fermis" => [0, "fermi"],  "fforce" => [-15, "force"],
-  "fg" => [-15, "g"],  "fgravity" => [-15, "gravity"],
-  "fh" => [-15, "h"],  "fhg" => [-15, "hg"],  "fhr" => [-15, "hr"],
-  "fin" => [-15, "in"],  "fkg" => [-15, "kg"],  "fkgf" => [-15, "kgf"],
-  "fkph" => [-15, "kph"],  "flb" => [-15, "lb"],  "flm" => [-15, "lm"],
-  "flx" => [-15, "lx"],  "fly" => [-15, "ly"],  "fm" => [-15, "m"],
-  "fmb" => [-15, "mb"],  "fmercury" => [-15, "mercury"],
-  "fmgal" => [-15, "mgal"],  "fmin" => [-15, "min"],
-  "fmol" => [-15, "mol"],  "fmon" => [-15, "mon"],
-  "fmph" => [-15, "mph"],  "fohm" => [-15, "ohm"],
-  "foz" => [-15, "oz"],  "fpc" => [-15, "pc"],
-  "fpercent" => [-15, "percent"],  "fpermil" => [-15, "permil"],
-  "fpsi" => [-15, "psi"],  "frad" => [-15, "rad"],  "fs" => [-15, "s"],
-  "fsr" => [-15, "sr"],  "ft" => [-15, "t"],  "fyr" => [-15, "yr"],
-  "gals" => [0, "gal"],  "gausses" => [0, "gauss"],
-  "gigaCelsius" => [9, "Celsius"],
-  "gigaFahrenheit" => [9, "Fahrenheit"],
-  "gigaJulian_year" => [9, "Julian_year"],
-  "gigaPascal" => [9, "Pascal"],  "gigaacre" => [9, "acre"],
-  "gigaampere" => [9, "ampere"],  "gigaangstrom" => [9, "angstrom"],
-  "gigaangular_degree" => [9, "angular_degree"],
-  "gigaangular_minute" => [9, "angular_minute"],
-  "gigaangular_second" => [9, "angular_second"],
-  "gigaare" => [9, "are"],  "gigaatmosphere" => [9, "atmosphere"],
-  "gigacalorie" => [9, "calorie"],  "gigacelsius" => [9, "celsius"],
-  "gigacentigrade" => [9, "centigrade"],
-  "gigacentury" => [9, "century"],  "gigachain" => [9, "chain"],
-  "gigacommon_year" => [9, "common_year"],
-  "gigacoulomb" => [9, "coulomb"],  "gigaday" => [9, "day"],
-  "gigadegK" => [9, "degK"],  "gigadeg_K" => [9, "deg_K"],
-  "gigadegree" => [9, "degree"],  "gigadegreeK" => [9, "degreeK"],
-  "gigadyne" => [9, "dyne"],  "gigaerg" => [9, "erg"],
-  "gigafahrenheit" => [9, "fahrenheit"],  "gigafarad" => [9, "farad"],
-  "gigafermi" => [9, "fermi"],  "gigagal" => [9, "gal"],
-  "gigagauss" => [9, "gauss"],  "gigagram" => [9, "gram"],
-  "gigahectare" => [9, "hectare"],  "gigahertz" => [9, "hertz"],
-  "gigahour" => [9, "hour"],  "gigainch" => [9, "inch"],
-  "gigajoule" => [9, "joule"],  "gigakelvin" => [9, "kelvin"],
-  "gigakilogram" => [9, "kilogram"],  "gigaknot" => [9, "knot"],
-  "gigalitre" => [9, "litre"],  "gigameter" => [9, "meter"],
-  "gigametre" => [9, "metre"],  "gigamicron" => [9, "micron"],
-  "gigamile" => [9, "mile"],  "gigamillibar" => [9, "millibar"],
-  "gigaminute" => [9, "minute"],
-  "gigaminute_angle" => [9, "minute_angle"],  "gigamole" => [9, "mole"],
-  "gigamonth" => [9, "month"],  "giganewton" => [9, "newton"],
-  "gigaounce" => [9, "ounce"],  "gigaparsec" => [9, "parsec"],
-  "gigapascal" => [9, "pascal"],  "gigapentad" => [9, "pentad"],
-  "gigapoise" => [9, "poise"],  "gigapound" => [9, "pound"],
-  "gigaradian" => [9, "radian"],  "gigasecond" => [9, "second"],
-  "gigasecond_angle" => [9, "second_angle"],
-  "gigasteradian" => [9, "steradian"],  "gigastokes" => [9, "stokes"],
-  "gigatesla" => [9, "tesla"],  "gigaton" => [9, "ton"],
-  "gigatonne" => [9, "tonne"],  "gigatorr" => [9, "torr"],
-  "gigavolt" => [9, "volt"],  "gigawatt" => [9, "watt"],
-  "gigaweber" => [9, "weber"],  "gigayard" => [9, "yard"],
-  "gigayd" => [9, "yd"],  "gigayear" => [9, "year"],
-  "grams" => [0, "gram"],  "h%" => [2, "%"],  "hA" => [2, "A"],
-  "hAu" => [2, "Au"],  "hBq" => [2, "Bq"],  "hC" => [2, "C"],
-  "hF" => [2, "F"],  "hG" => [2, "G"],  "hGal" => [2, "Gal"],
-  "hGy" => [2, "Gy"],  "hH" => [2, "H"],  "hHg" => [2, "Hg"],
-  "hHz" => [2, "Hz"],  "hJ" => [2, "J"],  "hK" => [2, "K"],
-  "hL" => [2, "L"],  "hN" => [2, "N"],  "hP" => [2, "P"],
-  "hPa" => [2, "Pa"],  "hS" => [2, "S"],  "hSt" => [2, "St"],
-  "hSv" => [2, "Sv"],  "hT" => [2, "T"],  "hV" => [2, "V"],
-  "hW" => [2, "W"],  "hWb" => [2, "Wb"],  "ha" => [2, "a"],
-  "hac" => [2, "ac"],  "hatm" => [2, "atm"],  "hbar" => [2, "bar"],
-  "hcal" => [2, "cal"],
-  "hconventional_mercury" => [2, "conventional_mercury"],
-  "hd" => [2, "d"],  "hdegC" => [2, "degC"],  "hdegF" => [2, "degF"],
-  "hdeg_C" => [2, "deg_C"],  "hdeg_F" => [2, "deg_F"],
-  "hdegreeC" => [2, "degreeC"],  "hdegreeF" => [2, "degreeF"],
-  "hdegree_C" => [2, "degree_C"],  "hdegree_E" => [2, "degree_E"],
-  "hdegree_F" => [2, "degree_F"],  "hdegree_N" => [2, "degree_N"],
-  "hdegree_R" => [2, "degree_R"],  "hdegree_S" => [2, "degree_S"],
-  "hdegree_W" => [2, "degree_W"],  "hdegree_c" => [2, "degree_c"],
-  "hdegree_east" => [2, "degree_east"],  "hdegree_f" => [2, "degree_f"],
-  "hdegree_north" => [2, "degree_north"],
-  "hdegree_south" => [2, "degree_south"],
-  "hdegree_west" => [2, "degree_west"],
-  "hdegrees_east" => [2, "degrees_east"],
-  "hdegrees_north" => [2, "degrees_north"],
-  "hdegrees_south" => [2, "degrees_south"],
-  "hdegrees_west" => [2, "degrees_west"],  "hdyn" => [2, "dyn"],
-  "hectares" => [0, "hectare"],  "hectoCelsius" => [2, "Celsius"],
-  "hectoFahrenheit" => [2, "Fahrenheit"],
-  "hectoJulian_year" => [2, "Julian_year"],
-  "hectoPascal" => [2, "Pascal"],  "hectoacre" => [2, "acre"],
-  "hectoampere" => [2, "ampere"],  "hectoangstrom" => [2, "angstrom"],
-  "hectoangular_degree" => [2, "angular_degree"],
-  "hectoangular_minute" => [2, "angular_minute"],
-  "hectoangular_second" => [2, "angular_second"],
-  "hectoare" => [2, "are"],  "hectoatmosphere" => [2, "atmosphere"],
-  "hectocalorie" => [2, "calorie"],  "hectocelsius" => [2, "celsius"],
-  "hectocentigrade" => [2, "centigrade"],
-  "hectocentury" => [2, "century"],  "hectochain" => [2, "chain"],
-  "hectocommon_year" => [2, "common_year"],
-  "hectocoulomb" => [2, "coulomb"],  "hectoday" => [2, "day"],
-  "hectodegK" => [2, "degK"],  "hectodeg_K" => [2, "deg_K"],
-  "hectodegree" => [2, "degree"],  "hectodegreeK" => [2, "degreeK"],
-  "hectodyne" => [2, "dyne"],  "hectoerg" => [2, "erg"],
-  "hectofahrenheit" => [2, "fahrenheit"],  "hectofarad" => [2, "farad"],
-  "hectofermi" => [2, "fermi"],  "hectogal" => [2, "gal"],
-  "hectogauss" => [2, "gauss"],  "hectogram" => [2, "gram"],
-  "hectohectare" => [2, "hectare"],  "hectohertz" => [2, "hertz"],
-  "hectohour" => [2, "hour"],  "hectoinch" => [2, "inch"],
-  "hectojoule" => [2, "joule"],  "hectokelvin" => [2, "kelvin"],
-  "hectokilogram" => [2, "kilogram"],  "hectoknot" => [2, "knot"],
-  "hectolitre" => [2, "litre"],  "hectometer" => [2, "meter"],
-  "hectometre" => [2, "metre"],  "hectomicron" => [2, "micron"],
-  "hectomile" => [2, "mile"],  "hectomillibar" => [2, "millibar"],
-  "hectominute" => [2, "minute"],
-  "hectominute_angle" => [2, "minute_angle"],
-  "hectomole" => [2, "mole"],  "hectomonth" => [2, "month"],
-  "hectonewton" => [2, "newton"],  "hectoounce" => [2, "ounce"],
-  "hectoparsec" => [2, "parsec"],  "hectopascal" => [2, "pascal"],
-  "hectopentad" => [2, "pentad"],  "hectopoise" => [2, "poise"],
-  "hectopound" => [2, "pound"],  "hectoradian" => [2, "radian"],
-  "hectosecond" => [2, "second"],
-  "hectosecond_angle" => [2, "second_angle"],
-  "hectosteradian" => [2, "steradian"],  "hectostokes" => [2, "stokes"],
-  "hectotesla" => [2, "tesla"],  "hectoton" => [2, "ton"],
-  "hectotonne" => [2, "tonne"],  "hectotorr" => [2, "torr"],
-  "hectovolt" => [2, "volt"],  "hectowatt" => [2, "watt"],
-  "hectoweber" => [2, "weber"],  "hectoyard" => [2, "yard"],
-  "hectoyd" => [2, "yd"],  "hectoyear" => [2, "year"],
-  "herg" => [2, "erg"],  "hertzes" => [0, "hertz"],
-  "hforce" => [2, "force"],  "hg" => [2, "g"],
-  "hgravity" => [2, "gravity"],  "hh" => [2, "h"],  "hhg" => [2, "hg"],
-  "hhr" => [2, "hr"],  "hin" => [2, "in"],  "hkg" => [2, "kg"],
-  "hkgf" => [2, "kgf"],  "hkph" => [2, "kph"],  "hlb" => [2, "lb"],
-  "hlm" => [2, "lm"],  "hlx" => [2, "lx"],  "hly" => [2, "ly"],
-  "hm" => [2, "m"],  "hmb" => [2, "mb"],  "hmercury" => [2, "mercury"],
-  "hmgal" => [2, "mgal"],  "hmin" => [2, "min"],  "hmol" => [2, "mol"],
-  "hmon" => [2, "mon"],  "hmph" => [2, "mph"],  "hohm" => [2, "ohm"],
-  "hours" => [0, "hour"],  "hoz" => [2, "oz"],  "hpc" => [2, "pc"],
-  "hpercent" => [2, "percent"],  "hpermil" => [2, "permil"],
-  "hpsi" => [2, "psi"],  "hrad" => [2, "rad"],  "hs" => [2, "s"],
-  "hsr" => [2, "sr"],  "ht" => [2, "t"],  "hyr" => [2, "yr"],
-  "inchs" => [0, "inch"],  "joules" => [0, "joule"],  "k%" => [3, "%"],
-  "kA" => [3, "A"],  "kAu" => [3, "Au"],  "kBq" => [3, "Bq"],
-  "kC" => [3, "C"],  "kF" => [3, "F"],  "kG" => [3, "G"],
-  "kGal" => [3, "Gal"],  "kGy" => [3, "Gy"],  "kH" => [3, "H"],
-  "kHg" => [3, "Hg"],  "kHz" => [3, "Hz"],  "kJ" => [3, "J"],
-  "kK" => [3, "K"],  "kL" => [3, "L"],  "kN" => [3, "N"],
-  "kP" => [3, "P"],  "kPa" => [3, "Pa"],  "kS" => [3, "S"],
-  "kSt" => [3, "St"],  "kSv" => [3, "Sv"],  "kT" => [3, "T"],
-  "kV" => [3, "V"],  "kW" => [3, "W"],  "kWb" => [3, "Wb"],
-  "ka" => [3, "a"],  "kac" => [3, "ac"],  "katm" => [3, "atm"],
-  "kbar" => [3, "bar"],  "kcal" => [3, "cal"],
-  "kconventional_mercury" => [3, "conventional_mercury"],
-  "kd" => [3, "d"],  "kdegC" => [3, "degC"],  "kdegF" => [3, "degF"],
-  "kdeg_C" => [3, "deg_C"],  "kdeg_F" => [3, "deg_F"],
-  "kdegreeC" => [3, "degreeC"],  "kdegreeF" => [3, "degreeF"],
-  "kdegree_C" => [3, "degree_C"],  "kdegree_E" => [3, "degree_E"],
-  "kdegree_F" => [3, "degree_F"],  "kdegree_N" => [3, "degree_N"],
-  "kdegree_R" => [3, "degree_R"],  "kdegree_S" => [3, "degree_S"],
-  "kdegree_W" => [3, "degree_W"],  "kdegree_c" => [3, "degree_c"],
-  "kdegree_east" => [3, "degree_east"],  "kdegree_f" => [3, "degree_f"],
-  "kdegree_north" => [3, "degree_north"],
-  "kdegree_south" => [3, "degree_south"],
-  "kdegree_west" => [3, "degree_west"],
-  "kdegrees_east" => [3, "degrees_east"],
-  "kdegrees_north" => [3, "degrees_north"],
-  "kdegrees_south" => [3, "degrees_south"],
-  "kdegrees_west" => [3, "degrees_west"],  "kdyn" => [3, "dyn"],
-  "kelvins" => [0, "kelvin"],  "kerg" => [3, "erg"],
-  "kforce" => [3, "force"],  "kgravity" => [3, "gravity"],
-  "kh" => [3, "h"],  "khg" => [3, "hg"],  "khr" => [3, "hr"],
-  "kiloCelsius" => [3, "Celsius"],
-  "kiloFahrenheit" => [3, "Fahrenheit"],
-  "kiloJulian_year" => [3, "Julian_year"],
-  "kiloPascal" => [3, "Pascal"],  "kiloacre" => [3, "acre"],
-  "kiloampere" => [3, "ampere"],  "kiloangstrom" => [3, "angstrom"],
-  "kiloangular_degree" => [3, "angular_degree"],
-  "kiloangular_minute" => [3, "angular_minute"],
-  "kiloangular_second" => [3, "angular_second"],
-  "kiloare" => [3, "are"],  "kiloatmosphere" => [3, "atmosphere"],
-  "kilocalorie" => [3, "calorie"],  "kilocelsius" => [3, "celsius"],
-  "kilocentigrade" => [3, "centigrade"],
-  "kilocentury" => [3, "century"],  "kilochain" => [3, "chain"],
-  "kilocommon_year" => [3, "common_year"],
-  "kilocoulomb" => [3, "coulomb"],  "kiloday" => [3, "day"],
-  "kilodegK" => [3, "degK"],  "kilodeg_K" => [3, "deg_K"],
-  "kilodegree" => [3, "degree"],  "kilodegreeK" => [3, "degreeK"],
-  "kilodyne" => [3, "dyne"],  "kiloerg" => [3, "erg"],
-  "kilofahrenheit" => [3, "fahrenheit"],  "kilofarad" => [3, "farad"],
-  "kilofermi" => [3, "fermi"],  "kilogal" => [3, "gal"],
-  "kilogauss" => [3, "gauss"],  "kilogram" => [3, "gram"],
-  "kilograms" => [0, "kilogram"],  "kilohectare" => [3, "hectare"],
-  "kilohertz" => [3, "hertz"],  "kilohour" => [3, "hour"],
-  "kiloinch" => [3, "inch"],  "kilojoule" => [3, "joule"],
-  "kilokelvin" => [3, "kelvin"],  "kilokilogram" => [3, "kilogram"],
-  "kiloknot" => [3, "knot"],  "kilolitre" => [3, "litre"],
-  "kilometer" => [3, "meter"],  "kilometre" => [3, "metre"],
-  "kilomicron" => [3, "micron"],  "kilomile" => [3, "mile"],
-  "kilomillibar" => [3, "millibar"],  "kilominute" => [3, "minute"],
-  "kilominute_angle" => [3, "minute_angle"],  "kilomole" => [3, "mole"],
-  "kilomonth" => [3, "month"],  "kilonewton" => [3, "newton"],
-  "kiloounce" => [3, "ounce"],  "kiloparsec" => [3, "parsec"],
-  "kilopascal" => [3, "pascal"],  "kilopentad" => [3, "pentad"],
-  "kilopoise" => [3, "poise"],  "kilopound" => [3, "pound"],
-  "kiloradian" => [3, "radian"],  "kilosecond" => [3, "second"],
-  "kilosecond_angle" => [3, "second_angle"],
-  "kilosteradian" => [3, "steradian"],  "kilostokes" => [3, "stokes"],
-  "kilotesla" => [3, "tesla"],  "kiloton" => [3, "ton"],
-  "kilotonne" => [3, "tonne"],  "kilotorr" => [3, "torr"],
-  "kilovolt" => [3, "volt"],  "kilowatt" => [3, "watt"],
-  "kiloweber" => [3, "weber"],  "kiloyard" => [3, "yard"],
-  "kiloyd" => [3, "yd"],  "kiloyear" => [3, "year"],
-  "kin" => [3, "in"],  "kkg" => [3, "kg"],  "kkgf" => [3, "kgf"],
-  "kkph" => [3, "kph"],  "klb" => [3, "lb"],  "klm" => [3, "lm"],
-  "klx" => [3, "lx"],  "kly" => [3, "ly"],  "km" => [3, "m"],
-  "kmb" => [3, "mb"],  "kmercury" => [3, "mercury"],
-  "kmgal" => [3, "mgal"],  "kmin" => [3, "min"],  "kmol" => [3, "mol"],
-  "kmon" => [3, "mon"],  "kmph" => [3, "mph"],  "knots" => [0, "knot"],
-  "kohm" => [3, "ohm"],  "koz" => [3, "oz"],  "kpc" => [3, "pc"],
-  "kpercent" => [3, "percent"],  "kpermil" => [3, "permil"],
-  "kpsi" => [3, "psi"],  "krad" => [3, "rad"],  "ks" => [3, "s"],
-  "ksr" => [3, "sr"],  "kt" => [3, "t"],  "kyr" => [3, "yr"],
-  "litres" => [0, "litre"],  "m%" => [-3, "%"],  "mA" => [-3, "A"],
-  "mAu" => [-3, "Au"],  "mBq" => [-3, "Bq"],  "mC" => [-3, "C"],
-  "mF" => [-3, "F"],  "mG" => [-3, "G"],  "mGal" => [-3, "Gal"],
-  "mGy" => [-3, "Gy"],  "mH" => [-3, "H"],  "mHg" => [-3, "Hg"],
-  "mHz" => [-3, "Hz"],  "mJ" => [-3, "J"],  "mK" => [-3, "K"],
-  "mL" => [-3, "L"],  "mN" => [-3, "N"],  "mP" => [-3, "P"],
-  "mPa" => [-3, "Pa"],  "mS" => [-3, "S"],  "mSt" => [-3, "St"],
-  "mSv" => [-3, "Sv"],  "mT" => [-3, "T"],  "mV" => [-3, "V"],
-  "mW" => [-3, "W"],  "mWb" => [-3, "Wb"],  "ma" => [-3, "a"],
-  "mac" => [-3, "ac"],  "matm" => [-3, "atm"],  "mbar" => [-3, "bar"],
-  "mcal" => [-3, "cal"],
-  "mconventional_mercury" => [-3, "conventional_mercury"],
-  "md" => [-3, "d"],  "mdegC" => [-3, "degC"],  "mdegF" => [-3, "degF"],
-  "mdeg_C" => [-3, "deg_C"],  "mdeg_F" => [-3, "deg_F"],
-  "mdegreeC" => [-3, "degreeC"],  "mdegreeF" => [-3, "degreeF"],
-  "mdegree_C" => [-3, "degree_C"],  "mdegree_E" => [-3, "degree_E"],
-  "mdegree_F" => [-3, "degree_F"],  "mdegree_N" => [-3, "degree_N"],
-  "mdegree_R" => [-3, "degree_R"],  "mdegree_S" => [-3, "degree_S"],
-  "mdegree_W" => [-3, "degree_W"],  "mdegree_c" => [-3, "degree_c"],
-  "mdegree_east" => [-3, "degree_east"],
-  "mdegree_f" => [-3, "degree_f"],
-  "mdegree_north" => [-3, "degree_north"],
-  "mdegree_south" => [-3, "degree_south"],
-  "mdegree_west" => [-3, "degree_west"],
-  "mdegrees_east" => [-3, "degrees_east"],
-  "mdegrees_north" => [-3, "degrees_north"],
-  "mdegrees_south" => [-3, "degrees_south"],
-  "mdegrees_west" => [-3, "degrees_west"],  "mdyn" => [-3, "dyn"],
-  "megaCelsius" => [6, "Celsius"],
-  "megaFahrenheit" => [6, "Fahrenheit"],
-  "megaJulian_year" => [6, "Julian_year"],
-  "megaPascal" => [6, "Pascal"],  "megaacre" => [6, "acre"],
-  "megaampere" => [6, "ampere"],  "megaangstrom" => [6, "angstrom"],
-  "megaangular_degree" => [6, "angular_degree"],
-  "megaangular_minute" => [6, "angular_minute"],
-  "megaangular_second" => [6, "angular_second"],
-  "megaare" => [6, "are"],  "megaatmosphere" => [6, "atmosphere"],
-  "megacalorie" => [6, "calorie"],  "megacelsius" => [6, "celsius"],
-  "megacentigrade" => [6, "centigrade"],
-  "megacentury" => [6, "century"],  "megachain" => [6, "chain"],
-  "megacommon_year" => [6, "common_year"],
-  "megacoulomb" => [6, "coulomb"],  "megaday" => [6, "day"],
-  "megadegK" => [6, "degK"],  "megadeg_K" => [6, "deg_K"],
-  "megadegree" => [6, "degree"],  "megadegreeK" => [6, "degreeK"],
-  "megadyne" => [6, "dyne"],  "megaerg" => [6, "erg"],
-  "megafahrenheit" => [6, "fahrenheit"],  "megafarad" => [6, "farad"],
-  "megafermi" => [6, "fermi"],  "megagal" => [6, "gal"],
-  "megagauss" => [6, "gauss"],  "megagram" => [6, "gram"],
-  "megahectare" => [6, "hectare"],  "megahertz" => [6, "hertz"],
-  "megahour" => [6, "hour"],  "megainch" => [6, "inch"],
-  "megajoule" => [6, "joule"],  "megakelvin" => [6, "kelvin"],
-  "megakilogram" => [6, "kilogram"],  "megaknot" => [6, "knot"],
-  "megalitre" => [6, "litre"],  "megameter" => [6, "meter"],
-  "megametre" => [6, "metre"],  "megamicron" => [6, "micron"],
-  "megamile" => [6, "mile"],  "megamillibar" => [6, "millibar"],
-  "megaminute" => [6, "minute"],
-  "megaminute_angle" => [6, "minute_angle"],  "megamole" => [6, "mole"],
-  "megamonth" => [6, "month"],  "meganewton" => [6, "newton"],
-  "megaounce" => [6, "ounce"],  "megaparsec" => [6, "parsec"],
-  "megapascal" => [6, "pascal"],  "megapentad" => [6, "pentad"],
-  "megapoise" => [6, "poise"],  "megapound" => [6, "pound"],
-  "megaradian" => [6, "radian"],  "megasecond" => [6, "second"],
-  "megasecond_angle" => [6, "second_angle"],
-  "megasteradian" => [6, "steradian"],  "megastokes" => [6, "stokes"],
-  "megatesla" => [6, "tesla"],  "megaton" => [6, "ton"],
-  "megatonne" => [6, "tonne"],  "megatorr" => [6, "torr"],
-  "megavolt" => [6, "volt"],  "megawatt" => [6, "watt"],
-  "megaweber" => [6, "weber"],  "megayard" => [6, "yard"],
-  "megayd" => [6, "yd"],  "megayear" => [6, "year"],
-  "merg" => [-3, "erg"],  "meters" => [0, "meter"],
-  "metres" => [0, "metre"],  "mforce" => [-3, "force"],
-  "mg" => [-3, "g"],  "mgravity" => [-3, "gravity"],  "mh" => [-3, "h"],
-  "mhg" => [-3, "hg"],  "mhr" => [-3, "hr"],
-  "microCelsius" => [-6, "Celsius"],
-  "microFahrenheit" => [-6, "Fahrenheit"],
-  "microJulian_year" => [-6, "Julian_year"],
-  "microPascal" => [-6, "Pascal"],  "microacre" => [-6, "acre"],
-  "microampere" => [-6, "ampere"],  "microangstrom" => [-6, "angstrom"],
-  "microangular_degree" => [-6, "angular_degree"],
-  "microangular_minute" => [-6, "angular_minute"],
-  "microangular_second" => [-6, "angular_second"],
-  "microare" => [-6, "are"],  "microatmosphere" => [-6, "atmosphere"],
-  "microcalorie" => [-6, "calorie"],  "microcelsius" => [-6, "celsius"],
-  "microcentigrade" => [-6, "centigrade"],
-  "microcentury" => [-6, "century"],  "microchain" => [-6, "chain"],
-  "microcommon_year" => [-6, "common_year"],
-  "microcoulomb" => [-6, "coulomb"],  "microday" => [-6, "day"],
-  "microdegK" => [-6, "degK"],  "microdeg_K" => [-6, "deg_K"],
-  "microdegree" => [-6, "degree"],  "microdegreeK" => [-6, "degreeK"],
-  "microdyne" => [-6, "dyne"],  "microerg" => [-6, "erg"],
-  "microfahrenheit" => [-6, "fahrenheit"],
-  "microfarad" => [-6, "farad"],  "microfermi" => [-6, "fermi"],
-  "microgal" => [-6, "gal"],  "microgauss" => [-6, "gauss"],
-  "microgram" => [-6, "gram"],  "microhectare" => [-6, "hectare"],
-  "microhertz" => [-6, "hertz"],  "microhour" => [-6, "hour"],
-  "microinch" => [-6, "inch"],  "microjoule" => [-6, "joule"],
-  "microkelvin" => [-6, "kelvin"],  "microkilogram" => [-6, "kilogram"],
-  "microknot" => [-6, "knot"],  "microlitre" => [-6, "litre"],
-  "micrometer" => [-6, "meter"],  "micrometre" => [-6, "metre"],
-  "micromicron" => [-6, "micron"],  "micromile" => [-6, "mile"],
-  "micromillibar" => [-6, "millibar"],  "microminute" => [-6, "minute"],
-  "microminute_angle" => [-6, "minute_angle"],
-  "micromole" => [-6, "mole"],  "micromonth" => [-6, "month"],
-  "micronewton" => [-6, "newton"],  "microns" => [0, "micron"],
-  "microounce" => [-6, "ounce"],  "microparsec" => [-6, "parsec"],
-  "micropascal" => [-6, "pascal"],  "micropentad" => [-6, "pentad"],
-  "micropoise" => [-6, "poise"],  "micropound" => [-6, "pound"],
-  "microradian" => [-6, "radian"],  "microsecond" => [-6, "second"],
-  "microsecond_angle" => [-6, "second_angle"],
-  "microsteradian" => [-6, "steradian"],
-  "microstokes" => [-6, "stokes"],  "microtesla" => [-6, "tesla"],
-  "microton" => [-6, "ton"],  "microtonne" => [-6, "tonne"],
-  "microtorr" => [-6, "torr"],  "microvolt" => [-6, "volt"],
-  "microwatt" => [-6, "watt"],  "microweber" => [-6, "weber"],
-  "microyard" => [-6, "yard"],  "microyd" => [-6, "yd"],
-  "microyear" => [-6, "year"],  "miles" => [0, "mile"],
-  "milliCelsius" => [-3, "Celsius"],
-  "milliFahrenheit" => [-3, "Fahrenheit"],
-  "milliJulian_year" => [-3, "Julian_year"],
-  "milliPascal" => [-3, "Pascal"],  "milliacre" => [-3, "acre"],
-  "milliampere" => [-3, "ampere"],  "milliangstrom" => [-3, "angstrom"],
-  "milliangular_degree" => [-3, "angular_degree"],
-  "milliangular_minute" => [-3, "angular_minute"],
-  "milliangular_second" => [-3, "angular_second"],
-  "milliare" => [-3, "are"],  "milliatmosphere" => [-3, "atmosphere"],
-  "millibars" => [0, "millibar"],  "millicalorie" => [-3, "calorie"],
-  "millicelsius" => [-3, "celsius"],
-  "millicentigrade" => [-3, "centigrade"],
-  "millicentury" => [-3, "century"],  "millichain" => [-3, "chain"],
-  "millicommon_year" => [-3, "common_year"],
-  "millicoulomb" => [-3, "coulomb"],  "milliday" => [-3, "day"],
-  "millidegK" => [-3, "degK"],  "millideg_K" => [-3, "deg_K"],
-  "millidegree" => [-3, "degree"],  "millidegreeK" => [-3, "degreeK"],
-  "millidyne" => [-3, "dyne"],  "millierg" => [-3, "erg"],
-  "millifahrenheit" => [-3, "fahrenheit"],
-  "millifarad" => [-3, "farad"],  "millifermi" => [-3, "fermi"],
-  "milligal" => [-3, "gal"],  "milligauss" => [-3, "gauss"],
-  "milligram" => [-3, "gram"],  "millihectare" => [-3, "hectare"],
-  "millihertz" => [-3, "hertz"],  "millihour" => [-3, "hour"],
-  "milliinch" => [-3, "inch"],  "millijoule" => [-3, "joule"],
-  "millikelvin" => [-3, "kelvin"],  "millikilogram" => [-3, "kilogram"],
-  "milliknot" => [-3, "knot"],  "millilitre" => [-3, "litre"],
-  "millimeter" => [-3, "meter"],  "millimetre" => [-3, "metre"],
-  "millimicron" => [-3, "micron"],  "millimile" => [-3, "mile"],
-  "millimillibar" => [-3, "millibar"],  "milliminute" => [-3, "minute"],
-  "milliminute_angle" => [-3, "minute_angle"],
-  "millimole" => [-3, "mole"],  "millimonth" => [-3, "month"],
-  "millinewton" => [-3, "newton"],  "milliounce" => [-3, "ounce"],
-  "milliparsec" => [-3, "parsec"],  "millipascal" => [-3, "pascal"],
-  "millipentad" => [-3, "pentad"],  "millipoise" => [-3, "poise"],
-  "millipound" => [-3, "pound"],  "milliradian" => [-3, "radian"],
-  "millisecond" => [-3, "second"],
-  "millisecond_angle" => [-3, "second_angle"],
-  "millisteradian" => [-3, "steradian"],
-  "millistokes" => [-3, "stokes"],  "millitesla" => [-3, "tesla"],
-  "milliton" => [-3, "ton"],  "millitonne" => [-3, "tonne"],
-  "millitorr" => [-3, "torr"],  "millivolt" => [-3, "volt"],
-  "milliwatt" => [-3, "watt"],  "milliweber" => [-3, "weber"],
-  "milliyard" => [-3, "yard"],  "milliyd" => [-3, "yd"],
-  "milliyear" => [-3, "year"],  "min" => [-3, "in"],
-  "minutes" => [0, "minute"],  "minutes_angle" => [0, "minute_angle"],
-  "mkg" => [-3, "kg"],  "mkgf" => [-3, "kgf"],  "mkph" => [-3, "kph"],
-  "mlb" => [-3, "lb"],  "mlm" => [-3, "lm"],  "mlx" => [-3, "lx"],
-  "mly" => [-3, "ly"],  "mm" => [-3, "m"],  "mmb" => [-3, "mb"],
-  "mmercury" => [-3, "mercury"],  "mmgal" => [-3, "mgal"],
-  "mmin" => [-3, "min"],  "mmol" => [-3, "mol"],  "mmon" => [-3, "mon"],
-  "mmph" => [-3, "mph"],  "mohm" => [-3, "ohm"],
-  "moles" => [0, "mole"],  "months" => [0, "month"],
-  "moz" => [-3, "oz"],  "mpc" => [-3, "pc"],
-  "mpercent" => [-3, "percent"],  "mpermil" => [-3, "permil"],
-  "mpsi" => [-3, "psi"],  "mrad" => [-3, "rad"],  "ms" => [-3, "s"],
-  "msr" => [-3, "sr"],  "mt" => [-3, "t"],  "myr" => [-3, "yr"],
-  "n%" => [-9, "%"],  "nA" => [-9, "A"],  "nAu" => [-9, "Au"],
-  "nBq" => [-9, "Bq"],  "nC" => [-9, "C"],  "nF" => [-9, "F"],
-  "nG" => [-9, "G"],  "nGal" => [-9, "Gal"],  "nGy" => [-9, "Gy"],
-  "nH" => [-9, "H"],  "nHg" => [-9, "Hg"],  "nHz" => [-9, "Hz"],
-  "nJ" => [-9, "J"],  "nK" => [-9, "K"],  "nL" => [-9, "L"],
-  "nN" => [-9, "N"],  "nP" => [-9, "P"],  "nPa" => [-9, "Pa"],
-  "nS" => [-9, "S"],  "nSt" => [-9, "St"],  "nSv" => [-9, "Sv"],
-  "nT" => [-9, "T"],  "nV" => [-9, "V"],  "nW" => [-9, "W"],
-  "nWb" => [-9, "Wb"],  "na" => [-9, "a"],  "nac" => [-9, "ac"],
-  "nanoCelsius" => [-9, "Celsius"],
-  "nanoFahrenheit" => [-9, "Fahrenheit"],
-  "nanoJulian_year" => [-9, "Julian_year"],
-  "nanoPascal" => [-9, "Pascal"],  "nanoacre" => [-9, "acre"],
-  "nanoampere" => [-9, "ampere"],  "nanoangstrom" => [-9, "angstrom"],
-  "nanoangular_degree" => [-9, "angular_degree"],
-  "nanoangular_minute" => [-9, "angular_minute"],
-  "nanoangular_second" => [-9, "angular_second"],
-  "nanoare" => [-9, "are"],  "nanoatmosphere" => [-9, "atmosphere"],
-  "nanocalorie" => [-9, "calorie"],  "nanocelsius" => [-9, "celsius"],
-  "nanocentigrade" => [-9, "centigrade"],
-  "nanocentury" => [-9, "century"],  "nanochain" => [-9, "chain"],
-  "nanocommon_year" => [-9, "common_year"],
-  "nanocoulomb" => [-9, "coulomb"],  "nanoday" => [-9, "day"],
-  "nanodegK" => [-9, "degK"],  "nanodeg_K" => [-9, "deg_K"],
-  "nanodegree" => [-9, "degree"],  "nanodegreeK" => [-9, "degreeK"],
-  "nanodyne" => [-9, "dyne"],  "nanoerg" => [-9, "erg"],
-  "nanofahrenheit" => [-9, "fahrenheit"],  "nanofarad" => [-9, "farad"],
-  "nanofermi" => [-9, "fermi"],  "nanogal" => [-9, "gal"],
-  "nanogauss" => [-9, "gauss"],  "nanogram" => [-9, "gram"],
-  "nanohectare" => [-9, "hectare"],  "nanohertz" => [-9, "hertz"],
-  "nanohour" => [-9, "hour"],  "nanoinch" => [-9, "inch"],
-  "nanojoule" => [-9, "joule"],  "nanokelvin" => [-9, "kelvin"],
-  "nanokilogram" => [-9, "kilogram"],  "nanoknot" => [-9, "knot"],
-  "nanolitre" => [-9, "litre"],  "nanometer" => [-9, "meter"],
-  "nanometre" => [-9, "metre"],  "nanomicron" => [-9, "micron"],
-  "nanomile" => [-9, "mile"],  "nanomillibar" => [-9, "millibar"],
-  "nanominute" => [-9, "minute"],
-  "nanominute_angle" => [-9, "minute_angle"],
-  "nanomole" => [-9, "mole"],  "nanomonth" => [-9, "month"],
-  "nanonewton" => [-9, "newton"],  "nanoounce" => [-9, "ounce"],
-  "nanoparsec" => [-9, "parsec"],  "nanopascal" => [-9, "pascal"],
-  "nanopentad" => [-9, "pentad"],  "nanopoise" => [-9, "poise"],
-  "nanopound" => [-9, "pound"],  "nanoradian" => [-9, "radian"],
-  "nanosecond" => [-9, "second"],
-  "nanosecond_angle" => [-9, "second_angle"],
-  "nanosteradian" => [-9, "steradian"],  "nanostokes" => [-9, "stokes"],
-  "nanotesla" => [-9, "tesla"],  "nanoton" => [-9, "ton"],
-  "nanotonne" => [-9, "tonne"],  "nanotorr" => [-9, "torr"],
-  "nanovolt" => [-9, "volt"],  "nanowatt" => [-9, "watt"],
-  "nanoweber" => [-9, "weber"],  "nanoyard" => [-9, "yard"],
-  "nanoyd" => [-9, "yd"],  "nanoyear" => [-9, "year"],
-  "natm" => [-9, "atm"],  "nbar" => [-9, "bar"],  "ncal" => [-9, "cal"],
-  "nconventional_mercury" => [-9, "conventional_mercury"],
-  "nd" => [-9, "d"],  "ndegC" => [-9, "degC"],  "ndegF" => [-9, "degF"],
-  "ndeg_C" => [-9, "deg_C"],  "ndeg_F" => [-9, "deg_F"],
-  "ndegreeC" => [-9, "degreeC"],  "ndegreeF" => [-9, "degreeF"],
-  "ndegree_C" => [-9, "degree_C"],  "ndegree_E" => [-9, "degree_E"],
-  "ndegree_F" => [-9, "degree_F"],  "ndegree_N" => [-9, "degree_N"],
-  "ndegree_R" => [-9, "degree_R"],  "ndegree_S" => [-9, "degree_S"],
-  "ndegree_W" => [-9, "degree_W"],  "ndegree_c" => [-9, "degree_c"],
-  "ndegree_east" => [-9, "degree_east"],
-  "ndegree_f" => [-9, "degree_f"],
-  "ndegree_north" => [-9, "degree_north"],
-  "ndegree_south" => [-9, "degree_south"],
-  "ndegree_west" => [-9, "degree_west"],
-  "ndegrees_east" => [-9, "degrees_east"],
-  "ndegrees_north" => [-9, "degrees_north"],
-  "ndegrees_south" => [-9, "degrees_south"],
-  "ndegrees_west" => [-9, "degrees_west"],  "ndyn" => [-9, "dyn"],
-  "nerg" => [-9, "erg"],  "newtons" => [0, "newton"],
-  "nforce" => [-9, "force"],  "ng" => [-9, "g"],
-  "ngravity" => [-9, "gravity"],  "nh" => [-9, "h"],
-  "nhg" => [-9, "hg"],  "nhr" => [-9, "hr"],  "nin" => [-9, "in"],
-  "nkg" => [-9, "kg"],  "nkgf" => [-9, "kgf"],  "nkph" => [-9, "kph"],
-  "nlb" => [-9, "lb"],  "nlm" => [-9, "lm"],  "nlx" => [-9, "lx"],
-  "nly" => [-9, "ly"],  "nm" => [-9, "m"],  "nmb" => [-9, "mb"],
-  "nmercury" => [-9, "mercury"],  "nmgal" => [-9, "mgal"],
-  "nmin" => [-9, "min"],  "nmol" => [-9, "mol"],  "nmon" => [-9, "mon"],
-  "nmph" => [-9, "mph"],  "nohm" => [-9, "ohm"],  "noz" => [-9, "oz"],
-  "npc" => [-9, "pc"],  "npercent" => [-9, "percent"],
-  "npermil" => [-9, "permil"],  "npsi" => [-9, "psi"],
-  "nrad" => [-9, "rad"],  "ns" => [-9, "s"],  "nsr" => [-9, "sr"],
-  "nt" => [-9, "t"],  "nyr" => [-9, "yr"],  "ounces" => [0, "ounce"],
-  "p%" => [-12, "%"],  "pA" => [-12, "A"],  "pAu" => [-12, "Au"],
-  "pBq" => [-12, "Bq"],  "pC" => [-12, "C"],  "pF" => [-12, "F"],
-  "pG" => [-12, "G"],  "pGal" => [-12, "Gal"],  "pGy" => [-12, "Gy"],
-  "pH" => [-12, "H"],  "pHg" => [-12, "Hg"],  "pHz" => [-12, "Hz"],
-  "pJ" => [-12, "J"],  "pK" => [-12, "K"],  "pL" => [-12, "L"],
-  "pN" => [-12, "N"],  "pP" => [-12, "P"],  "pPa" => [-12, "Pa"],
-  "pS" => [-12, "S"],  "pSt" => [-12, "St"],  "pSv" => [-12, "Sv"],
-  "pT" => [-12, "T"],  "pV" => [-12, "V"],  "pW" => [-12, "W"],
-  "pWb" => [-12, "Wb"],  "pa" => [-12, "a"],  "pac" => [-12, "ac"],
-  "parsecs" => [0, "parsec"],  "pascals" => [0, "pascal"],
-  "patm" => [-12, "atm"],  "pbar" => [-12, "bar"],
-  "pcal" => [-12, "cal"],
-  "pconventional_mercury" => [-12, "conventional_mercury"],
-  "pd" => [-12, "d"],  "pdegC" => [-12, "degC"],
-  "pdegF" => [-12, "degF"],  "pdeg_C" => [-12, "deg_C"],
-  "pdeg_F" => [-12, "deg_F"],  "pdegreeC" => [-12, "degreeC"],
-  "pdegreeF" => [-12, "degreeF"],  "pdegree_C" => [-12, "degree_C"],
-  "pdegree_E" => [-12, "degree_E"],  "pdegree_F" => [-12, "degree_F"],
-  "pdegree_N" => [-12, "degree_N"],  "pdegree_R" => [-12, "degree_R"],
-  "pdegree_S" => [-12, "degree_S"],  "pdegree_W" => [-12, "degree_W"],
-  "pdegree_c" => [-12, "degree_c"],
-  "pdegree_east" => [-12, "degree_east"],
-  "pdegree_f" => [-12, "degree_f"],
-  "pdegree_north" => [-12, "degree_north"],
-  "pdegree_south" => [-12, "degree_south"],
-  "pdegree_west" => [-12, "degree_west"],
-  "pdegrees_east" => [-12, "degrees_east"],
-  "pdegrees_north" => [-12, "degrees_north"],
-  "pdegrees_south" => [-12, "degrees_south"],
-  "pdegrees_west" => [-12, "degrees_west"],  "pdyn" => [-12, "dyn"],
-  "pentads" => [0, "pentad"],  "perg" => [-12, "erg"],
-  "petaCelsius" => [15, "Celsius"],
-  "petaFahrenheit" => [15, "Fahrenheit"],
-  "petaJulian_year" => [15, "Julian_year"],
-  "petaPascal" => [15, "Pascal"],  "petaacre" => [15, "acre"],
-  "petaampere" => [15, "ampere"],  "petaangstrom" => [15, "angstrom"],
-  "petaangular_degree" => [15, "angular_degree"],
-  "petaangular_minute" => [15, "angular_minute"],
-  "petaangular_second" => [15, "angular_second"],
-  "petaare" => [15, "are"],  "petaatmosphere" => [15, "atmosphere"],
-  "petacalorie" => [15, "calorie"],  "petacelsius" => [15, "celsius"],
-  "petacentigrade" => [15, "centigrade"],
-  "petacentury" => [15, "century"],  "petachain" => [15, "chain"],
-  "petacommon_year" => [15, "common_year"],
-  "petacoulomb" => [15, "coulomb"],  "petaday" => [15, "day"],
-  "petadegK" => [15, "degK"],  "petadeg_K" => [15, "deg_K"],
-  "petadegree" => [15, "degree"],  "petadegreeK" => [15, "degreeK"],
-  "petadyne" => [15, "dyne"],  "petaerg" => [15, "erg"],
-  "petafahrenheit" => [15, "fahrenheit"],  "petafarad" => [15, "farad"],
-  "petafermi" => [15, "fermi"],  "petagal" => [15, "gal"],
-  "petagauss" => [15, "gauss"],  "petagram" => [15, "gram"],
-  "petahectare" => [15, "hectare"],  "petahertz" => [15, "hertz"],
-  "petahour" => [15, "hour"],  "petainch" => [15, "inch"],
-  "petajoule" => [15, "joule"],  "petakelvin" => [15, "kelvin"],
-  "petakilogram" => [15, "kilogram"],  "petaknot" => [15, "knot"],
-  "petalitre" => [15, "litre"],  "petameter" => [15, "meter"],
-  "petametre" => [15, "metre"],  "petamicron" => [15, "micron"],
-  "petamile" => [15, "mile"],  "petamillibar" => [15, "millibar"],
-  "petaminute" => [15, "minute"],
-  "petaminute_angle" => [15, "minute_angle"],
-  "petamole" => [15, "mole"],  "petamonth" => [15, "month"],
-  "petanewton" => [15, "newton"],  "petaounce" => [15, "ounce"],
-  "petaparsec" => [15, "parsec"],  "petapascal" => [15, "pascal"],
-  "petapentad" => [15, "pentad"],  "petapoise" => [15, "poise"],
-  "petapound" => [15, "pound"],  "petaradian" => [15, "radian"],
-  "petasecond" => [15, "second"],
-  "petasecond_angle" => [15, "second_angle"],
-  "petasteradian" => [15, "steradian"],  "petastokes" => [15, "stokes"],
-  "petatesla" => [15, "tesla"],  "petaton" => [15, "ton"],
-  "petatonne" => [15, "tonne"],  "petatorr" => [15, "torr"],
-  "petavolt" => [15, "volt"],  "petawatt" => [15, "watt"],
-  "petaweber" => [15, "weber"],  "petayard" => [15, "yard"],
-  "petayd" => [15, "yd"],  "petayear" => [15, "year"],
-  "pforce" => [-12, "force"],  "pg" => [-12, "g"],
-  "pgravity" => [-12, "gravity"],  "ph" => [-12, "h"],
-  "phg" => [-12, "hg"],  "phr" => [-12, "hr"],
-  "picoCelsius" => [-12, "Celsius"],
-  "picoFahrenheit" => [-12, "Fahrenheit"],
-  "picoJulian_year" => [-12, "Julian_year"],
-  "picoPascal" => [-12, "Pascal"],  "picoacre" => [-12, "acre"],
-  "picoampere" => [-12, "ampere"],  "picoangstrom" => [-12, "angstrom"],
-  "picoangular_degree" => [-12, "angular_degree"],
-  "picoangular_minute" => [-12, "angular_minute"],
-  "picoangular_second" => [-12, "angular_second"],
-  "picoare" => [-12, "are"],  "picoatmosphere" => [-12, "atmosphere"],
-  "picocalorie" => [-12, "calorie"],  "picocelsius" => [-12, "celsius"],
-  "picocentigrade" => [-12, "centigrade"],
-  "picocentury" => [-12, "century"],  "picochain" => [-12, "chain"],
-  "picocommon_year" => [-12, "common_year"],
-  "picocoulomb" => [-12, "coulomb"],  "picoday" => [-12, "day"],
-  "picodegK" => [-12, "degK"],  "picodeg_K" => [-12, "deg_K"],
-  "picodegree" => [-12, "degree"],  "picodegreeK" => [-12, "degreeK"],
-  "picodyne" => [-12, "dyne"],  "picoerg" => [-12, "erg"],
-  "picofahrenheit" => [-12, "fahrenheit"],
-  "picofarad" => [-12, "farad"],  "picofermi" => [-12, "fermi"],
-  "picogal" => [-12, "gal"],  "picogauss" => [-12, "gauss"],
-  "picogram" => [-12, "gram"],  "picohectare" => [-12, "hectare"],
-  "picohertz" => [-12, "hertz"],  "picohour" => [-12, "hour"],
-  "picoinch" => [-12, "inch"],  "picojoule" => [-12, "joule"],
-  "picokelvin" => [-12, "kelvin"],  "picokilogram" => [-12, "kilogram"],
-  "picoknot" => [-12, "knot"],  "picolitre" => [-12, "litre"],
-  "picometer" => [-12, "meter"],  "picometre" => [-12, "metre"],
-  "picomicron" => [-12, "micron"],  "picomile" => [-12, "mile"],
-  "picomillibar" => [-12, "millibar"],  "picominute" => [-12, "minute"],
-  "picominute_angle" => [-12, "minute_angle"],
-  "picomole" => [-12, "mole"],  "picomonth" => [-12, "month"],
-  "piconewton" => [-12, "newton"],  "picoounce" => [-12, "ounce"],
-  "picoparsec" => [-12, "parsec"],  "picopascal" => [-12, "pascal"],
-  "picopentad" => [-12, "pentad"],  "picopoise" => [-12, "poise"],
-  "picopound" => [-12, "pound"],  "picoradian" => [-12, "radian"],
-  "picosecond" => [-12, "second"],
-  "picosecond_angle" => [-12, "second_angle"],
-  "picosteradian" => [-12, "steradian"],
-  "picostokes" => [-12, "stokes"],  "picotesla" => [-12, "tesla"],
-  "picoton" => [-12, "ton"],  "picotonne" => [-12, "tonne"],
-  "picotorr" => [-12, "torr"],  "picovolt" => [-12, "volt"],
-  "picowatt" => [-12, "watt"],  "picoweber" => [-12, "weber"],
-  "picoyard" => [-12, "yard"],  "picoyd" => [-12, "yd"],
-  "picoyear" => [-12, "year"],  "pin" => [-12, "in"],
-  "pkg" => [-12, "kg"],  "pkgf" => [-12, "kgf"],
-  "pkph" => [-12, "kph"],  "plb" => [-12, "lb"],  "plm" => [-12, "lm"],
-  "plx" => [-12, "lx"],  "ply" => [-12, "ly"],  "pm" => [-12, "m"],
-  "pmb" => [-12, "mb"],  "pmercury" => [-12, "mercury"],
-  "pmgal" => [-12, "mgal"],  "pmin" => [-12, "min"],
-  "pmol" => [-12, "mol"],  "pmon" => [-12, "mon"],
-  "pmph" => [-12, "mph"],  "pohm" => [-12, "ohm"],
-  "poises" => [0, "poise"],  "pounds" => [0, "pound"],
-  "poz" => [-12, "oz"],  "ppc" => [-12, "pc"],
-  "ppercent" => [-12, "percent"],  "ppermil" => [-12, "permil"],
-  "ppsi" => [-12, "psi"],  "prad" => [-12, "rad"],  "ps" => [-12, "s"],
-  "psr" => [-12, "sr"],  "pt" => [-12, "t"],  "pyr" => [-12, "yr"],
-  "radians" => [0, "radian"],  "seconds" => [0, "second"],
-  "seconds_angle" => [0, "second_angle"],
-  "steradians" => [0, "steradian"],  "stokeses" => [0, "stokes"],
-  "telaCelsius" => [12, "Celsius"],
-  "telaFahrenheit" => [12, "Fahrenheit"],
-  "telaJulian_year" => [12, "Julian_year"],
-  "telaPascal" => [12, "Pascal"],  "telaacre" => [12, "acre"],
-  "telaampere" => [12, "ampere"],  "telaangstrom" => [12, "angstrom"],
-  "telaangular_degree" => [12, "angular_degree"],
-  "telaangular_minute" => [12, "angular_minute"],
-  "telaangular_second" => [12, "angular_second"],
-  "telaare" => [12, "are"],  "telaatmosphere" => [12, "atmosphere"],
-  "telacalorie" => [12, "calorie"],  "telacelsius" => [12, "celsius"],
-  "telacentigrade" => [12, "centigrade"],
-  "telacentury" => [12, "century"],  "telachain" => [12, "chain"],
-  "telacommon_year" => [12, "common_year"],
-  "telacoulomb" => [12, "coulomb"],  "teladay" => [12, "day"],
-  "teladegK" => [12, "degK"],  "teladeg_K" => [12, "deg_K"],
-  "teladegree" => [12, "degree"],  "teladegreeK" => [12, "degreeK"],
-  "teladyne" => [12, "dyne"],  "telaerg" => [12, "erg"],
-  "telafahrenheit" => [12, "fahrenheit"],  "telafarad" => [12, "farad"],
-  "telafermi" => [12, "fermi"],  "telagal" => [12, "gal"],
-  "telagauss" => [12, "gauss"],  "telagram" => [12, "gram"],
-  "telahectare" => [12, "hectare"],  "telahertz" => [12, "hertz"],
-  "telahour" => [12, "hour"],  "telainch" => [12, "inch"],
-  "telajoule" => [12, "joule"],  "telakelvin" => [12, "kelvin"],
-  "telakilogram" => [12, "kilogram"],  "telaknot" => [12, "knot"],
-  "telalitre" => [12, "litre"],  "telameter" => [12, "meter"],
-  "telametre" => [12, "metre"],  "telamicron" => [12, "micron"],
-  "telamile" => [12, "mile"],  "telamillibar" => [12, "millibar"],
-  "telaminute" => [12, "minute"],
-  "telaminute_angle" => [12, "minute_angle"],
-  "telamole" => [12, "mole"],  "telamonth" => [12, "month"],
-  "telanewton" => [12, "newton"],  "telaounce" => [12, "ounce"],
-  "telaparsec" => [12, "parsec"],  "telapascal" => [12, "pascal"],
-  "telapentad" => [12, "pentad"],  "telapoise" => [12, "poise"],
-  "telapound" => [12, "pound"],  "telaradian" => [12, "radian"],
-  "telasecond" => [12, "second"],
-  "telasecond_angle" => [12, "second_angle"],
-  "telasteradian" => [12, "steradian"],  "telastokes" => [12, "stokes"],
-  "telatesla" => [12, "tesla"],  "telaton" => [12, "ton"],
-  "telatonne" => [12, "tonne"],  "telatorr" => [12, "torr"],
-  "telavolt" => [12, "volt"],  "telawatt" => [12, "watt"],
-  "telaweber" => [12, "weber"],  "telayard" => [12, "yard"],
-  "telayd" => [12, "yd"],  "telayear" => [12, "year"],
-  "teslas" => [0, "tesla"],  "tonnes" => [0, "tonne"],
-  "tons" => [0, "ton"],  "torrs" => [0, "torr"],  "u%" => [-6, "%"],
-  "uA" => [-6, "A"],  "uAu" => [-6, "Au"],  "uBq" => [-6, "Bq"],
-  "uC" => [-6, "C"],  "uF" => [-6, "F"],  "uG" => [-6, "G"],
-  "uGal" => [-6, "Gal"],  "uGy" => [-6, "Gy"],  "uH" => [-6, "H"],
-  "uHg" => [-6, "Hg"],  "uHz" => [-6, "Hz"],  "uJ" => [-6, "J"],
-  "uK" => [-6, "K"],  "uL" => [-6, "L"],  "uN" => [-6, "N"],
-  "uP" => [-6, "P"],  "uPa" => [-6, "Pa"],  "uS" => [-6, "S"],
-  "uSt" => [-6, "St"],  "uSv" => [-6, "Sv"],  "uT" => [-6, "T"],
-  "uV" => [-6, "V"],  "uW" => [-6, "W"],  "uWb" => [-6, "Wb"],
-  "ua" => [-6, "a"],  "uac" => [-6, "ac"],  "uatm" => [-6, "atm"],
-  "ubar" => [-6, "bar"],  "ucal" => [-6, "cal"],
-  "uconventional_mercury" => [-6, "conventional_mercury"],
-  "ud" => [-6, "d"],  "udegC" => [-6, "degC"],  "udegF" => [-6, "degF"],
-  "udeg_C" => [-6, "deg_C"],  "udeg_F" => [-6, "deg_F"],
-  "udegreeC" => [-6, "degreeC"],  "udegreeF" => [-6, "degreeF"],
-  "udegree_C" => [-6, "degree_C"],  "udegree_E" => [-6, "degree_E"],
-  "udegree_F" => [-6, "degree_F"],  "udegree_N" => [-6, "degree_N"],
-  "udegree_R" => [-6, "degree_R"],  "udegree_S" => [-6, "degree_S"],
-  "udegree_W" => [-6, "degree_W"],  "udegree_c" => [-6, "degree_c"],
-  "udegree_east" => [-6, "degree_east"],
-  "udegree_f" => [-6, "degree_f"],
-  "udegree_north" => [-6, "degree_north"],
-  "udegree_south" => [-6, "degree_south"],
-  "udegree_west" => [-6, "degree_west"],
-  "udegrees_east" => [-6, "degrees_east"],
-  "udegrees_north" => [-6, "degrees_north"],
-  "udegrees_south" => [-6, "degrees_south"],
-  "udegrees_west" => [-6, "degrees_west"],  "udyn" => [-6, "dyn"],
-  "uerg" => [-6, "erg"],  "uforce" => [-6, "force"],  "ug" => [-6, "g"],
-  "ugravity" => [-6, "gravity"],  "uh" => [-6, "h"],
-  "uhg" => [-6, "hg"],  "uhr" => [-6, "hr"],  "uin" => [-6, "in"],
-  "ukg" => [-6, "kg"],  "ukgf" => [-6, "kgf"],  "ukph" => [-6, "kph"],
-  "ulb" => [-6, "lb"],  "ulm" => [-6, "lm"],  "ulx" => [-6, "lx"],
-  "uly" => [-6, "ly"],  "um" => [-6, "m"],  "umb" => [-6, "mb"],
-  "umercury" => [-6, "mercury"],  "umgal" => [-6, "mgal"],
-  "umin" => [-6, "min"],  "umol" => [-6, "mol"],  "umon" => [-6, "mon"],
-  "umph" => [-6, "mph"],  "uohm" => [-6, "ohm"],  "uoz" => [-6, "oz"],
-  "upc" => [-6, "pc"],  "upercent" => [-6, "percent"],
-  "upermil" => [-6, "permil"],  "upsi" => [-6, "psi"],
-  "urad" => [-6, "rad"],  "us" => [-6, "s"],  "usr" => [-6, "sr"],
-  "ut" => [-6, "t"],  "uyr" => [-6, "yr"],  "volts" => [0, "volt"],
-  "watts" => [0, "watt"],  "webers" => [0, "weber"],
-  "yards" => [0, "yard"],  "yds" => [0, "yd"],  "years" => [0, "year"],
-}
-UPLURALS = {
-  "Celsiuses" => "Celsius",  "Fahrenheits" => "Fahrenheit",
-  "Julians_year" => "Julian_year",  "Pascals" => "Pascal",
-  "acres" => "acre",  "amperes" => "ampere",  "angstroms" => "angstrom",
-  "angulars_degree" => "angular_degree",
-  "angulars_minute" => "angular_minute",
-  "angulars_second" => "angular_second",  "ares" => "are",
-  "atmospheres" => "atmosphere",  "calories" => "calorie",
-  "celsiuses" => "celsius",  "centigrades" => "centigrade",
-  "centuries" => "century",  "chains" => "chain",
-  "commons_year" => "common_year",  "coulombs" => "coulomb",
-  "days" => "day",  "degKs" => "degK",  "degreeKs" => "degreeK",
-  "degrees" => "degree",  "degs_K" => "deg_K",  "dynes" => "dyne",
-  "ergs" => "erg",  "fahrenheits" => "fahrenheit",  "farads" => "farad",
-  "fermis" => "fermi",  "gals" => "gal",  "gausses" => "gauss",
-  "grams" => "gram",  "hectares" => "hectare",  "hertzes" => "hertz",
-  "hours" => "hour",  "inchs" => "inch",  "joules" => "joule",
-  "kelvins" => "kelvin",  "kilograms" => "kilogram",  "knots" => "knot",
-  "litres" => "litre",  "meters" => "meter",  "metres" => "metre",
-  "microns" => "micron",  "miles" => "mile",  "millibars" => "millibar",
-  "minutes" => "minute",  "minutes_angle" => "minute_angle",
-  "moles" => "mole",  "months" => "month",  "newtons" => "newton",
-  "ounces" => "ounce",  "parsecs" => "parsec",  "pascals" => "pascal",
-  "pentads" => "pentad",  "poises" => "poise",  "pounds" => "pound",
-  "radians" => "radian",  "seconds" => "second",
-  "seconds_angle" => "second_angle",  "steradians" => "steradian",
-  "stokeses" => "stokes",  "teslas" => "tesla",  "tonnes" => "tonne",
-  "tons" => "ton",  "torrs" => "torr",  "volts" => "volt",
-  "watts" => "watt",  "webers" => "weber",  "yards" => "yard",
-  "yds" => "yd",  "years" => "year",
-}
-end
-class NumberNode < TerminalNode
-
-    def initialize(arg)
-	raise TypeError unless Numeric === arg
-	@a = arg
-    end
-
-    UNITY = NumberNode.new(1)
-    ZERO = NumberNode.new(0)
-
-    def to_s
-      if @a == @a.to_i
-        sprintf("%d",@a)
-      else
-        String(@a)
-      end
-    end
-
-    attr_reader :a
-
-    alias :value :a
-    alias :factor :a
-
-    def == (other)
-      case other
-      when NumberNode
-	@a == other.a
-      else
-	false
-      end
-    end
-
-    def add_eval(another)
-	raise TypeError unless NumberNode === another
-	NumberNode.new(@a + another.value)
-    end
-
-    def mul_eval(another)
-	case another
-	when NumberNode then NumberNode.new(@a * another.a)
-	when PowNode
-	    raise TypeError unless NumberNode === another.lhs
-	    raise TypeError unless NumberNode === another.rhs
-	    NumberNode.new(@a * Units::pow_f(another.lhs.value, another.rhs.value))
-	else raise TypeError
-	end
-    end
-
-    def name; "1"; end
-
-    def power;  UNITY;  end
-
-end
-class XDate
-
-    def initialize(year, month, day)
-	@year, @month, @day = year.to_i, month.to_i, day.to_i
-    end
-
-    attr_reader :year, :month, :day
-
-    def to_s
-	format('%04d-%02d-%02d', @year, @month, @day)
-    end
-
-    alias :inspect :to_s
-
-    def to_time
-	Time.gm(@year, @month, @day)
-    end
-
-    def to_date
-	Date.new(@year, @month, @day)
-    end
-
-    def -(other)
-	case other
-	when XDate
-	    (to_date - other.to_date)
-	when Time
-	    to_time - other
-	when Date
-            (to_date - other.to_date)
-	else
-	    to_date - other
-	end
-    end
-
-    def +(other)
-	t = to_date + other
-	self.class.new(t.year, t.month, t.mday)
-    end
-
-end
-
-class TimeNode < TerminalNode
-
-    def initialize(date, time, zone)
-	@date, @time, @zone = date, time, zone
-	if :now === @date then
-	    now = Time.now.utc
-	    @date = XDate.new(now.year, now.month, now.day)
-	    @time = ((now.hour * 60 + now.min) * 60 + Float(now.sec))
-	else
-	    qdays = (@time / 86400).floor
-	    if not qdays.zero?
-	        @date += qdays
-	        @time -= (qdays * 86400)
-	    end
-	end
-	raise TypeError unless XDate === @date
-	@time = 0.0 unless @time
-	raise TypeError unless Float === @time
-	@zone = 0 unless @zone
-	raise TypeError unless Integer === @zone
-    end
-
-    attr_reader :date, :time, :zone
-
-    def to_s
-	hr = @time.floor / 3600
-	mi = (@time.floor / 60) % 60
-	sc = @time % 60
-	tzm = @zone.abs
-	tzh = tzm / 60
-	tzm %= 60
-	tzh = -tzh if @zone < 0
-	format("%sT%02d:%02d:%05.2f %+03d:%02d", \
-	    @date.to_s, hr, mi, sc, tzh, tzm)
-    end
-
-    def self::pentad(d)
-	(d > 25) ? 5 : ((d - 1) / 5)
-    end
-
-    def add_time(increment)
-	inc = increment.reduce5
-	case inc.name
-	when 's'
-	    t2 = @time + inc.factor
-	    d2 = @date + (t2 / 86400)
-	    t2 = t2 % 86400
-	    self.class.new(d2, t2, @zone)
-	when 'pentad'
-	    ifac = Integer(inc.factor)
-	    ipen = ifac % 6
-	    imon = ifac / 6
-	    spen = self.class.pentad(@date.day)
-	    smon = @date.month + imon + spen / 6
-	    spen = spen % 6
-	    sday = spen * 5 + (@date.day - 1) % 5 + 1
-	    syear = @date.year + (smon - 1) / 12
-	    smon = (smon - 1) % 12 + 1
-	    sdate = XDate.new(syear, smon, sday)
-	    self.class.new(sdate, @time, @zone)
-	else
-	    raise "bad time unit '#{inc.name}'"
-	end
-    end
-
-    def utcsod
-	@time - @zone * 60
-    end
-
-    def div_time(units)
-	base = units.ref
-	inc = units.deref.reduce5
-	begin
-	    incname = inc.name
-	rescue Exception
-	    incname = "(undefined)"
-	end
-	case incname
-	when 's'
-	    dif = (@date - base.date) * 86400 + (utcsod - base.utcsod)
-	    dif / inc.factor
-	when 'pentad'
-	    dif = (@date.year - base.date.year) * 72
-	    dif += (@date.month - base.date.month) * 6
-	    dif += self.class.pentad(@date.day)
-	    dif -= self.class.pentad(base.date.day)
-	    dif = Float(dif) if dif % inc.factor != 0
-	    dif / inc.factor
-	else
-	    raise "bad time unit '#{incname}'"
-	end
-    end
-
-end
-class PowNode < ContainerNode
-
-    include BinaryNode
-
-    def initialize(lhs, rhs)
-	@lhs, @rhs = lhs, rhs
-	raise TypeError unless NumberNode === @rhs
-    end
-
-    def to_s
-	lhs = @lhs.to_s
-	case lhs
-	when /\d$/, /[\d\.]/
-	    lhs = "(#{lhs})"
-	end
-	rhs = @rhs.to_s
-        if rhs == '1'
-	    lhs
-	else
-	    rhs = "^(#{rhs})" if (/\./ =~ rhs)
-	    lhs + rhs
-	end
-    end
-
-    attr_reader :lhs, :rhs
-    alias :power :rhs
-
-    def pow_eval(other)
-	case other
-	when NumberNode
-	    PowNode.new(@lhs, @rhs.mul_eval(other))
-	else
-	    super(other)
-	end
-    end
-
-    def flatten2
-	x = @lhs.flatten2
-	case x
-	when NumberNode
-	    a = @lhs.pow_eval(@rhs)
-	when TerminalNode
-	    a = self
-	when PowNode
-	    a = PowNode.new(x.lhs, x.rhs.mul_eval(@rhs))
-	when MulNode, MultiNode
-	    a = MultiNode.new()
-	    for gc in x
-		a.append(gc.pow_eval(@rhs))
-	    end
-	else
-	    raise "internal error"
-	end
-	return a
-    end
-
-    def name
-	case @lhs
-	when NumberNode, NameNode
-	    @lhs.name
-	else
-	    raise "internal error"
-	end
-    end
-
-    def value
-	case @lhs
-	when NumberNode
-	    Units::pow_f(@lhs.value, @rhs.value)
-	else
-	    raise(format('%s#value: internal error', self.class.to_s))
-	end
-    end
-
-    def mul_eval(another)
-	raise "internal error (#{name}, #{another.name})" if name != another.name
-	case @lhs
-	when NumberNode
-	    NumberNode.new(Units::pow_f(@lhs.value, @rhs.value) * another.value)
-	else
-	    self.class.new(@lhs, @rhs.add_eval(another.power))
-	end
-    end
-
-    def sort
-	case @lhs
-	when NumberNode
-	    NumberNode.new(Units::pow_f(@lhs.value, @rhs.value))
-	else
-	    self
-	end
-    end
-
-    def factor
-	Units::pow_f(@lhs.factor, @rhs.value)
-    end
-
-end
-
-module Kakezan
-
-    def flatten2
-	r = MultiNode.new()
-	each do |child|
-	    case child
-	    when MultiNode
-		r.append child
-	    when MulNode
-		r.append child.flatten2
-	    when ContainerNode
-		r.append child.flatten2
-	    else
-		r.append child
-	    end 
-	end
-	r
-    end
-
-    def name
-	n = nil
-	for c in @children
-	    next if NumberNode === c
-	    na = c.name
-	    if n.nil?
-		n = na
-	    else
-		raise "multiple names found" if na != n
-	    end
-	end
-	n = "1" if n.nil?
-	n
-    end
-
-    def factor
-	f = 1
-	for c in @children
-	    f *= c.factor
-	end
-	f
-    end
-
-end
-
-class MulNode < ContainerNode
-
-    include BinaryNode
-    include Kakezan
-
-    def initialize(lhs, rhs)
-	@lhs, @rhs = lhs, rhs
-    end
-
-    def to_s
-	lhs = @lhs.to_s
-	rhs = @rhs.to_s
-	if (/\d$/ =~ lhs && /^\w/ =~ rhs) then
-	    "#{lhs} #{rhs}"
-	else
-	    "#{lhs}.#{rhs}"
-	end
-    end
-
-end
-
-class MultiNode < ContainerNode
-
-    include Kakezan
-
-    def initialize(*children)
-	@children = children
-	for c in @children
-	    raise "# MultiNode.new(#{children.inspect})" unless Node === c
-	end
-    end
-
-    def to_s
-	s = @children.join(';')
-	s.gsub(/\d;\w/) { |dsw| dsw.sub(/;/, ' ') }.gsub(/;/, '.')
-    end
-
-    def each
-	@children.each {|child| yield child }
-    end
-
-    attr_reader :children
-    
-    def append(other)
-	case other
-	when MultiNode
-	    @children += other.children
-	else
-	    @children.push other
-	end
-    end
-
-    def sort
-	table = {}
-	for child in self
-	    name = child.name
-	    if (table.include?(name)) then
-		table[name] = table[name].mul_eval(child)
-	    else
-		table[name] = child
-	    end
-	end
-	list = []
-	for name in table.keys.sort
-	    candi = table[name]
-	    if PowNode === candi and NumberNode === candi.lhs then
-		v = candi.value
-		list.push NumberNode.new(v) unless v == 1
-		next
-	    end
-	    next if candi.power.value == 0
-	    list.push candi
-	end
-        if list.length > 1
-	  list.delete(NumberNode::UNITY)
-	end
-	self.class.new(*list)
-    end
-
-    def collect_hash(stopper, op)
-	list = []
-	for child in self
-	    list.push(child.send(op, stopper))
-	end
-	self.class.new(*list).flatten2
-    end
-
-    def expand(stopper)
-	collect_hash(stopper, :expand)
-    end
-
-    def unalias(stopper)
-	collect_hash(stopper, :unalias)
-    end
-
-    def foldnumber(stopper)
-	collect_hash(stopper, :foldnumber)
-    end
-
-    def value
-	raise "this is dimensional units" if (@children.size > 1)
-	@children.first ? @children.first.value : NumberNode::UNITY.value
-    end
-
-end
-class ShiftNode < ContainerNode
-
-    include BinaryNode
-
-    def initialize(lhs, rhs)
-	@lhs, @rhs = lhs, rhs
-    end
-
-    attr_reader :lhs, :rhs
-    alias :ref :rhs
-
-    def to_s
-	"(#{@lhs.to_s} @ #{@rhs.to_s})"
-    end
-
-    def trim2;  @lhs;  end
-    def trim
-      	self.class.new(@lhs.trim, @rhs.trim2)
-    end
-
-    def flatten2;  @lhs;  end
-    def flatten
-	lf = @lhs.flatten
-	case lf
-	when ShiftNode
-	    rf = lf.rhs.add_eval(@rhs)
-	    self.class.new(lf.lhs, rf)
-	else
-	    self.class.new(lf, @rhs.flatten)
-	end
-    end
-
-    def sort
-	self.class.new(@lhs.sort, @rhs.sort)
-    end
-
-    def ref
-	case @lhs
-	when ShiftNode
-	    @lhs.ref.add_eval(@rhs)
-	else
-	    @rhs
-	end
-    end
-
-    def deref
-	case @lhs
-	when ShiftNode
-	    @lhs.deref
-	else
-	    @lhs
-	end
-    end
-
-    def name
-	@lhs.name
-    end
-
-    def factor
-	@lhs.factor
-    end
-
-end
-def initialize string
-    case string
-    when String
-        @string, @ptree = string, nil
-    when Node
-        @string, @ptree = nil, string
-    else
-        @string, @ptree = String(string), nil
-    end
-    @copy = @lexstat = nil
-end
-
-#
-# === LEXICAL ANALYZER ===
-#
-
-def rewind
-    @copy = @string.dup.strip
-    @lexstat = nil
-end
-
-RE_SPACE	= '([ \t])'
-RE_INTEGER	= '([-+]?\d+)'
-RE_EXP		= '([eE][-+]?[0-9]+)'
-RE_REAL		= "([-+]?[0-9]*(\\.[0-9]*#{RE_EXP}?|#{RE_EXP}))"
-RE_YEAR		= "([-+]?[0-9]{1,4})"
-RE_MONTH	= "(0?[1-9]|1[0-2])"
-RE_DAY		= "([12][0-9]|30|31|0?[1-9])"
-RE_HOUR		= "(2[0-3]|[0-1]?[0-9])"
-RE_MINUTE	= "([0-5]?[0-9])"
-RE_SECOND	= "((#{RE_MINUTE}|60)(\\.[0-9]*)?)"
-RE_NAME		= "(%|[a-zA-Z][a-zA-Z_]*([0-9]+[a-zA-Z_]+)*)"
-
-RE_DATE		= "#{RE_YEAR}-#{RE_MONTH}-#{RE_DAY}"
-RE_TIME		= "#{RE_HOUR}((:[0-5]?[0-9]|[0-5][0-9])(:#{RE_SECOND})?)?"
-RE_HandM	= "#{RE_HOUR}((:[0-5]?[0-9]|[0-5][0-9]))?"
-
-def next_token
-
-    # decomment
-    @copy.sub!(/^#.*/, '');
-
-    if @copy.sub!(%r{^\s*(\))}, '') then
-	@lexstat = nil
-	return [$1, $1]
-    end
-
-    if @copy.sub!(%r{^\s*(\()\s*}, '') then
-	return [$1, $1]
-    end
-
-    if @copy.sub!(%r{^[ \t]*(@)[ \t]*}, '') \
-    or @copy.sub!(%r{^[ \t]+(after|from|since|ref)[ \t]+}i, '') then
-	@lexstat = :SHIFT_SEEN
-	return [:SHIFT, $1]
-    end
-
-    if @copy.sub!(%r{^[ \t]*(/)[ \t]*}, '') \
-    or @copy.sub!(%r{^[ \t]+(per)[ \t]+}i, '') then
-	@lexstat = nil
-	return [:DIVIDE, $1]
-    end
-
-    if @copy.sub!(%r{^(\^|\*\*)}, '') then
-	@lexstat = nil
-	return [:EXPONENT, $1]
-    end
-
-    if @copy.sub!(%r{^(\.|\*|[ \t]+)}, '') then
-	@lexstat = nil
-	return [:MULTIPLY, $1]
-    end
-
-    if :SHIFT_SEEN === @lexstat \
-    and @copy.sub!(%r{^#{RE_DATE}T?[ \t]*}, '') then
-	y, m, d = $1, $2, $3
-	@lexstat = :DATE_SEEN
-	return [:DATE, XDate.new(y.to_i, m.to_i, d.to_i)]
-    end
-
-    if :SHIFT_SEEN === @lexstat \
-    and @copy.sub!(%r{^now[ \t]*}, '') then
-	@lexstat = nil
-	return [:DATE, :now]
-    end
-
-    if :DATE_SEEN === @lexstat \
-    and @copy.sub!(%r{^#{RE_TIME}[ \t]*}, '') then
-	h, m, s = $1, $3, $5
-        m = m.sub(/:/,'') if m
-	s = 0 if s.nil?
-	@lexstat = :TIME_SEEN
-	return [:TIME, ((h.to_i * 60 + m.to_i) * 60 + Float(s))]
-    end
-
-    if :DATE_SEEN === @lexstat \
-    and @copy.sub!(%r{^([0-2][0-9])([0-5][0-9])[ \t]*}, '') then
-	h, m = $1, $2
-	@lexstat = :TIME_SEEN
-	return [:TIME, ((h.to_i * 60 + m.to_i) * 60.0)]
-    end
-
-    if :DATE_SEEN === @lexstat \
-    and @copy.sub!(%r{^([0-9])([0-5][0-9])[ \t]*}, '') then
-	h, m = $1, $2
-	@lexstat = :TIME_SEEN
-	return [:TIME, ((h.to_i * 60 + m.to_i) * 60.0)]
-    end
-
-    if :TIME_SEEN === @lexstat \
-    and @copy.sub!(%r{^UTC[ \t]*}, '') then
-	@lexstat = nil
-	return [:ZONE, 0]
-    end
-
-    if :TIME_SEEN === @lexstat \
-    and @copy.sub!(%r{^([-+]?)#{RE_HandM}[ \t]*}, '') then
-	sgn, h, m = $1, $2, $4
-        m = m.sub(/:/,'') if m
-	@lexstat = nil
-	h = h.to_i
-	h = -h if sgn == "-"
-	m = m.to_i
-	m = -m if sgn == "-"
-	return [:ZONE, ((h * 60) + m)]
-    end
-
-    if @copy.sub!(%r{^#{RE_NAME}}, '') then
-	@lexstat = nil
-	return [:NAME, $1]
-    end
-
-    if @copy.sub!(%r{^#{RE_REAL}}, '') then
-	@lexstat = nil
-	return [:REAL, $1.to_f]
-    end
-
-    if @copy.sub!(%r{^#{RE_INTEGER}}, '') then
-	@lexstat = nil
-	return [:INT, $1.to_i]
-    end
-
-    if @copy.sub!(%r{^(-)}, '') then
-	@lexstat = nil
-	return [:MULTIPLY, $1]
-    end
-
-    if @copy.sub!(%r{^(.)}, '') then
-	return [$1, $1]
-    end
-
-    return [false, false]
-
-end
-
-#
-# === USER LEVEL METHODS ===
-#
-
-def tokens
-    rewind
-    x = []
-    while (t = next_token).first
-	x.push t
-    end
-    x
-end
-
-def do_parse2
-    rewind
-    return NumberNode.new(1) if @string.nil? or @string.empty?
-    pa = do_parse
-    pa ? pa : ErrorNode.new(@string)
-end
-
-def ptree
-    @ptree = do_parse2 if not @ptree
-    @ptree
-end
-
-def dup
-    @string ? self.class.new(@string) : self.class.new(@ptree)
-end
-
-def parse
-    dup.parse!
-end
-
-def parse!
-    @ptree = do_parse2 if not @ptree
-    self
-end
-
-def self::parse(string)
-    new(string).parse!
-end
-
-=begin
---- reduce0
-    just do nothing.
-=end
-
-def reduce0
-    self
-end
-
-=begin
---- reduce1
-    removes unnecessary parentheses.
-=end
-
-def reduce1
-    @string = ptree.to_s
-    self
-end
-
-=begin
---- reduce2
-    removes shift operator within multiplication/division/exponent
-=end
-
-def reduce2
-    @ptree = ptree.reduce2
-    @string = nil
-    self
-end
-
-=begin
---- reduce3
-    flattens expression and collects all factors
-=end
-
-def reduce3
-    @ptree = ptree.reduce3
-    @string = nil
-    self
-end
-
-=begin
---- reduce4
-    collects terms with the same name
-=end
-
-def reduce4
-    @ptree = ptree.reduce4
-    @string = nil
-    self
-end
-
-=begin
---- reduce5
-    expands all terms recursively
-=end
-
-def reduce5
-    @ptree = ptree.reduce5
-    @string = nil
-    self
-end
-
-attr_reader :string
-
-def to_s
-    @string = @ptree.to_s if @string.nil?
-    @string
-end
-
-def inspect
-    if @ptree.nil? then
-	"Units{#{@string}}"
-    else
-	"Units[#{@ptree.inspect}]".gsub(/Units::/, '').gsub(/Node\[/, '[')
-    end
-end
-
-def self::[](string)
-    new(string)
-end
-
-def self::parse(string)
-    new(string).parse!
-end
-
-def eval(x = 0)
-    r5 = ptree.reduce5
-    case r = r5.ref
-    when TimeNode
-	r.add(x, r5.name)
-    else
-	fac = NumberNode.new(x + r.value)
-	self.class.new(MulNode.new(fac, r5.deref))
-    end
-end
-
-def convert(numeric, to_units)
-    to_units = Units.new( to_units ) if to_units.is_a?(String)
-    r5 = dup.ptree.reduce5
-    case r = r5.ref
-    when TimeNode
-	r.add_time(r5.deref.mul(numeric)).div_time(to_units.ptree)
-    else
-	shift1 = r.value
-	numeric = shift1 + numeric if shift1 != 0
-	fact = r5.divide(tp = to_units.dup.ptree).reduce5.value
-	numeric *= fact if fact != 1
-	shift2 = tp.reduce5.ref.value
-	numeric = numeric - shift2 if shift2 != 0
-	numeric
-    end
-end
-
-def factor_and_offset(to_units)
-    # To convert a numeric from self to to_units: 
-    # scale_factor * numeric + add_offset
-    to_units = Units.new( to_units ) if to_units.is_a?(String)
-    add_offset = convert(0, to_units)
-    scale_factor = convert(1, to_units) - add_offset
-    [ scale_factor, add_offset ]
-end
-
-def convert2(val, to_units)
-    # Like Units#convert, but applicable to any Numeric-like objects.
-    # Returns the original value if the units are incompatible.
-    to_units = Units.new( to_units ) if to_units.is_a?(String)
-    if ( self == to_units )
-        val
-    elsif ( self =~ to_units )
-        if Numeric===val
-            convert( val, to_units )
-        else
-            factor, offset = factor_and_offset( to_units )
-            val*factor + offset
-        end
-    else
-      unless $VERBOSE.nil?
-	$stderr.print( "*WARNING*: " +
-                 "incompatible units: #{self.to_s} and #{to_units.to_s}\n")
-        caller(0).each{|c| $stderr.print "\t* ",c,"\n"}
-      end        
-      val
-    end
-end
-
-@@reduce = :reduce4
-
-def self::reduce_level
-    @@reduce.to_s[-1]
-end
-
-def self::reduce_level=(n)
-    @@reduce = case n
-    when 1 then :reduce1
-    when 2 then :reduce2
-    when 3 then :reduce3
-    when 4 then :reduce4
-    else :reduce5
-    end
-end
-
-def binop(op, other)
-    case other
-    when Numeric
-	other = NumberNode.new(other)
-    when Units
-	other = other.ptree
-    end
-    q = self.ptree.send(op, other).send(@@reduce)
-    Units.new(q)
-end
-
-def *(other)
-    binop(:mul, other)
-end
-
-def **(other)
-    binop(:pow, other)
-end
-
-def /(other)
-    binop(:divide, other)
-end
-
-def ^(other)
-    binop(:shift, other)
-end
-
-def ==(other)
-    case other
-    when self.class
-	dup.reduce5.to_s == other.dup.reduce5.to_s
-    else
-	false
-    end
-end
-
-#def === (other)
-#    reduce5.ptree.deref.to_s == other.reduce5.ptree.deref.to_s
-#end
-
-alias === ==
-
-#def === (other)
-#  # returns true if other is within a factor and/or offset of difference.
-#  case other
-#  when self.class
-#    (self/other).reduce5.ptree.children.each do |child|
-#      return false if !( NumberNode === child )
-#    end
-#    true
-#  else
-#    false
-#  end
-#end
-
-
-def =~(other)
-  case other
-  when self.class
-    (self/other).reduce5.ptree.children.each{ |node|
-      return false unless NumberNode === node
-    }
-    true
-  else
-    false
-  end
-end
-
-def self::pow_f(a, b)
-    if Integer === b and b < 0 then
-	a ** b.to_f
-    else
-	a ** b
-    end
-end
-
-##### racc 1.4.5 generates ###
-
-racc_reduce_table = [
- 0, 0, :racc_error,
- 0, 17, :_reduce_none,
- 1, 17, :_reduce_2,
- 1, 17, :_reduce_3,
- 1, 18, :_reduce_none,
- 3, 18, :_reduce_5,
- 3, 18, :_reduce_6,
- 1, 19, :_reduce_none,
- 1, 19, :_reduce_none,
- 2, 19, :_reduce_9,
- 3, 19, :_reduce_10,
- 3, 19, :_reduce_11,
- 3, 19, :_reduce_12,
- 3, 19, :_reduce_13,
- 1, 22, :_reduce_14,
- 2, 22, :_reduce_15,
- 3, 22, :_reduce_16,
- 3, 22, :_reduce_17,
- 1, 20, :_reduce_none,
- 3, 20, :_reduce_19,
- 1, 23, :_reduce_20,
- 1, 23, :_reduce_21,
- 1, 21, :_reduce_none,
- 3, 21, :_reduce_23,
- 1, 24, :_reduce_24,
- 2, 24, :_reduce_25,
- 3, 24, :_reduce_26 ]
-
-racc_reduce_n = 27
-
-racc_shift_n = 39
-
-racc_action_table = [
-     3,     4,    34,     4,    14,    22,    23,    36,     9,    10,
-     9,     4,    24,     5,     4,    26,    37,     4,     9,    10,
-     4,     9,    38,     5,     9,    10,    20,     9,     4,     5,
-   nil,     4,    20,   nil,   nil,     9,   nil,    24,     9,    10,
-    26,   nil,    16,     5,    17,    18,   nil,     4,    10,     4,
-   nil,     4,     5,    12,     9,    12,     9,    12,     9,     4,
-   nil,   nil,   nil,   nil,   nil,    12,     9 ]
-
-racc_action_check = [
-     0,     0,    24,    26,     6,    13,    14,    33,     0,     0,
-    26,     5,    26,     0,    20,    26,    34,    18,     5,     5,
-    12,    20,    35,     5,    18,    18,    20,    12,    16,    18,
-   nil,    17,    12,   nil,   nil,    16,   nil,    16,    17,    17,
-    16,   nil,     8,    17,     8,     8,   nil,    29,     8,    31,
-   nil,    15,     8,    29,    29,    31,    31,    15,    15,     1,
-   nil,   nil,   nil,   nil,   nil,     1,     1 ]
-
-racc_action_pointer = [
-    -1,    57,   nil,   nil,   nil,     9,     4,   nil,    38,   nil,
-   nil,   nil,    18,   -10,     6,    49,    26,    29,    15,   nil,
-    12,   nil,   nil,   nil,   -10,   nil,     1,   nil,   nil,    45,
-   nil,    47,   nil,    -8,     3,     7,   nil,   nil,   nil ]
-
-racc_action_default = [
-    -1,    -7,    -8,    -3,   -20,   -27,   -27,    -2,    -4,   -21,
-   -14,   -15,   -27,   -27,   -27,    -9,   -27,   -27,   -27,   -18,
-   -27,   -16,   -17,    39,   -24,   -22,   -27,    -5,    -6,   -10,
-   -12,   -11,   -13,   -27,   -25,   -27,   -19,   -26,   -23 ]
-
-racc_goto_table = [
-     2,    15,     7,    28,    21,     2,     6,    13,    27,   nil,
-    29,    31,    19,    35,   nil,   nil,    19,    30,    32,   nil,
-    19,   nil,   nil,   nil,   nil,   nil,    19 ]
-
-racc_goto_check = [
-     7,     6,     2,     5,     4,     7,     1,     2,     4,   nil,
-     6,     6,     7,     5,   nil,   nil,     7,     7,     7,   nil,
-     7,   nil,   nil,   nil,   nil,   nil,     7 ]
-
-racc_goto_pointer = [
-   nil,     6,     2,   nil,    -8,   -13,    -7,     0,   nil ]
-
-racc_goto_default = [
-   nil,   nil,   nil,     8,    33,   nil,     1,    11,    25 ]
-
-racc_token_table = {
- false => 0,
- Object.new => 1,
- :INT => 2,
- :ERR => 3,
- :SHIFT => 4,
- :SPACE => 5,
- :MULTIPLY => 6,
- :DIVIDE => 7,
- :EXPONENT => 8,
- :REAL => 9,
- :NAME => 10,
- :DATE => 11,
- :TIME => 12,
- :ZONE => 13,
- "(" => 14,
- ")" => 15 }
-
-racc_use_result_var = false
-
-racc_nt_base = 16
-
-Racc_arg = [
- racc_action_table,
- racc_action_check,
- racc_action_default,
- racc_action_pointer,
- racc_goto_table,
- racc_goto_check,
- racc_goto_default,
- racc_goto_pointer,
- racc_nt_base,
- racc_reduce_table,
- racc_token_table,
- racc_shift_n,
- racc_reduce_n,
- racc_use_result_var ]
-
-Racc_token_to_s_table = [
-'$end',
-'error',
-'INT',
-'ERR',
-'SHIFT',
-'SPACE',
-'MULTIPLY',
-'DIVIDE',
-'EXPONENT',
-'REAL',
-'NAME',
-'DATE',
-'TIME',
-'ZONE',
-'"("',
-'")"',
-'$start',
-'unit_spec',
-'origin_exp',
-'unit_exp',
-'value_exp',
-'timestamp',
-'power_exp',
-'number_exp',
-'time_exp']
-
-Racc_debug_parser = false
-
-##### racc system variables end #####
-
- # reduce 0 omitted
-
- # reduce 1 omitted
-
-  def _reduce_2( val, _values)
- yyaccept;
-  end
-
-  def _reduce_3( val, _values)
- yyerrok
-  end
-
- # reduce 4 omitted
-
-  def _reduce_5( val, _values)
- val[0].shift(val[2])
-  end
-
-  def _reduce_6( val, _values)
- val[0].shift(val[2])
-  end
-
- # reduce 7 omitted
-
- # reduce 8 omitted
-
-  def _reduce_9( val, _values)
- val[0].mul(val[1])
-  end
-
-  def _reduce_10( val, _values)
- val[0].mul(val[2])
-  end
-
-  def _reduce_11( val, _values)
- val[0].divide(val[2])
-  end
-
-  def _reduce_12( val, _values)
- val[0].mul(val[2])
-  end
-
-  def _reduce_13( val, _values)
- val[0].divide(val[2])
-  end
-
-  def _reduce_14( val, _values)
- NameNode.new(val[0])
-  end
-
-  def _reduce_15( val, _values)
- val[0].pow(val[1])
-  end
-
-  def _reduce_16( val, _values)
- val[0].pow(val[2])
-  end
-
-  def _reduce_17( val, _values)
- val[1]
-  end
-
- # reduce 18 omitted
-
-  def _reduce_19( val, _values)
- val[1]
-  end
-
-  def _reduce_20( val, _values)
- NumberNode.new(val[0])
-  end
-
-  def _reduce_21( val, _values)
- NumberNode.new(val[0])
-  end
-
- # reduce 22 omitted
-
-  def _reduce_23( val, _values)
- val[1]
-  end
-
-  def _reduce_24( val, _values)
- TimeNode.new(val[0], 0.0, 0)
-  end
-
-  def _reduce_25( val, _values)
- TimeNode.new(val[0], val[1], 0)
-  end
-
-  def _reduce_26( val, _values)
- TimeNode.new(val[0], val[1], val[2])
-  end
-
- def _reduce_none( val, _values)
-  val[0]
- end
-
-end   # class Units
-end   # module NumRu
-
-####################
-if $0 == __FILE__
-  include NumRu
-  
-  def assert(test, seikai)
-  	raise "#{test.inspect} != #{seikai.inspect}" if test != seikai
-  	puts "ok #{seikai.inspect}"
-  end
-  
-  puts "=== reduce1 ==="
-  
-  assert Units.new('').reduce1.to_s, ""
-  assert Units.new('m').reduce1.to_s, "m"
-  assert Units.new('3').reduce1.to_s, "3"
-  assert Units.new('3.14').reduce1.to_s, "3.14"
-  assert Units.new('m2').reduce1.to_s, "m2"
-  assert Units.new('m.s').reduce1.to_s, "m.s"
-  assert Units.new('m/s').reduce1.to_s, "m.s-1"
-  assert Units.new('kg.m/s2').reduce1.to_s, "kg.m.(s2)-1"
-  assert Units.new('s @ 2003-11-29').reduce1.to_s,
-  	"(s @ 2003-11-29T00:00:00.00 +00:00)"
-  assert Units.new('s @ 2003-11-29T11:24').reduce1.to_s,
-  	"(s @ 2003-11-29T11:24:00.00 +00:00)"
-  assert Units.new('s @ 2003-11-29T11:24:11 -09:00').reduce1.to_s,
-  	"(s @ 2003-11-29T11:24:11.00 -09:00)"
-  
-  assert Units.new('100').reduce1.to_s, "100"
-  assert Units.new('(10)^2').reduce1.to_s, "(10)2"
-  assert Units.new('(10)^2/100').reduce1.to_s, "(10)2.(100)-1"
-  
-  puts "=== reduce2 ==="
-  
-  assert Units.new('s @ 2003-11-29').reduce2.to_s,
-  	"(s @ 2003-11-29T00:00:00.00 +00:00)"
-  assert Units.new('m/(s @ 2003-11-29)').reduce2.to_s, "m.s-1"
-  assert Units.new('m/((K @ 273.15) (s from 2003-11-29))').reduce2.to_s, "m.(K.s)-1"
-  
-  assert Units.new('(10)^2/100').reduce2.to_s, "(10)2.(100)-1"
-  
-  puts "=== reduce3 ==="
-  
-  assert Units::MultiNode.new(Units::NameNode.new('a'),  \
-  	Units::NumberNode.new(1), \
-  	Units::NameNode.new('b')).to_s, 'a.1 b'
-  
-  assert Units.new('kg').reduce3.inspect, "Units[Name[kg]]"
-  assert Units.new('kg.m').reduce3.inspect, "Units[Multi[Name[kg], Name[m]]]"
-  assert Units.new('kg.m.s').reduce3.inspect,
-  	"Units[Multi[Name[kg], Name[m], Name[s]]]"
-  
-  assert Units.new('(m.s)^2').reduce3.inspect,
-  	"Units[Multi[Pow[Name[m], Number[2]], Pow[Name[s], Number[2]]]]"
-  assert Units.new('K @ 273.15').reduce3.inspect,
-  	"Units[Shift[Name[K], Number[273.15]]]"
-  assert Units.new('((a.b)^2)^2').reduce3.inspect,
-  	"Units[Multi[Pow[Name[a], Number[4]], Pow[Name[b], Number[4]]]]"
-  assert Units.new('((a.b)^2 c4 d)^2').reduce3.inspect,
-  	"Units[Multi[Pow[Name[a], Number[4]], Pow[Name[b], Number[4]], Pow[Name[c], Number[8]], Pow[Name[d], Number[2]]]]"
-  assert Units.new('((a.b)^2 c4 d)^2').reduce3.to_s,
-  	"a4 b4 c8 d2"
-  assert Units.new('((a.b)^2 a4 b)^2').reduce3.to_s,
-  	"a4 b4 a8 b2"
-  
-  assert Units.new('s @ 2003-11-29').reduce3.to_s,
-  	"(s @ 2003-11-29T00:00:00.00 +00:00)"
-  assert Units.new('m/(s @ 2003-11-29)').reduce3.to_s, "m.s-1"
-  assert Units.new('m/((K @ 273.15) (s from 2003-11-29))').reduce3.to_s, "m.K-1 s-1"
-  
-  assert Units.new('(10)^2/100').reduce3.to_s, "(10)2.(100)-1"
-  
-  puts "=== reduce4 ==="
-  
-  assert Units.new('((a.b)^2 a4 b @ now)^2 @ 273.15').reduce4.to_s,
-  	"(a12 b6 @ 273.15)"
-  
-  assert Units.new('km2').reduce4.to_s, "km2"
-  assert Units.new('hours.hour').reduce4.to_s, "hour2"
-  assert Units.new('(10)^2').reduce4.to_s, "100"
-  assert Units.new('100/10').reduce4.to_s, "10.0"
-  assert Units.new('(10)^2/100').reduce4.to_s, "1.0"
-  
-  puts "=== reduce5 ==="
-  
-  assert Units.new('km2').reduce5.to_s, "1000000 m2"
-  assert Units.new('(10)^2/100').reduce5.to_s, "1.0"
-  
-  assert Units.new('hPa').reduce5.to_s, "100 kg.m-1 s-2"
-  assert Units.new('mb').reduce5.to_s, "100.0 kg.m-1 s-2"
-  
-  assert Units.new('hPa/mb').reduce5.to_s, "1.0"
-  
-  assert Units.new('(K @ 273.15)@ 10').reduce5.to_s, "(K @ 283.15)"
-  
-  puts "=== APPLICATIONS ==="
-  
-  assert Units.new('km @ 2').convert(3, Units.new('m @ 100')), 4900
-  assert Units.new('degree_F').convert(32, Units.new('K')).to_s, "273.15"
-  
-  u1 = Units.new('m/s')
-  u2 = Units.new('mm/s')
-  assert((u1/u2).to_s, "m.mm-1")
-  assert((u1*u2).to_s, "m.mm.s-2")
-  
-  u1 = Units.new('years since 1999-01-01 00:00').reduce4
-  u2 = Units.new('hours since 2001-01-01 00:00').reduce4
-  assert u1.convert(3, u2), 24 * 365
-  u3 = Units.new('months since 2001-01-01 00:00').reduce4
-  assert u1.convert(3, u3), 12.0
-  
-  Units.reduce_level = 3
-  assert((Units.new('hours') ** 2).to_s, "hours2")
-  Units.reduce_level = 4
-  assert((Units.new('hours') ** 2).to_s, "hour2")
-  Units.reduce_level = 5
-  assert((Units.new('hours') ** 2).to_s, "12960000 s2")
-  
-  assert(Units.new('day') =~ Units.new('s since 2002-01-01'), true)
-  assert(Units.new('m') =~ Units.new('1'), false)
-  
-  un1  = Units['day since 2000-01-01']
-  un2 = Units['s since 2000-01-01']
-  assert(un1.convert(0, un2), 0.0)
-  assert(un1.convert(1, un2), 86400.0)
-end
+require "numru/units/version"
+require "numru/units/units.rb"