sleeping_kangaroo12 0.0.1

data/ext/xkcp/util/KeccakSum/KeccakSum.c

@@ -0,0 +1,394 @@
+/*
+Implementation by Gilles Van Assche and Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "base64.h"
+#include "KeccakHash.h"
+#include "KangarooTwelve.h"
+#include "SP800-185.h"
+
+int hexencode(const void* data_buf, size_t dataLength, char* result, size_t resultSize)
+{
+   const char hexchars[] = "0123456789abcdef";
+   const uint8_t *data = (const uint8_t *)data_buf;
+   size_t resultIndex = 0;
+   size_t x;
+
+    for(x=0; x<dataLength; x++) {
+        if (resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+        result[resultIndex++] = hexchars[(data[x] / 16) % 16];
+        if (resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+        result[resultIndex++] = hexchars[data[x] % 16];
+   }
+   if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+   result[resultIndex] = 0;
+   return 0;   /* indicate success */
+}
+
+#define bufferSize 65536
+#define algorithm_Keccak    0
+#define algorithm_K12       1
+#define algorithm_ParallelHash  2
+
+typedef struct {
+    unsigned int algorithm;
+    unsigned int rate;
+    unsigned int capacity;
+    unsigned int hashbitlen;
+    unsigned char delimitedSuffix;
+    unsigned int blockByteLen;
+} Specifications;
+
+typedef union {
+    Keccak_HashInstance keccak;
+    KangarooTwelve_Instance k12;
+    ParallelHash_Instance ph;
+} Instance;
+
+int hashInitialize(Instance *instance, const Specifications *specs)
+{
+    if (specs->algorithm == algorithm_Keccak) {
+        if (Keccak_HashInitialize(&instance->keccak, specs->rate, specs->capacity, specs->hashbitlen, specs->delimitedSuffix)) {
+            printf("Incorrect Keccak parameters (%d, %d, %d, 0x%02x).\n", specs->rate, specs->capacity, specs->hashbitlen, specs->delimitedSuffix);
+            return -1;
+        }
+        else
+            return 0;
+    }
+    else if (specs->algorithm == algorithm_K12) {
+        if (KangarooTwelve_Initialize(&instance->k12, specs->hashbitlen/8)) {
+            printf("Incorrect KangarooTwelve parameters.\n");
+            return -1;
+        }
+        else
+            return 0;
+    }
+    else if (specs->algorithm == algorithm_ParallelHash) {
+        if (specs->capacity == 256) {
+            if (ParallelHash128_Initialize(&instance->ph, specs->blockByteLen, specs->hashbitlen, "", 0)) {
+                printf("Incorrect ParallelHash128 parameters.\n");
+                return -1;
+            }
+            else
+                return 0;
+        }
+       else if (specs->capacity == 512) {
+            if (ParallelHash256_Initialize(&instance->ph, specs->blockByteLen, specs->hashbitlen, "", 0)) {
+                printf("Incorrect ParallelHash256 parameters.\n");
+                return -1;
+            }
+            else
+                return 0;
+        }
+        else {
+            printf("Incorrect ParallelHash parameters.\n");
+            return -1;
+        }
+    }
+    else
+        return -1;
+}
+
+int hashUpdate(Instance *instance, const Specifications *specs, const unsigned char *buffer, size_t size)
+{
+    if (specs->algorithm == algorithm_Keccak)
+        Keccak_HashUpdate(&instance->keccak, buffer, size*8);
+    else if (specs->algorithm == algorithm_K12)
+        KangarooTwelve_Update(&instance->k12, buffer, size);
+    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 256))
+        ParallelHash128_Update(&instance->ph, buffer, size*8);
+    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 512))
+        ParallelHash256_Update(&instance->ph, buffer, size*8);
+    return 0;
+}
+
+int hashFinal(Instance *instance, const Specifications *specs, unsigned char *buffer)
+{
+    if (specs->algorithm == algorithm_Keccak)
+        Keccak_HashFinal(&instance->keccak, buffer);
+    else if (specs->algorithm == algorithm_K12)
+        KangarooTwelve_Final(&instance->k12, buffer, "", 0);
+    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 256))
+        ParallelHash128_Final(&instance->ph, buffer);
+    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 512))
+        ParallelHash256_Final(&instance->ph, buffer);
+    return 0;
+}
+
+int processFile(const char *fileName, const Specifications *specs, int base64)
+{
+    FILE *fp;
+    Instance instance;
+    size_t read;
+    unsigned char buffer[bufferSize];
+    char display[bufferSize*2+1];
+
+    if (specs->hashbitlen > (bufferSize*8)) {
+        printf("The requested digest length (%d bits) does not fit in the buffer.\n", specs->hashbitlen);
+        return -1;
+    }
+    if (strcmp("-", fileName) == 0) {
+        fp = stdin;
+    }
+    else {
+        fp = fopen(fileName, "rb");
+        if (fp == NULL) {
+            printf("File '%s' could not be opened.\n", fileName);
+            return -1;
+        }
+    }
+    if (hashInitialize(&instance, specs)) {
+        fclose(fp);
+        return -1;
+    }
+    do {
+        read = fread(buffer, 1, bufferSize, fp);
+        if (read > 0)
+            hashUpdate(&instance, specs, buffer, read);
+    } while(read>0);
+    if (fp != stdin) {
+        fclose(fp);
+    }
+    hashFinal(&instance, specs, buffer);
+    if (base64) {
+        if (base64encode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
+            printf("Error while converting to base64.\n");
+            return -1;
+        }
+    }
+    else {
+        if (hexencode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
+            printf("Error while converting to hex.\n");
+            return -1;
+        }
+    }
+    printf("%s  ", display);
+    printf("%s\n", fileName);
+    return 0;
+}
+
+int processString(const char *input, const Specifications *specs, int base64)
+{
+    Instance instance;
+    unsigned char buffer[bufferSize];
+    char display[bufferSize*2+1];
+
+    if (specs->hashbitlen > (bufferSize*8)) {
+        printf("The requested digest length (%d bits) does not fit in the buffer.\n", specs->hashbitlen);
+        return -1;
+    }
+    if (hashInitialize(&instance, specs)) {
+        return -1;
+    }
+    hashUpdate(&instance, specs, input, strlen(input));
+    hashFinal(&instance, specs, buffer);
+    if (base64) {
+        if (base64encode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
+            printf("Error while converting to base64.\n");
+            return -1;
+        }
+    }
+    else {
+        if (hexencode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
+            printf("Error while converting to hex.\n");
+            return -1;
+        }
+    }
+    printf("%s  ", display);
+    printf("\"%s\"\n", input);
+    return 0;
+}
+
+void printHelp()
+{
+    printf("Usage: KeccakSum [options] [file names] [options] [file names] ...\n\n");
+    printf("  --help or -h                To display this page\n");
+    printf("  --base64                    Print in base64\n");
+    printf("  --hex                       Print in hexadecimal\n");
+    printf("  --outputbits <numberOfBits> Number of bits as output\n");
+    printf("  --shake128                  Use SHAKE128\n");
+    printf("  --shake256                  Use SHAKE256\n");
+    printf("  --sha3-224                  Use SHA3-224\n");
+    printf("  --sha3-256                  Use SHA3-256\n");
+    printf("  --sha3-384                  Use SHA3-384\n");
+    printf("  --sha3-512                  Use SHA3-512\n");
+    printf("  --no-suffix                 Use 0x01 as delimited suffix (pure Keccak)\n");
+    printf("  --ethereum                  Equivalent to --sha3-256 --no-suffix\n");
+    printf("  --kangarootwelve or --k12   Use KangarooTwelve\n");
+    printf("  --ph128                     Use ParallelHash128\n");
+    printf("  --ph256                     Use ParallelHash256\n");
+    printf("  -B <block size in bytes>    ParallelHash's B parameter\n");
+    printf("  --string <string>           String to hash\n");
+    printf("  <file name>                 File to hash\n\n");
+    printf("The options are processed in order.\nBy default, it uses SHAKE128 and base64 display.\n");
+    printf("With no file names, or when file name is -, it reads standard input.\n"); 
+}
+
+int process(int argc, char* argv[])
+{
+    Specifications specs;
+    int base64 = 1;
+    int i, r;
+    int was_filename = 0;
+    specs.algorithm = algorithm_Keccak;
+    specs.rate = 1344;
+    specs.capacity = 256;
+    specs.hashbitlen = 264;
+    specs.delimitedSuffix = 0x1F;
+
+    for(i=1; i<argc; i++) {
+        int outputbits;
+        if (strcmp("--base64", argv[i]) == 0)
+            base64 = 1;
+        else if (strcmp("--hex", argv[i]) == 0)
+            base64 = 0;
+        else if ((strcmp("--outputbits", argv[i]) == 0) || (strcmp("-n", argv[i]) == 0)) {
+            if ((i+1) >= argc) {
+                printf("Error: missing argument for --outputbits\n");
+                return -1;
+            }
+            outputbits = 0;
+            if (sscanf(argv[i+1], "%d", &outputbits) && (outputbits > 0) && ((outputbits % 8) == 0)) {
+                specs.hashbitlen = outputbits;
+                i++;
+            }
+            else {
+                printf("Error: argument for --outputbits option must be a positive integer multiple of 8\n");
+                return -1;
+            }
+        }
+        else if (strcmp("--shake128", argv[i]) == 0) {
+            specs.rate = 1344;
+            specs.capacity = 256;
+            specs.hashbitlen = 264;
+            specs.delimitedSuffix = 0x1F;
+            base64 = 1;
+        }
+        else if (strcmp("--shake256", argv[i]) == 0) {
+            specs.rate = 1088;
+            specs.capacity = 512;
+            specs.hashbitlen = 528;
+            specs.delimitedSuffix = 0x1F;
+            base64 = 1;
+        }
+        else if (strcmp("--sha3-224", argv[i]) == 0) {
+            specs.rate = 1152;
+            specs.capacity = 448;
+            specs.hashbitlen = 224;
+            specs.delimitedSuffix = 0x06;
+            base64 = 0;
+        }
+        else if (strcmp("--sha3-256", argv[i]) == 0) {
+            specs.rate = 1088;
+            specs.capacity = 512;
+            specs.hashbitlen = 256;
+            specs.delimitedSuffix = 0x06;
+            base64 = 0;
+        }
+        else if (strcmp("--sha3-384", argv[i]) == 0) {
+            specs.rate = 832;
+            specs.capacity = 768;
+            specs.hashbitlen = 384;
+            specs.delimitedSuffix = 0x06;
+            base64 = 0;
+        }
+        else if (strcmp("--sha3-512", argv[i]) == 0) {
+            specs.rate = 576;
+            specs.capacity = 1024;
+            specs.hashbitlen = 512;
+            specs.delimitedSuffix = 0x06;
+            base64 = 0;
+        }
+        else if (strcmp("--no-suffix", argv[i]) == 0) {
+            specs.delimitedSuffix = 0x01;
+        }
+        else if (strcmp("--ethereum", argv[i]) == 0) {
+            specs.rate = 1088;
+            specs.capacity = 512;
+            specs.hashbitlen = 256;
+            specs.delimitedSuffix = 0x01;
+            base64 = 0;
+        }
+        else if ((strcmp("--kangarootwelve", argv[i]) == 0) || (strcmp("--k12", argv[i]) == 0)) {
+            specs.algorithm = algorithm_K12;
+            specs.hashbitlen = 264;
+            base64 = 1;
+        }
+        else if (strcmp("--ph128", argv[i]) == 0) {
+            specs.algorithm = algorithm_ParallelHash;
+            specs.capacity = 256;
+            specs.hashbitlen = 264;
+            specs.blockByteLen = 8192;
+            base64 = 1;
+        }
+        else if (strcmp("--ph256", argv[i]) == 0) {
+            specs.algorithm = algorithm_ParallelHash;
+            specs.capacity = 512;
+            specs.hashbitlen = 528;
+            specs.blockByteLen = 8192;
+            base64 = 1;
+        }
+        else if (strcmp("-B", argv[i]) == 0) {
+            int blockByteLen;
+            if ((i+1) >= argc) {
+                printf("Error: missing argument for -B\n");
+                return -1;
+            }
+            blockByteLen = 0;
+            if (sscanf(argv[i+1], "%d", &blockByteLen) && (blockByteLen > 0)) {
+                specs.blockByteLen = blockByteLen;
+                i++;
+            }
+            else {
+                printf("Error: argument for -B option must be a positive power of 2\n");
+                return -1;
+            }
+        }
+        else if (strcmp("--string", argv[i]) == 0) {
+            if ((i+1) >= argc) {
+                printf("Error: missing argument for --string\n");
+                return -1;
+            }
+            i++;
+            processString(argv[i], &specs, base64);
+        }
+        else if (strcmp("--help", argv[i]) == 0 || strcmp("-h", argv[i]) == 0) {
+            printHelp();
+            return 0;
+        }
+        else {
+            if (strlen(argv[i]) > 2) {
+                if ((argv[i][0] == '-') && (argv[i][1] == '-')) {
+                    printf("Unrecognized command '%s'\n", argv[i]);
+                    return -1;
+                }
+            }
+            was_filename = 1;
+            r = processFile(argv[i], &specs, base64);
+            if (r)
+                return r;
+        }
+    }
+    if (was_filename == 0) {
+        r = processFile("-", &specs, base64);
+        if (r)
+            return r;
+    }
+    return 0;
+}
+
+int main(int argc, char* argv[])
+{
+    return process(argc, argv);
+}

