n := len(values[0])
	r := values[0][1 : n-1]

	// Translate doubled quotes
	*qi = QuotedIdentifier(strings.ReplaceAll(r, `""`, `"`))
	return nil
}

// Types representing AST of SQL statement. Only SELECT is supported.

// Select is the top level AST node type
type Select struct {
	Expression *SelectExpression `parser:"\"SELECT\" @@"`
	From       *TableExpression  `parser:"\"FROM\" @@"`

import org.apache.maven.project.inheritance.AbstractProjectInheritanceTestCase;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * Verifies SCM inheritance uses modules statement from parent.
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {
    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0

Do not suppress NullAway errors without a justification.
Prefer rearranging the code to avoid the error, unless there is a provable performance penalty or a significant loss of code readability.
Use `Objects.requireNonNull` statement or `Preconditions` rather than `assert` or `@SuppressWarning` annotation to suppress if possible.

For gradual adoption, enable checks project-by-project.
Do not rely on `@NullMarked` annotations.

                // start building an argument here.
                currentArg = new StringBuilder(arg.substring(1));
                addedToBuffer = true;
            }

            // this has to be a separate "if" statement, to capture the case of: "-Dfoo=bar"
            if (addedToBuffer && arg.endsWith("\"")) {
                // if we're building an argument, keep doing so.

		// enable prepare statement
		tx3 := DB.Session(&gorm.Session{PrepareStmt: true})
		if err := tx3.Transaction(func(tx4 *gorm.DB) error {
			// nested transaction
			return tx4.Transaction(func(tx5 *gorm.DB) error {
				return tx5.First(&User{}, "name = ?", "transaction-2").Error
			})
		}); err != nil {
			t.Fatalf("prepare statement and nested transaction coexist: %v", err)
		}
	})
}

    val called = AtomicBoolean()
    val statement =
      server.apply(
        object : Statement() {
          override fun evaluate() {
            called.set(true)
            server
              .url("/")
              .toUrl()
              .openConnection()
              .connect()
          }
        },
        Description.EMPTY,
      )
    statement.evaluate()

        try {
            return ps.executeUpdate();
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Executes the statement.
     *
     * @param ps
     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @return Whether the result is a {@link ResultSet}.
     * @throws SQLRuntimeException

    <module name="SuppressWarningsFilter"/>
    <module name="TreeWalker">
        <!-- Blocks -->
        <module name="EmptyBlock">
            <property name="option" value="statement"/>
            <property name="tokens" value="LITERAL_DO,LITERAL_ELSE,LITERAL_FINALLY,LITERAL_IF,LITERAL_FOR,LITERAL_TRY,LITERAL_WHILE,INSTANCE_INIT,STATIC_INIT"/>
        </module>
        <module name="EmptyBlock">

   * sneaky checked exception.
   *
   * @return never; this method declares a return type of {@link Error} only so that callers can
   *     write {@code throw sneakyThrow(t);} to convince the compiler that the statement will always
   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

     -cscopes groups,openid,email,profile
```

```
~ mc admin policy create admin allaccess.json
```

Contents of `allaccess.json`

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:*"
      ],
      "Resource": [
        "arn:aws:s3:::*"
      ]
    }
  ]
}
```

### Visit <http://localhost:8080>