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