data/ext/xkcp/util/KeccakSum/base64.c

@@ -0,0 +1,86 @@
+/*
+Implementation taken from:
+https://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64
+(2015-12-16)
+
+Available under the Creative Commons Attribution-ShareAlike License:
+https://creativecommons.org/licenses/by-sa/3.0/
+*/
+
+#include <stdint.h>
+#include <string.h>
+
+int base64encode(const void* data_buf, size_t dataLength, char* result, size_t resultSize)
+{
+   const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+   const uint8_t *data = (const uint8_t *)data_buf;
+   size_t resultIndex = 0;
+   size_t x;
+   uint32_t n = 0;
+   int padCount = dataLength % 3;
+   uint8_t n0, n1, n2, n3;
+
+   /* increment over the length of the string, three characters at a time */
+   for (x = 0; x < dataLength; x += 3)
+   {
+      /* these three 8-bit (ASCII) characters become one 24-bit number */
+      n = ((uint32_t)data[x]) << 16; /* parenthesis needed, compiler depending on flags can do the shifting before conversion to uint32_t, resulting to 0 */
+
+      if((x+1) < dataLength)
+         n += ((uint32_t)data[x+1]) << 8; /* parenthesis needed, compiler depending on flags can do the shifting before conversion to uint32_t, resulting to 0 */
+
+      if((x+2) < dataLength)
+         n += data[x+2];
+
+      /* this 24-bit number gets separated into four 6-bit numbers */
+      n0 = (uint8_t)(n >> 18) & 63;
+      n1 = (uint8_t)(n >> 12) & 63;
+      n2 = (uint8_t)(n >> 6) & 63;
+      n3 = (uint8_t)n & 63;
+
+      /*
+       * if we have one byte available, then its encoding is spread
+       * out over two characters
+       */
+      if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+      result[resultIndex++] = base64chars[n0];
+      if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+      result[resultIndex++] = base64chars[n1];
+
+      /*
+       * if we have only two bytes available, then their encoding is
+       * spread out over three chars
+       */
+      if((x+1) < dataLength)
+      {
+         if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+         result[resultIndex++] = base64chars[n2];
+      }
+
+      /*
+       * if we have all three bytes available, then their encoding is spread
+       * out over four characters
+       */
+      if((x+2) < dataLength)
+      {
+         if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+         result[resultIndex++] = base64chars[n3];
+      }
+   }
+
+   /*
+    * create and add padding that is required if we did not have a multiple of 3
+    * number of characters available
+    */
+   if (padCount > 0)
+   {
+      for (; padCount < 3; padCount++)
+      {
+         if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+         result[resultIndex++] = '=';
+      }
+   }
+   if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
+   result[resultIndex] = 0;
+   return 0;   /* indicate success */
+}

