rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/EAN8Reader.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.common.BitArray;
+
+/**
+ * <p>Implements decoding of the EAN-8 format.</p>
+ *
+ * @author Sean Owen
+ */
+public final class EAN8Reader extends UPCEANReader {
+
+  private final int[] decodeMiddleCounters;
+
+  public EAN8Reader() {
+    decodeMiddleCounters = new int[4];
+  }
+
+  protected int decodeMiddle(BitArray row, int[] startRange, StringBuffer result)
+      throws NotFoundException {
+    int[] counters = decodeMiddleCounters;
+    counters[0] = 0;
+    counters[1] = 0;
+    counters[2] = 0;
+    counters[3] = 0;
+    int end = row.getSize();
+    int rowOffset = startRange[1];
+
+    for (int x = 0; x < 4 && rowOffset < end; x++) {
+      int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);
+      result.append((char) ('0' + bestMatch));
+      for (int i = 0; i < counters.length; i++) {
+        rowOffset += counters[i];
+      }
+    }
+
+    int[] middleRange = findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN);
+    rowOffset = middleRange[1];
+
+    for (int x = 0; x < 4 && rowOffset < end; x++) {
+      int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);
+      result.append((char) ('0' + bestMatch));
+      for (int i = 0; i < counters.length; i++) {
+        rowOffset += counters[i];
+      }
+    }
+
+    return rowOffset;
+  }
+
+  BarcodeFormat getBarcodeFormat() {
+    return BarcodeFormat.EAN_8;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/EAN8Writer.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+
+import java.util.Hashtable;
+
+/**
+ * This object renders an EAN8 code as a {@link BitMatrix}.
+ *
+ * @author aripollak@gmail.com (Ari Pollak)
+ */
+public final class EAN8Writer extends UPCEANWriter {
+
+  private static final int codeWidth = 3 + // start guard
+      (7 * 4) + // left bars
+      5 + // middle guard
+      (7 * 4) + // right bars
+      3; // end guard
+
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height,
+      Hashtable hints) throws WriterException {
+    if (format != BarcodeFormat.EAN_8) {
+      throw new IllegalArgumentException("Can only encode EAN_8, but got "
+          + format);
+    }
+
+    return super.encode(contents, format, width, height, hints);
+  }
+
+  /** @return a byte array of horizontal pixels (0 = white, 1 = black) */
+  public byte[] encode(String contents) {
+    if (contents.length() != 8) {
+      throw new IllegalArgumentException(
+          "Requested contents should be 8 digits long, but got " + contents.length());
+    }
+
+    byte[] result = new byte[codeWidth];
+    int pos = 0;
+
+    pos += appendPattern(result, pos, UPCEANReader.START_END_PATTERN, 1);
+
+    for (int i = 0; i <= 3; i++) {
+      int digit = Integer.parseInt(contents.substring(i, i + 1));
+      pos += appendPattern(result, pos, UPCEANReader.L_PATTERNS[digit], 0);
+    }
+
+    pos += appendPattern(result, pos, UPCEANReader.MIDDLE_PATTERN, 0);
+
+    for (int i = 4; i <= 7; i++) {
+      int digit = Integer.parseInt(contents.substring(i, i + 1));
+      pos += appendPattern(result, pos, UPCEANReader.L_PATTERNS[digit], 1);
+    }
+    pos += appendPattern(result, pos, UPCEANReader.START_END_PATTERN, 1);
+
+    return result;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/EANManufacturerOrgSupport.java

@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import java.util.Vector;
+
+/**
+ * Records EAN prefix to GS1 Member Organization, where the member organization
+ * correlates strongly with a country. This is an imperfect means of identifying
+ * a country of origin by EAN-13 barcode value. See
+ * <a href="http://en.wikipedia.org/wiki/List_of_GS1_country_codes">
+ * http://en.wikipedia.org/wiki/List_of_GS1_country_codes</a>.
+ *
+ * @author Sean Owen
+ */
+final class EANManufacturerOrgSupport {
+
+  private final Vector ranges = new Vector();
+  private final Vector countryIdentifiers = new Vector();
+
+  String lookupCountryIdentifier(String productCode) {
+    initIfNeeded();
+    int prefix = Integer.parseInt(productCode.substring(0, 3));
+    int max = ranges.size();
+    for (int i = 0; i < max; i++) {
+      int[] range = (int[]) ranges.elementAt(i);
+      int start = range[0];
+      if (prefix < start) {
+        return null;
+      }
+      int end = range.length == 1 ? start : range[1];
+      if (prefix <= end) {
+        return (String) countryIdentifiers.elementAt(i);
+      }
+    }
+    return null;
+  }
+  
+  private void add(int[] range, String id) {
+    ranges.addElement(range);
+    countryIdentifiers.addElement(id);
+  }
+  
+  private synchronized void initIfNeeded() {
+    if (!ranges.isEmpty()) {
+      return;
+    }
+    add(new int[] {0,19},    "US/CA");
+    add(new int[] {30,39},   "US");
+    add(new int[] {60,139},  "US/CA");
+    add(new int[] {300,379}, "FR");
+    add(new int[] {380},     "BG");
+    add(new int[] {383},     "SI");
+    add(new int[] {385},     "HR");
+    add(new int[] {387},     "BA");
+    add(new int[] {400,440}, "DE");
+    add(new int[] {450,459}, "JP");
+    add(new int[] {460,469}, "RU");
+    add(new int[] {471},     "TW");
+    add(new int[] {474},     "EE");
+    add(new int[] {475},     "LV");
+    add(new int[] {476},     "AZ");
+    add(new int[] {477},     "LT");
+    add(new int[] {478},     "UZ");
+    add(new int[] {479},     "LK");
+    add(new int[] {480},     "PH");
+    add(new int[] {481},     "BY");
+    add(new int[] {482},     "UA");
+    add(new int[] {484},     "MD");
+    add(new int[] {485},     "AM");
+    add(new int[] {486},     "GE");
+    add(new int[] {487},     "KZ");
+    add(new int[] {489},     "HK");
+    add(new int[] {490,499}, "JP");    
+    add(new int[] {500,509}, "GB");    
+    add(new int[] {520},     "GR");
+    add(new int[] {528},     "LB");
+    add(new int[] {529},     "CY");
+    add(new int[] {531},     "MK");
+    add(new int[] {535},     "MT");
+    add(new int[] {539},     "IE");
+    add(new int[] {540,549}, "BE/LU");    
+    add(new int[] {560},     "PT");
+    add(new int[] {569},     "IS");
+    add(new int[] {570,579}, "DK");
+    add(new int[] {590},     "PL");
+    add(new int[] {594},     "RO");
+    add(new int[] {599},     "HU");
+    add(new int[] {600,601}, "ZA");
+    add(new int[] {603},     "GH");    
+    add(new int[] {608},     "BH");
+    add(new int[] {609},     "MU");
+    add(new int[] {611},     "MA");
+    add(new int[] {613},     "DZ");
+    add(new int[] {616},     "KE");
+    add(new int[] {618},     "CI");    
+    add(new int[] {619},     "TN");
+    add(new int[] {621},     "SY");
+    add(new int[] {622},     "EG");
+    add(new int[] {624},     "LY");
+    add(new int[] {625},     "JO");
+    add(new int[] {626},     "IR");
+    add(new int[] {627},     "KW");
+    add(new int[] {628},     "SA");
+    add(new int[] {629},     "AE");
+    add(new int[] {640,649}, "FI");
+    add(new int[] {690,695}, "CN");
+    add(new int[] {700,709}, "NO");
+    add(new int[] {729},     "IL");
+    add(new int[] {730,739}, "SE");
+    add(new int[] {740},     "GT");
+    add(new int[] {741},     "SV");
+    add(new int[] {742},     "HN");
+    add(new int[] {743},     "NI");
+    add(new int[] {744},     "CR");
+    add(new int[] {745},     "PA");
+    add(new int[] {746},     "DO");
+    add(new int[] {750},     "MX");
+    add(new int[] {754,755}, "CA");
+    add(new int[] {759},     "VE");
+    add(new int[] {760,769}, "CH");
+    add(new int[] {770},     "CO");
+    add(new int[] {773},     "UY");
+    add(new int[] {775},     "PE");
+    add(new int[] {777},     "BO");
+    add(new int[] {779},     "AR");
+    add(new int[] {780},     "CL");
+    add(new int[] {784},     "PY");
+    add(new int[] {785},     "PE");  
+    add(new int[] {786},     "EC");
+    add(new int[] {789,790}, "BR");
+    add(new int[] {800,839}, "IT");
+    add(new int[] {840,849}, "ES");
+    add(new int[] {850},     "CU");
+    add(new int[] {858},     "SK");
+    add(new int[] {859},     "CZ");
+    add(new int[] {860},     "YU");
+    add(new int[] {865},     "MN");    
+    add(new int[] {867},     "KP");
+    add(new int[] {868,869}, "TR");
+    add(new int[] {870,879}, "NL");
+    add(new int[] {880},     "KR");
+    add(new int[] {885},     "TH");
+    add(new int[] {888},     "SG");
+    add(new int[] {890},     "IN");
+    add(new int[] {893},     "VN");
+    add(new int[] {896},     "PK");    
+    add(new int[] {899},     "ID");
+    add(new int[] {900,919}, "AT");
+    add(new int[] {930,939}, "AU");
+    add(new int[] {940,949}, "AZ");
+    add(new int[] {955},     "MY");
+    add(new int[] {958},     "MO");
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/ITFReader.java

@@ -0,0 +1,348 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Result;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitArray;
+
+import java.util.Hashtable;
+
+/**
+ * <p>Implements decoding of the ITF format.</p>
+ *
+ * <p>"ITF" stands for Interleaved Two of Five. This Reader will scan ITF barcode with 6, 10 or 14
+ * digits. The checksum is optional and is not applied by this Reader. The consumer of the decoded
+ * value will have to apply a checksum if required.</p>
+ *
+ * <p><a href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia.org/wiki/Interleaved_2_of_5</a>
+ * is a great reference for Interleaved 2 of 5 information.</p>
+ *
+ * @author kevin.osullivan@sita.aero, SITA Lab.
+ */
+public final class ITFReader extends OneDReader {
+
+  private static final int MAX_AVG_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+  private static final int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
+
+  private static final int W = 3; // Pixel width of a wide line
+  private static final int N = 1; // Pixed width of a narrow line
+
+  private static final int[] DEFAULT_ALLOWED_LENGTHS = { 6, 10, 12, 14, 44 };
+
+  // Stores the actual narrow line width of the image being decoded.
+  private int narrowLineWidth = -1;
+
+  /**
+   * Start/end guard pattern.
+   *
+   * Note: The end pattern is reversed because the row is reversed before
+   * searching for the END_PATTERN
+   */
+  private static final int[] START_PATTERN = {N, N, N, N};
+  private static final int[] END_PATTERN_REVERSED = {N, N, W};
+
+  /**
+   * Patterns of Wide / Narrow lines to indicate each digit
+   */
+  static final int[][] PATTERNS = {
+      {N, N, W, W, N}, // 0
+      {W, N, N, N, W}, // 1
+      {N, W, N, N, W}, // 2
+      {W, W, N, N, N}, // 3
+      {N, N, W, N, W}, // 4
+      {W, N, W, N, N}, // 5
+      {N, W, W, N, N}, // 6
+      {N, N, N, W, W}, // 7
+      {W, N, N, W, N}, // 8
+      {N, W, N, W, N}  // 9
+  };
+
+  public Result decodeRow(int rowNumber, BitArray row, Hashtable hints) throws FormatException, NotFoundException {
+
+    // Find out where the Middle section (payload) starts & ends
+    int[] startRange = decodeStart(row);
+    int[] endRange = decodeEnd(row);
+
+    StringBuffer result = new StringBuffer(20);
+    decodeMiddle(row, startRange[1], endRange[0], result);
+    String resultString = result.toString();
+
+    int[] allowedLengths = null;
+    if (hints != null) {
+      allowedLengths = (int[]) hints.get(DecodeHintType.ALLOWED_LENGTHS);
+
+    }
+    if (allowedLengths == null) {
+      allowedLengths = DEFAULT_ALLOWED_LENGTHS;
+    }
+
+    // To avoid false positives with 2D barcodes (and other patterns), make
+    // an assumption that the decoded string must be 6, 10 or 14 digits.
+    int length = resultString.length();
+    boolean lengthOK = false;
+    for (int i = 0; i < allowedLengths.length; i++) {
+      if (length == allowedLengths[i]) {
+        lengthOK = true;
+        break;
+      }
+
+    }
+    if (!lengthOK) {
+      throw FormatException.getFormatInstance();
+    }
+
+    return new Result(
+        resultString,
+        null, // no natural byte representation for these barcodes
+        new ResultPoint[] { new ResultPoint(startRange[1], (float) rowNumber),
+                            new ResultPoint(endRange[0], (float) rowNumber)},
+        BarcodeFormat.ITF);
+  }
+
+  /**
+   * @param row          row of black/white values to search
+   * @param payloadStart offset of start pattern
+   * @param resultString {@link StringBuffer} to append decoded chars to
+   * @throws NotFoundException if decoding could not complete successfully
+   */
+  private static void decodeMiddle(BitArray row, int payloadStart, int payloadEnd,
+      StringBuffer resultString) throws NotFoundException {
+
+    // Digits are interleaved in pairs - 5 black lines for one digit, and the
+    // 5
+    // interleaved white lines for the second digit.
+    // Therefore, need to scan 10 lines and then
+    // split these into two arrays
+    int[] counterDigitPair = new int[10];
+    int[] counterBlack = new int[5];
+    int[] counterWhite = new int[5];
+
+    while (payloadStart < payloadEnd) {
+
+      // Get 10 runs of black/white.
+      recordPattern(row, payloadStart, counterDigitPair);
+      // Split them into each array
+      for (int k = 0; k < 5; k++) {
+        int twoK = k << 1;
+        counterBlack[k] = counterDigitPair[twoK];
+        counterWhite[k] = counterDigitPair[twoK + 1];
+      }
+
+      int bestMatch = decodeDigit(counterBlack);
+      resultString.append((char) ('0' + bestMatch));
+      bestMatch = decodeDigit(counterWhite);
+      resultString.append((char) ('0' + bestMatch));
+
+      for (int i = 0; i < counterDigitPair.length; i++) {
+        payloadStart += counterDigitPair[i];
+      }
+    }
+  }
+
+  /**
+   * Identify where the start of the middle / payload section starts.
+   *
+   * @param row row of black/white values to search
+   * @return Array, containing index of start of 'start block' and end of
+   *         'start block'
+   * @throws NotFoundException
+   */
+  int[] decodeStart(BitArray row) throws NotFoundException {
+    int endStart = skipWhiteSpace(row);
+    int[] startPattern = findGuardPattern(row, endStart, START_PATTERN);
+
+    // Determine the width of a narrow line in pixels. We can do this by
+    // getting the width of the start pattern and dividing by 4 because its
+    // made up of 4 narrow lines.
+    this.narrowLineWidth = (startPattern[1] - startPattern[0]) >> 2;
+
+    validateQuietZone(row, startPattern[0]);
+
+    return startPattern;
+  }
+
+  /**
+   * The start & end patterns must be pre/post fixed by a quiet zone. This
+   * zone must be at least 10 times the width of a narrow line.  Scan back until
+   * we either get to the start of the barcode or match the necessary number of
+   * quiet zone pixels.
+   *
+   * Note: Its assumed the row is reversed when using this method to find
+   * quiet zone after the end pattern.
+   *
+   * ref: http://www.barcode-1.net/i25code.html
+   *
+   * @param row bit array representing the scanned barcode.
+   * @param startPattern index into row of the start or end pattern.
+   * @throws NotFoundException if the quiet zone cannot be found, a ReaderException is thrown.
+   */
+  private void validateQuietZone(BitArray row, int startPattern) throws NotFoundException {
+
+    int quietCount = this.narrowLineWidth * 10;  // expect to find this many pixels of quiet zone
+
+    for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
+      if (row.get(i)) {
+        break;
+      }
+      quietCount--;
+    }
+    if (quietCount != 0) {
+      // Unable to find the necessary number of quiet zone pixels.
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+  /**
+   * Skip all whitespace until we get to the first black line.
+   *
+   * @param row row of black/white values to search
+   * @return index of the first black line.
+   * @throws NotFoundException Throws exception if no black lines are found in the row
+   */
+  private static int skipWhiteSpace(BitArray row) throws NotFoundException {
+    int width = row.getSize();
+    int endStart = 0;
+    while (endStart < width) {
+      if (row.get(endStart)) {
+        break;
+      }
+      endStart++;
+    }
+    if (endStart == width) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    return endStart;
+  }
+
+  /**
+   * Identify where the end of the middle / payload section ends.
+   *
+   * @param row row of black/white values to search
+   * @return Array, containing index of start of 'end block' and end of 'end
+   *         block'
+   * @throws NotFoundException
+   */
+
+  int[] decodeEnd(BitArray row) throws NotFoundException {
+
+    // For convenience, reverse the row and then
+    // search from 'the start' for the end block
+    row.reverse();
+    try {
+      int endStart = skipWhiteSpace(row);
+      int[] endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);
+
+      // The start & end patterns must be pre/post fixed by a quiet zone. This
+      // zone must be at least 10 times the width of a narrow line.
+      // ref: http://www.barcode-1.net/i25code.html
+      validateQuietZone(row, endPattern[0]);
+
+      // Now recalculate the indices of where the 'endblock' starts & stops to
+      // accommodate
+      // the reversed nature of the search
+      int temp = endPattern[0];
+      endPattern[0] = row.getSize() - endPattern[1];
+      endPattern[1] = row.getSize() - temp;
+
+      return endPattern;
+    } finally {
+      // Put the row back the right way.
+      row.reverse();
+    }
+  }
+
+  /**
+   * @param row       row of black/white values to search
+   * @param rowOffset position to start search
+   * @param pattern   pattern of counts of number of black and white pixels that are
+   *                  being searched for as a pattern
+   * @return start/end horizontal offset of guard pattern, as an array of two
+   *         ints
+   * @throws NotFoundException if pattern is not found
+   */
+  private static int[] findGuardPattern(BitArray row, int rowOffset, int[] pattern) throws NotFoundException {
+
+    // TODO: This is very similar to implementation in UPCEANReader. Consider if they can be
+    // merged to a single method.
+    int patternLength = pattern.length;
+    int[] counters = new int[patternLength];
+    int width = row.getSize();
+    boolean isWhite = false;
+
+    int counterPosition = 0;
+    int patternStart = rowOffset;
+    for (int x = rowOffset; x < width; x++) {
+      boolean pixel = row.get(x);
+      if (pixel ^ isWhite) {
+        counters[counterPosition]++;
+      } else {
+        if (counterPosition == patternLength - 1) {
+          if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
+            return new int[]{patternStart, x};
+          }
+          patternStart += counters[0] + counters[1];
+          for (int y = 2; y < patternLength; y++) {
+            counters[y - 2] = counters[y];
+          }
+          counters[patternLength - 2] = 0;
+          counters[patternLength - 1] = 0;
+          counterPosition--;
+        } else {
+          counterPosition++;
+        }
+        counters[counterPosition] = 1;
+        isWhite = !isWhite;
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  /**
+   * Attempts to decode a sequence of ITF black/white lines into single
+   * digit.
+   *
+   * @param counters the counts of runs of observed black/white/black/... values
+   * @return The decoded digit
+   * @throws NotFoundException if digit cannot be decoded
+   */
+  private static int decodeDigit(int[] counters) throws NotFoundException {
+
+    int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
+    int bestMatch = -1;
+    int max = PATTERNS.length;
+    for (int i = 0; i < max; i++) {
+      int[] pattern = PATTERNS[i];
+      int variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
+      if (variance < bestVariance) {
+        bestVariance = variance;
+        bestMatch = i;
+      }
+    }
+    if (bestMatch >= 0) {
+      return bestMatch;
+    } else {
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+}