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