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