if (errorCode != 0 || andxCommand == (byte) 0xFF) {
            andxCommand = (byte) 0xFF;
            andx = null;
        } else if (andx == null) {
            andxCommand = (byte) 0xFF;
            throw new RuntimeException("no andx command supplied with response");
        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

		os.Setenv("CONSOLE_ANIMATED_LOGIN", value)
	}

	// Pass on the session duration environment variable, else we will default to 12 hours
	if valueSts := env.Get(config.EnvMinioStsDuration, ""); valueSts != "" {
		os.Setenv("CONSOLE_STS_DURATION", valueSts)
	} else if valueSession := env.Get(config.EnvBrowserSessionDuration, ""); valueSession != "" {
		os.Setenv("CONSOLE_STS_DURATION", valueSession)
	}

			}
			builder.WriteQuoted(column)
		}
	} else {
		builder.WriteByte('*')
	}
}

func (s Select) MergeClause(clause *Clause) {
	if s.Expression != nil {
		if s.Distinct {
			if expr, ok := s.Expression.(Expr); ok {
				expr.SQL = "DISTINCT " + expr.SQL
				clause.Expression = expr
				return
			}
		}

		clause.Expression = s.Expression
	} else {
		clause.Expression = s
	}
}

	}

	var resPointer *result
	if err := DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&resPointer).Error; err != nil {
		t.Fatalf("Failed to query with pointer of value, got error %v", err)
	} else if resPointer.ID != user3.ID || resPointer.Name != user3.Name || resPointer.Age != int(user3.Age) {
		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user3)
	}

    }

    // This loop optimizes for chars less than 0x800.
    for (; i < utf16Length; i++) {
      char c = sequence.charAt(i);
      if (c < 0x800) {
        utf8Length += (0x7f - c) >>> 31; // branch free!
      } else {
        utf8Length += encodedLengthGeneral(sequence, i);
        break;
      }
    }

    if (utf8Length < utf16Length) {
      // Necessary and sufficient condition for overflow because of maximum 3x expansion

        else -> append(addressHostname)
      }
      if (address.url.port != socketAddress.port || addressHostname == socketHostname) {
        append(":")
        append(address.url.port)
      }

      if (addressHostname != socketHostname) {
        when (proxy) {
          Proxy.NO_PROXY -> append(" at ")
          else -> append(" via proxy ")
        }

				err = errSkipFile
			case SlashSeparator:
				res, err = healDiskFormat(ctx, objAPI, task.opts)
			default:
				if task.object == "" {
					res, err = objAPI.HealBucket(ctx, task.bucket, task.opts)
				} else {
					res, err = objAPI.HealObject(ctx, task.bucket, task.object, task.versionID, task.opts)
				}
			}

			if task.respCh != nil {
				task.respCh <- healResult{result: res, err: err}
				continue
			}

func Lines(s []byte) iter.Seq[[]byte] {
	return func(yield func([]byte) bool) {
		for len(s) > 0 {
			var line []byte
			if i := IndexByte(s, '\n'); i >= 0 {
				line, s = s[:i+1], s[i+1:]
			} else {
				line, s = s, nil
			}
			if !yield(line[:len(line):len(line)]) {
				return
			}
		}
	}
}

// splitSeq is SplitSeq or SplitAfterSeq, configured by how many

            } else {
                ""
            }
        id("${model.projectId}_Gradleception$idSuffix")
        name = "Gradleception - ${labels.joinToString(separator = " ")}"
        val descriptionSuffix =
            if (descriptionParts.isNotEmpty()) {
                " (${descriptionParts.joinToString(separator = ", ")})"
            } else {
                ""
            }

                    triggerRules = triggerExcludes
                    branchFilter = determineBranchFilter(effectiveTriggerBranches)
                    enabled = enableTriggers
                }
            } else if (stage.trigger != Trigger.NEVER) {
                val effectiveTriggerBranches = mutableListOf(model.branch.branchName)

                if (model.branch.isMaster) {