import java.io.*;

public class Main {

    static class EntradaRapida {
        private final BufferedInputStream entrada =
            new BufferedInputStream(System.in);

        private final byte[] datos = new byte[1 << 16];
        private int pos = 0;
        private int longitud = 0;

        private int leer() throws IOException {
            if (pos >= longitud) {
                longitud = entrada.read(datos);
                pos = 0;

                if (longitud <= 0) return -1;
            }

            return datos[pos++];
        }

        int leerEntero() throws IOException {
            int caracter;

            do {
                caracter = leer();
                if (caracter == -1) return -1;
            } while (caracter <= 32);

            int valor = 0;

            while (caracter > 32) {
                valor = valor * 10 + caracter - '0';
                caracter = leer();
            }

            return valor;
        }

        String leerCadena() throws IOException {
            StringBuilder cadenaLeida = new StringBuilder();
            int caracter;

            do {
                caracter = leer();
                if (caracter == -1) return null;
            } while (caracter <= 32);

            while (caracter > 32) {
                cadenaLeida.append((char) caracter);
                caracter = leer();
            }

            return cadenaLeida.toString();
        }

        char leerLetra() throws IOException {
            int caracter;

            do {
                caracter = leer();
            } while (caracter <= 32 && caracter != -1);

            return (char) caracter;
        }
    }

    static class ArbolSegmentos {
        private final int inicioArbol;
        private final int[] segmentos;

        ArbolSegmentos(char[] letras) {
            int longitud = letras.length;
            int capacidad = 1;

            while (capacidad < longitud) {
                capacidad <<= 1;
            }

            inicioArbol = capacidad;
            segmentos = new int[inicioArbol << 1];

            construir(letras);
        }

        private void construir(char[] letras) {
            for (int i = 0; i < letras.length; i++) {
                segmentos[inicioArbol + i] =
                    1 << (letras[i] - 'a');
            }

            for (int actual = inicioArbol - 1; actual > 0; actual--) {
                segmentos[actual] = segmentos[actual << 1] |
                                    segmentos[actual << 1 | 1];
            }
        }

        void actualizar(int indice, char nuevoCaracter) {
            int actual = inicioArbol + indice;

            segmentos[actual] = 1 << (nuevoCaracter - 'a');

            for (actual >>= 1; actual > 0; actual >>= 1) {
                segmentos[actual] = segmentos[actual << 1] |
                                    segmentos[actual << 1 | 1];
            }
        }

        int consultar(int inicio, int fin) {
            int letrasPresentes = 0;

            inicio += inicioArbol;
            fin += inicioArbol + 1;

            while (inicio < fin) {

                if ((inicio & 1) != 0) {
                    letrasPresentes |= segmentos[inicio++];
                }

                if ((fin & 1) != 0) {
                    letrasPresentes |= segmentos[--fin];
                }

                inicio >>= 1;
                fin >>= 1;
            }

            return Integer.bitCount(letrasPresentes);
        }
    }

    static void resolver(EntradaRapida entrada) throws IOException {

        String cadenaInicial = entrada.leerCadena();

        if (cadenaInicial == null) return;

        char[] caracteres = cadenaInicial.toCharArray();

        int totalConsultas = entrada.leerEntero();

        ArbolSegmentos estructura = new ArbolSegmentos(caracteres);

        StringBuilder salida = new StringBuilder();

        for (int consulta = 0; consulta < totalConsultas; consulta++) {

            int operacion = entrada.leerEntero();

            if (operacion == 1) {

                int indice = entrada.leerEntero() - 1;
                char nuevoCaracter = entrada.leerLetra();

                if (caracteres[indice] != nuevoCaracter) {
                    caracteres[indice] = nuevoCaracter;
                    estructura.actualizar(indice, nuevoCaracter);
                }

            } else {

                int inicio = entrada.leerEntero() - 1;
                int fin = entrada.leerEntero() - 1;

                salida.append(
                    estructura.consultar(inicio, fin)
                ).append('\n');
            }
        }

        System.out.print(salida);
    }

    public static void main(String[] args) throws IOException {
        resolver(new EntradaRapida());
    }
}