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