} ]
}, {
  "scenario" : "org.gradle.performance.regression.android.RealLifeAndroidBuildPerformanceTest.run clean phthalic:assembleDebug",
  "durations" : [ {
    "testProject" : "largeAndroidBuild",
    "linux" : 368
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.android.RealLifeAndroidBuildPerformanceTest.run help",
  "durations" : [ {
    "testProject" : "largeAndroidBuild",
    "linux" : 328
  } ]
}, {

	testErrors(t, "arm64", "arm64error")
}

func TestAMD64EndToEnd(t *testing.T) {
	testEndToEnd(t, "amd64", "amd64")
}

func Test386Encoder(t *testing.T) {
	testEndToEnd(t, "386", "386enc")
}

func TestAMD64Encoder(t *testing.T) {
	filenames := [...]string{
		"amd64enc",
		"amd64enc_extra",
		"avx512enc/aes_avx512f",
		"avx512enc/gfni_avx512f",
		"avx512enc/vpclmulqdq_avx512f",

assembly sources should typically avoid CX except between memory references.
</p>

<h3 id="amd64">64-bit Intel 386 (a.k.a. amd64)</h3>

<p>
The two architectures behave largely the same at the assembler level.
Assembly code to access the <code>m</code> and <code>g</code>
pointers on the 64-bit version is the same as on the 32-bit 386,
except it uses <code>MOVQ</code> rather than <code>MOVL</code>:
</p>

<pre>
get_tls(CX)

   *
   * NOTE: The tests for this behavior (FinalizableReferenceQueueClassLoaderUnloadingTest) fail
   * strangely when run in JDK 9. We are considering this a known issue. Please see
   * https://github.com/google/guava/issues/3086 for more information.
   */

  private static final Logger logger = Logger.getLogger(FinalizableReferenceQueue.class.getName());

-------- | -----------
[kubernetes-client-darwin-386.tar.gz](https://dl.k8s.io/v1.5.8/kubernetes-client-darwin-386.tar.gz) | `95061ccf35dfe1d9aac0dd55c542c8f1b04874892196b0b71185ba3ea61ec424`
[kubernetes-client-darwin-amd64.tar.gz](https://dl.k8s.io/v1.5.8/kubernetes-client-darwin-amd64.tar.gz) | `37b14062a8f3701efa12cb2ae9eecef2831d31881990a15bbb526689b0fd2712`

	parser.allowABI = true
	testOperandParser(t, parser, amd64RuntimeOperandTests)
	testBadOperandParser(t, parser, amd64BadOperandRuntimeTests)
}

func Test386OperandParser(t *testing.T) {
	parser := newParser("386")
	testOperandParser(t, parser, x86OperandTests)
}

func TestARMOperandParser(t *testing.T) {
	parser := newParser("arm")
	testOperandParser(t, parser, armOperandTests)
}

So we put them in their own `dependencies` module (`app/dependencies.py`).

We will now use a simple dependency to read a custom `X-Token` header:

//// tab | Python 3.9+

```Python hl_lines="3  6-8" title="app/dependencies.py"
{!> ../../docs_src/bigger_applications/app_an_py39/dependencies.py!}
```

////

//// tab | Python 3.8+

```Python hl_lines="1  5-7" title="app/dependencies.py"

pkg syscall (freebsd-386), const SYS_FSTAT = 551 #53280
pkg syscall (freebsd-386), const SYS_FSTATAT = 552 #53280
pkg syscall (freebsd-386), const SYS_FSTATFS = 556 #53280
pkg syscall (freebsd-386), const SYS_GETDIRENTRIES = 554 #53280
pkg syscall (freebsd-386), const SYS_GETFSSTAT = 557 #53280
pkg syscall (freebsd-386), const SYS_MKNODAT = 559 #53280
pkg syscall (freebsd-386), const SYS_STATFS = 555 #53280

    X670,
    X671,
    X672,
    X673,
    X674,
    X675,
    X676,
    X677,
    X678,
    X679,
    X680,
    X681,
    X682,
    X683,
    X684,
    X685,
    X686,
    X687,
    X688,
    X689,
    X690,
    X691,
    X692,
    X693,
    X694,
    X695,
    X696,
    X697,
    X698,
    X699,
    X700,
    X701,
    X702,

        }.trustManagers.first() as X509TrustManager

      val sslContext =
        Platform.get().newSSLContext().apply {
          // TODO remove most of this code after https://github.com/bcgit/bc-java/issues/686
          init(null, arrayOf(trustManager), SecureRandom())
        }

      client =
        client.newBuilder()
          .sslSocketFactory(sslContext.socketFactory, trustManager)