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