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