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