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