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