glue/glue_point.cpp

Go to the documentation of this file.

#include <basix/int.hpp>
#include <basix/vector.hpp>
#include <basix/port.hpp>
#include <basix/literal.hpp>
#include <numerix/integer.hpp>
#include <numerix/modular.hpp>
#include <numerix/modular_integer.hpp>
#include <numerix/rational.hpp>
#include <numerix/floating.hpp>
#include <shape/axel_glue.hpp>
#include <shape/point_glue.hpp>
#include <basix/tuple.hpp>
#include <basix/alias.hpp>
#include <basix/glue.hpp>

#define int_literal(x) as_int (as_string (x))
#define is_generic_literal is<literal>
#define gen_literal_apply(f,v) gen (as<generic> (f), v)
#define gen_literal_access(f,v) access (as<generic> (f), v)
#define shape_point shape::point

namespace mmx {
  static int
  GLUE_1 (const literal &arg_1) {
    return int_literal (arg_1);
  }
  
  static int
  GLUE_2 (const string &arg_1) {
    return as_int (arg_1);
  }
  
  static string
  GLUE_3 (const int &arg_1) {
    return as_string (arg_1);
  }
  
  static string
  GLUE_4 (const int &arg_1) {
    return as_string_hexa (arg_1);
  }
  
  static int
  GLUE_5 (const int &arg_1) {
    return -arg_1;
  }
  
  static int
  GLUE_6 (const int &arg_1) {
    return square (arg_1);
  }
  
  static int
  GLUE_7 (const int &arg_1, const int &arg_2) {
    return arg_1 + arg_2;
  }
  
  static int
  GLUE_8 (const int &arg_1, const int &arg_2) {
    return arg_1 - arg_2;
  }
  
  static int
  GLUE_9 (const int &arg_1, const int &arg_2) {
    return arg_1 * arg_2;
  }
  
  static int
  GLUE_10 (const int &arg_1, const int &arg_2) {
    return arg_1 / arg_2;
  }
  
  static int
  GLUE_11 (const int &arg_1, const int &arg_2) {
    return quo (arg_1, arg_2);
  }
  
  static int
  GLUE_12 (const int &arg_1, const int &arg_2) {
    return rem (arg_1, arg_2);
  }
  
