hunk.code_window:                 </div>
                   <form onSubmit={this.handleSubmit}>
                       <div className={server_error ? 'form-group has-error' : 'form-group'}>
                           { server_error }
                           <input type="text" className="form-control" name="domain" ref="domain" placeholder="teamdomain" />
                       </div>
                       <div className="form-group">
                           <button type="submit" className="btn btn-primary">Continue</button>
                       </div>
  
hunk.labels: keep keep keep keep replace keep keep keep keep
hunk.after_edit:                         <input type="text" className="form-control" name="domain" ref="domain" placeholder="team domain" />
  
hunk.file_path: web/react/components/login.jsx
hunk.type: replace
file: // Copyright 2011 The draw2d Authors. All rights reserved.
  // created: 27/05/2011 by Laurent Le Goff
  package raster
  
  import (
  	"image"
  	"image/color"
  	"unsafe"
  )
  
  const (
  	SUBPIXEL_SHIFT = 3
  	SUBPIXEL_COUNT = 1 << SUBPIXEL_SHIFT
  )
  
  var SUBPIXEL_OFFSETS = SUBPIXEL_OFFSETS_SAMPLE_8_FIXED
  
  type SUBPIXEL_DATA uint8
  type NON_ZERO_MASK_DATA_UNIT uint8
  
  type Rasterizer8BitsSample struct {
  	MaskBuffer    []SUBPIXEL_DATA
  	WindingBuffer []NON_ZERO_MASK_DATA_UNIT
  
  	Width           int
  	BufferWidth     int
  	Height          int
  	ClipBound       [4]float64
  	RemappingMatrix [6]float64
  }
  
  /*  width and height define the maximum output size for the filler.
   *  The filler will output to larger bitmaps as well, but the output will
   *  be cropped.
   */
  func NewRasterizer8BitsSample(width, height int) *Rasterizer8BitsSample {
  	var r Rasterizer8BitsSample
  	// Scale the coordinates by SUBPIXEL_COUNT in vertical direction
  	// The sampling point for the sub-pixel is at the top right corner. This
  	// adjustment moves it to the pixel center.
  	r.RemappingMatrix = [6]float64{1, 0, 0, SUBPIXEL_COUNT, 0.5 / SUBPIXEL_COUNT, -0.5 * SUBPIXEL_COUNT}
  	r.Width = width
  	r.Height = height
  	// The buffer used for filling needs to be one pixel wider than the bitmap.
  	// This is because the end flag that turns the fill of is the first pixel
  	// after the actually drawn edge.
  	r.BufferWidth = width + 1
  
  	r.MaskBuffer = make([]SUBPIXEL_DATA, r.BufferWidth*height)
  	r.WindingBuffer = make([]NON_ZERO_MASK_DATA_UNIT, r.BufferWidth*height*SUBPIXEL_COUNT)
  	r.ClipBound = clip(0, 0, width, height, SUBPIXEL_COUNT)
  	return &r
  }
  
  func clip(x, y, width, height, scale int) [4]float64 {
  	var clipBound [4]float64
  
  	offset := 0.99 / float64(scale)
  
  	clipBound[0] = float64(x) + offset
  	clipBound[2] = float64(x+width) - offset
  
  	clipBound[1] = float64(y * scale)
  	clipBound[3] = float64((y + height) * scale)
  	return clipBound
  }
  
  func intersect(r1, r2 [4]float64) [4]float64 {
  	if r1[0] < r2[0] {
  		r1[0] = r2[0]
  	}
  	if r1[2] > r2[2] {
  		r1[2] = r2[2]
  	}
  	if r1[0] > r1[2] {
  		r1[0] = r1[2]
  	}
  
  	if r1[1] < r2[1] {
  		r1[1] = r2[1]
  	}
  	if r1[3] > r2[3] {
  		r1[3] = r2[3]
  	}
  	if r1[1] > r1[3] {
  		r1[1] = r1[3]
  	}
  	return r1
  }
  
  func (r *Rasterizer8BitsSample) RenderEvenOdd(img *image.RGBA, color *color.RGBA, polygon *Polygon, tr [6]float64) {
  	// memset 0 the mask buffer
  	r.MaskBuffer = make([]SUBPIXEL_DATA, r.BufferWidth*r.Height)
  
  	// inline matrix multiplication
  	transform := [6]float64{
  		tr[0]*r.RemappingMatrix[0] + tr[1]*r.RemappingMatrix[2],
  		tr[1]*r.RemappingMatrix[3] + tr[0]*r.RemappingMatrix[1],
  		tr[2]*r.RemappingMatrix[0] + tr[3]*r.RemappingMatrix[2],
  		tr[3]*r.RemappingMatrix[3] + tr[2]*r.RemappingMatrix[1],
  		tr[4]*r.RemappingMatrix[0] + tr[5]*r.RemappingMatrix[2] + r.RemappingMatrix[4],
  		tr[5]*r.RemappingMatrix[3] + tr[4]*r.RemappingMatrix[1] + r.RemappingMatrix[5],
  	}
  
  	clipRect := clip(img.Bounds().Min.X, img.Bounds().Min.Y, img.Bounds().Dx(), img.Bounds().Dy(), SUBPIXEL_COUNT)
  	clipRect = intersect(clipRect, r.ClipBound)
  	p := 0
  	l := len(*polygon) / 2
  	var edges [32]PolygonEdge
  	for p < l {
  		edgeCount := polygon.getEdges(p, 16, edges[:], transform, clipRect)
  		for k := 0; k < edgeCount; k++ {
  			r.addEvenOddEdge(&edges[k])
  		}
  		p += 16
  	}
  
  	r.fillEvenOdd(img, color, clipRect)
  }
  
  //! Adds an edge to be used with even-odd fill.
  func (r *Rasterizer8BitsSample) addEvenOddEdge(edge *PolygonEdge) {
  	x := Fix(edge.X * FIXED_FLOAT_COEF)
  	slope := Fix(edge.Slope * FIXED_FLOAT_COEF)
  	slopeFix := Fix(0)
  	if edge.LastLine-edge.FirstLine >= SLOPE_FIX_STEP {
  		slopeFix = Fix(edge.Slope*SLOPE_FIX_STEP*FIXED_FLOAT_COEF) - slope<<SLOPE_FIX_SHIFT
  	}
  
  	var mask SUBPIXEL_DATA
  	var ySub uint32
  	var xp, yLine int
  	for y := edge.FirstLine; y <= edge.LastLine; y++ {
  		ySub = uint32(y & (SUBPIXEL_COUNT - 1))
  		xp = int((x + SUBPIXEL_OFFSETS[ySub]) >> FIXED_SHIFT)
  		mask = SUBPIXEL_DATA(1 << ySub)
  		yLine = y >> SUBPIXEL_SHIFT
  		r.MaskBuffer[yLine*r.BufferWidth+xp] ^= mask
  		x += slope
  		if y&SLOPE_FIX_MASK == 0 {
  			x += slopeFix
  		}
  	}
  }
  
  //! Adds an edge to be used with non-zero winding fill.
  func (r *Rasterizer8BitsSample) addNonZeroEdge(edge *PolygonEdge) {
  	x := Fix(edge.X * FIXED_FLOAT_COEF)
  	slope := Fix(edge.Slope * FIXED_FLOAT_COEF)
  	slopeFix := Fix(0)
  	if edge.LastLine-edge.FirstLine >= SLOPE_FIX_STEP {
  		slopeFix = Fix(edge.Slope*SLOPE_FIX_STEP*FIXED_FLOAT_COEF) - slope<<SLOPE_FIX_SHIFT
  	}
  	var mask SUBPIXEL_DATA
  	var ySub uint32
  	var xp, yLine int
  	winding := NON_ZERO_MASK_DATA_UNIT(edge.Winding)
  	for y := edge.FirstLine; y <= edge.LastLine; y++ {
  		ySub = uint32(y & (SUBPIXEL_COUNT - 1))
  		xp = int((x + SUBPIXEL_OFFSETS[ySub]) >> FIXED_SHIFT)
  		mask = SUBPIXEL_DATA(1 << ySub)
  		yLine = y >> SUBPIXEL_SHIFT
  		r.MaskBuffer[yLine*r.BufferWidth+xp] |= mask
  		r.WindingBuffer[(yLine*r.BufferWidth+xp)*SUBPIXEL_COUNT+int(ySub)] += winding
  		x += slope
  		if y&SLOPE_FIX_MASK == 0 {
  			x += slopeFix
  		}
  	}
  }
  
  // Renders the mask to the canvas with even-odd fill.
  func (r *Rasterizer8BitsSample) fillEvenOdd(img *image.RGBA, color *color.RGBA, clipBound [4]float64) {
  	var x, y uint32
  
  	minX := uint32(clipBound[0])
  	maxX := uint32(clipBound[2])
  
  	minY := uint32(clipBound[1]) >> SUBPIXEL_SHIFT
  	maxY := uint32(clipBound[3]) >> SUBPIXEL_SHIFT
  
  	//pixColor :=  (uint32(color.R) << 24) |  (uint32(color.G) << 16) |  (uint32(color.B) << 8) | uint32(color.A)
  	pixColor := (*uint32)(unsafe.Pointer(color))
  	cs1 := *pixColor & 0xff00ff
  	cs2 := *pixColor >> 8 & 0xff00ff
  
  	stride := uint32(img.Stride)
  	var mask SUBPIXEL_DATA
  
  	for y = minY; y < maxY; y++ {
  		tp := img.Pix[y*stride:]
  
  		mask = 0
  		for x = minX; x <= maxX; x++ {
  			p := (*uint32)(unsafe.Pointer(&tp[x]))
  			mask ^= r.MaskBuffer[y*uint32(r.BufferWidth)+x]
  			// 8bits
  			alpha := uint32(coverageTable[mask])
  			// 16bits
  			//alpha := uint32(coverageTable[mask & 0xff] + coverageTable[(mask >> 8) & 0xff])
  			// 32bits
  			//alpha := uint32(coverageTable[mask & 0xff] + coverageTable[(mask >> 8) & 0xff] + coverageTable[(mask >> 16) & 0xff] + coverageTable[(mask >> 24) & 0xff])
  
  			// alpha is in range of 0 to SUBPIXEL_COUNT
  			invAlpha := SUBPIXEL_COUNT - alpha
  
  			ct1 := *p & 0xff00ff * invAlpha
  			ct2 := *p >> 8 & 0xff00ff * invAlpha
  
  			ct1 = (ct1 + cs1*alpha) >> SUBPIXEL_SHIFT & 0xff00ff
  			ct2 = (ct2 + cs2*alpha) << (8 - SUBPIXEL_SHIFT) & 0xff00ff00
  
  			*p = ct1 + ct2
  		}
  	}
  }
  
  /*
   * Renders the polygon with non-zero winding fill.
   *  param aTarget the target bitmap.
   *  param aPolygon the polygon to render.
   *  param aColor the color to be used for rendering.
   *  param aTransformation the transformation matrix.
   */
  func (r *Rasterizer8BitsSample) RenderNonZeroWinding(img *image.RGBA, color *color.RGBA, polygon *Polygon, tr [6]float64) {
  
  	r.MaskBuffer = make([]SUBPIXEL_DATA, r.BufferWidth*r.Height)
  	r.WindingBuffer = make([]NON_ZERO_MASK_DATA_UNIT, r.BufferWidth*r.Height*SUBPIXEL_COUNT)
  
  	// inline matrix multiplication
  	transform := [6]float64{
  		tr[0]*r.RemappingMatrix[0] + tr[1]*r.RemappingMatrix[2],
  		tr[1]*r.RemappingMatrix[3] + tr[0]*r.RemappingMatrix[1],
  		tr[2]*r.RemappingMatrix[0] + tr[3]*r.RemappingMatrix[2],
  		tr[3]*r.RemappingMatrix[3] + tr[2]*r.RemappingMatrix[1],
  		tr[4]*r.RemappingMatrix[0] + tr[5]*r.RemappingMatrix[2] + r.RemappingMatrix[4],
  		tr[5]*r.RemappingMatrix[3] + tr[4]*r.RemappingMatrix[1] + r.RemappingMatrix[5],
  	}
  
  	clipRect := clip(img.Bounds().Min.X, img.Bounds().Min.Y, img.Bounds().Dx(), img.Bounds().Dy(), SUBPIXEL_COUNT)
  	clipRect = intersect(clipRect, r.ClipBound)
  
  	p := 0
  	l := len(*polygon) / 2
  	var edges [32]PolygonEdge
  	for p < l {
  		edgeCount := polygon.getEdges(p, 16, edges[:], transform, clipRect)
  		for k := 0; k < edgeCount; k++ {
  			r.addNonZeroEdge(&edges[k])
  		}
  		p += 16
  	}
  
  	r.fillNonZero(img, color, clipRect)
  }
  
  //! Renders the mask to the canvas with non-zero winding fill.
  func (r *Rasterizer8BitsSample) fillNonZero(img *image.RGBA, color *color.RGBA, clipBound [4]float64) {
  	var x, y uint32
  
  	minX := uint32(clipBound[0])
  	maxX := uint32(clipBound[2])
  
  	minY := uint32(clipBound[1]) >> SUBPIXEL_SHIFT
  	maxY := uint32(clipBound[3]) >> SUBPIXEL_SHIFT
  
  	//pixColor :=  (uint32(color.R) << 24) |  (uint32(color.G) << 16) |  (uint32(color.B) << 8) | uint32(color.A)
  	pixColor := (*uint32)(unsafe.Pointer(color))
  	cs1 := *pixColor & 0xff00ff
  	cs2 := *pixColor >> 8 & 0xff00ff
  
  	stride := uint32(img.Stride)
  	var mask SUBPIXEL_DATA
  	var n uint32
  	var values [SUBPIXEL_COUNT]NON_ZERO_MASK_DATA_UNIT
  	for n = 0; n < SUBPIXEL_COUNT; n++ {
  		values[n] = 0
  	}
  
  	for y = minY; y < maxY; y++ {
  		tp := img.Pix[y*stride:]
  
  		mask = 0
  		for x = minX; x <= maxX; x++ {
  			p := (*uint32)(unsafe.Pointer(&tp[x]))
  			temp := r.MaskBuffer[y*uint32(r.BufferWidth)+x]
  			if temp != 0 {
  				var bit SUBPIXEL_DATA = 1
  				for n = 0; n < SUBPIXEL_COUNT; n++ {
  					if temp&bit != 0 {
  						t := values[n]
  						values[n] += r.WindingBuffer[(y*uint32(r.BufferWidth)+x)*SUBPIXEL_COUNT+n]
  						if (t == 0 || values[n] == 0) && t != values[n] {
  							mask ^= bit
  						}
  					}
  					bit <<= 1
  				}
  			}
  
  			// 8bits
  			alpha := uint32(coverageTable[mask])
  			// 16bits
  			//alpha := uint32(coverageTable[mask & 0xff] + coverageTable[(mask >> 8) & 0xff])
  			// 32bits
  			//alpha := uint32(coverageTable[mask & 0xff] + coverageTable[(mask >> 8) & 0xff] + coverageTable[(mask >> 16) & 0xff] + coverageTable[(mask >> 24) & 0xff])
  
  			// alpha is in range of 0 to SUBPIXEL_COUNT
  			invAlpha := uint32(SUBPIXEL_COUNT) - alpha
  
  			ct1 := *p & 0xff00ff * invAlpha
  			ct2 := *p >> 8 & 0xff00ff * invAlpha
  
  			ct1 = (ct1 + cs1*alpha) >> SUBPIXEL_SHIFT & 0xff00ff
  			ct2 = (ct2 + cs2*alpha) << (8 - SUBPIXEL_SHIFT) & 0xff00ff00
  
  			*p = ct1 + ct2
  		}
  	}
  }
  