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