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