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