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