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