data/ext/xkcp/util/KeccakSum/base64.h

@@ -0,0 +1,12 @@
+/*
+Implementation taken from:
+https://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64
+(2015-12-16)
+
+Available under the Creative Commons Attribution-ShareAlike License:
+https://creativecommons.org/licenses/by-sa/3.0/
+*/
+
+#include <string.h>
+
+int base64encode(const void* data_buf, size_t dataLength, char* result, size_t resultSize);

data/lib/sleeping_kangaroo12/binding.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'build/loader'
+
+module SleepingKangaroo12
+  module Binding
+    extend ::FFI::Library
+    ffi_lib Build::Loader.find('SleepingKangaroo12')
+
+    attach_function :init, :SleepingKangaroo12_Init, [:int], :pointer
+    attach_function :update, :SleepingKangaroo12_Update, %i[pointer pointer size_t], :int
+    attach_function :final, :SleepingKangaroo12_Final, %i[pointer pointer pointer size_t], :int
+    attach_function :destroy, :SleepingKangaroo12_Destroy, %i[pointer], :void
+  end
+end

data/lib/sleeping_kangaroo12/build/loader.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'pathname'
+require_relative 'platform'
+
+module SleepingKangaroo12
+  module Build
+    # taken from:
+    # https://github.com/ffi/ffi-compiler/blob/master/lib/ffi-compiler/loader.rb
+    module Loader
+      def self.find(name, start_path = nil)
+        library = Platform.instance.map_library_name(name)
+        root = false
+        ::Pathname.new(start_path || caller_path(caller[0])).ascend do |path|
+          Dir.glob("#{path}/**/{#{::FFI::Platform::ARCH}-#{::FFI::Platform::OS}/#{library},#{library}}") do |f|
+            return f
+          end
+
+          break if root
+
+          # Next iteration will be the root of the gem if this is the lib/ dir - stop after that
+          root = ::File.basename(path) == 'lib'
+        end
+        raise ::LoadError, "cannot find '#{name}' library"
+      end
+
+      def self.caller_path(line = caller[0])
+        if ::FFI::Platform::OS == 'windows'
+          drive = line[0..1]
+          path =  line[2..].split(/:/)[0]
+          full_path = drive + path
+        else
+          full_path = line.split(/:/)[0]
+        end
+        ::File.dirname full_path
+      end
+    end
+  end
+end