  static bool
  GLUE_13 (const int &arg_1, const int &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_14 (const int &arg_1, const int &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_15 (const int &arg_1, const int &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_16 (const int &arg_1, const int &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_17 (const int &arg_1, const int &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_18 (const int &arg_1, const int &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static int
  GLUE_19 (const int &arg_1) {
    return sign (arg_1);
  }
  
  static int
  GLUE_20 (const int &arg_1) {
    return abs (arg_1);
  }
  
  static int
  GLUE_21 (const int &arg_1, const int &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static int
  GLUE_22 (const int &arg_1, const int &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static int
  GLUE_23 (const int &arg_1, const int &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static int
  GLUE_24 (const int &arg_1, const int &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static int
  GLUE_25 (const int &arg_1, const int &arg_2) {
    return arg_1 & arg_2;
  }
  
  static int
  GLUE_26 (const int &arg_1, const int &arg_2) {
    return arg_1 | arg_2;
  }
  
  static int
  GLUE_27 (const int &arg_1, const int &arg_2) {
    return arg_1 ^ arg_2;
  }
  
  static int
  GLUE_28 (const int &arg_1) {
    return floor_sqrt (arg_1);
  }
  
  static bool
  GLUE_29 (const int &arg_1, const int &arg_2) {
    return divides (arg_1, arg_2);
  }
  
  static int
  GLUE_30 () {
    return rand ();
  }
  
  static bool
  GLUE_31 (const generic &arg_1) {
    return is_vector (arg_1);
  }
  
  static vector<generic>
  GLUE_32 (const tuple<generic> &arg_1) {
    return vector<generic > (as_vector (arg_1));
  }
  
  static vector<generic>
  GLUE_33 (const tuple<generic> &arg_1) {
    return vector<generic > (as_vector (arg_1));
  }
  
  static iterator<generic>
  GLUE_34 (const vector<generic> &arg_1) {
    return iterate (arg_1);
  }
  
  static int
  GLUE_35 (const vector<generic> &arg_1) {
    return N (arg_1);
  }
  
  static generic
  GLUE_36 (const vector<generic> &arg_1, const int &arg_2) {
    return arg_1[arg_2];
  }
  
  static alias<generic>
  GLUE_37 (const alias<vector<generic> > &arg_1, const int &arg_2) {
    return alias_access<generic > (arg_1, arg_2);
  }
  
  static vector<generic>
  GLUE_38 (const vector<generic> &arg_1, const int &arg_2, const int &arg_3) {
    return range (arg_1, arg_2, arg_3);
  }
  
  static vector<generic>
  GLUE_39 (const vector<generic> &arg_1) {
    return reverse (arg_1);
  }
  
  static vector<generic>
  GLUE_40 (const vector<generic> &arg_1, const vector<generic> &arg_2) {
    return append (arg_1, arg_2);
  }
  
  static alias<vector<generic> >
  GLUE_41 (const alias<vector<generic> > &arg_1, const vector<generic> &arg_2) {
    return alias_write (arg_1, arg_2);
  }
  
  static vector<generic>
  GLUE_42 (const generic &arg_1, const vector<generic> &arg_2) {
    return cons (arg_1, arg_2);
  }
  
  static generic
  GLUE_43 (const vector<generic> &arg_1) {
    return car (arg_1);
  }
  
  static vector<generic>
  GLUE_44 (const vector<generic> &arg_1) {
    return cdr (arg_1);
  }
  
  static bool
  GLUE_45 (const vector<generic> &arg_1) {
    return is_nil (arg_1);
  }
  
  static bool
  GLUE_46 (const vector<generic> &arg_1) {
    return is_atom (arg_1);
  }
  
  static vector<generic>
  GLUE_47 (const vector<generic> &arg_1, const generic &arg_2) {
    return insert (arg_1, arg_2);
  }
  
  static int
  GLUE_48 (const vector<generic> &arg_1, const generic &arg_2) {
    return find (arg_1, arg_2);
  }
  
  static bool
  GLUE_49 (const vector<generic> &arg_1, const generic &arg_2) {
    return contains (arg_1, arg_2);
  }
  
  static bool
  GLUE_50 (const generic &arg_1) {
    return generic_is_string (arg_1);
  }
  
  static int
  GLUE_51 (const string &arg_1) {
    return N (arg_1);
  }
  
  static string
  GLUE_52 (const string &arg_1, const int &arg_2, const int &arg_3) {
    return arg_1 (arg_2, arg_3);
  }
  
  static string
  GLUE_53 (const string &arg_1, const string &arg_2) {
    return arg_1 * arg_2;
  }
  
  static string
  GLUE_54 (const string &arg_1, const string &arg_2) {
    return arg_1 * arg_2;
  }
  
  static alias<string>
  GLUE_55 (const alias<string> &arg_1, const string &arg_2) {
    return alias_write (arg_1, arg_2);
  }
  
  static bool
  GLUE_56 (const string &arg_1, const string &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_57 (const string &arg_1, const string &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_58 (const string &arg_1, const string &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_59 (const string &arg_1, const string &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static bool
  GLUE_60 (const string &arg_1, const string &arg_2) {
    return starts (arg_1, arg_2);
  }
  
  static bool
  GLUE_61 (const string &arg_1, const string &arg_2) {
    return ends (arg_1, arg_2);
  }
  
  static string
  GLUE_62 (const string &arg_1, const string &arg_2, const string &arg_3) {
    return replace (arg_1, arg_2, arg_3);
  }
  
  static int
  GLUE_63 (const string &arg_1, const string &arg_2, const int &arg_3) {
    return search_forwards (arg_1, arg_2, arg_3);
  }
  
  static int
  GLUE_64 (const string &arg_1, const string &arg_2, const int &arg_3) {
    return search_backwards (arg_1, arg_2, arg_3);
  }
  
  static string
  GLUE_65 (const string &arg_1) {
    return upcase (arg_1);
  }
  
  static string
  GLUE_66 (const string &arg_1) {
    return locase (arg_1);
  }
  
  static string
  GLUE_67 (const string &arg_1) {
    return upcase_first (arg_1);
  }
  
  static string
  GLUE_68 (const string &arg_1) {
    return locase_first (arg_1);
  }
  
  static string
  GLUE_69 (const string &arg_1) {
    return quote (arg_1);
  }
  
  static string
  GLUE_70 (const string &arg_1) {
    return unquote (arg_1);
  }
  
  static string
  GLUE_71 (const int &arg_1) {
    return charcode_as_string (arg_1);
  }
  
  static int
  GLUE_72 (const string &arg_1) {
    return string_as_charcode (arg_1);
  }
  
  static bool
  GLUE_73 (const generic &arg_1) {
    return is_generic_literal (arg_1);
  }
  
  static generic
  GLUE_74 (const literal &arg_1, const tuple<generic> &arg_2) {
    return gen_literal_apply (arg_1, as_vector (arg_2));
  }
  
  static generic
  GLUE_75 (const literal &arg_1, const tuple<generic> &arg_2) {
    return gen_literal_access (arg_1, as_vector (arg_2));
  }
  
  static literal
  GLUE_76 (const string &arg_1) {
    return literal (arg_1);
  }
  
  static string
  GLUE_77 (const literal &arg_1) {
    return *arg_1;
  }
  
  static integer
  GLUE_78 (const literal &arg_1) {
    return make_literal_integer (arg_1);
  }
  
  static integer
  GLUE_79 (const int &arg_1) {
    return integer (arg_1);
  }
  
  static integer
  GLUE_80 (const int &arg_1) {
    return integer (arg_1);
  }
  
  static bool
  GLUE_81 (const integer &arg_1) {
    return is_int (arg_1);
  }
  
  static int
  GLUE_82 (const integer &arg_1) {
    return as_int (arg_1);
  }
  
  static integer
  GLUE_83 (const string &arg_1) {
    return integer (arg_1);
  }
  
  static string
  GLUE_84 (const integer &arg_1) {
    return as_string (arg_1);
  }
  
  static generic
  GLUE_85 (const int &arg_1) {
    return integer_construct (arg_1);
  }
  
  static int
  GLUE_86 (const integer &arg_1) {
    return as_int (arg_1);
  }
  
  static integer
  GLUE_87 (const integer &arg_1) {
    return -arg_1;
  }
  
  static integer
  GLUE_88 (const integer &arg_1) {
    return square (arg_1);
  }
  
  static integer
  GLUE_89 (const integer &arg_1, const integer &arg_2) {
    return arg_1 + arg_2;
  }
  
  static integer
  GLUE_90 (const integer &arg_1, const integer &arg_2) {
    return arg_1 - arg_2;
  }
  
  static integer
  GLUE_91 (const integer &arg_1, const integer &arg_2) {
    return arg_1 * arg_2;
  }
  
  static integer
  GLUE_92 (const integer &arg_1, const integer &arg_2) {
    return arg_1 / arg_2;
  }
  
  static integer
  GLUE_93 (const integer &arg_1, const integer &arg_2) {
    return quo (arg_1, arg_2);
  }
  
  static integer
  GLUE_94 (const integer &arg_1, const integer &arg_2) {
    return rem (arg_1, arg_2);
  }
  
  static bool
  GLUE_95 (const integer &arg_1, const integer &arg_2) {
    return divides (arg_1, arg_2);
  }
  
  static integer
  GLUE_96 (const integer &arg_1, const integer &arg_2) {
    return gcd (arg_1, arg_2);
  }
  
  static integer
  GLUE_97 (const integer &arg_1, const integer &arg_2) {
    return lcm (arg_1, arg_2);
  }
  
  static bool
  GLUE_98 (const integer &arg_1, const integer &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_99 (const integer &arg_1, const integer &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_100 (const integer &arg_1, const integer &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_101 (const integer &arg_1, const integer &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_102 (const integer &arg_1, const integer &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_103 (const integer &arg_1, const integer &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static int
  GLUE_104 (const integer &arg_1) {
    return sign (arg_1);
  }
  
  static integer
  GLUE_105 (const integer &arg_1) {
    return abs (arg_1);
  }
  
  static integer
  GLUE_106 (const integer &arg_1, const integer &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static integer
  GLUE_107 (const integer &arg_1, const integer &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static integer
  GLUE_108 (const integer &arg_1, const integer &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static integer
  GLUE_109 (const integer &arg_1, const integer &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static integer
  GLUE_110 (const integer &arg_1) {
    return factorial (arg_1);
  }
  
  static integer
  GLUE_111 (const integer &arg_1, const integer &arg_2) {
    return binomial (arg_1, arg_2);
  }
  
  static bool
  GLUE_112 (const integer &arg_1) {
    return is_probable_prime (arg_1);
  }
  
  static integer
  GLUE_113 (const integer &arg_1) {
    return probable_next_prime (arg_1);
  }
  
  static integer
  GLUE_114 (const integer &arg_1, const integer &arg_2) {
    return arg_1 & arg_2;
  }
  
  static integer
  GLUE_115 (const integer &arg_1, const integer &arg_2) {
    return arg_1 | arg_2;
  }
  
  static integer
  GLUE_116 (const integer &arg_1, const integer &arg_2) {
    return arg_1 ^ arg_2;
  }
  
  static integer
  GLUE_117 (const integer &arg_1) {
    return ~arg_1;
  }
  
  static int
  GLUE_118 (const integer &arg_1) {
    return bit_size (arg_1);
  }
  
  static bool
  GLUE_119 (const integer &arg_1, const int &arg_2) {
    return arg_1[arg_2];
  }
  
  static int
  GLUE_120 (const integer &arg_1) {
    return hamming_norm (arg_1);
  }
  
  static int
  GLUE_121 (const integer &arg_1, const integer &arg_2) {
    return hamming_distance (arg_1, arg_2);
  }
  
  static integer
  GLUE_122 (const integer &arg_1, const int &arg_2) {
    return arg_1 + arg_2;
  }
  
  static integer
  GLUE_123 (const integer &arg_1, const int &arg_2) {
    return arg_1 - arg_2;
  }
  
  static integer
  GLUE_124 (const integer &arg_1, const int &arg_2) {
    return arg_1 * arg_2;
  }
  
  static integer
  GLUE_125 (const int &arg_1, const integer &arg_2) {
    return arg_1 + arg_2;
  }
  
  static integer
  GLUE_126 (const int &arg_1, const integer &arg_2) {
    return arg_1 - arg_2;
  }
  
  static integer
  GLUE_127 (const int &arg_1, const integer &arg_2) {
    return arg_1 * arg_2;
  }
  
  static integer
  GLUE_128 (const integer &arg_1, const int &arg_2) {
    return arg_1 / arg_2;
  }
  
  static integer
  GLUE_129 (const integer &arg_1, const int &arg_2) {
    return quo (arg_1, arg_2);
  }
  
  static integer
  GLUE_130 (const integer &arg_1, const int &arg_2) {
    return rem (arg_1, arg_2);
  }
  
  static bool
  GLUE_131 (const integer &arg_1, const int &arg_2) {
    return divides (arg_1, arg_2);
  }
  
  static integer
  GLUE_132 (const int &arg_1, const integer &arg_2) {
    return arg_1 / arg_2;
  }
  
  static integer
  GLUE_133 (const int &arg_1, const integer &arg_2) {
    return quo (arg_1, arg_2);
  }
  
  static integer
  GLUE_134 (const int &arg_1, const integer &arg_2) {
    return rem (arg_1, arg_2);
  }
  
  static bool
  GLUE_135 (const int &arg_1, const integer &arg_2) {
    return divides (arg_1, arg_2);
  }
  
  static bool
  GLUE_136 (const integer &arg_1, const int &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_137 (const integer &arg_1, const int &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_138 (const integer &arg_1, const int &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_139 (const integer &arg_1, const int &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_140 (const integer &arg_1, const int &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_141 (const integer &arg_1, const int &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static bool
  GLUE_142 (const int &arg_1, const integer &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_143 (const int &arg_1, const integer &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_144 (const int &arg_1, const integer &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_145 (const int &arg_1, const integer &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_146 (const int &arg_1, const integer &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_147 (const int &arg_1, const integer &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static integer
  GLUE_148 (const integer &arg_1, const int &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static integer
  GLUE_149 (const integer &arg_1, const int &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static integer
  GLUE_150 (const int &arg_1, const integer &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static integer
  GLUE_151 (const int &arg_1, const integer &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static integer
  GLUE_152 (const integer &arg_1, const int &arg_2) {
    return arg_1 & arg_2;
  }
  
  static integer
  GLUE_153 (const integer &arg_1, const int &arg_2) {
    return arg_1 | arg_2;
  }
  
  static integer
  GLUE_154 (const integer &arg_1, const int &arg_2) {
    return arg_1 ^ arg_2;
  }
  
  static integer
  GLUE_155 (const int &arg_1, const integer &arg_2) {
    return arg_1 & arg_2;
  }
  
  static integer
  GLUE_156 (const int &arg_1, const integer &arg_2) {
    return arg_1 | arg_2;
  }
  
  static integer
  GLUE_157 (const int &arg_1, const integer &arg_2) {
    return arg_1 ^ arg_2;
  }
  
  static modulus<int>
  GLUE_158 (const int &arg_1) {
    return modulus<int > (arg_1);
  }
  
  static modulus<int>
  GLUE_159 (const int &arg_1) {
    return modulus<int > (arg_1);
  }
  
  static int
  GLUE_160 (const modulus<int> &arg_1) {
    return *arg_1;
  }
  
  static mmx_modular(int)
  GLUE_161 (const int &arg_1, const int &arg_2) {
    return (mmx_modular(int ) (arg_1, arg_2));
  }
  
  static mmx_modular(int)
  GLUE_162 (const int &arg_1, const modulus<int> &arg_2) {
    return (mmx_modular(int ) (arg_1, arg_2));
  }
  
  static mmx_modular(int)
  GLUE_163 (const int &arg_1, const modulus<int> &arg_2) {
    return (mmx_modular(int ) (arg_1, arg_2));
  }
  
  static modulus<int>
  GLUE_164 (const mmx_modular(int) &arg_1) {
    return get_modulus (arg_1);
  }
  
  static int
  GLUE_165 (const mmx_modular(int) &arg_1) {
    return *arg_1;
  }
  
  static mmx_modular(int)
  GLUE_166 (const mmx_modular(int) &arg_1) {
    return -arg_1;
  }
  
  static mmx_modular(int)
  GLUE_167 (const mmx_modular(int) &arg_1) {
    return square (arg_1);
  }
  
  static mmx_modular(int)
  GLUE_168 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(int)
  GLUE_169 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(int)
  GLUE_170 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(int)
  GLUE_171 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(int)
  GLUE_172 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(int)
  GLUE_173 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(int)
  GLUE_174 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(int)
  GLUE_175 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(int)
  GLUE_176 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(int)
  GLUE_177 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(int)
  GLUE_178 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(int)
  GLUE_179 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(int)
  GLUE_180 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return binpow (arg_1, arg_2);
  }
  
  static mmx_modular(int)
  GLUE_181 (const mmx_modular(int) &arg_1, const integer &arg_2) {
    return binpow (arg_1, arg_2);
  }
  
  static bool
  GLUE_182 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_183 (const mmx_modular(int) &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_184 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_185 (const mmx_modular(int) &arg_1, const int &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_186 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_187 (const int &arg_1, const mmx_modular(int) &arg_2) {
    return arg_1 != arg_2;
  }
  
  static modulus<integer>
  GLUE_188 (const integer &arg_1) {
    return modulus<integer > (arg_1);
  }
  
  static modulus<integer>
  GLUE_189 (const integer &arg_1) {
    return modulus<integer > (arg_1);
  }
  
  static integer
  GLUE_190 (const modulus<integer> &arg_1) {
    return *arg_1;
  }
  
  static mmx_modular(integer)
  GLUE_191 (const integer &arg_1, const integer &arg_2) {
    return (mmx_modular(integer ) (arg_1, arg_2));
  }
  
  static mmx_modular(integer)
  GLUE_192 (const integer &arg_1, const modulus<integer> &arg_2) {
    return (mmx_modular(integer ) (arg_1, arg_2));
  }
  
  static mmx_modular(integer)
  GLUE_193 (const integer &arg_1, const modulus<integer> &arg_2) {
    return (mmx_modular(integer ) (arg_1, arg_2));
  }
  
  static modulus<integer>
  GLUE_194 (const mmx_modular(integer) &arg_1) {
    return get_modulus (arg_1);
  }
  
  static integer
  GLUE_195 (const mmx_modular(integer) &arg_1) {
    return *arg_1;
  }
  
  static mmx_modular(integer)
  GLUE_196 (const mmx_modular(integer) &arg_1) {
    return -arg_1;
  }
  
  static mmx_modular(integer)
  GLUE_197 (const mmx_modular(integer) &arg_1) {
    return square (arg_1);
  }
  
  static mmx_modular(integer)
  GLUE_198 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_199 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_200 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_201 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_202 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_203 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_204 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_205 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_206 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_207 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_208 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_209 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_modular(integer)
  GLUE_210 (const mmx_modular(integer) &arg_1, const int &arg_2) {
    return binpow (arg_1, arg_2);
  }
  
  static mmx_modular(integer)
  GLUE_211 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return binpow (arg_1, arg_2);
  }
  
  static bool
  GLUE_212 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_213 (const mmx_modular(integer) &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_214 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_215 (const mmx_modular(integer) &arg_1, const integer &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_216 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_217 (const integer &arg_1, const mmx_modular(integer) &arg_2) {
    return arg_1 != arg_2;
  }
  
  static rational
  GLUE_218 (const integer &arg_1) {
    return rational (arg_1);
  }
  
  static rational
  GLUE_219 (const integer &arg_1, const integer &arg_2) {
    return rational_new (arg_1, arg_2);
  }
  
  static rational
  GLUE_220 (const int &arg_1) {
    return rational (arg_1);
  }
  
  static rational
  GLUE_221 (const integer &arg_1) {
    return rational (arg_1);
  }
  
  static double
  GLUE_222 (const rational &arg_1) {
    return as_double (arg_1);
  }
  
  static rational
  GLUE_223 (const integer &arg_1, const integer &arg_2) {
    return rational_new (arg_1, arg_2);
  }
  
  static integer
  GLUE_224 (const rational &arg_1) {
    return numerator (arg_1);
  }
  
  static integer
  GLUE_225 (const rational &arg_1) {
    return denominator (arg_1);
  }
  
  static bool
  GLUE_226 (const rational &arg_1) {
    return is_integer (arg_1);
  }
  
  static rational
  GLUE_227 (const rational &arg_1) {
    return -arg_1;
  }
  
  static rational
  GLUE_228 (const rational &arg_1) {
    return square (arg_1);
  }
  
  static rational
  GLUE_229 (const rational &arg_1, const rational &arg_2) {
    return arg_1 + arg_2;
  }
  
  static rational
  GLUE_230 (const rational &arg_1, const rational &arg_2) {
    return arg_1 - arg_2;
  }
  
  static rational
  GLUE_231 (const rational &arg_1, const rational &arg_2) {
    return arg_1 * arg_2;
  }
  
  static rational
  GLUE_232 (const rational &arg_1, const rational &arg_2) {
    return arg_1 / arg_2;
  }
  
  static rational
  GLUE_233 (const rational &arg_1, const integer &arg_2) {
    return arg_1 + arg_2;
  }
  
  static rational
  GLUE_234 (const rational &arg_1, const integer &arg_2) {
    return arg_1 - arg_2;
  }
  
  static rational
  GLUE_235 (const rational &arg_1, const integer &arg_2) {
    return arg_1 * arg_2;
  }
  
  static rational
  GLUE_236 (const rational &arg_1, const integer &arg_2) {
    return arg_1 / arg_2;
  }
  
  static rational
  GLUE_237 (const integer &arg_1, const rational &arg_2) {
    return arg_1 + arg_2;
  }
  
  static rational
  GLUE_238 (const integer &arg_1, const rational &arg_2) {
    return arg_1 - arg_2;
  }
  
  static rational
  GLUE_239 (const integer &arg_1, const rational &arg_2) {
    return arg_1 * arg_2;
  }
  
  static rational
  GLUE_240 (const integer &arg_1, const rational &arg_2) {
    return arg_1 / arg_2;
  }
  
  static generic
  GLUE_241 (const integer &arg_1, const integer &arg_2) {
    return old_integer_pow (arg_1, arg_2);
  }
  
  static rational
  GLUE_242 (const rational &arg_1, const integer &arg_2) {
    return pow (arg_1, arg_2);
  }
  
  static rational
  GLUE_243 (const rational &arg_1, const rational &arg_2) {
    return arg_1 / arg_2;
  }
  
  static bool
  GLUE_244 (const rational &arg_1, const rational &arg_2) {
    return divides (arg_1, arg_2);
  }
  
  static rational
  GLUE_245 (const rational &arg_1, const rational &arg_2) {
    return gcd (arg_1, arg_2);
  }
  
  static rational
  GLUE_246 (const rational &arg_1, const rational &arg_2) {
    return lcm (arg_1, arg_2);
  }
  
  static bool
  GLUE_247 (const rational &arg_1, const rational &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_248 (const rational &arg_1, const rational &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_249 (const rational &arg_1, const rational &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_250 (const rational &arg_1, const rational &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_251 (const rational &arg_1, const rational &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_252 (const rational &arg_1, const rational &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static bool
  GLUE_253 (const rational &arg_1, const integer &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_254 (const rational &arg_1, const integer &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_255 (const rational &arg_1, const integer &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_256 (const rational &arg_1, const integer &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_257 (const rational &arg_1, const integer &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_258 (const rational &arg_1, const integer &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static bool
  GLUE_259 (const integer &arg_1, const rational &arg_2) {
    return arg_1 == arg_2;
  }
  
  static bool
  GLUE_260 (const integer &arg_1, const rational &arg_2) {
    return arg_1 != arg_2;
  }
  
  static bool
  GLUE_261 (const integer &arg_1, const rational &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_262 (const integer &arg_1, const rational &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_263 (const integer &arg_1, const rational &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_264 (const integer &arg_1, const rational &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static int
  GLUE_265 (const rational &arg_1) {
    return sign (arg_1);
  }
  
  static rational
  GLUE_266 (const rational &arg_1) {
    return abs (arg_1);
  }
  
  static rational
  GLUE_267 (const rational &arg_1, const rational &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_268 (const rational &arg_1, const rational &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_269 (const rational &arg_1, const integer &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_270 (const rational &arg_1, const integer &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_271 (const integer &arg_1, const rational &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_272 (const integer &arg_1, const rational &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_273 (const rational &arg_1, const rational &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_274 (const rational &arg_1, const rational &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_275 (const rational &arg_1, const integer &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_276 (const rational &arg_1, const integer &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_277 (const integer &arg_1, const rational &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static rational
  GLUE_278 (const integer &arg_1, const rational &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static rational
  GLUE_279 (const rational &arg_1) {
    return floor (arg_1);
  }
  
  static rational
  GLUE_280 (const rational &arg_1) {
    return ceil (arg_1);
  }
  
  static rational
  GLUE_281 (const rational &arg_1) {
    return trunc (arg_1);
  }
  
  static rational
  GLUE_282 (const rational &arg_1) {
    return round (arg_1);
  }
  
  static rational
  GLUE_283 (const mmx_modular(int) &arg_1) {
    return reconstruct (arg_1);
  }
  
  static rational
  GLUE_284 (const mmx_modular(integer) &arg_1) {
    return reconstruct (arg_1);
  }
  
  static mmx_floating
  GLUE_285 (const literal &arg_1) {
    return make_literal_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_286 (const int &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_287 (const integer &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_288 (const rational &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_289 (const int &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_290 (const double &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_291 (const integer &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_292 (const rational &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static mmx_floating
  GLUE_293 (const string &arg_1) {
    return mmx_floating (arg_1);
  }
  
  static int
  GLUE_294 (const mmx_floating &arg_1) {
    return as_int (arg_1);
  }
  
  static double
  GLUE_295 (const mmx_floating &arg_1) {
    return as_double (arg_1);
  }
  
  static integer
  GLUE_296 (const mmx_floating &arg_1) {
    return as_integer (arg_1);
  }
  
  static string
  GLUE_297 (const mmx_floating &arg_1) {
    return as_string (arg_1);
  }
  
  static mmx_floating
  GLUE_298 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return uniform_deviate (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_299 (const mmx_floating &arg_1) {
    return -arg_1;
  }
  
  static mmx_floating
  GLUE_300 (const mmx_floating &arg_1) {
    return square (arg_1);
  }
  
  static mmx_floating
  GLUE_301 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 + arg_2;
  }
  
  static mmx_floating
  GLUE_302 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 - arg_2;
  }
  
  static mmx_floating
  GLUE_303 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 * arg_2;
  }
  
  static mmx_floating
  GLUE_304 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 / arg_2;
  }
  
  static mmx_floating
  GLUE_305 (const mmx_floating &arg_1) {
    return sqrt (arg_1);
  }
  
  static mmx_floating
  GLUE_306 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return pow (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_307 (const mmx_floating &arg_1) {
    return exp (arg_1);
  }
  
  static mmx_floating
  GLUE_308 (const mmx_floating &arg_1) {
    return log (arg_1);
  }
  
  static mmx_floating
  GLUE_309 (const mmx_floating &arg_1) {
    return cos (arg_1);
  }
  
  static mmx_floating
  GLUE_310 (const mmx_floating &arg_1) {
    return sin (arg_1);
  }
  
  static mmx_floating
  GLUE_311 (const mmx_floating &arg_1) {
    return tan (arg_1);
  }
  
  static mmx_floating
  GLUE_312 (const mmx_floating &arg_1) {
    return acos (arg_1);
  }
  
  static mmx_floating
  GLUE_313 (const mmx_floating &arg_1) {
    return asin (arg_1);
  }
  
  static mmx_floating
  GLUE_314 (const mmx_floating &arg_1) {
    return atan (arg_1);
  }
  
  static bool
  GLUE_315 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 < arg_2;
  }
  
  static bool
  GLUE_316 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 <= arg_2;
  }
  
  static bool
  GLUE_317 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 > arg_2;
  }
  
  static bool
  GLUE_318 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return arg_1 >= arg_2;
  }
  
  static int
  GLUE_319 (const mmx_floating &arg_1) {
    return sign (arg_1);
  }
  
  static mmx_floating
  GLUE_320 (const mmx_floating &arg_1) {
    return abs (arg_1);
  }
  
  static mmx_floating
  GLUE_321 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_322 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_323 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return min (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_324 (const mmx_floating &arg_1, const mmx_floating &arg_2) {
    return max (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_325 (const mmx_floating &arg_1) {
    return floor (arg_1);
  }
  
  static mmx_floating
  GLUE_326 (const mmx_floating &arg_1) {
    return ceil (arg_1);
  }
  
  static mmx_floating
  GLUE_327 (const mmx_floating &arg_1) {
    return trunc (arg_1);
  }
  
  static mmx_floating
  GLUE_328 (const mmx_floating &arg_1) {
    return round (arg_1);
  }
  
  static bool
  GLUE_329 (const mmx_floating &arg_1) {
    return is_finite (arg_1);
  }
  
  static bool
  GLUE_330 (const mmx_floating &arg_1) {
    return is_infinite (arg_1);
  }
  
  static bool
  GLUE_331 (const mmx_floating &arg_1) {
    return is_nan (arg_1);
  }
  
  static mmx_floating
  GLUE_332 (const mmx_floating &arg_1) {
    return times_infinity (arg_1);
  }
  
  static int
  GLUE_333 (const mmx_floating &arg_1) {
    return precision (arg_1);
  }
  
  static mmx_floating
  GLUE_334 (const mmx_floating &arg_1, const int &arg_2) {
    return change_precision (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_335 (const mmx_floating &arg_1) {
    return next_above (arg_1);
  }
  
  static mmx_floating
  GLUE_336 (const mmx_floating &arg_1) {
    return next_below (arg_1);
  }
  
  static int
  GLUE_337 (const mmx_floating &arg_1) {
    return exponent (arg_1);
  }
  
  static double
  GLUE_338 (const mmx_floating &arg_1) {
    return magnitude (arg_1);
  }
  
  static mmx_floating
  GLUE_339 (const mmx_floating &arg_1, const int &arg_2) {
    return incexp2 (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_340 (const mmx_floating &arg_1, const int &arg_2) {
    return decexp2 (arg_1, arg_2);
  }
  
  static mmx_floating
  GLUE_341 (const mmx_floating &arg_1) {
    return rounding_error (arg_1);
  }
  
  static mmx_floating
  GLUE_342 (const mmx_floating &arg_1) {
    return additive_error (arg_1);
  }
  
  static mmx_floating
  GLUE_343 (const mmx_floating &arg_1) {
    return multiplicative_error (arg_1);
  }
  
  static mmx_floating
  GLUE_344 (const mmx_floating &arg_1) {
    return elementary_error (arg_1);
  }
  
  static shape_axel
  GLUE_345 () {
    return shape_axel ();
  }
  
  static shape_axel
  GLUE_346 (const string &arg_1) {
    return shape_axel_string (arg_1);
  }
  
  static void
  GLUE_347 (const shape_axel &arg_1) {
    shape_axel_view (arg_1);
  }
  
  static shape_point<rational>
  GLUE_348 (const tuple<rational> &arg_1) {
    return shape_point_tuple<rational > (as_vector (arg_1));
  }
  
  static rational
  GLUE_349 (const shape_point<rational> &arg_1, const int &arg_2) {
    return arg_1[arg_2];
  }
  
  static alias<rational>
  GLUE_350 (const alias<shape_point<rational> > &arg_1, const int &arg_2) {
    return alias_access<rational > (arg_1, arg_2);
  }
  
  static shape_point<rational>
  GLUE_351 (const shape_point<rational> &arg_1, const shape_point<rational> &arg_2) {
    return arg_1 - arg_2;
  }
  
  static alias<shape_axel>
  GLUE_352 (const alias<shape_axel> &arg_1, const shape_point<rational> &arg_2) {
    return alias_write (arg_1, arg_2);
  }
  
  static vector<integer>
  GLUE_353 (const tuple<integer> &arg_1) {
    return vector<integer > (as_vector (arg_1));
  }
  
  static vector<integer>
  GLUE_354 (const tuple<integer> &arg_1) {
    return vector<integer > (as_vector (arg_1));
  }
  
  static iterator<generic>
  GLUE_355 (const vector<integer> &arg_1) {
    return as<iterator<generic> > (iterate (arg_1));
  }
  
  static int
  GLUE_356 (const vector<integer> &arg_1) {
    return N (arg_1);
  }
  
  static integer
  GLUE_357 (const vector<integer> &arg_1, const int &arg_2) {
    return arg_1[arg_2];
  }
  
  static alias<integer>
  GLUE_358 (const alias<vector<integer> > &arg_1, const int &arg_2) {
    return alias_access<integer > (arg_1, arg_2);
  }
  
  static vector<integer>
  GLUE_359 (const vector<integer> &arg_1, const int &arg_2, const int &arg_3) {
    return range (arg_1, arg_2, arg_3);
  }
  
  static vector<integer>
  GLUE_360 (const vector<integer> &arg_1) {
    return reverse (arg_1);
  }
  
  static vector<integer>
  GLUE_361 (const vector<integer> &arg_1, const vector<integer> &arg_2) {
    return append (arg_1, arg_2);
  }
  
  static alias<vector<integer> >
  GLUE_362 (const alias<vector<integer> > &arg_1, const vector<integer> &arg_2) {
    return alias_write (arg_1, arg_2);
  }
  
  static vector<integer>
  GLUE_363 (const integer &arg_1, const vector<integer> &arg_2) {
    return cons (arg_1, arg_2);
  }
  
  static integer
  GLUE_364 (const vector<integer> &arg_1) {
    return car (arg_1);
  }
  
  static vector<integer>
  GLUE_365 (const vector<integer> &arg_1) {
    return cdr (arg_1);
  }
  
  static bool
  GLUE_366 (const vector<integer> &arg_1) {
    return is_nil (arg_1);
  }
  
  static bool
  GLUE_367 (const vector<integer> &arg_1) {
    return is_atom (arg_1);
  }
  
  static vector<integer>
  GLUE_368 (const vector<integer> &arg_1, const integer &arg_2) {
    return insert (arg_1, arg_2);
  }
  
  static int
  GLUE_369 (const vector<integer> &arg_1, const integer &arg_2) {
    return find (arg_1, arg_2);
  }
  
  static bool
  GLUE_370 (const vector<integer> &arg_1, const integer &arg_2) {
    return contains (arg_1, arg_2);
  }
  
  static vector<rational>
  GLUE_371 (const tuple<rational> &arg_1) {
    return vector<rational > (as_vector (arg_1));
  }
  
  static vector<rational>
  GLUE_372 (const tuple<rational> &arg_1) {
    return vector<rational > (as_vector (arg_1));
  }
  
  static iterator<generic>
  GLUE_373 (const vector<rational> &arg_1) {
    return as<iterator<generic> > (iterate (arg_1));
  }
  
  static int
  GLUE_374 (const vector<rational> &arg_1) {
    return N (arg_1);
  }
  
  static rational
  GLUE_375 (const vector<rational> &arg_1, const int &arg_2) {
    return arg_1[arg_2];
  }
  
  static alias<rational>
  GLUE_376 (const alias<vector<rational> > &arg_1, const int &arg_2) {
    return alias_access<rational > (arg_1, arg_2);
  }
  
  static vector<rational>
  GLUE_377 (const vector<rational> &arg_1, const int &arg_2, const int &arg_3) {
    return range (arg_1, arg_2, arg_3);
  }
  
  static vector<rational>
  GLUE_378 (const vector<rational> &arg_1) {
    return reverse (arg_1);
  }
  
  static vector<rational>
  GLUE_379 (const vector<rational> &arg_1, const vector<rational> &arg_2) {
    return append (arg_1, arg_2);
  }
  
  static alias<vector<rational> >
  GLUE_380 (const alias<vector<rational> > &arg_1, const vector<rational> &arg_2) {
    return alias_write (arg_1, arg_2);
  }
  
  static vector<rational>
  GLUE_381 (const rational &arg_1, const vector<rational> &arg_2) {
    return cons (arg_1, arg_2);
  }
  
  static rational
  GLUE_382 (const vector<rational> &arg_1) {
    return car (arg_1);
  }
  
  static vector<rational>
  GLUE_383 (const vector<rational> &arg_1) {
    return cdr (arg_1);
  }
  
  static bool
  GLUE_384 (const vector<rational> &arg_1) {
    return is_nil (arg_1);
  }
  
  static bool
  GLUE_385 (const vector<rational> &arg_1) {
    return is_atom (arg_1);
  }
  
  static vector<rational>
  GLUE_386 (const vector<rational> &arg_1, const rational &arg_2) {
    return insert (arg_1, arg_2);
  }
  
  static int
  GLUE_387 (const vector<rational> &arg_1, const rational &arg_2) {
    return find (arg_1, arg_2);
  }
  
  static bool
  GLUE_388 (const vector<rational> &arg_1, const rational &arg_2) {
    return contains (arg_1, arg_2);
  }
  
  static vector<generic>
  GLUE_389 (const vector<integer> &arg_1) {
    return as<vector<generic> > (arg_1);
  }
  
  static vector<rational>
  GLUE_390 (const vector<integer> &arg_1) {
    return as<vector<rational> > (arg_1);
  }
  
  static vector<generic>
  GLUE_391 (const vector<rational> &arg_1) {
    return as<vector<generic> > (arg_1);
  }
  
  static shape_point<rational>
  GLUE_392 (const shape_point<rational> &arg_1, const vector<rational> &arg_2) {
    return arg_1 + arg_2;
  }
  
  void
  glue_point () {
    static bool done = false;
    if (done) return;
    done = true;
    define_type<int > (lit ("Int"));
    define ("literal_integer", GLUE_1);
    define ("as_int", GLUE_2);
    define ("as_string", GLUE_3);
    define ("as_string_hexa", GLUE_4);
    define ("-", GLUE_5);
    define ("square", GLUE_6);
    define ("+", GLUE_7);
    define ("-", GLUE_8);
    define ("*", GLUE_9);
    define ("div", GLUE_10);
    define ("quo", GLUE_11);
    define ("rem", GLUE_12);
    define ("=", GLUE_13);
    define ("!=", GLUE_14);
    define ("<", GLUE_15);
    define ("<=", GLUE_16);
    define (">", GLUE_17);
    define (">=", GLUE_18);
    define ("sign", GLUE_19);
    define ("abs", GLUE_20);
    define ("min", GLUE_21);
    define ("max", GLUE_22);
    define ("inf", GLUE_23);
    define ("sup", GLUE_24);
    define ("/\\", GLUE_25);
    define ("\\/", GLUE_26);
    define ("xor", GLUE_27);
    define ("floor_sqrt", GLUE_28);
    define ("divides?", GLUE_29);
    define ("random", GLUE_30);
    define_constant<int > ("int_minus_infinity", int_minus_infinity);
    define_constant<int > ("int_plus_infinity", int_plus_infinity);
    define_type<vector<generic> > (gen (lit ("Vector"), lit ("Generic")));
    define ("vector?", GLUE_31);
    define ("vector", GLUE_32);
    define ("[]", GLUE_33);
    define_converter (":>", GLUE_34, PENALTY_PROMOTE_GENERIC);
    define ("#", GLUE_35);
    define (".[]", GLUE_36);
    define (".[]", GLUE_37);
    define (".[]", GLUE_38);
    define ("reverse", GLUE_39);
    define ("><", GLUE_40);
    define ("<<", GLUE_41);
    define ("cons", GLUE_42);
    define ("car", GLUE_43);
    define ("cdr", GLUE_44);
    define ("nil?", GLUE_45);
    define ("atom?", GLUE_46);
    define ("insert", GLUE_47);
    define ("find", GLUE_48);
    define ("contains?", GLUE_49);
    define ("string?", GLUE_50);
    define ("#", GLUE_51);
    define (".[]", GLUE_52);
    define ("*", GLUE_53);
    define ("><", GLUE_54);
    define ("<<", GLUE_55);
    define ("<", GLUE_56);
    define ("<=", GLUE_57);
    define (">", GLUE_58);
    define (">=", GLUE_59);
    define ("starts?", GLUE_60);
    define ("ends?", GLUE_61);
    define ("replace", GLUE_62);
    define ("search_forwards", GLUE_63);
    define ("search_backwards", GLUE_64);
    define ("upcase", GLUE_65);
    define ("locase", GLUE_66);
    define ("upcase_first", GLUE_67);
    define ("locase_first", GLUE_68);
    define ("quote", GLUE_69);
    define ("unquote", GLUE_70);
    define ("ascii", GLUE_71);
    define ("ascii_code", GLUE_72);
    define ("literal?", GLUE_73);
    define (".()", GLUE_74);
    define (".[]", GLUE_75);
    define ("as_literal", GLUE_76);
    define ("as_string", GLUE_77);
    define_type<integer > (lit ("Integer"));
    define ("literal_integer", GLUE_78);
    define ("integer", GLUE_79);
    define_converter ("upgrade", GLUE_80, PENALTY_INCLUSION);
    define ("int?", GLUE_81);
    define ("as_int", GLUE_82);
    define ("as_integer", GLUE_83);
    define ("as_string", GLUE_84);
    define_constructor<int > (GLUE_85);
    define_converter (":>", GLUE_86, PENALTY_INCLUSION);
    define ("-", GLUE_87);
    define ("square", GLUE_88);
    define ("+", GLUE_89);
    define ("-", GLUE_90);
    define ("*", GLUE_91);
    define ("div", GLUE_92);
    define ("quo", GLUE_93);
    define ("rem", GLUE_94);
    define ("divides?", GLUE_95);
    define ("gcd", GLUE_96);
    define ("lcm", GLUE_97);
    define ("=", GLUE_98);
    define ("!=", GLUE_99);
    define ("<", GLUE_100);
    define ("<=", GLUE_101);
    define (">", GLUE_102);
    define (">=", GLUE_103);
    define ("sign", GLUE_104);
    define ("abs", GLUE_105);
    define ("min", GLUE_106);
    define ("max", GLUE_107);
    define ("inf", GLUE_108);
    define ("sup", GLUE_109);
    define (".!", GLUE_110);
    define ("binomial", GLUE_111);
    define ("probable_prime?", GLUE_112);
    define ("probable_next_prime", GLUE_113);
    define ("/\\", GLUE_114);
    define ("\\/", GLUE_115);
    define ("xor", GLUE_116);
    define ("!", GLUE_117);
    define ("#", GLUE_118);
    define (".[]", GLUE_119);
    define ("hamming_norm", GLUE_120);
    define ("hamming_distance", GLUE_121);
    define ("+", GLUE_122);
    define ("-", GLUE_123);
    define ("*", GLUE_124);
    define ("+", GLUE_125);
    define ("-", GLUE_126);
    define ("*", GLUE_127);
    define ("div", GLUE_128);
    define ("quo", GLUE_129);
    define ("rem", GLUE_130);
    define ("divides?", GLUE_131);
    define ("div", GLUE_132);
    define ("quo", GLUE_133);
    define ("rem", GLUE_134);
    define ("divides?", GLUE_135);
    define ("=", GLUE_136);
    define ("!=", GLUE_137);
    define ("<", GLUE_138);
    define ("<=", GLUE_139);
    define (">", GLUE_140);
    define (">=", GLUE_141);
    define ("=", GLUE_142);
    define ("!=", GLUE_143);
    define ("<", GLUE_144);
    define ("<=", GLUE_145);
    define (">", GLUE_146);
    define (">=", GLUE_147);
    define ("min", GLUE_148);
    define ("max", GLUE_149);
    define ("min", GLUE_150);
    define ("max", GLUE_151);
    define ("/\\", GLUE_152);
    define ("\\/", GLUE_153);
    define ("xor", GLUE_154);
    define ("/\\", GLUE_155);
    define ("\\/", GLUE_156);
    define ("xor", GLUE_157);
    define_type<modulus<int> > (gen (lit ("Modulus"), lit ("Int")));
    define_type<modulus<integer> > (gen (lit ("Modulus"), lit ("Integer")));
    define_type<mmx_modular(int) > (gen (lit ("Modular"), lit ("Int")));
    define_type<mmx_modular(integer) > (gen (lit ("Modular"), lit ("Integer")));
    define ("modulus", GLUE_158);
    define_converter ("upgrade", GLUE_159, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_160, PENALTY_CAST);
    define ("modular", GLUE_161);
    define ("modular", GLUE_162);
    define ("mod", GLUE_163);
    define ("get_modulus", GLUE_164);
    define ("preimage", GLUE_165);
    define ("-", GLUE_166);
    define ("square", GLUE_167);
    define ("+", GLUE_168);
    define ("-", GLUE_169);
    define ("*", GLUE_170);
    define ("+", GLUE_171);
    define ("+", GLUE_172);
    define ("-", GLUE_173);
    define ("-", GLUE_174);
    define ("*", GLUE_175);
    define ("*", GLUE_176);
    define ("/", GLUE_177);
    define ("/", GLUE_178);
    define ("/", GLUE_179);
    define ("^", GLUE_180);
    define ("^", GLUE_181);
    define ("=", GLUE_182);
    define ("!=", GLUE_183);
    define ("=", GLUE_184);
    define ("!=", GLUE_185);
    define ("=", GLUE_186);
    define ("!=", GLUE_187);
    define ("modulus", GLUE_188);
    define_converter ("upgrade", GLUE_189, PENALTY_HOMOMORPHISM);
    define_converter (":>", GLUE_190, PENALTY_CAST);
    define ("modular", GLUE_191);
    define ("modular", GLUE_192);
    define ("mod", GLUE_193);
    define ("get_modulus", GLUE_194);
    define ("preimage", GLUE_195);
    define ("-", GLUE_196);
    define ("square", GLUE_197);
    define ("+", GLUE_198);
    define ("-", GLUE_199);
    define ("*", GLUE_200);
    define ("+", GLUE_201);
    define ("+", GLUE_202);
    define ("-", GLUE_203);
    define ("-", GLUE_204);
    define ("*", GLUE_205);
    define ("*", GLUE_206);
    define ("/", GLUE_207);
    define ("/", GLUE_208);
    define ("/", GLUE_209);
    define ("^", GLUE_210);
    define ("^", GLUE_211);
    define ("=", GLUE_212);
    define ("!=", GLUE_213);
    define ("=", GLUE_214);
    define ("!=", GLUE_215);
    define ("=", GLUE_216);
    define ("!=", GLUE_217);
    define_type<rational > (lit ("Rational"));
    define ("rational", GLUE_218);
    define ("rational", GLUE_219);
    define_converter ("upgrade", GLUE_220, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_221, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_222, PENALTY_INCLUSION);
    define ("/", GLUE_223);
    define ("numerator", GLUE_224);
    define ("denominator", GLUE_225);
    define ("integer?", GLUE_226);
    define ("-", GLUE_227);
    define ("square", GLUE_228);
    define ("+", GLUE_229);
    define ("-", GLUE_230);
    define ("*", GLUE_231);
    define ("/", GLUE_232);
    define ("+", GLUE_233);
    define ("-", GLUE_234);
    define ("*", GLUE_235);
    define ("/", GLUE_236);
    define ("+", GLUE_237);
    define ("-", GLUE_238);
    define ("*", GLUE_239);
    define ("/", GLUE_240);
    define ("^", GLUE_241);
    define ("^", GLUE_242);
    define ("div", GLUE_243);
    define ("divides?", GLUE_244);
    define ("gcd", GLUE_245);
    define ("lcm", GLUE_246);
    define ("=", GLUE_247);
    define ("!=", GLUE_248);
    define ("<", GLUE_249);
    define ("<=", GLUE_250);
    define (">", GLUE_251);
    define (">=", GLUE_252);
    define ("=", GLUE_253);
    define ("!=", GLUE_254);
    define ("<", GLUE_255);
    define ("<=", GLUE_256);
    define (">", GLUE_257);
    define (">=", GLUE_258);
    define ("=", GLUE_259);
    define ("!=", GLUE_260);
    define ("<", GLUE_261);
    define ("<=", GLUE_262);
    define (">", GLUE_263);
    define (">=", GLUE_264);
    define ("sign", GLUE_265);
    define ("abs", GLUE_266);
    define ("min", GLUE_267);
    define ("max", GLUE_268);
    define ("min", GLUE_269);
    define ("max", GLUE_270);
    define ("min", GLUE_271);
    define ("max", GLUE_272);
    define ("inf", GLUE_273);
    define ("sup", GLUE_274);
    define ("inf", GLUE_275);
    define ("sup", GLUE_276);
    define ("inf", GLUE_277);
    define ("sup", GLUE_278);
    define ("floor", GLUE_279);
    define ("ceil", GLUE_280);
    define ("trunc", GLUE_281);
    define ("round", GLUE_282);
    define ("reconstruct", GLUE_283);
    define ("reconstruct", GLUE_284);
    static alias<int> mmx_significant_digits_alias = global_alias (((int&) mmx_significant_digits));
    define_constant<alias<int> > ("significant_digits", mmx_significant_digits_alias);
    static alias<int> mmx_bit_precision_alias = global_alias (((int&) mmx_bit_precision));
    define_constant<alias<int> > ("bit_precision", mmx_bit_precision_alias);
    static alias<int> mmx_discrepancy_alias = global_alias (((int&) mmx_discrepancy));
    define_constant<alias<int> > ("discrepancy", mmx_discrepancy_alias);
    static alias<bool> mmx_pretty_exponents_alias = global_alias (((bool&) mmx_pretty_exponents));
    define_constant<alias<bool> > ("pretty_exponents", mmx_pretty_exponents_alias);
    define_type<mmx_floating > (lit ("Floating"));
    define ("literal_floating", GLUE_285);
    define_converter ("upgrade", GLUE_286, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_287, PENALTY_INCLUSION);
    define_converter ("upgrade", GLUE_288, PENALTY_INCLUSION);
    define ("as_floating", GLUE_289);
    define ("as_floating", GLUE_290);
    define ("as_floating", GLUE_291);
    define ("as_floating", GLUE_292);
    define ("as_floating", GLUE_293);
    define ("as_int", GLUE_294);
    define ("as_double", GLUE_295);
    define ("as_integer", GLUE_296);
    define ("as_string", GLUE_297);
    define ("uniform_deviate", GLUE_298);
    define ("-", GLUE_299);
    define ("square", GLUE_300);
    define ("+", GLUE_301);
    define ("-", GLUE_302);
    define ("*", GLUE_303);
    define ("/", GLUE_304);
    define ("sqrt", GLUE_305);
    define ("^", GLUE_306);
    define ("exp", GLUE_307);
    define ("log", GLUE_308);
    define ("cos", GLUE_309);
    define ("sin", GLUE_310);
    define ("tan", GLUE_311);
    define ("arccos", GLUE_312);
    define ("arcsin", GLUE_313);
    define ("arctan", GLUE_314);
    define ("<", GLUE_315);
    define ("<=", GLUE_316);
    define (">", GLUE_317);
    define (">=", GLUE_318);
    define ("sign", GLUE_319);
    define ("abs", GLUE_320);
    define ("min", GLUE_321);
    define ("max", GLUE_322);
    define ("inf", GLUE_323);
    define ("sup", GLUE_324);
    define ("floor", GLUE_325);
    define ("ceil", GLUE_326);
    define ("trunc", GLUE_327);
    define ("round", GLUE_328);
    define ("finite?", GLUE_329);
    define ("infinite?", GLUE_330);
    define ("nan?", GLUE_331);
    define ("times_infinity", GLUE_332);
    define ("precision", GLUE_333);
    define ("change_precision", GLUE_334);
    define ("next_above", GLUE_335);
    define ("next_below", GLUE_336);
    define ("exponent", GLUE_337);
    define ("magnitude", GLUE_338);
    define ("increase_exponent", GLUE_339);
    define ("decrease_exponent", GLUE_340);
    define ("rounding_error", GLUE_341);
    define ("additive_error", GLUE_342);
    define ("multiplicative_error", GLUE_343);
    define ("elementary_error", GLUE_344);
    define_type<shape_axel > (lit ("Axel"));
    define ("axel", GLUE_345);
    define ("axel", GLUE_346);
    define ("view", GLUE_347);
    define_type<shape_point<rational> > (gen (lit ("Point"), lit ("Rational")));
    define ("point", GLUE_348);
    define (".[]", GLUE_349);
    define (".[]", GLUE_350);
    define ("-", GLUE_351);
    define ("<<", GLUE_352);
    define_type<vector<integer> > (gen (lit ("Vector"), lit ("Integer")));
    define_type<vector<rational> > (gen (lit ("Vector"), lit ("Rational")));
    define ("vector", GLUE_353);
    define ("[]", GLUE_354);
    define_converter (":>", GLUE_355, PENALTY_CAST);
    define ("#", GLUE_356);
    define (".[]", GLUE_357);
    define (".[]", GLUE_358);
    define (".[]", GLUE_359);
    define ("reverse", GLUE_360);
    define ("><", GLUE_361);
    define ("<<", GLUE_362);
    define ("cons", GLUE_363);
    define ("car", GLUE_364);
    define ("cdr", GLUE_365);
    define ("nil?", GLUE_366);
    define ("atom?", GLUE_367);
    define ("insert", GLUE_368);
    define ("find", GLUE_369);
    define ("contains?", GLUE_370);
    define ("vector", GLUE_371);
    define ("[]", GLUE_372);
    define_converter (":>", GLUE_373, PENALTY_CAST);
    define ("#", GLUE_374);
    define (".[]", GLUE_375);
    define (".[]", GLUE_376);
    define (".[]", GLUE_377);
    define ("reverse", GLUE_378);
    define ("><", GLUE_379);
    define ("<<", GLUE_380);
    define ("cons", GLUE_381);
    define ("car", GLUE_382);
    define ("cdr", GLUE_383);
    define ("nil?", GLUE_384);
    define ("atom?", GLUE_385);
    define ("insert", GLUE_386);
    define ("find", GLUE_387);
    define ("contains?", GLUE_388);
    define_converter (":>", GLUE_389, PENALTY_PROMOTE_GENERIC);
    define_converter (":>", GLUE_390, PENALTY_INCLUSION);
    define_converter (":>", GLUE_391, PENALTY_PROMOTE_GENERIC);
    define ("+", GLUE_392);
  }
}

---