Does the segfaulting.
339791
def Run(self, unused_args):
    """"""
    if flags.FLAGS.pdb_post_mortem:
      logging.warning("Segfault action requested :(")
      print(ctypes.cast(1, ctypes.POINTER(ctypes.c_void_p)).contents)
    else:
      logging.warning("Segfault requested but not running in debug mode.")
354017
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = buf.length;
        int newCapacity = oldCapacity << 1;
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity < 0) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        buf = copyOf(buf, newCapacity);
    }
664004
public static void setFloat(MemorySegment[] segments, int offset, float value) {
		if (inFirstSegment(segments, offset, 4)) {
			segments[0].putFloat(offset, value);
		} else {
			setFloatMultiSegments(segments, offset, value);
		}
	}
637716
private final void primitiveLeftShift(int n) {
        int[] val = value;
        int n2 = 32 - n;
        for (int i=offset, c=val[i], m=i+intLen-1; i < m; i++) {
            int b = c;
            c = val[i+1];
            val[i] = (b << n) | (c >>> n2);
        }
        val[offset+intLen-1] <<= n;
    }
521043
public static void bitSet(MemorySegment[] segments, int baseOffset, int index) {
		if (segments.length == 1) {
			int offset = baseOffset + ((index & BIT_BYTE_POSITION_MASK) >>> 3);
			MemorySegment segment = segments[0];
			byte current = segment.get(offset);
			current |= (1 << (index & BIT_BYTE_INDEX_MASK));
			segment.put(offset, current);
		} else {
			bitSetMultiSegments(segments, baseOffset, index);
		}
	}
821503
void buildPT_T() {
    int numTags = tagIndex.size();
    m_TT = new double[numTags][numTags];
    m_T = new double[numTags];
    double[] tmp = new double[numTags];
    for (IntTaggedWord word : words) {
      double tot = 0.0;
      for (int t = 0; t < numTags; t++) {
        IntTaggedWord iTW = new IntTaggedWord(word.word, t);
        tmp[t] = seenCounter.getCount(iTW);
        tot += tmp[t];
      }
      if (tot < 10) {
        continue;
      }
      for (int t = 0; t < numTags; t++) {
        for (int t2 = 0; t2 < numTags; t2++) {
          if (tmp[t2] > 0.0) {
            double c = tmp[t] / tot;
            m_T[t] += c;
            m_TT[t2][t] += c;
          }
        }
      }
    }
  }
1318539
private void downHeap() {
        E elem = storage.array[0];
        int currIdx = 0;

        while (2 * currIdx < size) {
            int leftChildIdx = 2 * currIdx;
            E leftChild = storage.array[leftChildIdx];
            if (comparator.compare(elem, leftChild) > 0) {
                storage.array[currIdx] = leftChild;
                storage.array[leftChildIdx] = elem;
                currIdx = leftChildIdx;
            } else if (2 * currIdx + 1 < size) {
                int rightChildIdx = 2 * currIdx + 1;
                E rightChild = storage.array[rightChildIdx];
                if (comparator.compare(elem, rightChild) > 0) {
                    storage.array[currIdx] = rightChild;
                    storage.array[rightChildIdx] = elem;
                    currIdx = rightChildIdx;
                } else {
                    return;
                }
            } else {
                return;
            }
        }
    }