data/lib/sleeping_kangaroo12/build/platform.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'singleton'
+
+module SleepingKangaroo12
+  module Build
+    # mostly taken from:
+    # https://github.com/ffi/ffi-compiler/blob/master/lib/ffi-compiler/platform.rb
+
+    class Platform
+      include ::Singleton
+
+      LIBSUFFIX = ::FFI::Platform.mac? ? 'bundle' : ::FFI::Platform::LIBSUFFIX
+
+      def map_library_name(name)
+        "#{::FFI::Platform::LIBPREFIX}#{name}.#{LIBSUFFIX}"
+      end
+
+      def arch
+        ::FFI::Platform::ARCH
+      end
+
+      def os
+        ::FFI::Platform::OS
+      end
+
+      def name
+        ::FFI::Platform.name
+      end
+
+      def mac?
+        ::FFI::Platform.mac?
+      end
+    end
+  end
+end

data/lib/sleeping_kangaroo12/build.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative './build/platform'
+require_relative './build/loader'

data/lib/sleeping_kangaroo12/digest.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'binding'
+
+module SleepingKangaroo12
+  class Digest
+    class UpdatingFailed < ::StandardError
+    end
+
+    class FinalizationFailed < ::StandardError
+    end
+
+    class Finalized < ::StandardError
+    end
+
+    def initialize(output_length: 32, key: nil)
+      raise ::TypeError, 'Hash length is not an Integer' unless output_length.is_a?(::Integer)
+      raise ::ArgumentError, 'Hash length out of range' unless (1...(1 << 20)).include?(output_length)
+      raise ::TypeError, 'Key is not a String' if !key.nil? && !key.is_a?(::String)
+
+      # id = SecureRandom.uuid
+      @native_instance = Binding.init(output_length).tap do |pointer|
+        ::ObjectSpace.define_finalizer(self, self.class._create_finalizer(pointer))
+      end
+      @output_length = output_length
+      @key = key
+      @finalized = false
+      @result = nil
+    end
+
+    def update(data)
+      raise Finalized if @finalized
+
+      data_size = data.bytesize
+      data_buffer = ::FFI::MemoryPointer.new(:char, data_size)
+      data_buffer.put_bytes(0, data)
+      Binding.update(@native_instance, data_buffer, data_size).tap do |result|
+        raise UpdatingFailed unless result.zero?
+      end
+      nil
+    end
+
+    def <<(*args, **kwargs)
+      update(*args, **kwargs)
+    end
+
+    def digest
+      @finalized = true
+      return @_digest if @_digest
+
+      data_buffer = ::FFI::MemoryPointer.new(:char, @output_length)
+      customization_buffer, customization_size = @key.then do |key|
+        next [::FFI::MemoryPointer.new(:char, 0), 0] unless key
+
+        size = key.bytesize
+        [::FFI::MemoryPointer.new(:char, size).tap do |buffer|
+          buffer.put_bytes(0, key)
+        end, size]
+      end
+      Binding.final(@native_instance, data_buffer, customization_buffer, customization_size).tap do |result|
+        raise FinalizationFailed unless result.zero?
+      end
+      @_digest = data_buffer.get_bytes(0, @output_length)
+    end
+
+    def hexdigest
+      @_hexdigest ||= digest.unpack1('H*')
+    end
+
+    def base64digest
+      @_base64digest ||= ::Base64.strict_encode64(digest)
+    end
+
+    class << self
+      # https://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
+      def _create_finalizer(instance)
+        proc {
+          Binding.destroy(instance)
+        }
+      end
+
+      def digest(*args, **kwargs)
+        _generic_digest(*args, **kwargs, &:digest)
+      end
+
+      def hexdigest(*args, **kwargs)
+        _generic_digest(*args, **kwargs, &:hexdigest)
+      end
+
+      def base64digest(*args, **kwargs)
+        _generic_digest(*args, **kwargs, &:base64digest)
+      end
+
+      private
+
+      def _generic_digest(data, output_length: nil, key: nil, &hash_finalizer)
+        instance = new(**{ output_length: output_length, key: key }.compact)
+        instance.update(data)
+        hash_finalizer.call(instance)
+      end
+    end
+  end
+end