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