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