? pattern.length - 1
? offset + pattern.length - 1
	public int match(char[] text, int offset, int length)	{		// position variable for pattern start		int anchor = reverseSearch ? offset - 1 : offset;		// position variable for pattern test position		int pos;		// last possible start position of a match with this pattern;		// this is negative if the pattern is longer than the text		// causing the search loop below to immediately fail		int last_anchor = reverseSearch			? pattern.length - 1			: length - pattern.length;		// each time the pattern is checked, we start this many		// characters ahead of 'anchor'		int pattern_end = pattern.length - 1;		char ch = 0;		int bad_char;		int good_suffix;		// the search works by starting the anchor (first character		// of the pattern) at the initial offset. as long as the		// anchor is far enough from the enough of the text for the		// pattern to match, and until the pattern matches, we		// compare the pattern to the text from the last character		// to the first character in reverse order. where a character		// in the pattern mismatches, we use the two heuristics		// based on the mismatch character and its position in the		// pattern to determine the furthest we can move the anchor		// without missing any potential pattern matches.SEARCH:		while (reverseSearch ? anchor >= last_anchor : anchor <= last_anchor)		{			for (pos = pattern_end; pos >= 0; --pos)			{				int idx = reverseSearch ? anchor - pos : anchor + pos;				ch = ignoreCase					? Character.toUpperCase(text[idx])					: text[idx];				// pattern test				if (ch != pattern[pos])				{					// character mismatch, determine how many characters to skip					// heuristic #1					bad_char = pos - skip[getSkipIndex(ch)];					// heuristic #2					good_suffix = suffix[pos];					// skip the greater of the two distances provided by the					// heuristics					int skip = (bad_char > good_suffix) ? bad_char : good_suffix;					anchor += reverseSearch ? -skip : skip;					// go back to the while loop					continue SEARCH;				}			}			// MATCH: return the position of its first character			return reverseSearch ? anchor - (pattern.length - 1) : anchor;		}		// MISMATCH: return -1 as defined by API		return -1;	}