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