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