1006136
private void ssSwapMerge(int PA, int first, int middle, int last, int buf,
                             int bufsize, int depth) {
        // Pa, first, middle, last and buf - pointers in SA array

        final int STACK_SIZE = SS_SMERGE_STACKSIZE;
        StackElement[] stack = new StackElement[STACK_SIZE];
        int l, r, lm, rm;// pointers in SA
        int m, len, half;
        int ssize;
        int check, next;

        for (check = 0, ssize = 0; ; ) {

            if ((last - middle) <= bufsize) {
                if ((first < middle) && (middle < last)) {
                    ssMergeBackward(PA, first, middle, last, buf, depth);
                }
                if (((check & 1) != 0)
                    || (((check & 2) != 0) && (ssCompare(PA + getIDX(SA[first - 1]), PA
                    + SA[first], depth) == 0))) {
                    SA[first] = ~SA[first];
                }
                if (((check & 4) != 0)
                    && ((ssCompare(PA + getIDX(SA[last - 1]), PA + SA[last], depth) == 0))) {
                    SA[last] = ~SA[last];
                }

                if (ssize > 0) {
                    StackElement se = stack[--ssize];
                    first = se.a;
                    middle = se.b;
                    last = se.c;
                    check = se.d;
                } else {
                    return;
                }
                continue;
            }

            if ((middle - first) <= bufsize) {
                if (first < middle) {
                    ssMergeForward(PA, first, middle, last, buf, depth);
                }
                if (((check & 1) != 0)
                    || (((check & 2) != 0) && (ssCompare(PA + getIDX(SA[first - 1]), PA
                    + SA[first], depth) == 0))) {
                    SA[first] = ~SA[first];
                }
                if (((check & 4) != 0)
                    && ((ssCompare(PA + getIDX(SA[last - 1]), PA + SA[last], depth) == 0))) {
                    SA[last] = ~SA[last];
                }

                if (ssize > 0) {
                    StackElement se = stack[--ssize];
                    first = se.a;
                    middle = se.b;
                    last = se.c;
                    check = se.d;
                } else {
                    return;
                }

                continue;
            }

            for (m = 0, len = min(middle - first, last - middle), half = len >> 1; 0 < len; len = half, half >>= 1) {
                if (ssCompare(PA + getIDX(SA[middle + m + half]), PA
                    + getIDX(SA[middle - m - half - 1]), depth) < 0) {
                    m += half + 1;
                    half -= (len & 1) ^ 1;
                }
            }

            if (0 < m) {
                lm = middle - m;
                rm = middle + m;
                ssBlockSwap(lm, middle, m);
                l = r = middle;
                next = 0;
                if (rm < last) {
                    if (SA[rm] < 0) {
                        SA[rm] = ~SA[rm];
                        if (first < lm) {
                            for (; SA[--l] < 0; ) {
                            }
                            next |= 4;
                        }
                        next |= 1;
                    } else if (first < lm) {
                        for (; SA[r] < 0; ++r) {
                        }
                        next |= 2;
                    }
                }

                if ((l - first) <= (last - r)) {
                    stack[ssize++] = new StackElement(r, rm, last, (next & 3)
                        | (check & 4));

                    middle = lm;
                    last = l;
                    check = (check & 3) | (next & 4);
                } else {
                    if (((next & 2) != 0) && (r == middle)) {
                        next ^= 6;
                    }
                    stack[ssize++] = new StackElement(first, lm, l, (check & 3)
                        | (next & 4));

                    first = r;
                    middle = rm;
                    check = (next & 3) | (check & 4);
                }
            } else {
                if (ssCompare(PA + getIDX(SA[middle - 1]), PA + SA[middle], depth) == 0) {
                    SA[middle] = ~SA[middle];
                }

                if (((check & 1) != 0)
                    || (((check & 2) != 0) && (ssCompare(PA + getIDX(SA[first - 1]), PA
                    + SA[first], depth) == 0))) {
                    SA[first] = ~SA[first];
                }
                if (((check & 4) != 0)
                    && ((ssCompare(PA + getIDX(SA[last - 1]), PA + SA[last], depth) == 0))) {
                    SA[last] = ~SA[last];
                }

                if (ssize > 0) {
                    StackElement se = stack[--ssize];
                    first = se.a;
                    middle = se.b;
                    last = se.c;
                    check = se.d;
                } else {
                    return;
                }

            }

        }

    }
1184626
private void heapify() {
        Object[] array = queue;
        int n = size;
        int half = (n >>> 1) - 1;
        Comparator<? super E> cmp = comparator;
        if (cmp == null) {
            for (int i = half; i >= 0; i--)
                siftDownComparable(i, (E) array[i], array, n);
        }
        else {
            for (int i = half; i >= 0; i--)
                siftDownUsingComparator(i, (E) array[i], array, n, cmp);
        }
    }
389047
private void gobble(Iterator iter)
    {
        if (eatTheRest)
        {
            while (iter.hasNext())
            {
                tokens.add(iter.next());
            }
        }
    }
397930
private void ensureAvail(int n) {
    if (pos + n >= buf.length) {
      int newSize = Math.max(pos + n, buf.length * 2);
      buf = Arrays.copyOf(buf, newSize);
    }
  }
447767
public void seg(File input, File output) throws Exception{
        Utils.seg(input, output, isRemoveStopWord(), segmentation.getSegmentationAlgorithm(), word -> statistics(word, 1, statisticsMap));
    }
74024
public static void bitUnSet(MemorySegment segment, int baseOffset, int index) {
		int offset = baseOffset + ((index & BIT_BYTE_POSITION_MASK) >>> 3);
		byte current = segment.get(offset);
		current &= ~(1 << (index & BIT_BYTE_INDEX_MASK));
		segment.put(offset, current);
	}
556988
private void checkMallocedChunk(int mem, int s) {
    if (VALIDATING) {
      int p = memToChunk(mem);
      int sz = head(p) & ~INUSE_BITS;
      checkInUseChunk(p);
      if (sz < MIN_CHUNK_SIZE) 
        throw new AssertionError("Allocated chunk " + p + " is too small");
      if ((sz & CHUNK_ALIGN_MASK) != 0)
        throw new AssertionError("Chunk size " + sz + " of " + p + " is not correctly aligned");
      if (sz < s)
        throw new AssertionError("Allocated chunk " + p + " is smaller than requested [" + sz + "<" + s + "]");
      if (sz > (s + MIN_CHUNK_SIZE)) {
        throw new AssertionError("Allocated chunk " + p + " is too large (should have been split off) [" + sz + ">>" + s + "]");
      }
    }
  }
975232
void init( DMatrixSparseCSC A ) {
        this.A = A;
        this.m = A.numRows;
        this.n = A.numCols;

        this.next = 0;
        this.head = m;
        this.tail = m + n;
        this.nque = m + 2*n;

        if( parent.length < n || leftmost.length < m) {
            parent = new int[n];
            post = new int[n];
            pinv = new int[m+n];
            countsR = new int[n];
            leftmost = new int[m];
        }
        gwork.reshape(m+3*n);
    }
956044
protected void checkOffset(long offset) {
    if (offset(offset) < this.offset) {
      throw new IndexOutOfBoundsException();
    } else if (limit == -1) {
      if (offset > maxCapacity)
        throw new IndexOutOfBoundsException();
    } else {
      if (offset > limit)
        throw new IndexOutOfBoundsException();
    }
  }
1191765
private void visit(int v, int c) {
        remaining--;
        component[v] = c;
        for (int w : g[v])
            if (component[w] == 0) visit(w, c);
    }