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