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