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