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