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