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