//    // find_among_b is for backwards processing. Same comments apply

        internal int find_among_b(Among[] v, int v_size)
        {
            int  i                   = 0;
            int  j                   = v_size;
            int  c                   = cursor;
            int  lb                  = limit_backward;
            int  common_i            = 0;
            int  common_j            = 0;
            bool first_key_inspected = false;

            while (true)
            {
                int   k      = i + ((j - i) >> 1);
                int   diff   = 0;
                int   common = common_i < common_j ? common_i : common_j;
                Among w      = v[k];
                int   i2;
                for (i2 = w.s_size - 1 - common; i2 >= 0; i2--)
                {
                    if (c - common == lb)
                    {
                        diff = -1;
                        break;
                    }
                    //                   diff = current.charAt(c - 1 - common) - w.s[i2];
                    diff = current[c - 1 - common] - w.s[i2];
                    if (diff != 0)
                    {
                        break;
                    }
                    common++;
                }
                if (diff < 0)
                {
                    j        = k;
                    common_j = common;
                }
                else
                {
                    i        = k;
                    common_i = common;
                }
                if (j - i <= 1)
                {
                    if (i > 0)
                    {
                        break;
                    }
                    if (j == i)
                    {
                        break;
                    }
                    if (first_key_inspected)
                    {
                        break;
                    }
                    first_key_inspected = true;
                }
            }
            while (true)
            {
                Among w = v[i];
                if (common_i >= w.s_size)
                {
                    cursor = c - w.s_size;
                    if (w.method == null)
                    {
                        return(w.result);
                    }
                    //boolean res;
                    //try
                    //{
                    //    Object resobj = w.method.invoke(w.methodobject,
                    //        new Object[0]);
                    //    res = resobj.toString().equals("true");
                    // }
                    //catch (InvocationTargetException e)
                    //{
                    //    res = false;
                    //    // FIXME - debug message
                    // }
                    //catch (IllegalAccessException e)
                    //{
                    //    res = false;
                    //    // FIXME - debug message
                    // }
                    //cursor = c - w.s_size;
                    //if (res) return w.result;
                }
                i = w.substring_i;
                if (i < 0)
                {
                    return(0);
                }
            }
        }
        internal int find_among(Among[] v, int v_size)
        {
            int i = 0;
            int j = v_size;

            int c = cursor;
            int l = limit;

            int common_i = 0;
            int common_j = 0;

            bool first_key_inspected = false;
            while (true)
            {
                int k = i + ((j - i) >> 1);
                int diff = 0;
                int common = common_i < common_j ? common_i : common_j; // smaller
                Among w = v[k];
                int i2;

                for (i2 = common; i2 < w.s_size; i2++)
                {
                    if (c + common == l)
                    {
                        diff = -1;
                        break;
                    }
                    diff = current[c + common] - w.s[i2];
                    if (diff != 0) break;
                    common++;
                }
                if (diff < 0)
                {
                    j = k;
                    common_j = common;
                }
                else
                {
                    i = k;
                    common_i = common;
                }
                if (j - i <= 1)
                {
                    if (i > 0) break; // v->s has been inspected
                    if (j == i) break; // only one item in v
                    // - but now we need to go round once more to get
                    // v->s inspected. This looks messy, but is actually
                    // the optimal approach.
                    if (first_key_inspected) break;
                    first_key_inspected = true;
                }
            }
            while (true)
            {
                Among w = v[i];
                if (common_i >= w.s_size)
                {
                    cursor = c + w.s_size;
                    if (w.method == null) return w.result;
                    //bool res;
                    //try
                    //{
                    //    Object resobj = w.method.invoke(w.methodobject,new Object[0]);
                    //    res = resobj.toString().equals("true");
                    //}
                    //catch (InvocationTargetException e)
                    //{
                    //    res = false;
                    //    // FIXME - debug message
                    //}
                    //catch (IllegalAccessException e)
                    //{
                    //    res = false;
                    //// FIXME - debug message
                    //}
                    //cursor = c + w.s_size;
                    //if (res) return w.result;
                }
                i = w.substring_i;
                if (i < 0) return 0;
            }
        }
        internal int find_among(Among[] v, int v_size)
        {
            int i = 0;
            int j = v_size;

            int c = cursor;
            int l = limit;

            int common_i = 0;
            int common_j = 0;

            bool first_key_inspected = false;

            while (true)
            {
                int   k      = i + ((j - i) >> 1);
                int   diff   = 0;
                int   common = common_i < common_j ? common_i : common_j; // smaller
                Among w      = v[k];
                int   i2;

                for (i2 = common; i2 < w.s_size; i2++)
                {
                    if (c + common == l)
                    {
                        diff = -1;
                        break;
                    }
                    diff = current[c + common] - w.s[i2];
                    if (diff != 0)
                    {
                        break;
                    }
                    common++;
                }
                if (diff < 0)
                {
                    j        = k;
                    common_j = common;
                }
                else
                {
                    i        = k;
                    common_i = common;
                }
                if (j - i <= 1)
                {
                    if (i > 0)
                    {
                        break;        // v->s has been inspected
                    }
                    if (j == i)
                    {
                        break;         // only one item in v
                    }
                    // - but now we need to go round once more to get
                    // v->s inspected. This looks messy, but is actually
                    // the optimal approach.
                    if (first_key_inspected)
                    {
                        break;
                    }
                    first_key_inspected = true;
                }
            }
            while (true)
            {
                Among w = v[i];
                if (common_i >= w.s_size)
                {
                    cursor = c + w.s_size;
                    if (w.method == null)
                    {
                        return(w.result);
                    }
                    //bool res;
                    //try
                    //{
                    //    Object resobj = w.method.invoke(w.methodobject,new Object[0]);
                    //    res = resobj.toString().equals("true");
                    //}
                    //catch (InvocationTargetException e)
                    //{
                    //    res = false;
                    //    // FIXME - debug message
                    //}
                    //catch (IllegalAccessException e)
                    //{
                    //    res = false;
                    //// FIXME - debug message
                    //}
                    //cursor = c + w.s_size;
                    //if (res) return w.result;
                }
                i = w.substring_i;
                if (i < 0)
                {
                    return(0);
                }
            }
        }
 //    // find_among_b is for backwards processing. Same comments apply
 internal int find_among_b(Among[] v, int v_size)
 {
     int i = 0;
     int j = v_size;
     int c = cursor;
     int lb = limit_backward;
     int common_i = 0;
     int common_j = 0;
     bool first_key_inspected = false;
     while (true)
     {
         int k = i + ((j - i) >> 1);
         int diff = 0;
         int common = common_i < common_j ? common_i : common_j;
         Among w = v[k];
         int i2;
         for (i2 = w.s_size - 1 - common; i2 >= 0; i2--)
         {
             if (c - common == lb)
             {
                 diff = -1;
                 break;
             }
             //                   diff = current.charAt(c - 1 - common) - w.s[i2];
             diff = current[c - 1 - common] - w.s[i2];
             if (diff != 0) break;
             common++;
         }
         if (diff < 0)
         {
             j = k;
             common_j = common;
         }
         else
         {
             i = k;
             common_i = common;
         }
         if (j - i <= 1)
         {
             if (i > 0) break;
             if (j == i) break;
             if (first_key_inspected) break;
             first_key_inspected = true;
         }
     }
     while (true)
     {
         Among w = v[i];
         if (common_i >= w.s_size)
         {
             cursor = c - w.s_size;
             if (w.method == null) return w.result;
             //boolean res;
             //try
             //{
             //    Object resobj = w.method.invoke(w.methodobject,
             //        new Object[0]);
             //    res = resobj.toString().equals("true");
             // }
             //catch (InvocationTargetException e)
             //{
             //    res = false;
             //    // FIXME - debug message
             // }
             //catch (IllegalAccessException e)
             //{
             //    res = false;
             //    // FIXME - debug message
             // }
             //cursor = c - w.s_size;
             //if (res) return w.result;
         }
         i = w.substring_i;
         if (i < 0) return 0;
     }
 }