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