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