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