<?xml version="1.0" encoding="utf-8"?>
<!--
    Copyright (C) 2015 The Android Open Source Project

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->

<!-- go/gm2-icons, from quantum_gm_ic_keyboard_arrow_right_vd_theme_24.xml -->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="@dimen/sud_navbar_ic_intrinsic_size"
    android:height="@dimen/sud_navbar_ic_intrinsic_size"
    android:autoMirrored="true"
    android:tint="?attr/sudNavBarTextColor"
    android:viewportHeight="24"
    android:viewportWidth="24">

  <!-- Fill with solid black as the actual button color will be tinted on the entire drawable -->
  <path
      android:fillColor="@android:color/black"
      android:pathData="M9.71,18.71l-1.42,-1.42 5.3,-5.29 -5.3,-5.29 1.42,-1.42 6.7,6.71z" />
</vector>
