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