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