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